fix(linetype): an opened drawing keeps exactly its own linetypes (#1826)

Opening a drawing added all 50 catalog linetypes to it, so PURGE found
and removed them again after every save and reopen. Opening now only
repairs the catalog linetypes a drawing already has. The linetype
pickers (layers, properties, ribbon, attribute editor, layer states)
offer the missing catalog ones after the drawing's own, and the one
picked, or named in LINETYPE SET, is loaded on first use.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

src/app/commands/styleprops.rs

@@ -205,6 +205,11 @@ impl OpenCADStudio {
                             } else if name.eq_ignore_ascii_case("BYBLOCK") {
                                 Some(("ByBlock".to_string(), codec::types::Handle::NULL))
                             } else {
+                                // A catalog linetype loads on first use.
+                                crate::io::linetypes::ensure_catalog_linetype(
+                                    &mut self.tabs[i].scene.document,
+                                    name,
+                                );
                                 self.tabs[i]
                                     .scene
                                     .document

src/app/layers.rs

@@ -157,6 +157,7 @@ impl OpenCADStudio {
                 let art = crate::io::linetypes::extract_pattern(&lt.description);
                 ui::properties::LinetypeItem { name, art }
             })
+            .chain(catalog_linetype_items(&self.tabs[i].scene.document))
             .collect();
         self.tabs[i].layers.sync_linetypes(lt_items.clone());
         self.ribbon.set_available_linetypes(lt_items);
@@ -247,3 +248,16 @@ impl OpenCADStudio {
         );
     }
 }
+
+/// The catalog linetypes the drawing lacks, offered after its own; a pick
+/// loads the one chosen (`ensure_catalog_linetype`).
+pub(super) fn catalog_linetype_items(
+    document: &codec::CadDocument,
+) -> impl Iterator<Item = ui::properties::LinetypeItem> {
+    crate::io::linetypes::catalog_missing_from(document)
+        .into_iter()
+        .map(|(name, description)| ui::properties::LinetypeItem {
+            name,
+            art: crate::io::linetypes::extract_pattern(&description),
+        })
+}

src/app/properties.rs

@@ -1824,6 +1824,9 @@ impl OpenCADStudio {
                 let art = linetypes::extract_pattern(&lt.description);
                 ui::properties::LinetypeItem { name, art }
             })
+            .chain(super::layers::catalog_linetype_items(
+                &self.tabs[i].scene.document,
+            ))
             .collect();
         let text_style_names: Vec<String> = self.tabs[i]
             .scene

src/app/update/file.rs

@@ -2315,7 +2315,7 @@ impl OpenCADStudio {
         // not inherit the previous tab's filter, and persisted entity
         // visibility remains independent (not an isolation session).
         self.tabs[i].scene.reset_transient_visibility();
-        crate::io::linetypes::populate_document(&mut self.tabs[i].scene.document);
+        crate::io::linetypes::repair_document(&mut self.tabs[i].scene.document);
         self.tabs[i].properties = PropertiesPanel::empty();
         // Seed the current table / multileader style from the file's
         // header so the ✓ marks the right one (text/dim/mline come from

src/app/update/mod.rs

@@ -389,6 +389,20 @@ impl OpenCADStudio {
         // creating or closing a tab), the contextual ribbon tab follows that
         // document's selection.
         let before = self.tabs.get(self.active_tab).map(|tab| tab.id);
+        // Pickers offer the catalog linetypes the drawing lacks; the one
+        // picked is loaded before it is assigned.
+        if let Message::LayerLinetypeSet(name)
+        | Message::LayerStateEditorLayerLinetype(_, name)
+        | Message::RibbonLinetypeChanged(name)
+        | Message::PropLinetypeChanged(name)
+        | Message::AttrEditorLinetype(name) = &msg
+        {
+            if let Some(tab) = self.tabs.get_mut(self.active_tab) {
+                if crate::io::linetypes::ensure_catalog_linetype(&mut tab.scene.document, name) {
+                    tab.scene.bump_geometry();
+                }
+            }
+        }
         let task = self.update_message(msg);
         self.restore_dynamic_ucs_after_command();
         self.sync_block_visibility_display();

src/io/linetypes.rs

@@ -271,6 +271,40 @@ pub fn populate_document(doc: &mut CadDocument) {
     populate_document_from_source(doc, lin_source());
 }
 
+/// Repair the catalog linetypes `doc` already has (see
+/// [`populate_document_from_source`]) without adding any: an opened drawing
+/// keeps exactly its own linetypes, so a purged one stays purged.
+pub fn repair_document(doc: &mut CadDocument) {
+    populate_matching(doc, lin_source(), |_| false);
+}
+
+/// The catalog linetypes `doc` does not have, as (name, description): what a
+/// picker offers beside the drawing's own. Picking one loads it with
+/// [`ensure_catalog_linetype`].
+pub fn catalog_missing_from(doc: &CadDocument) -> Vec<(String, String)> {
+    static CATALOG: OnceLock<Vec<(String, String)>> = OnceLock::new();
+    CATALOG
+        .get_or_init(|| {
+            parse(lin_source())
+                .into_iter()
+                .map(|lt| (lt.name, lt.description))
+                .collect()
+        })
+        .iter()
+        .filter(|(name, _)| !doc.line_types.contains(name))
+        .cloned()
+        .collect()
+}
+
+/// Load catalog linetype `name` into `doc` when the drawing lacks it.
+/// Returns whether it was added.
+pub fn ensure_catalog_linetype(doc: &mut CadDocument, name: &str) -> bool {
+    !doc.line_types.contains(name)
+        && populate_matching(doc, lin_source(), |candidate| {
+            candidate.eq_ignore_ascii_case(name)
+        }) > 0
+}
+
 /// Add the linetypes of a caller-supplied `.lin` source, embedded shapes and
 /// text included, so the drawing draws them and a saved file carries them.
 /// Returns the number of definitions newly registered in the drawing.
@@ -280,6 +314,12 @@ pub fn populate_document(doc: &mut CadDocument) {
 /// and so saved) gets its shapes and text back when its dashes match the
 /// source's exactly.
 pub fn populate_document_from_source(doc: &mut CadDocument, source: &str) -> usize {
+    populate_matching(doc, source, |_| true)
+}
+
+/// [`populate_document_from_source`], adding only the missing linetypes
+/// `add` accepts by name; existing ones are repaired either way.
+fn populate_matching(doc: &mut CadDocument, source: &str, add: impl Fn(&str) -> bool) -> usize {
     let complex = parse_complex(source);
     let mut added = 0;
     for mut lt in parse(source) {
@@ -303,6 +343,9 @@ pub fn populate_document_from_source(doc: &mut CadDocument, source: &str) -> usi
             }
             continue;
         }
+        if !add(&lt.name) {
+            continue;
+        }
         if let Some(elements) = segments.and_then(|s| complex_elements(doc, s, &lt.elements)) {
             lt.elements = elements;
         }

src/io/mod.rs

@@ -450,10 +450,11 @@ async fn open_path_with_phase_attempt(
                             recoverable: true,
                         });
                     }
-                    // Before the geometry is prepared below: completing the
-                    // drawing's catalog linetypes (and repairing stripped ones)
-                    // after it would leave the first view drawn without them.
-                    crate::io::linetypes::populate_document(&mut doc);
+                    // Before the geometry is prepared below: repairing the
+                    // drawing's stripped catalog linetypes after it would leave
+                    // the first view drawn without their shapes. None is added:
+                    // the drawing keeps exactly its own linetypes (#1826).
+                    crate::io::linetypes::repair_document(&mut doc);
                     progress2.set(crate::app::OPEN_PHASE_XREF, 6000, 0, 1);
                     let t_xref = Instant::now();
                     let (xref_infos, xref_dropped) = if let Some(base_dir) = path2.parent() {