增加类似Vs code的搜索统计功能。

Author: lieta-king

crates/edit/src/bin/edit/draw_editor.rs

@@ -77,7 +77,13 @@ fn draw_search(ctx: &mut Context, state: &mut State) {
         {
             {
                 ctx.table_next_row();
-                ctx.label("label", loc(LocId::SearchNeedleLabel));
+                
+                let label_text = if let Some((idx, total)) = state.search_count {
+                    format!("{} ({}/{})", loc(LocId::SearchNeedleLabel), idx, total)
+                } else {
+                    loc(LocId::SearchNeedleLabel).to_string()
+                };
+                ctx.label("label", &label_text);
 
                 if ctx.editline("needle", &mut state.search_needle) {
                     action = Some(SearchAction::Search);
@@ -174,7 +180,7 @@ pub fn search_execute(ctx: &mut Context, state: &mut State, action: SearchAction
         return;
     };
 
-    state.search_success = match action {
+    let result = match action {
         SearchAction::Search => {
             doc.buffer.borrow_mut().find_and_select(&state.search_needle, state.search_options)
         }
@@ -188,8 +194,18 @@ pub fn search_execute(ctx: &mut Context, state: &mut State, action: SearchAction
             state.search_options,
             state.search_replacement.as_bytes(),
         ),
+    };
+
+    match result {
+        Ok(count) => {
+            state.search_success = true;
+            state.search_count = count;
+        }
+        Err(_) => {
+            state.search_success = false;
+            state.search_count = None;
+        }
     }
-    .is_ok();
 
     ctx.needs_rerender();
 }

crates/edit/src/bin/edit/state.rs

@@ -151,6 +151,8 @@ pub struct State {
     pub search_replacement: String,
     pub search_options: buffer::SearchOptions,
     pub search_success: bool,
+    // (current_index, total_count)
+    pub search_count: Option<(usize, usize)>,
 
     pub wants_encoding_picker: bool,
     pub wants_encoding_change: StateEncodingChange,
@@ -199,6 +201,7 @@ impl State {
             search_replacement: Default::default(),
             search_options: Default::default(),
             search_success: true,
+            search_count: None,
 
             wants_encoding_picker: false,
             encoding_picker_needle: Default::default(),

crates/edit/src/buffer/mod.rs

@@ -125,10 +125,11 @@ struct ActiveSearch {
     /// created. When the user manually selects text, we need to
     /// refresh the [`ActiveSearch::pattern`] with it.
     selection_generation: u32,
-    /// Stores the text buffer offset in between searches.
-    next_search_offset: usize,
-    /// If we know there were no hits, we can skip searching.
-    no_matches: bool,
+    
+    /// All found matches in the buffer.
+    matches: Vec<Range<usize>>,
+    /// The index of the currently selected match in `matches`.
+    current_match_index: Option<usize>,
 }
 
 /// Options for a search operation.
@@ -1080,7 +1081,7 @@ impl TextBuffer {
     }
 
     /// Find the next occurrence of the given `pattern` and select it.
-    pub fn find_and_select(&mut self, pattern: &str, options: SearchOptions) -> apperr::Result<()> {
+    pub fn find_and_select(&mut self, pattern: &str, options: SearchOptions) -> apperr::Result<Option<(usize, usize)>> {
         if let Some(search) = &mut self.search {
             let search = search.get_mut();
             // When the search input changes we must reset the search.
@@ -1097,7 +1098,7 @@ impl TextBuffer {
         }
 
         if pattern.is_empty() {
-            return Ok(());
+            return Ok(None);
         }
 
         let search = match &self.search {
@@ -1109,18 +1110,19 @@ impl TextBuffer {
             }
         };
 
-        // If we previously searched through the entire document and found 0 matches,
-        // then we can avoid searching again.
-        if search.no_matches {
-            return Ok(());
+        if search.matches.is_empty() {
+            return Ok(Some((0, 0)));
         }
 
         // If the user moved the cursor since the last search, but the needle remained the same,
         // we still need to move the start of the search to the new cursor position.
         let next_search_offset = match self.selection {
             Some(TextBufferSelection { beg, end }) => {
                 if self.selection_generation == search.selection_generation {
-                    search.next_search_offset
+                    // search.next_search_offset was removed.
+                    // If we have a valid selection from previous search, start after it.
+                    let p = beg.max(end);
+                    self.cursor_move_to_logical_internal(self.cursor, p).offset
                 } else {
                     self.cursor_move_to_logical_internal(self.cursor, beg.min(end)).offset
                 }
@@ -1129,7 +1131,12 @@ impl TextBuffer {
         };
 
         self.find_select_next(search, next_search_offset, true);
-        Ok(())
+        
+        if let Some(idx) = search.current_match_index {
+            Ok(Some((idx + 1, search.matches.len())))
+        } else {
+            Ok(Some((0, search.matches.len())))
+        }
     }
 
     /// Find the next occurrence of the given `pattern` and replace it with `replacement`.
@@ -1138,7 +1145,7 @@ impl TextBuffer {
         pattern: &str,
         options: SearchOptions,
         replacement: &[u8],
-    ) -> apperr::Result<()> {
+    ) -> apperr::Result<Option<(usize, usize)>> {
         // Editors traditionally replace the previous search hit, not the next possible one.
         if let (Some(search), Some(..)) = (&self.search, &self.selection) {
             let search = unsafe { &mut *search.get() };
@@ -1161,7 +1168,7 @@ impl TextBuffer {
         pattern: &str,
         options: SearchOptions,
         replacement: &[u8],
-    ) -> apperr::Result<()> {
+    ) -> apperr::Result<Option<(usize, usize)>> {
         let scratch = scratch_arena(None);
         let mut search = self.find_construct_search(pattern, options)?;
         let mut offset = 0;
@@ -1179,7 +1186,7 @@ impl TextBuffer {
             offset = self.cursor.offset;
         }
 
-        Ok(())
+        Ok(None)
     }
 
     fn find_construct_search(
@@ -1228,7 +1235,13 @@ impl TextBuffer {
         // or otherwise to the current cursor position.
 
         let text = unsafe { icu::Text::new(self)? };
-        let regex = unsafe { icu::Regex::new(&sanitized_pattern, flags, &text)? };
+        let mut regex = unsafe { icu::Regex::new(&sanitized_pattern, flags, &text)? };
+
+        let mut matches = Vec::new();
+        regex.reset(0);
+        while let Some(range) = regex.next() {
+            matches.push(range);
+        }
 
         Ok(ActiveSearch {
             pattern: pattern.to_string(),
@@ -1237,50 +1250,62 @@ impl TextBuffer {
             regex,
             buffer_generation: self.buffer.generation(),
             selection_generation: 0,
-            next_search_offset: 0,
-            no_matches: false,
+            matches,
+            current_match_index: None,
         })
     }
 
     fn find_select_next(&mut self, search: &mut ActiveSearch, offset: usize, wrap: bool) {
         if search.buffer_generation != self.buffer.generation() {
             unsafe { search.regex.set_text(&mut search.text, offset) };
             search.buffer_generation = self.buffer.generation();
-            search.next_search_offset = offset;
-        } else if search.next_search_offset != offset {
-            search.next_search_offset = offset;
-            search.regex.reset(offset);
+            
+            search.matches.clear();
+            search.regex.reset(0);
+            while let Some(range) = search.regex.next() {
+                search.matches.push(range);
+            }
+            search.current_match_index = None;
+        } 
+        
+        if search.matches.is_empty() {
+            search.current_match_index = None;
+            self.set_selection(None);
+            return;
         }
 
-        let mut hit = search.regex.next();
-
-        // If we hit the end of the buffer, and we know that there's something to find,
-        // start the search again from the beginning (= wrap around).
-        if wrap && hit.is_none() && search.next_search_offset != 0 {
-            search.next_search_offset = 0;
-            search.regex.reset(0);
-            hit = search.regex.next();
+        // Find match >= offset
+        let idx_res = search.matches.binary_search_by_key(&offset, |r| r.start);
+        let start_idx = match idx_res {
+             Ok(i) => i, 
+             Err(i) => i,
+        };
+        
+        let mut next_idx = None;
+        if start_idx < search.matches.len() {
+             next_idx = Some(start_idx);
+        } else if wrap {
+             next_idx = Some(0);
         }
 
-        search.selection_generation = if let Some(range) = hit {
-            // Now the search offset is no more at the start of the buffer.
-            search.next_search_offset = range.end;
+        if let Some(idx) = next_idx {
+            search.current_match_index = Some(idx);
+            let range = search.matches[idx].clone();
 
             let beg = self.cursor_move_to_offset_internal(self.cursor, range.start);
             let end = self.cursor_move_to_offset_internal(beg, range.end);
 
             unsafe { self.set_cursor(end) };
             self.make_cursor_visible();
 
-            self.set_selection(Some(TextBufferSelection {
+            search.selection_generation = self.set_selection(Some(TextBufferSelection {
                 beg: beg.logical_pos,
                 end: end.logical_pos,
-            }))
+            }));
         } else {
-            // Avoid searching through the entire document again if we know there's nothing to find.
-            search.no_matches = true;
-            self.set_selection(None)
-        };
+            search.current_match_index = None;
+            self.set_selection(None);
+        }
     }
 
     fn find_parse_replacement<'a>(