Add lock toggle to inspector Name section header

Pin the inspector to a specific entity so it stops following selection.
Click the lock icon at the right of the Name section header to toggle;
the lock auto-clears if the locked entity is despawned.

Author: RenzoraEngine

crates/renzora_inspector/src/lib.rs

@@ -6,12 +6,12 @@ mod state;
 use std::sync::RwLock;
 
 use bevy::prelude::*;
-use bevy_egui::egui::{self, RichText};
+use bevy_egui::egui::{self, Color32, CursorIcon, RichText};
 use egui_phosphor::regular;
 use renzora_editor_framework::{
-    collapsible_section, collapsible_section_removable, empty_state, search_overlay,
-    AppEditorExt, EditorCommands, EditorPanel, EditorSelection, InspectorRegistry,
-    OverlayAction, OverlayEntry, PanelLocation,
+    collapsible_section, collapsible_section_removable, collapsible_section_with_actions,
+    empty_state, search_overlay, AppEditorExt, EditorCommands, EditorPanel, EditorSelection,
+    InspectorRegistry, OverlayAction, OverlayEntry, PanelLocation,
 };
 use renzora_theme::ThemeManager;
 
@@ -49,8 +49,19 @@ impl EditorPanel for InspectorPanel {
             None => return,
         };
 
+        let mut state = self._state.write().unwrap();
+
+        // If a locked entity was despawned, drop the lock so we resume following selection.
+        if let Some(locked) = state.locked_entity {
+            if world.get_entity(locked).is_err() {
+                state.locked_entity = None;
+            }
+        }
+
         let selection = world.get_resource::<EditorSelection>();
-        let entity = selection.and_then(|s| s.get());
+        let entity = state
+            .locked_entity
+            .or_else(|| selection.and_then(|s| s.get()));
 
         let Some(entity) = entity else {
             empty_state(
@@ -83,8 +94,6 @@ impl EditorPanel for InspectorPanel {
             return;
         };
 
-        let mut state = self._state.write().unwrap();
-
         // Add Component overlay
         if state.show_add_overlay {
             let entries: Vec<OverlayEntry> = registry
@@ -217,6 +226,56 @@ impl EditorPanel for InspectorPanel {
                                 });
                             }
                         }
+                    } else if entry.type_id == "name" {
+                        let is_locked = state.locked_entity == Some(entity);
+                        let mut lock_clicked = false;
+                        let accent = theme.semantic.accent.to_color32();
+                        let muted = theme.text.muted.to_color32();
+                        collapsible_section_with_actions(
+                            ui,
+                            entry.icon,
+                            entry.display_name,
+                            entry.category,
+                            &theme,
+                            &format!("inspector_{}", entry.type_id),
+                            true,
+                            |ui| {
+                                let (icon, color, tooltip) = if is_locked {
+                                    (regular::LOCK_SIMPLE, accent, "Unlock — resume following selection")
+                                } else {
+                                    (regular::LOCK_SIMPLE_OPEN, muted, "Lock inspector to this entity")
+                                };
+                                let btn = ui
+                                    .add(
+                                        egui::Button::new(
+                                            RichText::new(icon).size(14.0).color(color),
+                                        )
+                                        .fill(Color32::TRANSPARENT)
+                                        .frame(false),
+                                    )
+                                    .on_hover_text(tooltip);
+                                if btn.hovered() {
+                                    ui.ctx().set_cursor_icon(CursorIcon::PointingHand);
+                                }
+                                if btn.clicked() {
+                                    lock_clicked = true;
+                                }
+                            },
+                            |ui| {
+                                if let Some(custom_fn) = entry.custom_ui_fn {
+                                    custom_fn(ui, world, entity, cmds, &theme);
+                                } else {
+                                    for (i, field) in entry.fields.iter().enumerate() {
+                                        field_widget::render_field(
+                                            ui, field, world, entity, cmds, &theme, i,
+                                        );
+                                    }
+                                }
+                            },
+                        );
+                        if lock_clicked {
+                            state.locked_entity = if is_locked { None } else { Some(entity) };
+                        }
                     } else {
                         collapsible_section(
                             ui,

crates/renzora_inspector/src/state.rs

@@ -1,7 +1,11 @@
+use bevy::prelude::Entity;
+
 /// Persistent UI state for the inspector panel.
 #[derive(Default)]
 pub struct InspectorState {
     pub show_add_overlay: bool,
     pub add_search: String,
     pub component_filter: String,
+    /// When set, the inspector pins to this entity and ignores selection changes.
+    pub locked_entity: Option<Entity>,
 }

crates/renzora_ui/src/widgets/category.rs

@@ -93,6 +93,103 @@ pub fn collapsible_section(
     state.store(ui.ctx());
 }
 
+/// Render a collapsible category section with custom right-aligned header actions.
+///
+/// Identical to [`collapsible_section`] but reserves space on the right side of the
+/// header bar for caller-supplied widgets (e.g. a lock toggle). The `header_actions`
+/// closure is rendered inside a right-to-left layout, so the first widget you add
+/// sits at the far right.
+pub fn collapsible_section_with_actions(
+    ui: &mut egui::Ui,
+    icon: &str,
+    label: &str,
+    category: &str,
+    theme: &Theme,
+    id_source: &str,
+    default_open: bool,
+    header_actions: impl FnOnce(&mut egui::Ui),
+    add_contents: impl FnOnce(&mut egui::Ui),
+) {
+    let id = ui.make_persistent_id(id_source);
+    let mut state =
+        egui::collapsing_header::CollapsingState::load_with_default_open(ui.ctx(), id, default_open);
+
+    let (accent_color, header_bg) = category_colors(theme, category);
+    let frame_bg = theme.panels.category_frame_bg.to_color32();
+    let text_muted = theme.text.muted.to_color32();
+    let text_primary = theme.text.primary.to_color32();
+
+    egui::Frame::new()
+        .fill(frame_bg)
+        .corner_radius(CornerRadius::ZERO)
+        .outer_margin(egui::Margin::ZERO)
+        .inner_margin(egui::Margin::ZERO)
+        .show(ui, |ui| {
+            ui.spacing_mut().item_spacing.y = 0.0;
+
+            // Header bar
+            let header_inner = egui::Frame::new()
+                .fill(header_bg)
+                .corner_radius(CornerRadius::ZERO)
+                .inner_margin(egui::Margin::symmetric(8, 6))
+                .show(ui, |ui| {
+                    ui.horizontal(|ui| {
+                        let left_response = ui.scope(|ui| {
+                            ui.set_max_width(
+                                (ui.available_width() - 32.0).max(20.0),
+                            );
+
+                            let caret = if state.is_open() { CARET_DOWN } else { CARET_RIGHT };
+                            ui.label(RichText::new(caret).size(12.0).color(text_muted));
+                            ui.label(RichText::new(icon).size(15.0).color(accent_color));
+                            ui.add_space(4.0);
+                            ui.add(
+                                egui::Label::new(
+                                    RichText::new(label)
+                                        .size(13.0)
+                                        .strong()
+                                        .color(text_primary),
+                                )
+                                .truncate(),
+                            );
+                        }).response;
+
+                        ui.with_layout(
+                            egui::Layout::right_to_left(egui::Align::Center),
+                            |ui| {
+                                header_actions(ui);
+                            },
+                        );
+
+                        left_response.rect
+                    }).inner
+                }).inner;
+
+            let click = ui.interact(header_inner, id.with("header_click"), Sense::click());
+            if click.hovered() {
+                ui.ctx().set_cursor_icon(CursorIcon::PointingHand);
+            }
+            if click.clicked() {
+                state.toggle(ui);
+            }
+
+            if state.is_open() {
+                egui::Frame::new()
+                    .inner_margin(egui::Margin {
+                        left: 4,
+                        right: 4,
+                        top: 4,
+                        bottom: 4,
+                    })
+                    .show(ui, |ui| {
+                        add_contents(ui);
+                    });
+            }
+        });
+
+    state.store(ui.ctx());
+}
+
 /// Render a collapsible category with toggle switch, remove button, and drag handle.
 ///
 /// Returns a [`CategoryHeaderAction`] indicating which buttons were clicked.

crates/renzora_ui/src/widgets/mod.rs

@@ -57,7 +57,8 @@ pub mod tree;
 
 pub use buttons::icon_button;
 pub use category::{
-    category_colors, collapsible_section, collapsible_section_removable, CategoryHeaderAction,
+    category_colors, collapsible_section, collapsible_section_removable,
+    collapsible_section_with_actions, CategoryHeaderAction,
 };
 pub use colors::{checkerboard, dim_color, get_theme_colors, set_theme_colors, ThemeColors};
 pub use drop_zone::{file_drop_zone, FileDropResult};