feat(xref): docked External References panel with previews and translations

Docked External References panel with host row, thumbnail previews, and translated interface strings.

src/app/commands/blocks.rs

@@ -574,10 +574,24 @@ impl OpenCADStudio {
                 }
             }
 
-            // XREFMAN — open/focus the Reference Manager palette (display-only,
-            // Task 7). The XREF command below is untouched.
-            "XREFMAN" => {
-                return Some(Task::done(Message::ToggleXrefManager));
+            // EXTERNALREFERENCES — toggle the docked External References panel.
+            // (XREFMAN was a provisional name and is not kept, not even as an
+            // alias.) The XREF command below is untouched.
+            "EXTERNALREFERENCES" => {
+                self.show_external_references ^= true;
+                if self.show_external_references {
+                    // Always open expanded so the panel is immediately usable;
+                    // dock it on the right if the user closed it from the layout.
+                    if self.dock.location(crate::ui::dock::PanelId::ExternalReferences).is_none() {
+                        self.dock.dock(
+                            crate::ui::dock::PanelId::ExternalReferences,
+                            crate::app::config::DockSide::Right,
+                            usize::MAX,
+                        );
+                    }
+                    self.dock_expanded = Some(crate::ui::dock::PanelId::ExternalReferences);
+                    self.refresh_xref_manager();
+                }
             }
 
             cmd if cmd.eq_ignore_ascii_case("XREF") || cmd.to_ascii_uppercase().starts_with("XREF ") || cmd.eq_ignore_ascii_case("-XREF") || cmd.to_ascii_uppercase().starts_with("-XREF ") => {                // XREF sub-option dispatcher (Task 5). The verb is
@@ -1452,6 +1466,35 @@ mod tests {
         assert!(out.contains("No external references") || out.contains("External references"));
     }
 
+    #[test]
+    fn externalreferences_opens_palette() {
+        // EXTERNALREFERENCES is the palette command; XREFMAN is not kept,
+        // not even as an alias (single-token verbs take the no-suggest path,
+        // so an unknown verb reports "Unknown command").
+        let mut app = fresh_app();
+        let out = run_capture(&mut app, "EXTERNALREFERENCES");
+        assert!(!out.contains("Unknown command"), "got: {out:?}");
+        let out_old = run_capture(&mut app, "XREFMAN");
+        assert!(out_old.contains("Unknown command"), "got: {out_old:?}");
+    }
+
+    #[test]
+    fn externalreferences_populates_panel_table() {
+        // The panel table must list whatever `XREF ?` lists: opening the
+        // palette refreshes entries synchronously in the command arm.
+        let mut app = fresh_app();
+        add_dwg_xref(&mut app, "PLAN", "old/plan.dwg");
+        let list = run_capture(&mut app, "XREF ?");
+        assert!(list.contains("PLAN"), "CLI lists it, got: {list:?}");
+        let _ = run_capture(&mut app, "EXTERNALREFERENCES");
+        assert!(app.show_external_references);
+        assert!(
+            app.xref_manager.entries.iter().any(|e| e.name == "PLAN"),
+            "panel table must list what XREF lists"
+        );
+        assert!(app.xref_manager.display_rows().len() >= 2);
+    }
+
     #[test]
     fn xref_reload_no_match_resolves_nothing() {
         let mut app = fresh_app();

src/app/commands/mod.rs

@@ -612,6 +612,7 @@ inventory::submit!(crate::command::CommandRegistration {
         "EXPORT",
         "EXPORTSTEP",
         "EXPORTSTL",
+        "EXTERNALREFERENCES",
         "EXTRIM",
         "FILETAB",
         "FIND",
@@ -714,7 +715,6 @@ inventory::submit!(crate::command::CommandRegistration {
         "XR",
         "XREF",
         "-XREF",
-        "XREFMAN",
         "XRELOAD",
         "ZOOM",
         "ZS",

src/app/document.rs

@@ -202,7 +202,7 @@ pub(super) struct DocumentTab {
     /// palette refresh; `Stale` is detectable from the second refresh on.
     pub(super) xref_stat_cache: crate::io::xref_model::RefStatCache,
     /// NotFound count from the last file-open xref resolution (Task 8b).
-    /// The palette renders a neutral "open XREFMAN" notice while non-zero;
+    /// The palette renders a neutral "open EXTERNALREFERENCES" notice while non-zero;
     /// never auto-opens a modal. Cleared by a clean palette refresh.
     pub(super) xref_missing: usize,
     /// Sentinel "Welcome / Start" tab. Always at index 0 when present.

src/app/mod.rs

@@ -693,6 +693,8 @@ pub(super) struct OpenCADStudio {
     show_properties: bool,
     /// Docked Insert Block panel visibility.
     pub(crate) show_block_palette: bool,
+    /// Docked External References panel visibility (EXTERNALREFERENCES).
+    pub(crate) show_external_references: bool,
     /// General edge-stack dock layout for the side panels.
     pub(crate) dock: crate::ui::dock::DockState,
     /// Which panel is currently floated at full height (hovered, or a pinned
@@ -1730,7 +1732,6 @@ pub enum ModalKind {
     UpdateNotice,
     DonationPrompt,
     Layers,
-    XrefManager,
     LayerStateManager,
     LayerTranslator,
     DrawingUnits,
@@ -2355,6 +2356,22 @@ pub enum Message {
     XrefManagerSelect(usize),
     /// Flip the palette's list/tree presentation.
     XrefManagerToggleTree,
+    /// Flip the palette's details/preview lower pane.
+    XrefManagerTogglePreview,
+    /// Toggle the Attach dropdown menu.
+    XrefManagerAttachMenu,
+    /// Toggle the Refresh dropdown menu.
+    XrefManagerRefreshMenu,
+    /// Toggle the Change Path dropdown menu.
+    XrefManagerPathMenu,
+    /// Close all palette dropdown menus (overlay dismissal).
+    XrefManagerDismissMenus,
+    /// Open the file picker for Select New Path (anchor entry).
+    XrefPathPick,
+    /// Result of the Select New Path picker.
+    XrefPathPickResult(Result<std::path::PathBuf, String>),
+    /// Reload every direct reference (toolbar Reload All).
+    XrefManagerReloadAll,
     /// Expand/collapse one tree parent (block-record handle key).
     XrefManagerToggleExpand(u64),
     /// Selection-scoped palette operation (detach/unload/reload/overlay/pathtype).
@@ -3733,6 +3750,7 @@ impl OpenCADStudio {
             render_mode_preview: None,
             show_properties: true,
             show_block_palette: false,
+            show_external_references: false,
             block_palette: Default::default(),
             xref_manager: Default::default(),
             dock: Default::default(),

src/app/update/dialog.rs

@@ -599,6 +599,9 @@ pub(super) fn on_ribbon_tool_click(&mut self, tool_id: String, event: ModuleEven
                         self.show_block_palette = false;
                         self.block_palette.placing = None;
                     }
+                    PanelId::ExternalReferences => {
+                        self.show_external_references = false;
+                    }
                     PanelId::Properties => {
                         self.show_properties = false;
                         self.ribbon.set_properties(false);
@@ -692,6 +695,7 @@ pub(super) fn on_ribbon_tool_click(&mut self, tool_id: String, event: ModuleEven
         match id {
             PanelId::Properties => self.show_properties,
             PanelId::BlockPalette => self.show_block_palette,
+            PanelId::ExternalReferences => self.show_external_references,
         }
     }
 
@@ -772,6 +776,15 @@ pub(super) fn on_ribbon_tool_click(&mut self, tool_id: String, event: ModuleEven
             .unwrap_or_else(|| std::path::PathBuf::from("."));
         let tab_id = self.tabs[i].id;
         let revision = self.tabs[i].edit_revision;
+        let (host_name, host_path) = match &self.tabs[i].current_path {
+            Some(p) => (
+                p.file_stem()
+                    .map(|s| s.to_string_lossy().into_owned())
+                    .unwrap_or_default(),
+                p.to_string_lossy().into_owned(),
+            ),
+            None => (String::new(), String::new()),
+        };
         let baselines = {
             let tab = &self.tabs[i];
             self.xref_manager.refresh(
@@ -779,6 +792,8 @@ pub(super) fn on_ribbon_tool_click(&mut self, tool_id: String, event: ModuleEven
                 &base_dir,
                 tab.xref_unloaded.as_set(),
                 &tab.xref_stat_cache.0,
+                &host_name,
+                &host_path,
             )
         };
         let tab = &mut self.tabs[i];
@@ -803,7 +818,7 @@ pub(super) fn on_ribbon_tool_click(&mut self, tool_id: String, event: ModuleEven
     /// XOPEN-return edit, undo/redo — all bump `edit_revision`). Cheap:
     /// `collect_entries` stats files without re-parsing the host.
     pub(crate) fn refresh_xref_manager_if_stale(&mut self) {
-        if self.active_modal != Some(crate::app::ModalKind::XrefManager) {
+        if !self.dock_panel_visible(crate::ui::dock::PanelId::ExternalReferences) {
             return;
         }
         let i = self.active_tab;
@@ -1164,6 +1179,62 @@ pub(super) fn on_ribbon_tool_click(&mut self, tool_id: String, event: ModuleEven
         self.refresh_xref_manager();
     }
 
+    /// Reload every direct drawing reference (toolbar Reload All). Same
+    /// engine path as `XRELOAD`: undo snapshot, session flags cleared,
+    /// full resolve, per-ref report, stat baselines refreshed.
+    pub(crate) fn xref_manager_reload_all(&mut self) {
+        if cfg!(target_arch = "wasm32") {
+            self.command_line.push_error(crate::t!("Reference changes are not available on web — the reference list is read-only.").as_ref());
+            return;
+        }
+        let i = self.active_tab;
+        let Some(path) = self.tabs[i].current_path.clone() else {
+            self.command_line
+                .push_error(crate::t!("XREF  Save the drawing first to resolve relative XREF paths.").as_ref());
+            return;
+        };
+        let Some(base_dir) = path.parent().map(|p| p.to_path_buf()) else {
+            self.command_line
+                .push_error(crate::t!("XREF  Save the drawing first to resolve relative XREF paths.").as_ref());
+            return;
+        };
+        let reload_keys: Vec<u64> = crate::io::xref::collect_entries_with_prev(
+            &self.tabs[i].scene.document,
+            &base_dir,
+            self.tabs[i].xref_unloaded.as_set(),
+            &self.tabs[i].xref_stat_cache.0,
+        )
+        .iter()
+        .filter(|e| e.kind == crate::io::xref_model::RefKind::DwgXref && e.parent_key.is_none())
+        .map(|e| e.key)
+        .collect();
+        self.push_undo_snapshot(i, "XREF-RELOAD");
+        for key in &reload_keys {
+            self.tabs[i].xref_unloaded.remove(key);
+            self.tabs[i].xref_stat_cache.remove(key);
+        }
+        let (infos, _dropped) =
+            crate::io::xref::resolve_xrefs(&mut self.tabs[i].scene.document, &base_dir);
+        let fresh = crate::io::xref::collect_entries_with_prev(
+            &self.tabs[i].scene.document,
+            &base_dir,
+            self.tabs[i].xref_unloaded.as_set(),
+            &self.tabs[i].xref_stat_cache.0,
+        );
+        for e in &fresh {
+            if e.status == crate::io::xref_model::RefStatus::Loaded {
+                if let Some(m) = e.modified {
+                    self.tabs[i].xref_stat_cache.insert(e.key, m);
+                }
+            }
+        }
+        for info in &infos {
+            self.report_xref_status(info);
+        }
+        self.post_ref_op(i);
+        self.refresh_xref_manager();
+    }
+
     /// Apply the details-pane path draft to the anchor entry (verbatim
     /// store, same engine fn as `XREF Path`).
     pub(crate) fn xref_manager_path_apply(&mut self) {

src/app/update/mod.rs

@@ -2131,12 +2131,15 @@ impl OpenCADStudio {
             }
 
             Message::ToggleXrefManager => {
-                if self.active_modal == Some(super::ModalKind::XrefManager) {
-                    self.active_modal = None;
-                    self.reset_modal_geometry();
-                } else {
+                self.show_external_references ^= true;
+                if self.show_external_references {
+                    use crate::app::config::DockSide;
+                    use crate::ui::dock::PanelId;
+                    if self.dock.location(PanelId::ExternalReferences).is_none() {
+                        self.dock.dock(PanelId::ExternalReferences, DockSide::Right, usize::MAX);
+                    }
+                    self.dock_expanded = Some(PanelId::ExternalReferences);
                     self.refresh_xref_manager();
-                    self.active_modal = Some(super::ModalKind::XrefManager);
                 }
                 Task::none()
             }
@@ -2152,6 +2155,90 @@ impl OpenCADStudio {
                 self.xref_manager.toggle_tree();
                 Task::none()
             }
+            Message::XrefManagerTogglePreview => {
+                self.xref_manager.show_preview ^= true;
+                Task::none()
+            }
+            Message::XrefManagerAttachMenu => {
+                self.xref_manager.attach_open ^= true;
+                self.xref_manager.refresh_open = false;
+                self.xref_manager.path_open = false;
+                Task::none()
+            }
+            Message::XrefManagerRefreshMenu => {
+                self.xref_manager.refresh_open ^= true;
+                self.xref_manager.attach_open = false;
+                self.xref_manager.path_open = false;
+                Task::none()
+            }
+            Message::XrefManagerPathMenu => {
+                self.xref_manager.path_open ^= true;
+                self.xref_manager.attach_open = false;
+                self.xref_manager.refresh_open = false;
+                Task::none()
+            }
+            Message::XrefManagerDismissMenus => {
+                self.xref_manager.attach_open = false;
+                self.xref_manager.refresh_open = false;
+                self.xref_manager.path_open = false;
+                Task::none()
+            }
+            Message::XrefPathPick => Task::perform(
+                async {
+                    let handle = crate::sys::file_dialog()
+                        .set_title(crate::t!("Select New Path").as_ref())
+                        .pick_file()
+                        .await;
+                    match handle {
+                        Some(h) => Ok(crate::sys::handle_path(&h)),
+                        None => Err("Cancelled".to_string()),
+                    }
+                },
+                Message::XrefPathPickResult,
+            ),
+            Message::XrefPathPickResult(Ok(path)) => {
+                // Select New Path applies the picked file to the single
+                // direct anchor entry (menu gates the rest).
+                let i = self.active_tab;
+                let anchor = self.xref_manager.anchor.and_then(|a| {
+                    self.xref_manager
+                        .entries
+                        .get(a)
+                        .filter(|_| !self.xref_manager.nested.contains(&a))
+                        .map(|e| (e.key, e.name.clone()))
+                });
+                let Some((key, _)) = anchor else {
+                    return Task::none();
+                };
+                let new_raw = path.to_string_lossy().into_owned();
+                self.push_undo_snapshot(i, "XREF-PATH");
+                match crate::io::xref::set_ref_path(
+                    &mut self.tabs[i].scene.document,
+                    key,
+                    &new_raw,
+                ) {
+                    Ok(name) => {
+                        self.command_line.push_output(crate::tf!(
+                            "XREF: Path set for \"{}\" — Reload to apply.",
+                            name
+                        ).as_ref());
+                        self.post_ref_op(i);
+                    }
+                    Err(msg) => self.command_line.push_error(msg.as_str()),
+                }
+                self.refresh_xref_manager();
+                Task::none()
+            }
+            Message::XrefPathPickResult(Err(e)) => {
+                if e != "Cancelled" {
+                    self.command_line.push_error(crate::tf!("XREF: {e}").as_ref());
+                }
+                Task::none()
+            }
+            Message::XrefManagerReloadAll => {
+                self.xref_manager_reload_all();
+                Task::none()
+            }
             Message::XrefManagerToggleExpand(key) => {
                 self.xref_manager.toggle_expand(key);
                 Task::none()

src/app/view/mod.rs

@@ -1812,6 +1812,7 @@ bg={bg_ms:.1}ms n={view_count}"
             match id {
                 crate::ui::dock::PanelId::Properties => self.show_properties,
                 crate::ui::dock::PanelId::BlockPalette => self.show_block_palette,
+                crate::ui::dock::PanelId::ExternalReferences => self.show_external_references,
             }
         };
         let edge_stack = |side: crate::app::config::DockSide| -> Option<Element<'_, Message>> {
@@ -2839,6 +2840,12 @@ impl OpenCADStudio {
             crate::ui::dock::PanelId::BlockPalette => {
                 crate::ui::window::block_palette::view(&self.block_palette, width, auto_collapse)
             }
+            crate::ui::dock::PanelId::ExternalReferences => self.xref_manager.view(
+                width,
+                auto_collapse,
+                tab.xref_missing,
+                &tab.scene.document,
+            ),
         };
         let divider = dock_divider(id);
         match side {

src/app/view/modal.rs

@@ -20,7 +20,6 @@ impl OpenCADStudio {
             Some(K::UpdateNotice) => crate::tr!("modal", "update-available"),
             Some(K::DonationPrompt) => crate::tr!("donation", "title"),
             Some(K::Layers) => crate::tr!("modal", "layer-manager"),
-            Some(K::XrefManager) => crate::t!("Reference Manager").into_owned(),
             Some(K::LayerStateManager) => crate::tr!("modal", "layer-state-manager"),
             Some(K::LayerTranslator) => crate::t!("Layer Translator").into_owned(),
             Some(K::DrawingUnits) => crate::t!("Drawing Units").into_owned(),
@@ -395,12 +394,6 @@ impl OpenCADStudio {
                     |flow| tab.layers.view_window(self.layer_name_col_w, flow),
                 )
             }
-            super::super::ModalKind::XrefManager => {
-                sized_flow(ex, 960, 560, |flow| {
-                    let missing = self.tabs[self.active_tab].xref_missing;
-                    self.xref_manager.view_window(flow, missing)
-                })
-            }
             super::super::ModalKind::LayerTranslator => {
                 use crate::modules::draw::layers::laytrans;
                 let i = self.active_tab;