Inspector reset-to-default + component copy/paste, code editor find/replace

Author: RenzoraEngine

crates/renzora_code_editor/src/lib.rs

@@ -123,6 +123,11 @@ impl EditorPanel for CodeEditorPanel {
                     open_files: local.open_files.clone(),
                     active_tab: local.active_tab,
                     font_size: local.font_size,
+                    find_open: local.find_open,
+                    find_text: local.find_text.clone(),
+                    replace_text: local.replace_text.clone(),
+                    find_case_sensitive: local.find_case_sensitive,
+                    find_focus_requested: local.find_focus_requested,
                 });
             }
         }

crates/renzora_code_editor/src/render.rs

@@ -4,7 +4,7 @@ use renzora_theme::Theme;
 
 use std::path::PathBuf;
 
-use egui_phosphor::regular::{CODE, FILE_PLUS, FLOPPY_DISK, WARNING, X};
+use egui_phosphor::regular::{CODE, FILE_PLUS, FLOPPY_DISK, MAGNIFYING_GLASS, WARNING, X};
 
 use crate::state::CodeEditorState;
 
@@ -190,6 +190,17 @@ pub fn render_code_editor_content(
                     }
                 }
 
+                let find_btn = ui
+                    .button(RichText::new(MAGNIFYING_GLASS).size(12.0))
+                    .on_hover_text("Find / Replace (Ctrl+F)");
+                if find_btn.hovered() {
+                    ui.ctx().set_cursor_icon(CursorIcon::PointingHand);
+                }
+                if find_btn.clicked() {
+                    state.find_open = !state.find_open;
+                    state.find_focus_requested = state.find_open;
+                }
+
                 ui.separator();
 
                 // Zoom controls
@@ -232,9 +243,29 @@ pub fn render_code_editor_content(
                 if should_save {
                     state.save_active();
                 }
+
+                let (ctrl_f, ctrl_h, esc) = ui.ctx().input(|i| {
+                    (
+                        i.modifiers.ctrl && i.key_pressed(egui::Key::F),
+                        i.modifiers.ctrl && i.key_pressed(egui::Key::H),
+                        i.key_pressed(egui::Key::Escape),
+                    )
+                });
+                if ctrl_f || ctrl_h {
+                    state.find_open = true;
+                    state.find_focus_requested = true;
+                }
+                if esc && state.find_open {
+                    state.find_open = false;
+                }
             });
         });
 
+    // --- Find/Replace bar ---
+    if state.find_open {
+        render_find_bar(ui, state, theme);
+    }
+
     // Handle Ctrl+scroll zoom
     let panel_hovered = ui.rect_contains_pointer(ui.max_rect());
     let zoom_delta = if panel_hovered {
@@ -390,3 +421,107 @@ pub fn render_code_editor_content(
         }
     }
 }
+
+fn render_find_bar(ui: &mut egui::Ui, state: &mut CodeEditorState, theme: &Theme) {
+    let surface_faint = theme.surfaces.faint.to_color32();
+    let muted = theme.text.muted.to_color32();
+
+    egui::Frame::new()
+        .fill(surface_faint)
+        .inner_margin(egui::Margin::symmetric(8, 4))
+        .show(ui, |ui| {
+            ui.horizontal(|ui| {
+                ui.label(RichText::new("Find").size(11.0).color(muted));
+                let find_resp = ui.add(
+                    egui::TextEdit::singleline(&mut state.find_text)
+                        .desired_width(180.0)
+                        .hint_text("search..."),
+                );
+                if state.find_focus_requested {
+                    find_resp.request_focus();
+                    state.find_focus_requested = false;
+                }
+
+                let next_clicked = ui.small_button("Next").clicked()
+                    || (find_resp.lost_focus()
+                        && ui.ctx().input(|i| i.key_pressed(egui::Key::Enter)));
+
+                ui.checkbox(&mut state.find_case_sensitive, RichText::new("Aa").size(11.0))
+                    .on_hover_text("Case sensitive");
+
+                ui.separator();
+
+                ui.label(RichText::new("Replace").size(11.0).color(muted));
+                ui.add(
+                    egui::TextEdit::singleline(&mut state.replace_text)
+                        .desired_width(180.0)
+                        .hint_text("replace with..."),
+                );
+
+                let replace_clicked = ui.small_button("Replace").clicked();
+                let replace_all_clicked = ui.small_button("Replace All").clicked();
+
+                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                    if ui
+                        .add(egui::Button::new(RichText::new(X).size(11.0)).frame(false))
+                        .clicked()
+                    {
+                        state.find_open = false;
+                    }
+                });
+
+                if next_clicked {
+                    find_next_active(state);
+                }
+                if replace_clicked {
+                    replace_current_active(state);
+                }
+                if replace_all_clicked {
+                    let n = state.replace_all_active();
+                    log::info!("Replaced {} occurrences", n);
+                }
+            });
+        });
+}
+
+fn find_next_active(state: &mut CodeEditorState) {
+    let Some(idx) = state.active_tab else { return };
+    let Some(file) = state.open_files.get(idx) else { return };
+    if state.find_text.is_empty() {
+        return;
+    }
+    let from = 0;
+    if let Some(_pos) = CodeEditorState::find_next_in(
+        &file.content,
+        &state.find_text,
+        from,
+        state.find_case_sensitive,
+    ) {
+        // Match exists; underlying CodeEditor widget doesn't expose cursor placement,
+        // so this acts as a presence check for now.
+        log::debug!("match found in {}", file.name);
+    }
+}
+
+fn replace_current_active(state: &mut CodeEditorState) {
+    // Without cursor API from the editor widget, "Replace" behaves as
+    // "replace first occurrence". Replace All handles the bulk case.
+    let Some(idx) = state.active_tab else { return };
+    let Some(file) = state.open_files.get_mut(idx) else { return };
+    if state.find_text.is_empty() {
+        return;
+    }
+    let pos = CodeEditorState::find_next_in(
+        &file.content,
+        &state.find_text,
+        0,
+        state.find_case_sensitive,
+    );
+    if let Some(start) = pos {
+        let end = start + state.find_text.len();
+        if end <= file.content.len() {
+            file.content.replace_range(start..end, &state.replace_text);
+            file.is_modified = true;
+        }
+    }
+}

crates/renzora_code_editor/src/state.rs

@@ -30,6 +30,11 @@ pub struct CodeEditorState {
     pub open_files: Vec<OpenFile>,
     pub active_tab: Option<usize>,
     pub font_size: f32,
+    pub find_open: bool,
+    pub find_text: String,
+    pub replace_text: String,
+    pub find_case_sensitive: bool,
+    pub find_focus_requested: bool,
 }
 
 impl Default for CodeEditorState {
@@ -38,10 +43,78 @@ impl Default for CodeEditorState {
             open_files: Vec::new(),
             active_tab: None,
             font_size: DEFAULT_FONT_SIZE,
+            find_open: false,
+            find_text: String::new(),
+            replace_text: String::new(),
+            find_case_sensitive: false,
+            find_focus_requested: false,
         }
     }
 }
 
+impl CodeEditorState {
+    /// Find the next match of `find_text` in the active file's content starting from `from`.
+    /// Returns the byte index of the match start.
+    pub fn find_next_in(content: &str, needle: &str, from: usize, case_sensitive: bool) -> Option<usize> {
+        if needle.is_empty() || from > content.len() {
+            return None;
+        }
+        if case_sensitive {
+            content[from..].find(needle).map(|i| from + i)
+                .or_else(|| content[..from.min(content.len())].find(needle))
+        } else {
+            let hay_lower = content.to_lowercase();
+            let needle_lower = needle.to_lowercase();
+            hay_lower[from..].find(&needle_lower).map(|i| from + i)
+                .or_else(|| hay_lower[..from.min(hay_lower.len())].find(&needle_lower))
+        }
+    }
+
+    /// Replace all occurrences in active file. Returns count replaced.
+    pub fn replace_all_active(&mut self) -> usize {
+        let Some(idx) = self.active_tab else { return 0 };
+        let Some(file) = self.open_files.get_mut(idx) else { return 0 };
+        if self.find_text.is_empty() {
+            return 0;
+        }
+        let (new_content, count) = if self.find_case_sensitive {
+            let c = file.content.matches(&self.find_text).count();
+            (file.content.replace(&self.find_text, &self.replace_text), c)
+        } else {
+            replace_all_case_insensitive(&file.content, &self.find_text, &self.replace_text)
+        };
+        if count > 0 {
+            file.content = new_content;
+            file.is_modified = true;
+        }
+        count
+    }
+}
+
+fn replace_all_case_insensitive(haystack: &str, needle: &str, replacement: &str) -> (String, usize) {
+    if needle.is_empty() {
+        return (haystack.to_string(), 0);
+    }
+    let hay_lower = haystack.to_lowercase();
+    let needle_lower = needle.to_lowercase();
+    let mut out = String::with_capacity(haystack.len());
+    let mut i = 0;
+    let mut count = 0;
+    while i <= hay_lower.len() {
+        if let Some(pos) = hay_lower[i..].find(&needle_lower) {
+            let abs = i + pos;
+            out.push_str(&haystack[i..abs]);
+            out.push_str(replacement);
+            i = abs + needle.len();
+            count += 1;
+        } else {
+            out.push_str(&haystack[i..]);
+            break;
+        }
+    }
+    (out, count)
+}
+
 impl CodeEditorState {
     pub fn zoom_in(&mut self) {
         self.font_size = (self.font_size + 1.0).min(MAX_FONT_SIZE);

crates/renzora_editor_framework/src/inspector_registry.rs

@@ -15,6 +15,22 @@ pub enum FieldValue {
     Asset(Option<String>),
 }
 
+impl FieldValue {
+    /// A type-appropriate zero / empty default, used by the inspector's
+    /// "reset to default" action when a field doesn't provide its own default.
+    pub fn type_default(&self) -> FieldValue {
+        match self {
+            FieldValue::Float(_) => FieldValue::Float(0.0),
+            FieldValue::Vec3(_) => FieldValue::Vec3([0.0; 3]),
+            FieldValue::Bool(_) => FieldValue::Bool(false),
+            FieldValue::Color(_) => FieldValue::Color([1.0; 3]),
+            FieldValue::String(_) => FieldValue::String(String::new()),
+            FieldValue::ReadOnly(s) => FieldValue::ReadOnly(s.clone()),
+            FieldValue::Asset(_) => FieldValue::Asset(None),
+        }
+    }
+}
+
 /// Metadata about a field's type, used to select the correct widget.
 #[derive(Debug, Clone)]
 pub enum FieldType {

crates/renzora_inspector/src/clipboard.rs

@@ -0,0 +1,26 @@
+//! Clipboard for copying component values between entities.
+
+use bevy::prelude::Resource;
+use renzora_editor_framework::FieldValue;
+
+/// Holds a snapshot of one component's field values.
+#[derive(Resource, Default, Clone)]
+pub struct ComponentClipboard {
+    pub type_id: Option<&'static str>,
+    pub fields: Vec<(&'static str, FieldValue)>,
+}
+
+impl ComponentClipboard {
+    pub fn set(&mut self, type_id: &'static str, fields: Vec<(&'static str, FieldValue)>) {
+        self.type_id = Some(type_id);
+        self.fields = fields;
+    }
+
+    pub fn matches(&self, type_id: &'static str) -> bool {
+        self.type_id == Some(type_id)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.type_id.is_none()
+    }
+}