1687a9c05b0c
editing.rs
use super::{SheetApp, clean_error, editor, formula_bar, formula_locale, json, now_ms};
/// Why a draft whose sheet was deleted while it was open is dropped.
pub(crate) const DRAFT_SHEET_GONE: &str = "The sheet of the cell being edited was deleted, so the entry was discarded.";
/// Why a draft of Python code that sheet protection hid while it was open is dropped.
pub(crate) const DRAFT_CODE_HIDDEN: &str = "Sheet protection now hides the code of the cell being edited, so the entry was discarded.";
impl SheetApp {
/// Starts editing the active cell. `text` replaces the content (typing) or pre-fills it.
pub fn begin_edit(&mut self, text: Option<String>, from_formula_bar: bool) {
// The source formula is display-only on spill children. Grid replacement keeps its
// existing behavior, but no formula-bar entry path may edit that displayed formula.
if from_formula_bar && formula_bar::active_spill_anchor(self).is_some() {
return;
}
if let Err(e) = self.commit_text_box_edit() {
self.message = Some(("Text Box".into(), clean_error(&e)));
return;
}
let Some(d) = self.session.active() else { return };
let Some(sh) = d.wb.active() else { return };
let at = sh.merge_at(d.selection.active).map(|m| m.start).unwrap_or(d.selection.active);
// A locked cell on a protected sheet can't be entered (Excel's warning, and the engine
// refuses `cell.set` anyway): refuse before a draft exists, rather than leaving one that
// can never be committed and blocks Save (#2945).
if let Some(m) = self.session.locked_cell_message(d.wb.active_sheet(), at) {
self.message = Some(("GridCraft".into(), m));
return;
}
// A picture has no editable scalar text. Selecting it, F2, or clicking
// the formula bar must not turn its fallback value into a text edit.
// Typing still starts an intentional replacement.
if text.is_none() && sh.cell_pictures.contains_key(&at) {
return;
}
// Editing a Python cell edits its code, in Python mode; typing replaces it as in Excel.
if text.is_none()
&& let Some(py) = sh.cell(at).and_then(|c| c.py.as_deref())
{
// Code hidden on a protected sheet isn't loaded into an edit, and a blank edit would
// write over it on commit: no edit starts. Typing still replaces the cell.
if gridcraft_engine::display::formula_hidden(&d.wb, sh, at) {
return;
}
let mut ed = editor::EditState::python(d.uid, d.wb.active_sheet(), at, py.code.clone()).on_sheet(&d.wb);
ed.py_cell = true;
ed.window = self.session.active_window();
self.editor = Some(ed);
self.session.mode = gridcraft_engine::Mode::Edit;
return;
}
// A hidden formula's source isn't loaded into an edit (a blank edit would also write over
// it on commit): no edit starts. Typing still replaces the cell.
if text.is_none() && gridcraft_engine::display::formula_hidden(&d.wb, sh, at) {
return;
}
let locale = self.ui.language.formula_locale();
let current = if sh.cell_pictures.contains_key(&at) {
String::new()
} else {
match sh.cell(at) {
Some(c) if c.formula.is_some() => formula_locale::display(&c.input_text(), locale, &d.wb, d.wb.active_sheet()),
_ => gridcraft_engine::display::edit_text(&d.wb, sh, at),
}
};
let (text, replace) = match text {
Some(t) => (t, true),
None => (current.clone(), false),
};
let mut ed = editor::EditState::new(d.uid, d.wb.active_sheet(), at, text, replace, from_formula_bar).on_sheet(&d.wb);
ed.window = self.session.active_window();
ed.locale = locale;
if replace && self.ui.autocomplete && !ed.is_formula() {
ed.completion = editor::column_completion(sh, at, &ed.text);
}
self.editor = Some(ed);
self.session.mode = if replace { gridcraft_engine::Mode::Enter } else { gridcraft_engine::Mode::Edit };
}
/// Commits the edit; `then` moves the selection (dr, dc) afterwards.
///
/// The draft goes into the window and workbook it was typed in. If another window is
/// showing, that window stays active afterwards; a draft its own workbook refuses
/// (validation, a bad formula) brings its window back to the front with the draft still open.
pub fn commit_edit(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
let Some((doc, window)) = self.editor.as_ref().map(|ed| (ed.doc, ed.window)) else { return true };
if !self.draft_elsewhere() {
return self.commit_edit_here(dr, dc, array, fill_selection);
}
// Its window, or (when that window closed) its workbook's most recent one.
let Some(owner) = window.filter(|w| self.session.window(*w).is_some()).or_else(|| self.session.doc_window(doc)) else {
self.cancel_edit();
return true;
};
let back = self.session.active_window();
self.session.activate_window(owner);
if !self.commit_edit_here(dr, dc, array, fill_selection) {
// Refused: its window stays in front with the draft open and the reason shown.
return false;
}
if let Some(back) = back {
self.session.activate_window(back);
}
true
}
/// The cell draft belongs to a window or workbook other than the one showing.
pub(super) fn draft_elsewhere(&self) -> bool {
self.editor.as_ref().is_some_and(|ed| {
self.session.active().map(|d| d.uid) != Some(ed.doc) || ed.window.is_some_and(|w| self.session.active_window() != Some(w))
})
}
/// Commits the cell and text-box drafts, as Enter would, before a command that can show
/// another workbook or write this one to a file, so a draft never lands in another workbook.
/// A draft its workbook refuses stays open with the reason shown, and the command doesn't run.
pub(crate) fn settle_drafts(&mut self) -> Result<(), String> {
if !self.commit_edit(0, 0, false, false) {
return Err(self.message.as_ref().map(|(_, m)| m.clone()).unwrap_or_else(|| "The cell being edited can't be entered.".into()));
}
self.commit_text_box_edit()
}
fn commit_edit_here(&mut self, dr: i64, dc: i64, array: bool, fill_selection: bool) -> bool {
// Python code goes in through `python.set`, whichever way the edit is committed (the
// formula bar's Enter button, a click on the sheet).
if self.editor.as_ref().is_some_and(|e| e.python) {
let ok = self.commit_python_edit();
if ok && (dr != 0 || dc != 0) {
self.move_after_enter(dr, dc);
}
return ok;
}
let Some(mut ed) = self.editor.take() else { return true };
self.session.mode = gridcraft_engine::Mode::Ready;
if !self.follow_draft_sheet(&mut ed) {
return true;
}
let text = match &ed.completion {
// A code edit commits the code as typed, whatever a completion holds.
Some(full) if !ed.python && full.to_lowercase().starts_with(&ed.text.to_lowercase()) => full.clone(),
_ => ed.text.clone(),
};
// F2 then Enter (or a file command) on an untouched draft: nothing to write.
if !fill_selection && !array && ed.original.as_ref() == Some(&text) {
if dr != 0 || dc != 0 {
self.move_after_enter(dr, dc);
}
return true;
}
// A draft on a cell sheet protection now locks (the sheet was protected while it was
// open) can't be entered: drop it with the warning instead of keeping it, which would
// block Save with a draft that can never be committed (#2945).
if let Some(m) = self.session.locked_cell_message(ed.sheet, ed.cell) {
self.message = Some(("GridCraft".into(), m));
return true;
}
let text = match self.session.active().map(|d| formula_locale::canonical(&text, ed.locale, &d.wb, ed.sheet, ed.cell)) {
Some(Ok(text)) => text,
Some(Err(error)) => {
self.message = Some(("GridCraft".into(), error.to_string()));
self.editor = Some(ed);
self.session.mode = gridcraft_engine::Mode::Edit;
return false;
}
None => text,
};
// Data validation.
if let Some(d) = self.session.active()
&& let Some((dv, msg)) = gridcraft_engine::cmd::data::check_validation(&d.wb, ed.sheet, ed.cell, &text)
{
if dv.error_style == gridcraft_engine::model::ErrorStyle::Stop {
let title = if dv.error_title.is_empty() { "GridCraft".to_string() } else { dv.error_title.clone() };
self.message = Some((title, msg));
self.editor = Some(ed);
self.session.mode = gridcraft_engine::Mode::Edit;
return false;
}
self.toast = Some((msg, now_ms()));
}
// Point mode can leave another sheet active; the edit belongs to the sheet it started on.
if self.session.active().is_some_and(|d| d.wb.active_sheet() != ed.sheet)
&& let Err(e) = self.session.run("sheet.activate", json!({"sheet": ed.sheet}))
{
self.message = Some(("GridCraft".into(), clean_error(&e)));
self.editor = Some(ed);
self.session.mode = gridcraft_engine::Mode::Edit;
return false;
}
// Committing nothing into an empty cell changes nothing: no undo step (#1855, Backspace has
// already cleared the cell as its own step).
let unchanged = !fill_selection
&& !array
&& text.is_empty()
&& self.session.active().and_then(|d| d.wb.sheet(ed.sheet)).is_some_and(|sh| {
sh.cell(ed.cell).is_none_or(|c| c.formula.is_none() && c.py.is_none() && c.value == gridcraft_engine::core::Value::Empty)
});
let r = if unchanged {
Ok(json!({}))
} else if fill_selection {
self.session.run("range.fill", json!({"input": text}))
} else {
self.session.run("cell.set", json!({"cell": ed.cell.a1(), "input": text, "array": array}))
};
match r {
Ok(_) => {
if dr != 0 || dc != 0 {
self.move_after_enter(dr, dc);
}
self.after_engine();
true
}
Err(e) => {
self.message = Some(("GridCraft".into(), clean_error(&e)));
self.editor = Some(ed);
self.session.mode = gridcraft_engine::Mode::Edit;
false
}
}
}
/// After a command, keeps the open draft on its own sheet: a sheet inserted, deleted or moved
/// before it (an undo or a macro too) changes which sheet sits at its index. The draft is then
/// drawn, pointed from and committed on its sheet, and the point-mode anchor, held by sheet
/// index, is let go. A draft is dropped at once with a message when its sheet is gone, or when
/// it holds Python code that sheet protection now hides (a draft in Python mode, or one that
/// began on a Python cell's code): neither editor shows hidden code, as the Python editor
/// window closes then too. A draft typed over a Python cell holds only what was typed, so it
/// stays open.
pub(crate) fn follow_open_draft(&mut self) {
let Some(ed) = self.editor.as_ref() else { return };
let Some(d) = self.session.documents().iter().find(|d| d.uid == ed.doc) else { return };
let order = editor::sheet_order(&d.wb);
let moved = ed.sheet_uid != 0 && order != ed.sheet_order;
let found = if moved { ed.sheet_in(&d.wb) } else { Some(ed.sheet) };
let hidden = found
.and_then(|i| d.wb.sheet(i))
.is_some_and(|sh| (ed.python || ed.py_cell) && gridcraft_engine::display::formula_hidden(&d.wb, sh, ed.cell));
let why = match found {
None => Some(DRAFT_SHEET_GONE),
Some(_) if hidden => Some(DRAFT_CODE_HIDDEN),
Some(_) => None,
};
if let Some(why) = why {
self.editor = None;
self.session.mode = gridcraft_engine::Mode::Ready;
self.message = Some(("GridCraft".into(), why.into()));
return;
}
if let (true, Some(sheet), Some(ed)) = (moved, found, self.editor.as_mut()) {
ed.sheet = sheet;
ed.sheet_order = order;
ed.point_anchor = None;
}
}
/// Points a draft being committed at its sheet, found by identity: commands (a sheet inserted
/// or deleted before it, a move, an undo, a macro) change which sheet sits at its index while
/// it is open. A draft whose sheet is gone is dropped with a message, as one whose cell
/// protection locks is, rather than being entered on whichever sheet took its place; `false`
/// then.
fn follow_draft_sheet(&mut self, ed: &mut editor::EditState) -> bool {
let Some(d) = self.session.active() else { return true };
match ed.sheet_in(&d.wb) {
Some(sheet) => {
ed.sheet = sheet;
true
}
None => {
self.message = Some(("GridCraft".into(), DRAFT_SHEET_GONE.into()));
false
}
}
}
/// Commits the edit with an arrow key. The arrow is an ordinary move, so it ends a run of Tabs
/// instead of continuing it (Right) or going back to its column like Enter (Down), as in Excel.
pub fn commit_edit_arrow(&mut self, dr: i64, dc: i64) -> bool {
let run = self.tab_run.take();
let ok = self.commit_edit(dr, dc, false, false);
self.tab_run = if ok { None } else { run };
ok
}
pub fn cancel_edit(&mut self) {
self.editor = None;
self.session.mode = gridcraft_engine::Mode::Ready;
}
/// Starts editing the active cell in Python mode, in the formula bar: its code, or no code
/// yet for a cell that isn't a Python cell. A cell inside a spill isn't edited, as with the
/// formula bar's other entry paths.
pub fn begin_python_edit(&mut self) {
if formula_bar::active_spill_anchor(self).is_some() {
return;
}
if let Err(e) = self.commit_text_box_edit() {
self.message = Some(("Text Box".into(), clean_error(&e)));
return;
}
let Some(d) = self.session.active() else { return };
let Some(sh) = d.wb.active() else { return };
let at = sh.merge_at(d.selection.active).map(|m| m.start).unwrap_or(d.selection.active);
// A locked cell on a protected sheet is refused before a draft exists, as `begin_edit`
// refuses it (#2945).
if let Some(m) = self.session.locked_cell_message(d.wb.active_sheet(), at) {
self.message = Some(("GridCraft".into(), m));
return;
}
let py = sh.cell(at).and_then(|c| c.py.as_deref());
// A Python cell's code hidden on a protected sheet stays out of view, and Python mode
// doesn't start on it with no code, which a commit would write over the hidden code.
if py.is_some() && gridcraft_engine::display::formula_hidden(&d.wb, sh, at) {
return;
}
let code = py.map(|py| py.code.clone()).unwrap_or_default();
// The draft belongs to this window, as `begin_edit`'s do: switching windows commits it here.
let mut ed = editor::EditState::python(d.uid, d.wb.active_sheet(), at, code).on_sheet(&d.wb);
ed.py_cell = py.is_some();
ed.window = self.session.active_window();
self.editor = Some(ed);
self.session.mode = gridcraft_engine::Mode::Edit;
}
/// Ctrl+Alt+Shift+P (and the PY badge): Python mode on or off. An edit in progress keeps its
/// text; with no edit, Python mode starts on the active cell.
pub fn toggle_python_mode(&mut self) {
if self.editor.as_ref().is_some_and(|ed| !ed.python && self.draft_in_spill(ed)) {
return;
}
match self.editor.as_mut() {
Some(ed) if ed.python => ed.leave_python(),
Some(ed) => ed.enter_python(),
None => return self.begin_python_edit(),
}
self.session.mode = gridcraft_engine::Mode::Edit;
}
/// Whether a draft's cell lies inside another cell's spill. A draft typed there stays an
/// ordinary entry: Python mode starts on no cell inside a spill, as the formula bar's entry
/// paths don't.
pub(crate) fn draft_in_spill(&self, ed: &editor::EditState) -> bool {
let doc = self.session.documents().iter().find(|d| d.uid == ed.doc);
doc.and_then(|d| d.wb.sheet(ed.sheet)).is_some_and(|sh| sh.spill_anchor(ed.cell).is_some())
}
/// Why Python mode didn't start where a command asked for it: the cell lies inside another
/// cell's spill, it is locked on a protected sheet, or its code is hidden there.
pub(crate) fn python_mode_refused(&self) -> String {
let in_spill = match self.editor.as_ref() {
Some(ed) => self.draft_in_spill(ed),
None => formula_bar::active_spill_anchor(self).is_some(),
};
if in_spill {
return "Python mode doesn't start on a cell inside another cell's spill.".into();
}
let locked = self.session.active().and_then(|d| {
let at = d.wb.active().and_then(|sh| sh.merge_at(d.selection.active)).map(|m| m.start).unwrap_or(d.selection.active);
self.session.locked_cell_message(d.wb.active_sheet(), at)
});
locked.unwrap_or_else(|| "Python mode can't start on this cell: its code is hidden on a protected sheet.".into())
}
/// Commits a Python mode edit through `python.set`, on the sheet the edit started on; with no
/// code left, a Python cell is cleared through `cell.set`. When the command refuses (code
/// longer than a cell holds), its message shows and the edit stays open with the code as
/// typed.
pub fn commit_python_edit(&mut self) -> bool {
let Some(mut ed) = self.editor.take() else { return true };
self.session.mode = gridcraft_engine::Mode::Ready;
if !self.follow_draft_sheet(&mut ed) {
return true;
}
// The code of a Python cell committed unchanged: nothing to write (no undo step, the
// workbook stays clean), as with F2 then Enter on any other cell.
let code = gridcraft_engine::model::python::normalize_code(&ed.text);
let old = self.session.active().and_then(|d| d.wb.sheet(ed.sheet)).and_then(|sh| sh.cell(ed.cell)).and_then(|c| c.py.as_deref());
let python_cell = old.is_some();
if old.is_some_and(|py| py.code == code) {
return true;
}
// A draft on a cell sheet protection now locks can never be entered: it is dropped with
// the warning, as `commit_edit_here` drops an ordinary one (#2945).
if let Some(m) = self.session.locked_cell_message(ed.sheet, ed.cell) {
self.message = Some(("GridCraft".into(), m));
return true;
}
// No code at all: a Python cell is cleared through cell.set, as an empty entry clears any
// other cell (code of spaces is still code). On another cell there is nothing to write.
let r = match (ed.text.is_empty(), python_cell) {
(true, false) => return true,
(true, true) => self.session.run("cell.set", json!({"sheet": ed.sheet, "cell": ed.cell.a1(), "input": ""})),
(false, _) => self.session.run("python.set", json!({"sheet": ed.sheet, "cell": ed.cell.a1(), "code": ed.text})),
};
match r {
Ok(_) => {
self.after_engine();
true
}
Err(e) => {
self.message = Some(("GridCraft".into(), clean_error(&e)));
self.editor = Some(ed);
self.session.mode = gridcraft_engine::Mode::Edit;
false
}
}
}
/// Enter/Tab move inside a multi-cell selection, otherwise to the next cell.
pub fn move_after_enter(&mut self, dr: i64, dc: i64) {
// A selection that is just one merged cell moves like one cell (Enter leaves it).
let multi = self
.session
.active()
.is_some_and(|d| !d.selection.is_single_cell() && !d.wb.active().is_some_and(|sh| d.selection.is_one_merged_cell(sh)));
// Any other move (arrows, clicks, another sheet) leaves the selection off the cell the
// last Tab landed on, which ends the run.
let here = self.session.active().map(|d| (d.uid, d.wb.active_sheet(), d.selection.active));
let run = self.tab_run.take().filter(|&(uid, sheet, _, at)| here == Some((uid, sheet, at)));
if multi {
let fwd = dr > 0 || dc > 0;
let _ = self.session.run("selection.next", json!({"forward": fwd, "byRow": dc != 0}));
} else if let (Some((_, _, col, at)), 1, 0) = (run, dr, dc) {
let back = i64::from(col) - i64::from(at.col);
let _ = self.session.run("selection.move", json!({"dr": 1, "dc": back}));
} else {
let _ = self.session.run("selection.move", json!({"dr": dr, "dc": dc}));
if dr == 0 && dc != 0 {
let start = run.map(|r| r.2);
self.tab_run = self.session.active().and_then(|d| {
let (uid, sheet) = (d.uid, d.wb.active_sheet());
let col = start.or(here.map(|h| h.2.col))?;
Some((uid, sheet, col, d.selection.active))
});
}
}
self.grid.ensure_visible = true;
}
}
#[cfg(test)]
mod protected_cell_tests {
use super::*;
use gridcraft_engine::Session;
use gridcraft_engine::core::{CellRef, Value};
/// A protected sheet whose C2 is unlocked; C2 holds "keep" as the last undo step.
fn protected_book() -> SheetApp {
let mut session = Session::new();
session.new_workbook();
let mut app = SheetApp::new(session, Default::default());
app.run("cell.set", json!({"cell": "C2", "input": "keep"})).unwrap();
app.run("home.formatCells", json!({"range": "C2", "style": {"protection": {"locked": false}}})).unwrap();
app.run("review.protectSheet", json!({})).unwrap();
app
}
fn value(app: &SheetApp, a1: &str) -> Value {
let at = CellRef::parse(a1).unwrap();
app.session.active().and_then(|d| d.wb.sheet(0)).map(|sh| sh.value(at)).unwrap_or_default()
}
fn protected_message(app: &SheetApp) -> Option<&str> {
app.message.as_ref().map(|(_, m)| m.as_str())
}
#[test]
fn typing_in_a_locked_cell_does_not_leave_a_draft_that_blocks_undo_and_save() {
let mut app = protected_book();
assert_eq!(app.session.active().unwrap().selection.active.a1(), "A1", "the locked A1 is the active cell");
let undo = app.session.active().unwrap().undo.len();
let dirty = app.session.active().unwrap().is_dirty();
app.begin_edit(Some("locked".into()), false);
assert!(app.editor.is_none(), "a locked cell must not open an editor");
assert!(protected_message(&app).is_some_and(|m| m.contains("protected sheet")), "the warning names the protected sheet");
assert_eq!(app.session.active().unwrap().undo.len(), undo, "a refused edit adds no undo step");
assert_eq!(app.session.active().unwrap().is_dirty(), dirty, "a refused edit leaves the workbook as it was");
assert!(app.run("file.saveBytes", json!({"format": "xlsx"})).is_ok(), "Save is not blocked by a draft that can never be entered");
}
#[test]
fn an_unlocked_cell_on_a_protected_sheet_still_edits_undoes_and_saves() {
let mut app = protected_book();
app.run("selection.set", json!({"cell": "C2"})).unwrap();
app.begin_edit(Some("typed".into()), false);
assert!(app.editor.is_some(), "an unlocked cell opens its editor");
assert!(app.commit_edit(0, 0, false, false));
assert_eq!(value(&app, "C2"), Value::text("typed"));
assert!(app.run("edit.undo", json!({})).is_ok());
assert_eq!(value(&app, "C2"), Value::text("keep"), "Undo of the typed edit still works");
assert!(app.run("file.saveBytes", json!({"format": "xlsx"})).is_ok());
}
#[test]
fn a_draft_that_becomes_locked_is_cancelled_instead_of_staying_open() {
let mut app = protected_book();
app.run("selection.set", json!({"cell": "C2"})).unwrap();
app.begin_edit(Some("typed".into()), false);
// The sheet is unprotected, C2 locked, and the sheet protected again while the draft is open.
app.run("review.unprotectSheet", json!({})).unwrap();
app.run("home.formatCells", json!({"range": "C2", "style": {"protection": {"locked": true}}})).unwrap();
app.run("review.protectSheet", json!({})).unwrap();
assert!(app.commit_edit(0, 0, false, false), "the refused draft is handled, not left open");
assert!(app.editor.is_none());
assert!(protected_message(&app).is_some_and(|m| m.contains("protected sheet")));
assert_eq!(value(&app, "C2"), Value::text("keep"));
assert!(app.run("file.saveBytes", json!({"format": "xlsx"})).is_ok());
}
}
#[cfg(test)]
mod merged_cell_enter_tests {
use super::*;
use gridcraft_engine::Session;
#[test]
fn enter_and_tab_leave_a_selected_merged_cell_and_keep_the_tab_run() {
let mut session = Session::new();
session.new_workbook();
let mut app = SheetApp::new(session, Default::default());
app.run("selection.set", json!({"range": "B2:C3"})).unwrap();
app.run("home.mergeCells", json!({})).unwrap();
let sel = |app: &SheetApp| app.session.active().map(|d| d.selection.a1()).unwrap_or_default();
for ((dr, dc), want) in [((1, 0), "B4"), ((-1, 0), "B1"), ((0, 1), "D2"), ((0, -1), "A2")] {
app.run("selection.set", json!({"cell": "B2"})).unwrap();
assert_eq!(sel(&app), "B2:C3");
app.move_after_enter(dr, dc);
assert_eq!(sel(&app), want, "Enter/Tab ({dr},{dc}) from the merged cell B2:C3");
}
// A Tab run through the merged cell goes on past it: Enter then goes back to the column
// the run started in, on the next row.
app.tab_run = None; // the Shift+Tab above ended on A2 and started a run there
app.run("selection.set", json!({"cell": "A2"})).unwrap();
app.move_after_enter(0, 1);
assert_eq!(sel(&app), "B2:C3");
app.move_after_enter(0, 1);
assert_eq!(sel(&app), "D2");
app.move_after_enter(1, 0);
assert_eq!(sel(&app), "A3");
// Enter straight from the merged cell in a Tab run leaves it below its bottom edge and
// still goes back to the run's start column.
app.tab_run = None;
app.run("selection.set", json!({"cell": "A2"})).unwrap();
app.move_after_enter(0, 1);
assert_eq!(sel(&app), "B2:C3");
app.move_after_enter(1, 0);
assert_eq!(sel(&app), "A4");
}
#[test]
fn enter_from_a_merged_cell_in_a_tab_run_skips_a_hidden_row_and_keeps_the_column() {
let mut session = Session::new();
session.new_workbook();
let mut app = SheetApp::new(session, Default::default());
app.run("selection.set", json!({"range": "D2:E3"})).unwrap();
app.run("home.mergeCells", json!({})).unwrap();
app.run("selection.set", json!({"range": "A4"})).unwrap();
app.run("home.hideRows", json!({})).unwrap();
let sel = |app: &SheetApp| app.session.active().map(|d| d.selection.a1()).unwrap_or_default();
app.run("selection.set", json!({"cell": "C2"})).unwrap();
app.move_after_enter(0, 1);
assert_eq!(sel(&app), "D2:E3");
// Row 4 is hidden: Enter lands on C5, the run's column, not B5.
app.move_after_enter(1, 0);
assert_eq!(sel(&app), "C5");
}
}
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.