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;

src/locale_catalog.rs

@@ -3157,6 +3157,22 @@ pub(super) fn message_attribute(source: &str) -> Option<(&'static str, &'static
         "XREF: bound \"{}\" with {} unremapped style handles (see bind limitations)." => Some(("insert", "xref-bound-with-unremapped-handles")),
         "XREF: cannot bind nested reference '{}'. Bind it in its host drawing." => Some(("insert", "xref-cannot-bind-nested-reference")),
         "Unreferenced" => Some(("insert", "unreferenced")),
+        "Change Path" => Some(("insert", "xref-change-path")),
+        "Make Absolute" => Some(("insert", "xref-make-absolute")),
+        "Make Relative" => Some(("insert", "xref-make-relative")),
+        "Remove Path" => Some(("insert", "xref-remove-path")),
+        "Select New Path" => Some(("insert", "xref-select-new-path")),
+        "Select a single reference first." => Some(("insert", "xref-select-a-single-reference-first")),
+        "Reload All References" => Some(("insert", "xref-reload-all-references")),
+        "Opened" => Some(("insert", "xref-opened")),
+        "Untitled" => Some(("insert", "xref-untitled")),
+        "Unresolved" => Some(("insert", "xref-unresolved")),
+        "Preview not available" => Some(("insert", "xref-preview-not-available")),
+        "Reload All" => Some(("insert", "xref-reload-all")),
+        "DWG" => Some(("insert", "xref-dwg")),
+        "Pixel Width" => Some(("insert", "xref-pixel-width")),
+        "Pixel Height" => Some(("insert", "xref-pixel-height")),
+        "Resolution Unit" => Some(("insert", "xref-resolution-unit")),
         "XREF: cannot unload nested reference '{}'. Unload it in its host drawing." => Some(("insert", "xref-cannot-unload-nested-reference")),
         "XREF: cannot overlay nested reference '{}'. Overlay it in its host drawing." => Some(("insert", "xref-cannot-overlay-nested-reference")),
         "XREF: cannot reload nested reference '{}'. Reload it in its host drawing." => Some(("insert", "xref-cannot-reload-nested-reference")),
@@ -3164,7 +3180,7 @@ pub(super) fn message_attribute(source: &str) -> Option<(&'static str, &'static
         "XREF: cannot set path type for nested reference '{}'. Set it in its host drawing." => Some(("insert", "xref-cannot-set-path-type-nested-reference")),
         "{}: reload applies to drawing references only." => Some(("insert", "reload-applies-to-drawing-references-only")),
         "XREF: \"{}\" set to Attach." => Some(("insert", "xref-set-to-attach")),
-        "Reference Manager" => Some(("insert", "xref-manager-title")),
+        "External References" => Some(("insert", "xref-manager-title")),
         "XATTACH: cannot attach the host drawing into itself." => Some(("insert", "xref-self-attach-blocked")),
         "XREF: cannot bind \"{}\": {}." => Some(("insert", "xref-cannot-bind")),
         "XREF: cannot detach nested reference '{}'. Detach it in its host drawing." => Some(("insert", "xref-cannot-detach-nested-reference")),
@@ -3178,10 +3194,6 @@ pub(super) fn message_attribute(source: &str) -> Option<(&'static str, &'static
         "XREF: unloaded \"{}\"." => Some(("insert", "xref-unloaded")),
         "XREF: unknown option '{}'. Options: ? Reload Unload Detach Path Pathtype Bind Overlay Attach" => Some(("insert", "xref-unknown-option")),
         "XREF: updated {} reference(s)." => Some(("insert", "xref-updated-references")),
-        "XREF  Recovered with warnings: \"{}\"" => Some(("file", "xref-recovered-with-warnings")),
-        "XREF  Recovery failed: \"{}\" ({})" => Some(("file", "xref-recovery-failed")),
-        "XREF  Reload failed: \"{}\" ({})" => Some(("insert", "xref-reload-failed")),
-        "XREF  Reloaded with repairs: \"{}\"" => Some(("insert", "xref-reloaded-with-repairs")),
         "Usage: XREF Path <pattern> <new path>" => Some(("insert", "usage-xref-path-pattern")),
         "Usage: XREF Path Find <old> <new>" => Some(("insert", "usage-xref-path-find")),
         "Usage: XREF Pathtype <Full|Relative|None> [pattern]" => Some(("insert", "usage-xref-pathtype")),
@@ -3196,14 +3208,11 @@ pub(super) fn message_attribute(source: &str) -> Option<(&'static str, &'static
         "File name" => Some(("insert", "xref-file-name")),
         "Found At" => Some(("insert", "found-at")),
         "Help" => Some(("insert", "xref-help")),
-        "Image" => Some(("insert", "image")),
         "Nested references are read-only — edit them in their host drawing." => Some(("insert", "xref-nested-references-are-read-only")),
         "Not found" => Some(("insert", "not-found")),
         "Orphaned" => Some(("insert", "orphaned")),
         "Overlay" => Some(("insert", "xref-overlay")),
         "Path:" => Some(("insert", "path")),
-        "PDF" => Some(("insert", "pdf")),
-        "Reference Manager — select rows, then Detach, Unload, Reload, Overlay, or a Change Path mode." => Some(("insert", "xref-reference-manager-select-rows")),
         "Reference Manager — select rows, then Detach, Unload, Reload, Bind, Overlay, or a Change Path mode." => Some(("insert", "xref-reference-manager-select-rows-bind")),
         "Bind" => Some(("insert", "xref-bind")),
         "Refresh" => Some(("insert", "xref-refresh")),

src/ui/dock.rs

@@ -41,6 +41,7 @@ pub enum DockMsg {
 pub enum PanelId {
     Properties,
     BlockPalette,
+    ExternalReferences,
 }
 
 impl PanelId {
@@ -49,6 +50,7 @@ impl PanelId {
         match self {
             PanelId::Properties => "Properties",
             PanelId::BlockPalette => "Block Palette",
+            PanelId::ExternalReferences => "External References",
         }
     }
 
@@ -57,6 +59,7 @@ impl PanelId {
         match self {
             PanelId::Properties => 250.0,
             PanelId::BlockPalette => 260.0,
+            PanelId::ExternalReferences => 300.0,
         }
     }
 }
@@ -131,7 +134,7 @@ impl DockState {
     /// resize never hit a missing configuration. Also a cheap heal for configs
     /// written by an older version.
     pub fn ensure_settings(&mut self) {
-        for id in [PanelId::Properties, PanelId::BlockPalette] {
+        for id in [PanelId::Properties, PanelId::BlockPalette, PanelId::ExternalReferences] {
             self.panels.entry(id).or_insert_with(|| DockPanel::for_id(id));
         }
     }