1687a9c05b0c
formula_bar.rs
//! The auto-growing formula bar, the 5-line in-cell editor and the code editor widget.
use egui::{Event, Key, Modifiers, Rect, vec2};
use gridcraft_engine::Session;
use gridcraft_engine::core::{CellRef, Value};
use gridcraft_ui_egui::formula_bar::{BarLayout, MAX_LINES, one_line};
use gridcraft_ui_egui::widgets::{Lang, code_editor};
use gridcraft_ui_egui::{SheetApp, theme};
use serde_json::json;
type Harness = egui_kittest::Harness<'static, SheetApp>;
/// Builds a stepped 1200x800 harness around the caller's session and settles its frames.
fn harness(session: Session) -> Harness {
let mut h = crate::common::builder().with_size(vec2(1200.0, 800.0)).with_step_dt(1.0 / 60.0).build_ui_state(
|ui, app: &mut SheetApp| {
app.logic(ui.ctx());
app.ui(ui);
},
crate::common::app(session),
);
settle(&mut h);
h
}
fn blank() -> Session {
let mut s = Session::new();
s.new_workbook();
s
}
/// Long enough for the 120 ms height ease to finish.
fn settle(h: &mut Harness) {
h.run_steps(16);
}
fn key(key: Key, modifiers: Modifiers) -> [Event; 2] {
[
Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers },
Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers },
]
}
fn type_text(h: &mut Harness, text: &str) {
h.input_mut().events.push(Event::Text(text.into()));
h.run_steps(2);
}
fn alt_enter(h: &mut Harness) {
h.input_mut().events.extend(key(Key::Enter, Modifiers::ALT));
h.run_steps(2);
}
fn layout(h: &Harness) -> BarLayout {
BarLayout::get(&h.ctx)
}
fn row_height(h: &Harness) -> f32 {
h.ctx.fonts_mut(|f| f.row_height(&theme::ui_font(13.0)))
}
fn same(a: Rect, b: Rect) -> bool {
(a.min - b.min).length() < 0.5 && (a.max - b.max).length() < 0.5
}
#[test]
fn bar_grows_to_five_lines_then_scrolls_with_name_box_pinned() {
let mut h = harness(blank());
// The one-line height is 30 px unless the font's rows need more (Windows' do).
let rh = row_height(&h);
let base = one_line(rh);
let one = layout(&h);
assert!((one.height - base).abs() < 0.5, "one line is {base} px, got {}", one.height);
assert_eq!(one.lines, 1);
h.state_mut().begin_edit(None, true);
h.run_steps(2);
type_text(&mut h, "line 1");
for n in 2..=8 {
alt_enter(&mut h);
type_text(&mut h, &format!("line {n}"));
settle(&mut h);
let l = layout(&h);
assert_eq!(l.lines, n, "the editor holds {n} lines");
let expect = base + (n.min(MAX_LINES) - 1) as f32 * rh;
assert!((l.height - expect).abs() < 0.5, "{n} lines: height {} expected {expect}", l.height);
assert!(same(l.name_box, one.name_box), "the Name Box stays on the first line ({n} lines)");
assert!(same(l.buttons, one.buttons), "the buttons stay on the first line ({n} lines)");
let caret = l.caret.expect("a caret while editing");
assert!(l.field.contains_rect(caret.shrink(0.5)), "the caret stays visible at {n} lines: {caret:?} in {:?}", l.field);
}
assert_eq!(layout(&h).visible_lines, MAX_LINES);
// Enter commits the multi-line text; viewing the cell keeps the bar at five lines.
h.input_mut().events.extend(key(Key::Enter, Modifiers::NONE));
settle(&mut h);
let text = (1..=8).map(|n| format!("line {n}")).collect::<Vec<_>>().join("\n");
let d = h.state().session.active().unwrap();
assert_eq!(d.wb.active().unwrap().value(CellRef::parse("A1").unwrap()), Value::from(text.as_str()));
h.state_mut().session.execute("selection.set", json!({"cell": "A1"})).unwrap();
settle(&mut h);
let viewing = layout(&h);
assert_eq!(viewing.lines, 8);
assert!((viewing.height - (base + 4.0 * rh)).abs() < 0.5);
// An empty cell shrinks it back to one line.
h.state_mut().session.execute("selection.set", json!({"cell": "B1"})).unwrap();
settle(&mut h);
assert!((layout(&h).height - base).abs() < 0.5);
}
#[test]
fn enter_that_closes_a_message_box_adds_no_line_to_the_entry() {
// A message box over the editor (a data validation alert) takes Enter to close. The bar's
// field is multi-line, and a field of its own would add a line on that Enter; the editor
// handles Enter itself, so the field does nothing with it.
let mut h = harness(blank());
h.state_mut().begin_edit(None, true);
h.run_steps(2);
type_text(&mut h, "abc");
h.state_mut().message = Some(("Stop".into(), "Whole numbers only.".into()));
h.run_steps(2);
h.input_mut().events.extend(key(Key::Enter, Modifiers::NONE));
h.run_steps(2);
assert!(h.state().message.is_none(), "Enter closed the message box");
assert_eq!(h.state().editor.as_ref().map(|e| e.text.as_str()), Some("abc"), "and added nothing to the entry");
assert_eq!(layout(&h).lines, 1);
}
#[test]
fn chevron_pins_the_bar_at_five_lines() {
let mut h = harness(blank());
h.state_mut().ui.formula_bar_expanded = true;
settle(&mut h);
let rh = row_height(&h);
let base = one_line(rh);
assert!((layout(&h).height - (base + 4.0 * rh)).abs() < 0.5);
h.state_mut().ui.formula_bar_expanded = false;
settle(&mut h);
assert!((layout(&h).height - base).abs() < 0.5);
}
#[test]
fn height_eases_instead_of_jumping() {
let mut h = harness(blank());
h.state_mut().ui.formula_bar_expanded = true;
h.run_steps(2);
let mid = layout(&h).height;
let rh = row_height(&h);
let base = one_line(rh);
assert!(mid > base + 0.5 && mid < base + 4.0 * rh - 0.5, "mid-ease height {mid}");
settle(&mut h);
assert!((layout(&h).height - (base + 4.0 * rh)).abs() < 0.5);
}
/// Opens a multi-line edit in B3, checks the text is kept whole, and returns the painted editor height.
fn in_cell_height(lines: usize) -> f32 {
let mut s = blank();
s.execute("selection.set", json!({"cell": "B3"})).unwrap();
let mut h = harness(s);
let text = (1..=lines).map(|n| format!("row {n}")).collect::<Vec<_>>().join("\n");
h.state_mut().begin_edit(Some(text.clone()), false);
settle(&mut h);
assert_eq!(h.state().editor.as_ref().unwrap().text, text, "the text is kept whole");
let rect: Rect = h.ctx.data(|d| d.get_temp(egui::Id::unique("gridcraft.cell_editor.rect"))).expect("the in-cell editor painted");
rect.height()
}
#[test]
fn in_cell_editor_grows_with_every_line() {
// The formula bar stops at five lines and scrolls; the in-cell editor shows every line, as
// the grid's own tests ask (`an_unwrapped_multiline_edit_shows_every_line`).
let (four, five, nine) = (in_cell_height(4), in_cell_height(5), in_cell_height(9));
assert!(five > four + 1.0, "grows with the lines ({four} then {five})");
assert!(nine > five + 1.0, "and past five ({five} then {nine})");
}
#[test]
/// The code editor indents after Enter and preserves indentation across typed lines, with an accessibility check.
fn code_editor_indents_and_keeps_indentation() {
struct State {
text: String,
focused: bool,
}
let mut h = crate::common::builder().with_size(vec2(400.0, 300.0)).build_ui_state(
|ui, s: &mut State| {
let id = egui::Id::unique("code");
if !s.focused {
ui.memory_mut(|m| m.request_focus(id));
s.focused = true;
}
code_editor(ui, id, &mut s.text, Lang::Python, 5);
},
State { text: String::new(), focused: false },
);
h.run_steps(2);
// The code editor's text field has no visible label; the strict policy checks its name.
h.check_accessibility();
h.input_mut().events.push(Event::Text("if x:".into()));
h.run_steps(1);
h.input_mut().events.extend(key(Key::Enter, Modifiers::NONE));
h.run_steps(1);
h.input_mut().events.push(Event::Text("y = 1".into()));
h.run_steps(1);
h.input_mut().events.extend(key(Key::Enter, Modifiers::NONE));
h.run_steps(1);
h.input_mut().events.extend(key(Key::Tab, Modifiers::NONE));
h.run_steps(1);
h.input_mut().events.push(Event::Text("z".into()));
h.run_steps(1);
assert_eq!(h.state().text, "if x:\n y = 1\n z");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.