feat(ui): ask to save unsaved changes before quitting or replacing the project

apps/rustgis-web/src/web.rs

@@ -444,7 +444,7 @@ impl eframe::App for WebShell {
             embed.exchange(&mut self.app, ctx);
         }
         self.app.logic(ctx);
-        self.dirty.set(self.app.session.dirty);
+        self.dirty.set(self.app.session.dirty());
         // The shortcuts can be changed in the app: the key listener follows, rebuilt only when
         // the keymap changed.
         let print = self.app.shortcuts_fingerprint();

apps/rustgis/src/main.rs

@@ -391,7 +391,7 @@ fn main() -> eframe::Result {
     for e in open_files(&mut app, &files) {
         eprintln!("rustgis: {e}");
     }
-    app.session.dirty = false;
+    app.session.mark_saved();
     let mut viewport = egui::ViewportBuilder::default()
         .with_title("RustGIS")
         .with_app_id("org.rustgis.RustGIS")

crates/engine/src/cmd/design.rs

@@ -278,7 +278,7 @@ pub fn commands() -> Vec<C> {
                 .iter()
                 .filter_map(|(id, c)| s.map().layer(*id).map(|l| json!({"layer": l.name, "added": c.added, "modified": c.modified, "deleted": c.deleted})))
                 .collect();
-            Ok(json!({"unsaved": s.dirty, "layers": rows}))
+            Ok(json!({"unsaved": s.dirty(), "layers": rows}))
         })
         .view(),
         C::new("edit.template", "Manage Templates", "Edit › Manage Edits", template).when(need_feature_layer).params(

crates/engine/src/cmd/history.rs

@@ -50,7 +50,7 @@ fn script(s: &mut Session, _: &Value) -> CmdResult {
     // there until the project is saved again.
     if s.path.is_none() {
         text.push_str("# The project hasn't been saved yet: save it as this file first.\n");
-    } else if s.dirty {
+    } else if s.dirty() {
         text.push_str("# The project has changes that aren't saved: save it first, so its layers are there.\n");
     }
     text.push_str(&format!("import rustgis\n\ns = rustgis.Session({})\n", quoted(&project_file(s))));

crates/engine/src/cmd/project.rs

@@ -140,10 +140,12 @@ fn open_text(s: &mut Session, p: &Value) -> CmdResult {
     Ok(Value::Null)
 }
 
+/// Saves the project to `path` (`.rgis` added when it has no extension) and makes it the
+/// project's file. The project as it is now is the saved state undo can return to.
 fn write(s: &mut Session, path: PathBuf) -> CmdResult {
     let path = if path.extension().is_none() { path.with_extension(crate::project::EXTENSION) } else { path };
     let stripped = s.project.save(&path)?;
-    s.dirty = false;
+    s.mark_saved();
     s.edit_counts.clear();
     s.notify(format!("Saved {}", path.display()), false);
     if stripped > 0 {
@@ -295,7 +297,7 @@ fn info(s: &mut Session, p: &Value) -> CmdResult {
     Ok(json!({
         "name": s.project.name,
         "path": s.path.as_ref().map(|p| p.display().to_string()),
-        "unsaved": s.dirty,
+        "unsaved": s.dirty(),
         "maps": s.project.maps.iter().map(|m| m.name.clone()).collect::<Vec<_>>(),
         "activeMap": m.name,
         "basemap": m.basemap.code(),

crates/engine/src/lib.rs

@@ -416,8 +416,9 @@ pub struct Notice {
 
 const UNDO_LIMIT: usize = 40;
 
-/// An undo or redo step: the project before it, the layout open then, its label and who made it.
-type Step = (Project, Option<usize>, &'static str, Option<String>);
+/// An undo or redo step: the project before it, the layout open then, its label, who made it,
+/// and which state of the project it is ([`Session::dirty`]).
+type Step = (Project, Option<usize>, &'static str, Option<String>, u64);
 
 /// What a project holds in the session beside itself: what [`Session::clear_history`] forgets
 /// when another project starts, and what opening one sets (its file, layer, tool…). When another
@@ -436,7 +437,8 @@ struct PutAside {
     /// The projection those cameras are in: without it, the extent history given back would be
     /// taken for another projection's and cleared.
     history_projection: String,
-    dirty: bool,
+    state: u64,
+    saved: Option<u64>,
     trusted_tasks: std::collections::HashSet<String>,
     trusted_models: std::collections::HashSet<String>,
     trusted_notebooks: std::collections::HashSet<String>,
@@ -475,7 +477,13 @@ struct PutAside {
 pub struct Session {
     pub project: Project,
     pub path: Option<PathBuf>,
-    pub dirty: bool,
+    /// Which state of the project is open: a new one after each change, an earlier one again
+    /// after undo. Each is given once in a session (`states` counts them).
+    state: u64,
+    states: u64,
+    /// The state last saved, or opened from its file; `None` when no state of the open project is
+    /// (recovered work). The project has unsaved changes while another is open ([`Session::dirty`]).
+    saved: Option<u64>,
     /// Favourite, recent and saved data sources (kept with the app's preferences, not the
     /// project).
     pub sources: sources::Sources,
@@ -703,7 +711,9 @@ impl Session {
         Session {
             project,
             path: None,
-            dirty: false,
+            state: 0,
+            states: 0,
+            saved: Some(0),
             sources: sources::Sources::default(),
             connections: connections::Connections::default(),
             s3_bindings: std::collections::BTreeMap::new(),
@@ -952,6 +962,7 @@ impl Session {
     /// and restored if `f` fails or panics.
     pub(crate) fn guarded(&mut self, label: &'static str, mutates: bool, f: impl FnOnce(&mut Session) -> CmdResult) -> CmdResult {
         let snapshot = mutates.then(|| self.project.clone());
+        let state = self.state;
         // The merge key asked for applies to this command only, whatever it does; and to a
         // command run by itself, not to those it runs.
         let merge = if self.depth == 0 { self.merge.take() } else { None };
@@ -1012,7 +1023,7 @@ impl Session {
                 // back to before the first of them. Only a command run by itself merges.
                 let key = merge;
                 if key.is_none() || key != self.merged || self.undo.is_empty() {
-                    self.undo.push((snap, open_layout, label, self.actor.clone()));
+                    self.undo.push((snap, open_layout, label, self.actor.clone(), state));
                     if self.undo.len() > UNDO_LIMIT {
                         self.undo.remove(0);
                     }
@@ -1021,7 +1032,7 @@ impl Session {
                     self.merged = key;
                 }
                 self.redo.clear();
-                self.dirty = true;
+                self.state = self.new_state();
             }
             (Err(_), Some(snap)) => {
                 // The project as it was before the command, so the layout open then, whatever
@@ -1034,6 +1045,7 @@ impl Session {
                     self.give_back(opened);
                 }
                 self.opened = opened;
+                self.state = state;
                 if let Some(c) = counts {
                     self.edit_counts = c;
                 }
@@ -1090,7 +1102,8 @@ impl Session {
             forward: take(&mut self.forward),
             last_camera: self.last_camera.take(),
             history_projection: self.history_projection.clone(),
-            dirty: std::mem::replace(&mut self.dirty, false),
+            state: self.state,
+            saved: self.saved,
             trusted_tasks: take(&mut self.trusted_tasks),
             trusted_models: take(&mut self.trusted_models),
             trusted_notebooks: take(&mut self.trusted_notebooks),
@@ -1135,7 +1148,8 @@ impl Session {
             forward,
             last_camera,
             history_projection,
-            dirty,
+            state,
+            saved,
             trusted_tasks,
             trusted_models,
             trusted_notebooks,
@@ -1167,7 +1181,8 @@ impl Session {
         } = *a;
         (self.undo, self.redo, self.back, self.forward, self.last_camera) = (undo, redo, back, forward, last_camera);
         self.history_projection = history_projection;
-        (self.dirty, self.project_starts, self.history_from_file) = (dirty, project_starts, history_from_file);
+        (self.state, self.saved) = (state, saved);
+        (self.project_starts, self.history_from_file) = (project_starts, history_from_file);
         (self.trusted_tasks, self.trusted_models, self.trusted_notebooks) = (trusted_tasks, trusted_models, trusted_notebooks);
         (self.active_layer, self.table_layer, self.table_standalone, self.tool) = (active_layer, table_layer, table_standalone, tool);
         (self.layer_selection, self.layer_selection_of) = (layer_selection, layer_selection_of);
@@ -1241,30 +1256,63 @@ impl Session {
     pub fn clear_history(&mut self) {
         drop(self.take_project_state());
         self.project_starts = self.project_starts.wrapping_add(1);
+        // A state of its own: undo back past a replacement made within a command (a task's step)
+        // reaches a state of the project before, which isn't this one's saved state.
+        self.state = self.new_state();
+        self.saved = Some(self.state);
+    }
+
+    /// Whether the project has changes that aren't saved: it is in another state than the one
+    /// last saved or opened. Undo or redo back to that state leaves none.
+    pub fn dirty(&self) -> bool {
+        self.saved != Some(self.state)
+    }
+
+    /// Which state the project is in: another after each change, an earlier one after undo. A
+    /// front end compares it to tell whether the project changed since it last looked.
+    pub fn state(&self) -> u64 {
+        self.state
+    }
+
+    /// The project as it is now is saved (written to its file, or downloaded in the browser).
+    pub fn mark_saved(&mut self) {
+        self.saved = Some(self.state);
+    }
+
+    /// The project has changes that aren't saved, whatever undo does (work recovered after a
+    /// crash: no state of it is in a file).
+    pub fn mark_unsaved(&mut self) {
+        self.saved = None;
+    }
+
+    /// A state of the project not given before in this session, for a change just made.
+    fn new_state(&mut self) -> u64 {
+        self.states = self.states.wrapping_add(1);
+        self.states
     }
 
     pub(crate) fn undo(&mut self) -> bool {
         self.merged = None;
-        let Some((p, saved, label, actor)) = self.undo.pop() else { return false };
+        let Some((p, saved, label, actor, state)) = self.undo.pop() else { return false };
         let (open, was) = (self.open_layout_name(), self.active_layout);
         let cur = std::mem::replace(&mut self.project, p);
         self.project.keep_table_ids(&cur);
         self.reopen_layout(open, saved);
         self.keep_time_position(&cur);
-        self.redo.push((cur, was, label, actor));
+        self.redo.push((cur, was, label, actor, std::mem::replace(&mut self.state, state)));
         self.touch_all_geometry();
         true
     }
 
     pub(crate) fn redo(&mut self) -> bool {
         self.merged = None;
-        let Some((p, saved, label, actor)) = self.redo.pop() else { return false };
+        let Some((p, saved, label, actor, state)) = self.redo.pop() else { return false };
         let (open, was) = (self.open_layout_name(), self.active_layout);
         let cur = std::mem::replace(&mut self.project, p);
         self.project.keep_table_ids(&cur);
         self.reopen_layout(open, saved);
         self.keep_time_position(&cur);
-        self.undo.push((cur, was, label, actor));
+        self.undo.push((cur, was, label, actor, std::mem::replace(&mut self.state, state)));
         self.touch_all_geometry();
         true
     }

crates/engine/src/sample.rs

@@ -46,7 +46,7 @@ fn countries_in(w: Worldview) -> &'static str {
 /// that is unsaved, unchanged and has nothing to undo, and only a layer named `Countries` holding
 /// exactly the built-in countries of `from`. Returns whether a layer was swapped.
 pub fn swap_countries(s: &mut crate::Session, from: Worldview, to: Worldview) -> bool {
-    if from == to || s.dirty || s.path.is_some() || s.can_undo() {
+    if from == to || s.dirty() || s.path.is_some() || s.can_undo() {
         return false;
     }
     let read = |w| read_geojson(countries_in(w), "Countries").ok().map(|(ds, _)| ds);