UI: an unsaved macro-editor draft counts as unsaved work when its workbook closes

crates/ui-egui/src/app/commands.rs

@@ -46,6 +46,11 @@ impl SheetApp {
         if let Some(r) = self.run_ui_command(id, &params) {
             return r;
         }
+        // The macro editor's unsaved draft is part of its workbook: closing the workbook asks
+        // about it first, and goes on once the editor has closed.
+        if matches!(id, "file.close" | "window.close") && crate::macro_editor::ask_before_closing(self, id, &params) {
+            return Ok(json!({"closed": false, "dirty": true, "macroDraft": true}));
+        }
         let before = self.session.active_window();
         let r = self.session.run(id, params);
         if id.starts_with("file.") && self.session.active_window() != before {

crates/ui-egui/src/app/quit.rs

@@ -80,8 +80,9 @@ impl SheetApp {
         true
     }
 
-    /// Quit (the macOS app menu, ⌘Q): commits every window's cell draft as Enter would, then asks
-    /// about each unsaved workbook in its window; Cancel on any of them stops the quit. A draft its
+    /// Quit (the macOS app menu, ⌘Q): commits every window's cell draft as Enter would, lets the
+    /// macro step editor ask about its unsaved steps, then asks about each unsaved workbook in its
+    /// window; Cancel on any of them stops the quit. A draft its
     /// workbook refuses stops the quit too, with its window in front and the reason shown.
     pub fn request_quit(&mut self, ctx: &egui::Context) {
         while let Some(window) = self.parked_window_with_draft() {
@@ -93,6 +94,16 @@ impl SheetApp {
         if self.settle_drafts().is_err() {
             return;
         }
+        // The macro step editor asks about its own unsaved steps and debug run first, as for the
+        // window's close button, in the window it is shown in; once it has closed, the quit goes
+        // on, and Cancel stops it.
+        if let Some(window) = self.window_with_dialog("macroEditor") {
+            if self.ui_window() != Some(window) {
+                self.enter_window(window);
+            }
+            crate::macro_editor::request_close(self, true);
+            return;
+        }
         if let Some(d) = self.dialog.as_mut().filter(|d| d.name() == "saveChanges") {
             // Already asking about a workbook (File › Close): answering it goes on to quit.
             d.values.insert("quit".into(), json!(true));

crates/ui-egui/src/macro_editor.rs

@@ -57,6 +57,9 @@ pub struct Editor {
     pub draft: Macro,
     /// The name the macro is saved under (`None` until it is first saved).
     pub saved_as: Option<String>,
+    /// The name the editor opened with: a new macro that still has it and nothing else counts
+    /// as untouched.
+    pub opened_as: String,
     pub dirty: bool,
     /// The selected row: a step path (`3`, `2.1`, `4.then.1`) or an If branch (`4.then`).
     pub selected: Option<String>,
@@ -79,6 +82,9 @@ pub struct Editor {
     pub close_requested: bool,
     /// The window is quitting: once the editor has closed, the window close goes on.
     pub quit: bool,
+    /// The workbook is closing: once the editor has closed, this command (`file.close` or
+    /// `window.close` with its params) runs again.
+    pub then_close: Option<(String, Json)>,
     /// Asking whether to save before closing.
     pub ask_close: bool,
     /// Start debugging on the first frame (Macros › Step Into).
@@ -523,6 +529,7 @@ pub fn open(app: &mut SheetApp, params: &Json) -> Option<Dialog> {
     let doc = doc.uid;
     app.macros.editor = Some(Editor {
         doc,
+        opened_as: draft.name.clone(),
         draft,
         dirty: saved_as.is_none(),
         saved_as,
@@ -538,6 +545,7 @@ pub fn open(app: &mut SheetApp, params: &Json) -> Option<Dialog> {
         closing: false,
         close_requested: false,
         quit: false,
+        then_close: None,
         ask_close: false,
         start_debug,
         start_check: params["check"].as_bool() == Some(true),
@@ -612,6 +620,50 @@ fn ensure_saved(app: &mut SheetApp, ed: &mut Editor) -> bool {
     if ed.dirty || ed.saved_as.is_none() { save(app, ed) } else { true }
 }
 
+impl Editor {
+    /// The draft holds changes not yet saved into the workbook. A new macro counts once it
+    /// differs from the empty one the editor started with, its name included.
+    pub fn has_unsaved_changes(&self) -> bool {
+        let untouched = Macro { name: self.opened_as.clone(), inputs: vec![NamedInput::default()], ..Default::default() };
+        self.dirty && (self.saved_as.is_some() || self.draft != untouched)
+    }
+}
+
+/// Closing the editor's workbook (File › Close, Cmd+W, the Backstage Close, a window's close
+/// button) while the draft has unsaved changes: the editor asks about them first, as its own
+/// close button does, and the close (`id` with `params`) goes on once the editor has closed;
+/// Cancel keeps both. Closing the window that shows the editor asks too, even when the workbook
+/// stays open in another window. Returns whether the editor was asked. A close of another of the
+/// workbook's windows, or a forced one, goes ahead as before.
+pub fn ask_before_closing(app: &mut SheetApp, id: &str, params: &Json) -> bool {
+    let flag = |k: &str| params.get(k).and_then(Json::as_bool) == Some(true);
+    if flag("force") {
+        return false;
+    }
+    let Some(doc) = app.macros.editor.as_ref().filter(|ed| ed.has_unsaved_changes()).map(|ed| ed.doc) else { return false };
+    let window = match id {
+        "file.close" => app.session.active_window(),
+        "window.close" => gridcraft_engine::Target::from_json(params).ok().and_then(|t| app.session.target_window(t).ok()),
+        _ => None,
+    };
+    let Some(owner) = window.and_then(|w| app.session.window(w)).map(|w| w.doc_uid) else { return false };
+    // The editor asks in the window it is shown in.
+    let Some(home) = app.window_with_dialog("macroEditor") else { return false };
+    let only = app.session.windows().iter().filter(|w| w.doc_uid == owner).count() <= 1;
+    // The workbook closes, or the window that shows the editor does (taking the editor with it).
+    if owner != doc || !(only || (id == "file.close" && flag("document")) || window == Some(home)) {
+        return false;
+    }
+    if app.ui_window() != Some(home) {
+        app.enter_window(home);
+    }
+    if let Some(ed) = app.macros.editor.as_mut() {
+        ed.close_requested = true;
+        ed.then_close = Some((id.to_string(), params.clone()));
+    }
+    true
+}
+
 /// The inputs a run from the editor uses: the first input's example.
 fn run_inputs(ed: &Editor) -> Json {
     match ed.draft.inputs.first() {
@@ -863,7 +915,7 @@ pub fn window(app: &mut SheetApp, ctx: &egui::Context, d: &mut Dialog, open: &mu
         if app.session.macro_debug.is_some() {
             ed.ask_stop = true;
             ed.closing = true;
-        } else if ed.dirty {
+        } else if ed.has_unsaved_changes() {
             ed.ask_close = true;
         } else {
             *open = false;
@@ -882,14 +934,25 @@ pub fn window(app: &mut SheetApp, ctx: &egui::Context, d: &mut Dialog, open: &mu
             restore_home(app, &ed.refs);
         }
         if ed.quit {
-            ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+            // A quit takes over a workbook close waiting on the editor: it asks about every
+            // unsaved workbook itself, and the close replayed after it would act on whichever
+            // workbook the quit is asking about.
+            if app.native_windows {
+                // Each workbook window is a native window whose close button closes only it:
+                // the quit goes on directly.
+                app.continue_quit(ctx);
+            } else {
+                ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+            }
+        } else if let Some((id, params)) = ed.then_close.take() {
+            app.run_or_alert(&id, params);
         }
     }
 }
 
 /// Asks the open step editor to close, as its close button does: it asks about a debug run or
-/// unsaved steps first. With `quit` (the window is closing), the window close goes on once the
-/// editor has closed; a Cancel in its questions keeps both open.
+/// unsaved steps first. With `quit` (the window is closing, or the app is quitting), the close or
+/// quit goes on once the editor has closed; a Cancel in its questions keeps both open.
 pub fn request_close(app: &mut SheetApp, quit: bool) {
     if let Some(ed) = app.macros.editor.as_mut() {
         ed.close_requested = true;
@@ -904,7 +967,7 @@ pub fn close_now(app: &mut SheetApp) -> Result<(), String> {
     if app.session.macro_debug.is_some() {
         return Err("A macro is being debugged: stop it first (macro.debug {\"action\": \"stop\"}).".into());
     }
-    if app.macros.editor.as_ref().is_some_and(|ed| ed.dirty) {
+    if app.macros.editor.as_ref().is_some_and(Editor::has_unsaved_changes) {
         return Err("The macro step editor has unsaved steps: save them or close the editor in its window.".into());
     }
     if let Some(ed) = app.macros.editor.take()
@@ -1018,14 +1081,15 @@ fn prompts(app: &mut SheetApp, ctx: &egui::Context, ed: &mut Editor, open: &mut
                 ed.ask_stop = false;
                 stop(app, ed, keep);
                 if ed.closing {
-                    if ed.dirty { ed.ask_close = true } else { *open = false }
+                    if ed.has_unsaved_changes() { ed.ask_close = true } else { *open = false }
                 }
                 ed.closing = false;
             }
             Some(None) => {
                 ed.ask_stop = false;
                 ed.closing = false;
                 ed.quit = false;
+                ed.then_close = None;
             }
             None => {}
         }
@@ -1054,6 +1118,11 @@ fn prompts(app: &mut SheetApp, ctx: &egui::Context, ed: &mut Editor, open: &mut
                 ed.ask_close = false;
                 if save(app, ed) {
                     *open = false;
+                } else {
+                    // The draft stays open with the reason shown; the workbook is not closed and
+                    // the app does not quit, then or when the editor closes later.
+                    ed.then_close = None;
+                    ed.quit = false;
                 }
             }
             Some(Some(false)) => {
@@ -1063,6 +1132,7 @@ fn prompts(app: &mut SheetApp, ctx: &egui::Context, ed: &mut Editor, open: &mut
             Some(None) => {
                 ed.ask_close = false;
                 ed.quit = false;
+                ed.then_close = None;
             }
             None => {}
         }

crates/ui-egui/src/macro_ui.rs

@@ -181,10 +181,16 @@ pub fn note_result(app: &mut SheetApp, id: &str, params: &Json, v: &Json) {
     app.toast = Some((text, crate::now_ms()));
 }
 
-/// Drops the step editor once its workbook is closed. The editor's dialog stays with its
-/// workbook's window, so it may not be drawn again to notice.
+/// Drops the step editor once its workbook is closed, or once no window shows it (the window it
+/// was shown in closed while the workbook stays open in another). The editor's dialog stays with
+/// its window, so it may not be drawn again to notice.
 pub fn forget_closed_editor(app: &mut SheetApp) {
-    if app.macros.editor.as_ref().is_some_and(|ed| !app.session.documents().iter().any(|d| d.uid == ed.doc)) {
+    if app
+        .macros
+        .editor
+        .as_ref()
+        .is_some_and(|ed| !app.session.documents().iter().any(|d| d.uid == ed.doc) || app.window_with_dialog("macroEditor").is_none())
+    {
         app.macros.editor = None;
         app.grid.macro_overlay = None;
     }

crates/ui-egui/src/window_ui.rs

@@ -139,6 +139,19 @@ impl SheetApp {
         }
     }
 
+    /// The window that shows the dialog `name`: the current one or a parked one. A window that has
+    /// closed shows nothing, even while its parked state is still kept.
+    pub(crate) fn window_with_dialog(&self, name: &str) -> Option<u64> {
+        if self.dialog.as_ref().is_some_and(|d| d.name == name) {
+            return self.ui_window;
+        }
+        self.parked
+            .iter()
+            .filter(|(id, w)| w.dialog.as_ref().is_some_and(|d| d.name == name) && self.session.window(**id).is_some())
+            .map(|(id, _)| *id)
+            .min()
+    }
+
     /// Whether a window other than the current one has a cell or text-box draft open.
     pub fn parked_window_with_draft(&self) -> Option<u64> {
         self.parked.iter().filter(|(_, w)| w.editor.is_some() || w.text_box_editor.is_some()).map(|(id, _)| *id).min()

crates/ui-egui/tests/doc_windows.rs

@@ -420,3 +420,61 @@ fn arrange_all_lays_out_the_native_windows_active_first() {
     let r = |x, y, w, h| craft_window::Rect::new(x, y, w, h);
     assert_eq!(tiled, [r(0.0, 0.0, 500.0, 400.0), r(500.0, 0.0, 500.0, 400.0), r(0.0, 400.0, 1000.0, 400.0)]);
 }
+
+#[test]
+fn quit_with_the_macro_editor_open_goes_on_once_the_editor_has_closed() {
+    let mut desk = Desk::new(false);
+    desk.app.run("macro.save", json!({"macro": {"name": "Kept", "steps": []}})).unwrap();
+    let d = desk.app.session.active_mut().unwrap();
+    d.saved = d.wb.clone();
+    desk.app.open_dialog("macroEditor", json!({"macro": "Kept"}));
+    desk.frames(3);
+    assert!(desk.app.macros.editor.is_some());
+    // The editor has nothing unsaved, so it closes; then the quit goes on as the app's quit, not
+    // as the editor window's close button (which would close only that workbook's window).
+    let mut sent = desk.frame_with(|app, ctx| app.request_quit(ctx));
+    sent.extend(desk.frames(2));
+    assert!(desk.app.macros.editor.is_none());
+    assert!(desk.app.allow_close, "the quit goes on: {sent:?}");
+    assert!(sent_to(&sent, ViewportId::ROOT, &ViewportCommand::Close), "{sent:?}");
+    assert_eq!(desk.app.session.documents().len(), 1, "the workbook was not closed on its own");
+}
+
+#[test]
+fn quit_takes_over_a_workbook_close_waiting_on_the_macro_editor() {
+    let mut desk = Desk::new(false);
+    let w1 = desk.window_of(0);
+    desk.app.open_dialog("macroEditor", json!({}));
+    desk.frames(3);
+    if let Some(ed) = desk.app.macros.editor.as_mut() {
+        ed.draft.steps.push(gridcraft_engine::model::Step::command("cell.set", json!({"cell": "A1", "input": "7"})));
+        ed.dirty = true;
+    }
+    desk.frames(2);
+    // Book2 has unsaved changes; Book1, with the editor, is saved.
+    desk.app.run("file.new", json!({})).unwrap();
+    desk.app.run("cell.set", json!({"cell": "A1", "input": "2"})).unwrap();
+    desk.frames(3);
+    let w2 = desk.window_of(1);
+    desk.app.enter_window(w1);
+    desk.frames(2);
+    // File › Close on Book1 waits on the editor's question; then Quit takes over.
+    let r = desk.app.run("file.close", json!({})).unwrap();
+    assert_eq!(r["closed"], false);
+    desk.frames(3);
+    desk.frame_with(|app, ctx| app.request_quit(ctx));
+    // Don't Save (the question's answer closes the editor without saving).
+    if let Some(ed) = desk.app.macros.editor.as_mut() {
+        ed.ask_close = false;
+        ed.dirty = false;
+        ed.close_requested = true;
+    }
+    desk.frames(3);
+    assert!(desk.app.macros.editor.is_none());
+    // The quit asks about Book2 in its window, as the quit's question, not as a File › Close.
+    assert_eq!(desk.app.session.active_window(), Some(w2));
+    let d = desk.app.dialog.as_ref().expect("Book2 is asked about");
+    assert_eq!(d.name(), "saveChanges");
+    assert_eq!(d.values.get("quit"), Some(&json!(true)), "{:?}", d.values);
+    assert_eq!(desk.app.session.documents().len(), 2, "nothing closed before the answer");
+}