code polishing

Author: hexqnt

src/app/points_state.rs

@@ -199,6 +199,17 @@ impl CurveFitApp {
         }
     }
 
+    fn finish_valid_points_change(&mut self) {
+        self.clear_fit_outputs();
+        self.refresh_status_after_points_edit();
+        if !matches!(
+            self.status.as_ref(),
+            Some(StatusMessage::Error(message)) if message.starts_with(POINTS_PARSE_ERROR_PREFIX)
+        ) {
+            self.status = Some(self.idle_status_after_points_edit());
+        }
+    }
+
     fn first_visible_points_parse_error(&mut self) -> Option<String> {
         for layer in &mut self.point_layers.layers {
             if !layer.visible {
@@ -248,7 +259,7 @@ impl CurveFitApp {
         edit: F,
     ) -> Result<(), String>
     where
-        F: FnOnce(&mut Vec<Point>),
+        F: FnOnce(&mut Vec<Point>) -> bool,
     {
         let parse_error = match &self.points_cache_with_policy(true).parsed_points {
             Ok(_) => None,
@@ -273,7 +284,9 @@ impl CurveFitApp {
                 Ok(points) => points,
                 Err(error) => return Err(error.clone()),
             };
-            edit(points);
+            if !edit(points) {
+                return Ok(());
+            }
             cache.parse_error_line = None;
             cache.plot_points = points
                 .iter()
@@ -291,7 +304,7 @@ impl CurveFitApp {
             self.selected_points_editor_mut().text_sync_pending = true;
         }
 
-        self.refresh_status_after_points_edit();
+        self.finish_valid_points_change();
 
         Ok(())
     }
@@ -302,6 +315,7 @@ impl CurveFitApp {
         }
         self.selected_points_editor_mut().text = new_text;
         self.invalidate_points_cache();
+        self.clear_fit_outputs();
         if !keep_redo {
             self.selected_points_editor_mut().redo_stack.clear();
         }
@@ -355,16 +369,20 @@ impl CurveFitApp {
     }
 
     pub(super) fn create_point_layer_from_points(&mut self, points: &[Point]) -> PointLayerId {
-        self.point_layers.create_layer_from_points(points)
+        let id = self.point_layers.create_layer_from_points(points);
+        self.finish_valid_points_change();
+        id
     }
 
     pub(super) fn duplicate_selected_point_layer(&mut self) -> PointLayerId {
-        self.point_layers.duplicate_selected_layer()
+        let id = self.point_layers.duplicate_selected_layer();
+        self.finish_valid_points_change();
+        id
     }
 
     pub(super) fn delete_selected_point_layer(&mut self) {
         self.point_layers.delete_selected_layer();
-        self.refresh_status_after_points_edit();
+        self.finish_valid_points_change();
     }
 
     pub(super) fn visible_point_layer_plot_data(&mut self) -> Vec<VisiblePointLayerPlotData> {
@@ -403,7 +421,7 @@ impl CurveFitApp {
         }
         self.selected_points_editor_mut().redo_stack.clear();
         self.set_points_cache_from_valid_points(&[]);
-        self.refresh_status_after_points_edit();
+        self.finish_valid_points_change();
     }
 
     pub(super) fn write_points_text(&mut self, points: &[Point], record_undo: bool) {
@@ -419,7 +437,7 @@ impl CurveFitApp {
         points_state.text = new_text;
         points_state.redo_stack.clear();
         self.set_points_cache_from_valid_points(points);
-        self.refresh_status_after_points_edit();
+        self.finish_valid_points_change();
     }
 
     pub(super) fn can_move_points_to_positive_xy(&mut self) -> bool {

src/app/tests/points_editing.rs

@@ -207,6 +207,34 @@ fn selected_layer_only_editing_preserves_other_layers() {
     );
 }
 
+#[test]
+fn points_data_change_clears_stale_fit_outputs() {
+    let mut app = CurveFitApp {
+        fit_result: Some(FitResult {
+            family: CurveFamily::Linear,
+            params: CurveParams::Linear { a: 1.0, b: 0.0 },
+            mse: 0.0,
+            rmse: 0.0,
+            iterations: 1,
+        }),
+        last_fit_duration: Some(std::time::Duration::from_millis(42)),
+        status: Some(StatusMessage::FitCompleted),
+        ..Default::default()
+    };
+
+    app.write_points_text(
+        &[
+            Point::try_new(10.0, 20.0).unwrap(),
+            Point::try_new(30.0, 40.0).unwrap(),
+        ],
+        false,
+    );
+
+    assert!(app.fit_result.is_none());
+    assert!(app.last_fit_duration.is_none());
+    assert!(matches!(app.status, Some(StatusMessage::Ready)));
+}
+
 #[test]
 fn duplicate_layer_copies_points_and_selects_copy() {
     let mut app = CurveFitApp::default();

src/app/ui/plot_panel.rs

@@ -13,6 +13,7 @@ pub(super) fn add_point_from_plot(app: &mut CurveFitApp, x: f64, y: f64, record_
 
     if let Err(error) = app.edit_valid_points_in_cache(record_undo, false, move |points| {
         points.push(point);
+        true
     }) {
         app.status = Some(StatusMessage::Error(error));
     }
@@ -46,6 +47,7 @@ pub(super) fn spray_points_from_plot(
 
     if let Err(error) = app.edit_valid_points_in_cache(false, false, |points| {
         points.extend(generated_points);
+        true
     }) {
         app.status = Some(StatusMessage::Error(error));
     }
@@ -63,11 +65,13 @@ pub(super) fn erase_points_from_plot(
     }
 
     if let Err(error) = app.edit_valid_points_in_cache(false, false, |points| {
+        let previous_len = points.len();
         points.retain(|point| {
             let dx = (point.x() - center_x) / radius_x;
             let dy = (point.y() - center_y) / radius_y;
             dx * dx + dy * dy > 1.0
         });
+        points.len() != previous_len
     }) {
         app.status = Some(StatusMessage::Error(error));
     }

src/app/ui/points_editor_panel.rs

@@ -602,6 +602,8 @@ pub(super) fn ui_points_editor(app: &mut CurveFitApp, ui: &mut egui::Ui) {
                 app.push_points_undo_snapshot(before_edit);
                 app.selected_points_editor_mut().redo_stack.clear();
                 app.invalidate_points_cache();
+                app.clear_fit_outputs();
+                app.status = Some(StatusMessage::Ready);
             }
         });