refactoring

Author: hexqnt

src/app/points_state.rs

@@ -12,6 +12,7 @@ pub(super) struct PointsEditorState {
     pub(super) text: String,
     pub(super) cache: Option<ParsedPointsCache>,
     pub(super) cache_dirty: bool,
+    pub(super) text_sync_pending: bool,
     pub(super) parse_debounce_deadline: Option<Instant>,
     pub(super) undo_stack: Vec<String>,
     pub(super) redo_stack: Vec<String>,
@@ -23,6 +24,7 @@ impl Default for PointsEditorState {
             text: String::new(),
             cache: None,
             cache_dirty: true,
+            text_sync_pending: false,
             parse_debounce_deadline: None,
             undo_stack: Vec::new(),
             redo_stack: Vec::new(),
@@ -33,6 +35,7 @@ impl Default for PointsEditorState {
 impl CurveFitApp {
     pub(super) fn invalidate_points_cache(&mut self) {
         self.points.cache_dirty = true;
+        self.points.text_sync_pending = false;
         // Небольшой debounce уменьшает число парсингов во время быстрого ввода текста.
         self.points.parse_debounce_deadline =
             Some(Instant::now() + Duration::from_millis(POINTS_PARSE_DEBOUNCE_MS));
@@ -59,6 +62,7 @@ impl CurveFitApp {
         if should_parse {
             self.points.cache = Some(parse_points_text_cache(&self.points.text));
             self.points.cache_dirty = false;
+            self.points.text_sync_pending = false;
             self.points.parse_debounce_deadline = None;
         }
         self.points
@@ -130,6 +134,88 @@ impl CurveFitApp {
         }
     }
 
+    pub(super) fn flush_points_text_from_cache_if_pending(&mut self) {
+        if !self.points.text_sync_pending {
+            return;
+        }
+
+        let synced_text = self.points.cache.as_ref().and_then(|cache| {
+            cache
+                .parsed_points
+                .as_ref()
+                .ok()
+                .map(|points| points_to_text(points))
+        });
+        if let Some(synced_text) = synced_text {
+            self.points.text = synced_text;
+        }
+        self.points.text_sync_pending = false;
+    }
+
+    pub(super) fn push_current_points_undo_snapshot(&mut self) {
+        self.flush_points_text_from_cache_if_pending();
+        self.push_points_undo_snapshot(self.points.text.clone());
+    }
+
+    pub(super) fn edit_valid_points_in_cache<F>(
+        &mut self,
+        record_undo: bool,
+        sync_text_immediately: bool,
+        edit: F,
+    ) -> Result<(), String>
+    where
+        F: FnOnce(&mut Vec<Point>),
+    {
+        let parse_error = match &self.points_cache_with_policy(true).parsed_points {
+            Ok(_) => None,
+            Err(error) => Some(error.clone()),
+        };
+        if let Some(error) = parse_error {
+            return Err(error);
+        }
+
+        if record_undo {
+            self.push_current_points_undo_snapshot();
+        }
+        self.points.redo_stack.clear();
+
+        let maybe_synced_text = {
+            let cache = self
+                .points
+                .cache
+                .as_mut()
+                .expect("points cache must be initialized");
+            let points = cache
+                .parsed_points
+                .as_mut()
+                .expect("parse error branch is handled above");
+            edit(points);
+            cache.parse_error_line = None;
+            cache.plot_points = points
+                .iter()
+                .map(|point| PlotPoint::new(point.x(), point.y()))
+                .collect::<Vec<_>>()
+                .into();
+            sync_text_immediately.then(|| points_to_text(points))
+        };
+
+        if let Some(synced_text) = maybe_synced_text {
+            self.points.text = synced_text;
+            self.points.text_sync_pending = false;
+        } else {
+            self.points.text_sync_pending = true;
+        }
+
+        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());
+        }
+
+        Ok(())
+    }
+
     pub(super) fn apply_points_text_change(&mut self, new_text: String, keep_redo: bool) {
         if self.points.text == new_text {
             return;
@@ -160,20 +246,17 @@ impl CurveFitApp {
         let Some(next) = self.points.redo_stack.pop() else {
             return;
         };
-        self.push_points_undo_snapshot(self.points.text.clone());
+        self.push_current_points_undo_snapshot();
         self.apply_points_text_change(next, true);
         self.refresh_status_after_points_edit();
     }
 
-    pub(super) fn parse_points_for_edit(&mut self) -> Result<Vec<Point>, String> {
-        match &self.points_cache_with_policy(true).parsed_points {
-            Ok(points) => Ok(points.clone()),
-            Err(error) => Err(error.clone()),
-        }
-    }
-
     pub(super) fn parse_points_strict(&mut self) -> Result<Points, String> {
-        Points::try_from(self.parse_points_for_edit()?).map_err(|error| error.to_string())
+        let parsed_points = match &self.points_cache_with_policy(true).parsed_points {
+            Ok(points) => points.clone(),
+            Err(error) => return Err(error.clone()),
+        };
+        Points::try_from(parsed_points).map_err(|error| error.to_string())
     }
 
     pub(super) fn set_points_cache_from_valid_points(&mut self, points: &[Point]) {
@@ -189,10 +272,12 @@ impl CurveFitApp {
             plot_points,
         });
         self.points.cache_dirty = false;
+        self.points.text_sync_pending = false;
         self.points.parse_debounce_deadline = None;
     }
 
     pub(super) fn clear_points_text(&mut self, record_undo: bool) {
+        self.flush_points_text_from_cache_if_pending();
         if self.points.text.is_empty() {
             return;
         }
@@ -211,12 +296,13 @@ impl CurveFitApp {
     }
 
     pub(super) fn write_points_text(&mut self, points: &[Point], record_undo: bool) {
+        self.flush_points_text_from_cache_if_pending();
         let new_text = points_to_text(points);
         if self.points.text == new_text {
             return;
         }
         if record_undo {
-            self.push_points_undo_snapshot(self.points.text.clone());
+            self.push_current_points_undo_snapshot();
         }
         self.points.text = new_text;
         self.points.redo_stack.clear();

src/app/ui/plot_panel.rs

@@ -1,22 +1,18 @@
 use super::*;
 
 pub(super) fn add_point_from_plot(app: &mut CurveFitApp, x: f64, y: f64, record_undo: bool) {
-    let mut points = match app.parse_points_for_edit() {
-        Ok(points) => points,
+    let point = match Point::try_new(x, y) {
+        Ok(point) => point,
         Err(error) => {
-            app.status = Some(StatusMessage::Error(error));
+            app.status = Some(StatusMessage::Error(error.to_string()));
             return;
         }
     };
 
-    match Point::try_new(x, y) {
-        Ok(point) => {
-            points.push(point);
-            app.write_points_text(&points, record_undo);
-        }
-        Err(error) => {
-            app.status = Some(StatusMessage::Error(error.to_string()));
-        }
+    if let Err(error) = app.edit_valid_points_in_cache(record_undo, false, move |points| {
+        points.push(point);
+    }) {
+        app.status = Some(StatusMessage::Error(error));
     }
 }
 
@@ -32,24 +28,25 @@ pub(super) fn spray_points_from_plot(
         return;
     }
 
-    let mut points = match app.parse_points_for_edit() {
-        Ok(points) => points,
-        Err(error) => {
-            app.status = Some(StatusMessage::Error(error));
-            return;
-        }
-    };
-
+    let mut generated_points = Vec::with_capacity(points_to_add);
     for _ in 0..points_to_add {
         let [offset_x, offset_y] = app.next_spray_unit_disk_offset();
         let x = center_x + offset_x * radius_x;
         let y = center_y + offset_y * radius_y;
         if let Ok(point) = Point::try_new(x, y) {
-            points.push(point);
+            generated_points.push(point);
         }
     }
 
-    app.write_points_text(&points, false);
+    if generated_points.is_empty() {
+        return;
+    }
+
+    if let Err(error) = app.edit_valid_points_in_cache(false, false, |points| {
+        points.extend(generated_points);
+    }) {
+        app.status = Some(StatusMessage::Error(error));
+    }
 }
 
 pub(super) fn erase_points_from_plot(
@@ -59,25 +56,19 @@ pub(super) fn erase_points_from_plot(
     radius_x: f64,
     radius_y: f64,
 ) {
-    let mut points = match app.parse_points_for_edit() {
-        Ok(points) => points,
-        Err(error) => {
-            app.status = Some(StatusMessage::Error(error));
-            return;
-        }
-    };
-
     if radius_x <= 0.0 || radius_y <= 0.0 {
         return;
     }
 
-    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
-    });
-
-    app.write_points_text(&points, false);
+    if let Err(error) = app.edit_valid_points_in_cache(false, false, |points| {
+        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
+        });
+    }) {
+        app.status = Some(StatusMessage::Error(error));
+    }
 }
 
 fn plot_position_from_screen(
@@ -111,7 +102,7 @@ pub(super) fn handle_plot_tools(app: &mut CurveFitApp, plot_response: &PlotRespo
             .input(|input| input.pointer.button_pressed(egui::PointerButton::Primary));
     if is_continuous_tool && primary_down_on_plot {
         if app.active_tool_bounds.is_none() {
-            app.push_points_undo_snapshot(app.points.text.clone());
+            app.push_current_points_undo_snapshot();
         }
         app.active_tool_bounds
             .get_or_insert(*plot_response.transform.bounds());
@@ -184,6 +175,7 @@ pub(super) fn handle_plot_tools(app: &mut CurveFitApp, plot_response: &PlotRespo
     }
 
     if !(is_continuous_tool && primary_down_on_plot) {
+        app.flush_points_text_from_cache_if_pending();
         app.active_tool_bounds = None;
     }
 }