//! The "Find in files" tab. use std::collections::HashSet; use std::path::PathBuf; use std::sync::Arc; use std::sync::atomic::Ordering; use egui::text::LayoutJob; use egui::{Key, RichText, TextFormat, Ui}; use crate::grep::{self, GrepOptions, GrepShared}; use crate::job::{Generation, Notify}; use crate::passes::SearchQuery; use crate::ui::log_tab::{fmt_num, fmt_size}; use crate::ui::palette; pub enum GrepAction { Open { path: PathBuf, offset: u64, query: SearchQuery }, Status(String), } #[derive(Clone, Copy)] enum Row { File(usize), Hit(usize, usize), } pub struct GrepTab { pub opts: GrepOptions, folder_text: String, max_mb_text: String, generation: Generation, shared: Option>, /// The query the current results were produced with. ran: Option, error: Option, collapsed: HashSet, rows: Vec, rows_key: (usize, usize), selected: Option, notify: Notify, } impl GrepTab { pub fn new(folder: Option, notify: Notify) -> Self { let opts = GrepOptions { folder: folder.unwrap_or_default(), ..Default::default() }; Self { folder_text: opts.folder.display().to_string(), max_mb_text: String::new(), opts, generation: Generation::new(), shared: None, ran: None, error: None, collapsed: HashSet::new(), rows: Vec::new(), rows_key: (usize::MAX, 0), selected: None, notify, } } pub fn title(&self) -> String { match self.opts.folder.file_name() { Some(n) => format!("Find in {}", n.to_string_lossy()), None => "Find in files".into(), } } pub fn set_folder(&mut self, folder: PathBuf) { self.folder_text = folder.display().to_string(); self.opts.folder = folder; } pub fn start(&mut self) { self.opts.folder = PathBuf::from(self.folder_text.trim()); self.opts.max_file_mb = self.max_mb_text.trim().parse().unwrap_or(0); self.error = None; self.collapsed.clear(); self.selected = None; self.rows_key = (usize::MAX, 0); if self.opts.query.text.is_empty() { self.error = Some("Enter a pattern".into()); return; } if !self.opts.folder.is_dir() { self.error = Some(format!("{} is not a folder", self.opts.folder.display())); return; } match grep::spawn(self.opts.clone(), self.generation.bump(), self.notify.clone()) { Ok(s) => { self.shared = Some(s); self.ran = Some(self.opts.clone()); } Err(e) => self.error = Some(format!("{e:#}")), } } pub fn cancel(&mut self) { self.generation.cancel(); } fn rebuild_rows(&mut self, files: &[grep::FileResult]) { let key = (files.len(), self.collapsed.len()); if key == self.rows_key { return; } self.rows_key = key; self.rows.clear(); for (fi, f) in files.iter().enumerate() { self.rows.push(Row::File(fi)); if !self.collapsed.contains(&fi) { self.rows.extend((0..f.hits.len()).map(|hi| Row::Hit(fi, hi))); } } } pub fn show(&mut self, ui: &mut Ui) -> Vec { let mut actions = Vec::new(); egui::Panel::top("grep_inputs").show(ui, |ui| self.inputs(ui, &mut actions)); egui::CentralPanel::default().show(ui, |ui| self.results(ui, &mut actions)); actions } fn inputs(&mut self, ui: &mut Ui, _actions: &mut [GrepAction]) { let mut go = false; egui::Grid::new("grep_grid").num_columns(2).spacing([8.0, 4.0]).show(ui, |ui| { ui.label("Folder"); ui.horizontal(|ui| { ui.add(egui::TextEdit::singleline(&mut self.folder_text).desired_width(420.0)); if ui.button("Browse…").clicked() && let Some(d) = rfd::FileDialog::new().pick_folder() { self.folder_text = d.display().to_string(); } }); ui.end_row(); ui.label("Pattern"); ui.horizontal(|ui| { let r = ui.add( egui::TextEdit::singleline(&mut self.opts.query.text) .desired_width(320.0) .hint_text("text or regex"), ); go |= r.lost_focus() && ui.input(|i| i.key_pressed(Key::Enter)); ui.toggle_value(&mut self.opts.query.regex, ".*").on_hover_text("Regex"); ui.toggle_value(&mut self.opts.query.case_sensitive, "Aa").on_hover_text("Case sensitive"); ui.toggle_value(&mut self.opts.query.whole_word, "\\b").on_hover_text("Whole word"); }); ui.end_row(); ui.label("Include"); ui.horizontal(|ui| { ui.add(egui::TextEdit::singleline(&mut self.opts.include).desired_width(180.0)); ui.label("Exclude"); ui.add( egui::TextEdit::singleline(&mut self.opts.exclude).desired_width(140.0).hint_text("*.gz;old/**"), ); }); ui.end_row(); ui.label(""); ui.horizontal(|ui| { ui.checkbox(&mut self.opts.recursive, "Recursive"); ui.checkbox(&mut self.opts.respect_gitignore, "Respect .gitignore"); ui.checkbox(&mut self.opts.skip_binary, "Skip binary files"); ui.label("Max size (MB)"); ui.add(egui::TextEdit::singleline(&mut self.max_mb_text).desired_width(50.0).hint_text("any")); }); ui.end_row(); }); ui.horizontal(|ui| { let running = self.shared.as_ref().is_some_and(|s| !s.is_done()); if ui.button("🔍 Search").clicked() || go { self.start(); } if running && ui.button("Cancel").clicked() { self.cancel(); if let Some(s) = &self.shared { s.done.store(true, Ordering::Release); } } if let Some(s) = self.shared.clone() { let files = s.results.lock().unwrap(); let matches: usize = files.iter().map(|f| f.hits.len()).sum(); let searched = s.files_searched.load(Ordering::Relaxed); ui.label(format!( "{} matches in {} of {} files{}", fmt_num(matches as u64), fmt_num(files.len() as u64), fmt_num(searched as u64), if running { " (searching…)" } else { "" } )); if s.capped.load(Ordering::Relaxed) || files.iter().any(|f| f.truncated) { ui.colored_label(ui.visuals().warn_fg_color, "results capped (10,000 per file, 1M total)"); } let errs = s.errors.lock().unwrap(); if !errs.is_empty() { ui.colored_label(ui.visuals().warn_fg_color, format!("{} errors", errs.len())) .on_hover_text(errs.iter().take(20).cloned().collect::>().join("\n")); } drop(errs); if !files.is_empty() { if ui.button("📋 Copy").on_hover_text("Copy as path:line:text").clicked() { ui.ctx().copy_text(grep::export_text(&files)); } if ui.button("Export…").clicked() && let Some(p) = rfd::FileDialog::new().set_file_name("grep-results.txt").save_file() { let _ = std::fs::write(p, grep::export_text(&files)); } } } if let Some(e) = &self.error { ui.colored_label(ui.visuals().error_fg_color, e); } }); } fn results(&mut self, ui: &mut Ui, actions: &mut Vec) { let Some(shared) = self.shared.clone() else { ui.weak("Pick a folder and a pattern, then press Search. Double-click a hit to open it."); return; }; let files = shared.results.lock().unwrap(); self.rebuild_rows(&files); let root = self.ran.as_ref().map(|o| o.folder.clone()).unwrap_or_default(); let query = self.ran.as_ref().map(|o| o.query.clone()).unwrap_or_default(); // Selectable labels are padded; the virtualized rows must use the same height. let pad = ui.spacing().button_padding.y * 2.0; let row_h = ui.spacing().interact_size.y.max(ui.text_style_height(&egui::TextStyle::Monospace) + pad); let dark = ui.visuals().dark_mode; let font = egui::FontId::monospace(ui.text_style_height(&egui::TextStyle::Monospace) - 1.0); let text_color = ui.visuals().text_color(); let weak = ui.visuals().weak_text_color(); let mut open: Option<(usize, usize)> = None; let mut toggle: Option = None; // Keyboard: Up/Down to move, Enter to open. if !ui.ctx().egui_wants_keyboard_input() && !self.rows.is_empty() { let (up, down, enter) = ui.input(|i| (i.key_pressed(Key::ArrowUp), i.key_pressed(Key::ArrowDown), i.key_pressed(Key::Enter))); let cur = self.selected.unwrap_or(0); if down { self.selected = Some((cur + 1).min(self.rows.len() - 1)); } if up { self.selected = Some(cur.saturating_sub(1)); } if enter && let Some(Row::Hit(f, h)) = self.selected.and_then(|s| self.rows.get(s).copied()) { open = Some((f, h)); } } egui::ScrollArea::both().auto_shrink(false).show_rows(ui, row_h, self.rows.len(), |ui, range| { for i in range { let selected = self.selected == Some(i); match self.rows[i] { Row::File(fi) => { let f = &files[fi]; let arrow = if self.collapsed.contains(&fi) { "▶" } else { "▼" }; let text = format!( "{arrow} {} ({} matches{}, {})", grep::display_path(&root, &f.path), fmt_num(f.hits.len() as u64), if f.truncated { "+" } else { "" }, fmt_size(f.size) ); let r = ui.selectable_label(selected, RichText::new(text).strong()); if r.clicked() { self.selected = Some(i); toggle = Some(fi); } } Row::Hit(fi, hi) => { let h = &files[fi].hits[hi]; let mut job = LayoutJob::default(); job.append(&format!("{:>8}: ", h.line_number), 16.0, TextFormat::simple(font.clone(), weak)); let mut pos = 0; let (bg, fg) = palette::match_colors("amber", dark); for r in &h.ranges { if r.start < pos || r.end > h.text.len() { continue; } job.append(&h.text[pos..r.start], 0.0, TextFormat::simple(font.clone(), text_color)); job.append( &h.text[r.clone()], 0.0, TextFormat { background: bg, ..TextFormat::simple(font.clone(), fg) }, ); pos = r.end; } job.append(&h.text[pos..], 0.0, TextFormat::simple(font.clone(), text_color)); job.wrap.max_width = f32::INFINITY; let r = ui.selectable_label(selected, job); if r.clicked() { self.selected = Some(i); } if r.double_clicked() { open = Some((fi, hi)); } r.context_menu(|ui| { if ui.button("Open in viewer").clicked() { open = Some((fi, hi)); ui.close(); } if ui.button("Copy line").clicked() { ui.ctx().copy_text(h.text.clone()); ui.close(); } }); } } } }); if let Some(fi) = toggle && !self.collapsed.remove(&fi) { self.collapsed.insert(fi); } if let Some((fi, hi)) = open { let f = &files[fi]; actions.push(GrepAction::Open { path: f.path.clone(), offset: f.hits[hi].offset, query: query.clone() }); } } }