fix: edit history

lbqh · kasonyang · commit 1c10c067f869 · 2025-12-04T23:44:22.000+08:00
diff --git a/lib.js b/lib.js
@@ -1844,6 +1844,22 @@ export class TextEditElement extends Element {
         return TextEdit_get_placeholder(this.handle);
     }
 
+    /**
+     *
+     * @returns {number}
+     */
+    get maxHistory() {
+        return TextEdit_get_max_history(this.handle);
+    }
+
+    /**
+     *
+     * @param maxHistory {number}
+     */
+    set maxHistory(maxHistory) {
+        TextEdit_set_max_history(this.handle, maxHistory);
+    }
+
     /**
      *
      * @param start {number}
diff --git a/src/element/common/editable.rs b/src/element/common/editable.rs
@@ -2,7 +2,7 @@ use crate as deft;
 use crate::app::AppEvent;
 use crate::base::{Callback, EventContext, Rect};
 use crate::canvas_util::CanvasHelper;
-use crate::element::edit_history::{EditHistory, EditOpType};
+use crate::element::edit_history::{EditDetail, EditHistory};
 use crate::element::util::is_form_event;
 use crate::element::{Element, ElementBackend, ElementWeak};
 use crate::event::{BlurEvent, BoundsChangeEvent, CaretChangeEvent, Event, FocusEvent, KeyDownEvent, KeyEventDetail, MouseDownEvent, MouseLeaveEvent, PreeditEvent, ScrollEvent, TextChangeEvent, TextInputEvent, TextUpdateEvent, KEY_MOD_CTRL, KEY_MOD_SHIFT};
@@ -186,6 +186,14 @@ impl Editable {
             ele.remove_attribute("disabled".to_string());
         }
     }
+    
+    pub fn set_max_history(&mut self, max_history: usize) {
+        self.edit_history.set_max_history(max_history);
+    }
+    
+    pub fn get_max_history(&self) -> usize {
+        self.edit_history.get_max_history()
+    }
 
     fn get_caret_pixels_position(&self) -> Option<Rect> {
         let element = self.element.upgrade_mut().ok()?;
@@ -354,7 +362,7 @@ impl Editable {
                 match nk {
                     NamedKey::Backspace => {
                         let end = self.paragraph.get_caret();
-                        if self.paragraph.get_selection().is_none() {
+                        if self.paragraph.get_selection().is_empty() {
                             if end.0 > 0 || end.1 > 0 {
                                 self.move_caret(-1);
                                 let start = self.paragraph.get_caret();
@@ -412,20 +420,35 @@ impl Editable {
                     _ => {}
                 }
             }
+        } else if event.modifiers == KEY_MOD_CTRL | KEY_MOD_SHIFT {
+            if let Some(text) = &event.key_str {
+                match text.to_lowercase().as_str() {
+                    "z" => {
+                        self.redo();
+                    }
+                    _ => {}
+                }
+            }
         }
     }
 
     fn undo(&mut self) {
-        if let Some(op) = &self.edit_history.undo() {
-            match op.op {
-                EditOpType::Insert => {
-                    //TODO self.insert_text(op.content.as_str(), op.caret, false);
-                }
-                EditOpType::Delete => {
-                    //TODO self.base.select(op.caret, op.caret + op.content.chars_count());
-                    //TODO self.insert_text("", op.caret, false);
-                }
+        if let Some(op) = self.edit_history.undo() {
+            if let Some(insert) = op.insert {
+                self.paragraph.select(op.caret, insert.end);
+            }
+            let delete_content = op.delete.map(|it| it.content).unwrap_or_else(String::new);
+            self.insert_text(&delete_content, op.caret, false);
+        }
+    }
+
+    fn redo(&mut self) {
+        if let Some(op) = self.edit_history.redo() {
+            if let Some(delete) = op.delete {
+                self.paragraph.select(op.caret, delete.end);
             }
+            let insert_content = op.insert.map(|it| it.content).unwrap_or_else(String::new);
+            self.insert_text(&insert_content, op.caret, false);
         }
     }
 
@@ -456,12 +479,12 @@ impl Editable {
     }
 
     fn insert_text(&mut self, input: &str, mut caret: TextCoord, record_history: bool) {
-        if let Some((start, end)) = self.paragraph.get_selection() {
-            if record_history {
-                // let text= self.paragraph.get_selection_text().unwrap();
-                //TODO self.edit_history.record_delete(begin, &text);
-            }
-
+        let mut delete_detail = None;
+        let mut insert_detail = None;
+        let selection = self.paragraph.get_selection();
+        if !selection.is_empty() {
+            let (start, end) = selection.normalize();
+            let selected_text = self.paragraph.get_selection_text().unwrap_or(String::new());
             if start.0 == end.0 {
                 let line_text = self.paragraph.get_line_text(start.0).unwrap();
                 let left = line_text.substring(0, start.1);
@@ -487,11 +510,15 @@ impl Editable {
             self.paragraph.unselect();
             self.update_caret_value(start, false);
             caret = start;
+            if start != end {
+                delete_detail = Some(EditDetail {
+                    content: selected_text,
+                    end,
+                });
+            }
         }
+        let start_caret = caret;
         if !input.is_empty() {
-            if record_history {
-                //TODO self.edit_history.record_input(caret, input);
-            }
             let line_text = self.paragraph.get_line_text(caret.0).unwrap();
             let left_str = line_text.substring(0, caret.1);
             let right_str = line_text.substring(caret.1, line_text.len() - caret.1);
@@ -526,6 +553,14 @@ impl Editable {
             };
             //TODO maybe update caret twice?
             self.update_caret_value(new_caret, false);
+            insert_detail = Some(EditDetail {
+                content: input.to_string(),
+                end: self.paragraph.get_caret(),
+            });
+        }
+
+        if record_history {
+            self.edit_history.record_input(start_caret, delete_detail, insert_detail);
         }
 
         // emit text update
@@ -768,7 +803,7 @@ impl ElementBackend for Editable {
             align: TextAlign::Left,
             multiple_line: false,
             element: ele.as_weak(),
-            edit_history: EditHistory::new(),
+            edit_history: EditHistory::new(10),
             rows: 5,
             disabled: false,
             line_height: None,
diff --git a/src/element/edit_history.rs b/src/element/edit_history.rs
@@ -1,15 +1,17 @@
-use crate::string::StringUtils;
+use crate::some_or_return;
+use crate::text::textbox::TextCoord;
 
-#[derive(PartialEq, Eq)]
-pub enum EditOpType {
-    Insert,
-    Delete,
+#[derive(Clone, Debug)]
+pub struct EditDetail {
+    pub content: String,
+    pub end: TextCoord,
 }
 
+#[derive(Clone, Debug)]
 pub struct EditOp {
-    pub caret: usize,
-    pub op: EditOpType,
-    pub content: String,
+    pub caret: TextCoord,
+    pub delete: Option<EditDetail>,
+    pub insert: Option<EditDetail>,
 }
 
 pub struct EditHistory {
@@ -19,30 +21,36 @@ pub struct EditHistory {
 }
 
 impl EditHistory {
-    pub fn new() -> Self {
+    pub fn new(max_history: usize) -> Self {
         EditHistory {
             history: Vec::new(),
             history_ptr: 0,
-            max_history: 20,
+            max_history,
         }
     }
 
-    pub fn record_input(&mut self, caret: usize, content: &str) {
-        if !self.merge_input(caret, content) {
-            self.push_op(EditOp {
-                caret,
-                op: EditOpType::Insert,
-                content: content.to_string(),
-            });
-        }
+    pub fn set_max_history(&mut self, max_history: usize) {
+        self.max_history = max_history;
+    }
+    
+    pub fn get_max_history(&self) -> usize {
+        self.max_history
     }
 
-    pub fn record_delete(&mut self, caret: usize, content: &str) {
-        if !self.merge_delete(caret, content) {
+    pub fn record_input(
+        &mut self,
+        caret: TextCoord,
+        delete_detail: Option<EditDetail>,
+        insert_detail: Option<EditDetail>,
+    ) {
+        if self.max_history == 0 || (delete_detail.is_none() && insert_detail.is_none()) {
+            return;
+        }
+        if !self.merge_input(caret, &delete_detail, &insert_detail) {
             self.push_op(EditOp {
                 caret,
-                op: EditOpType::Delete,
-                content: content.to_string(),
+                delete: delete_detail,
+                insert: insert_detail,
             });
         }
     }
@@ -53,55 +61,55 @@ impl EditHistory {
         }
         let prev_op = unsafe { self.history.get_unchecked(self.history_ptr - 1) };
         self.history_ptr -= 1;
-        let op = match prev_op.op {
-            EditOpType::Insert => EditOp {
-                caret: prev_op.caret,
-                op: EditOpType::Delete,
-                content: prev_op.content.to_string(),
-            },
-            EditOpType::Delete => EditOp {
-                caret: prev_op.caret,
-                op: EditOpType::Insert,
-                content: prev_op.content.to_string(),
-            },
-        };
-        Some(op)
+        Some(prev_op.clone())
     }
 
-    fn merge_input(&mut self, op_caret: usize, content: &str) -> bool {
-        if self.history_ptr == 0 || self.history_ptr != self.history.len() {
-            return false;
-        }
-        let last_op = unsafe { self.history.get_unchecked_mut(self.history_ptr - 1) };
-        if last_op.op == EditOpType::Insert
-            && last_op.caret + last_op.content.chars_count() == op_caret
-        {
-            last_op.content.push_str(content);
-            true
-        } else {
-            false
+    pub fn redo(&mut self) -> Option<EditOp> {
+        if self.history.is_empty() || self.history_ptr >= self.history.len() {
+            return None;
         }
+        let next_op = unsafe { self.history.get_unchecked(self.history_ptr) };
+        self.history_ptr += 1;
+        Some(next_op.clone())
     }
 
-    fn merge_delete(&mut self, op_caret: usize, content: &str) -> bool {
+    fn merge_input(
+        &mut self,
+        caret: TextCoord,
+        delete_detail: &Option<EditDetail>,
+        insert_detail: &Option<EditDetail>,
+    ) -> bool {
         if self.history_ptr == 0 || self.history_ptr != self.history.len() {
             return false;
         }
         let last_op = unsafe { self.history.get_unchecked_mut(self.history_ptr - 1) };
-        if last_op.op != EditOpType::Delete {
-            return false;
-        }
-        if last_op.caret + last_op.content.chars_count() == op_caret {
-            last_op.content.push_str(content);
-            true
-        } else if op_caret + content.chars_count() == last_op.caret {
-            last_op.caret = op_caret;
-            let mut content = content.to_string();
-            content.push_str(&last_op.content);
-            last_op.content = content;
-            true
-        } else {
-            false
+        match (
+            delete_detail,
+            insert_detail,
+            &mut last_op.delete,
+            &mut last_op.insert,
+        ) {
+            (None, Some(insert_detail), None, Some(last_insert)) => {
+                if last_insert.end == caret
+                    && !Self::starts_with_whitespace(&insert_detail.content)
+                {
+                    last_insert.content.push_str(&insert_detail.content);
+                    last_insert.end = insert_detail.end;
+                    true
+                } else {
+                    false
+                }
+            }
+            (Some(delete_detail), None, Some(last_delete), None) => {
+                if delete_detail.end == last_op.caret {
+                    last_delete.content = format!("{}{}", delete_detail.content, last_delete.content);
+                    last_op.caret = caret;
+                    true
+                } else {
+                    false
+                }
+            }
+            _ => false,
         }
     }
 
@@ -117,4 +125,10 @@ impl EditHistory {
         self.history.push(op);
         self.history_ptr += 1;
     }
+
+    fn starts_with_whitespace(content: &str) -> bool {
+        let first = some_or_return!(content.chars().next(), false);
+        ['\t', '\r', '\n', ' '].contains(&first)
+    }
+
 }
diff --git a/src/element/textedit.rs b/src/element/textedit.rs
@@ -32,6 +32,16 @@ impl TextEdit {
         self.editable.set_placeholder(placeholder);
     }
 
+    #[js_func]
+    pub fn set_max_history(&mut self, max_history: usize) {
+        self.editable.set_max_history(max_history);
+    }
+
+    #[js_func]
+    pub fn get_max_history(&self) -> usize {
+        self.editable.get_max_history()
+    }
+
     #[js_func]
     pub fn get_placeholder(&self) -> String {
         self.editable.get_placeholder()
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,7 +1,6 @@
 #![allow(dead_code)]
 #![allow(deprecated)]
 
-use std::env;
 use crate::app::{App, AppEvent, AppEventPayload, WinitApp};
 use anyhow::{anyhow, Error};
 use measure_time::debug_time;
@@ -99,7 +98,7 @@ pub fn bootstrap(deft_app: App) {
     {
         use ::winit::platform::wayland::EventLoopBuilderExtWayland;
         use ::winit::platform::x11::EventLoopBuilderExtX11;
-        if env::var("DEFT_FORCE_WAYLAND").is_ok() {
+        if std::env::var("DEFT_FORCE_WAYLAND").is_ok() {
             elb.with_wayland();
         } else {
             elb.with_x11();
diff --git a/src/text/textbox.rs b/src/text/textbox.rs
