Feat: implement CTB/STB plot style table with PDF export integration

- src/io/plot_style.rs: PlotStyleTable and PlotStyleEntry data structures;
  CTB reader (deflate/zlib decompressed text format) with ACI→RGB and
  ACI→lineweight lookup; CTB writer (zlib compressed); LW_TABLE constant
- src/io/pdf_export.rs: accept optional PlotStyleTable; apply ACI color
  and lineweight overrides during PDF rendering
- src/scene/wire_model.rs: add `aci: u8` field to carry ACI index
- src/scene/render.rs: render_style() now returns ACI alongside RGBA
- src/scene/mod.rs + tessellate.rs: propagate aci through wire building
- app: PlotStyleLoad/Loaded/Clear messages and handlers;
  PLOTSTYLE LOAD | CLEAR | STATUS command; active_plot_style state on H7CAD
- flate2 added as dependency

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/io/plot_style.rs

@@ -0,0 +1,270 @@
+//! Plot Style Table — CTB (color-based) and STB (named) file support.
+//!
+//! CTB files map AutoCAD Color Index (ACI, 1-255) to pen properties:
+//! RGB color override, lineweight, and screeing percentage.
+//!
+//! File format: deflate-compressed text (key = value pairs) with
+//! 255 `begin_plot_style … end_plot_style` blocks.
+//!
+//! STB files follow the same format but use named styles instead of
+//! ACI indices; they are read into a `Vec<NamedPlotStyle>`.
+
+use std::collections::HashMap;
+use std::io::Read;
+use std::path::Path;
+
+// ── AutoCAD standard lineweight table (index → mm) ───────────────────────────
+
+/// Lineweight table: index value → mm, matching AutoCAD's LWEIGHT codes.
+/// Index 0 = 0.00 mm (hairline), others follow the DXF lineweight enum.
+pub const LW_TABLE: &[f32] = &[
+    0.00, 0.05, 0.09, 0.10, 0.13, 0.15, 0.18, 0.20,
+    0.25, 0.30, 0.35, 0.40, 0.50, 0.53, 0.60, 0.70,
+    0.80, 0.90, 1.00, 1.06, 1.20, 1.40, 1.58, 2.00, 2.11,
+];
+
+// ── Per-color entry ───────────────────────────────────────────────────────────
+
+/// A single entry in a CTB or STB plot style table.
+#[derive(Debug, Clone)]
+pub struct PlotStyleEntry {
+    /// Optional display name (empty for CTB; the style name for STB).
+    pub description: String,
+    /// If `Some([r,g,b])`, override the entity color with this RGB value (0..255).
+    /// If `None`, use the object color.
+    pub color: Option<[u8; 3]>,
+    /// Lineweight index into `LW_TABLE`.  255 = use object lineweight.
+    pub lineweight: u8,
+    /// Screen percentage 0–100 (100 = opaque).
+    pub screening: u8,
+}
+
+impl Default for PlotStyleEntry {
+    fn default() -> Self {
+        PlotStyleEntry {
+            description: String::new(),
+            color: None,
+            lineweight: 255, // use object lineweight
+            screening: 100,
+        }
+    }
+}
+
+// ── Plot Style Table ──────────────────────────────────────────────────────────
+
+/// A loaded CTB or STB plot style table.
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct PlotStyleTable {
+    /// File name (without path), e.g. "monochrome.ctb".
+    pub name: String,
+    /// Whether this is a named-style (STB) table rather than color-based (CTB).
+    pub is_stb: bool,
+    /// For CTB: entries indexed by ACI (index 0 unused; 1..=255 are valid).
+    pub aci_entries: Vec<PlotStyleEntry>, // 256 entries, index = ACI
+    /// For STB: named style entries.
+    pub named_entries: HashMap<String, PlotStyleEntry>,
+}
+
+impl PlotStyleTable {
+    /// Create an identity CTB table (no overrides for any color).
+    #[allow(dead_code)]
+    pub fn identity(name: impl Into<String>) -> Self {
+        PlotStyleTable {
+            name: name.into(),
+            is_stb: false,
+            aci_entries: (0..=255).map(|_| PlotStyleEntry::default()).collect(),
+            named_entries: HashMap::new(),
+        }
+    }
+
+    /// Load a CTB or STB file from disk.
+    pub fn load(path: &Path) -> Result<Self, String> {
+        let raw = std::fs::read(path).map_err(|e| e.to_string())?;
+        let name = path.file_name()
+            .unwrap_or_default().to_string_lossy().into_owned();
+        let is_stb = name.to_lowercase().ends_with(".stb");
+        let text = decompress_ctb(&raw)?;
+        parse_plot_style_text(&text, name, is_stb)
+    }
+
+    /// Write this table to disk as a CTB/STB file.
+    #[allow(dead_code)]
+    pub fn save(&self, path: &Path) -> Result<(), String> {
+        let text = self.to_text();
+        let compressed = compress_ctb(text.as_bytes())?;
+        std::fs::write(path, compressed).map_err(|e| e.to_string())
+    }
+
+    /// Resolve the effective print RGB color for the given ACI index.
+    /// Returns None if no override (use object color).
+    pub fn resolve_color(&self, aci: u8) -> Option<[f32; 3]> {
+        let entry = self.aci_entries.get(aci as usize)?;
+        entry.color.map(|[r, g, b]| {
+            [r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0]
+        })
+    }
+
+    /// Resolve the effective lineweight in mm for the given ACI index.
+    /// Returns None if no override (use object lineweight).
+    pub fn resolve_lineweight(&self, aci: u8) -> Option<f32> {
+        let entry = self.aci_entries.get(aci as usize)?;
+        if entry.lineweight == 255 {
+            None
+        } else {
+            LW_TABLE.get(entry.lineweight as usize).copied()
+        }
+    }
+
+    // ── Internal serialisation ────────────────────────────────────────────
+
+    fn to_text(&self) -> String {
+        let mut s = String::new();
+        s.push_str("description=\n");
+        s.push_str("apply_factor=0\n");
+        s.push_str("unit_type=1\n");
+        s.push_str("custom_lineweight_display_units=0\n");
+        for (_idx, entry) in self.aci_entries.iter().enumerate().skip(1) {
+            s.push_str("begin_plot_style\n");
+            s.push_str(&format!(" description={}\n", entry.description));
+            s.push_str(" physical_pen_number=0\n");
+            s.push_str(" virtual_pen_number=0\n");
+            s.push_str(&format!(" screen={}\n", entry.screening));
+            s.push_str(" linepattern_size=0.5\n");
+            s.push_str(" linetype=31\n");
+            s.push_str(" adaptive_linetype=TRUE\n");
+            s.push_str(&format!(" lineweight={}\n", entry.lineweight));
+            s.push_str(" fill_style=64\n");
+            s.push_str(" end_style=0\n");
+            s.push_str(" join_style=0\n");
+            if let Some([r, g, b]) = entry.color {
+                s.push_str(&format!(" color1=#{:02X}{:02X}{:02X}\n", r, g, b));
+            } else {
+                // 0xC2000000 = "use object color"
+                s.push_str(" color1=-1056964608\n");
+            }
+            s.push_str("end_plot_style\n");
+        }
+        s
+    }
+}
+
+// ── Deflate helpers ───────────────────────────────────────────────────────────
+
+/// Decompress a CTB/STB file's raw bytes into the text content.
+///
+/// CTB files start with a plain-text header (first line: "PIAFILEVERSION_2.0")
+/// followed by raw-deflate compressed content.  Some tools write pure zlib
+/// (with the two-byte zlib header 0x78 0x9C) instead — we handle both.
+fn decompress_ctb(data: &[u8]) -> Result<String, String> {
+    // Find the first newline — everything after it is the compressed payload.
+    let split_at = data.iter().position(|&b| b == b'\n')
+        .map(|p| p + 1)
+        .unwrap_or(0);
+    let payload = &data[split_at..];
+
+    // Try zlib (0x78 prefix) first, then raw deflate.
+    let mut text = String::new();
+    if payload.starts_with(&[0x78]) {
+        use flate2::read::ZlibDecoder;
+        ZlibDecoder::new(payload)
+            .read_to_string(&mut text)
+            .map_err(|e| format!("zlib decompress: {e}"))?;
+    } else {
+        use flate2::read::DeflateDecoder;
+        DeflateDecoder::new(payload)
+            .read_to_string(&mut text)
+            .map_err(|e| format!("deflate decompress: {e}"))?;
+    }
+    Ok(text)
+}
+
+/// Compress plot-style text content as a CTB/STB file.
+fn compress_ctb(text: &[u8]) -> Result<Vec<u8>, String> {
+    use flate2::{write::ZlibEncoder, Compression};
+    use std::io::Write;
+    let header = b"PIAFILEVERSION_2.0\r\n";
+    let mut compressed: Vec<u8> = Vec::new();
+    {
+        let mut enc = ZlibEncoder::new(&mut compressed, Compression::default());
+        enc.write_all(text).map_err(|e| e.to_string())?;
+    }
+    let mut out = header.to_vec();
+    out.extend_from_slice(&compressed);
+    Ok(out)
+}
+
+// ── Text parser ───────────────────────────────────────────────────────────────
+
+fn parse_plot_style_text(
+    text: &str,
+    name: String,
+    is_stb: bool,
+) -> Result<PlotStyleTable, String> {
+    let mut aci_entries: Vec<PlotStyleEntry> = (0..=255).map(|_| PlotStyleEntry::default()).collect();
+    let mut named_entries: HashMap<String, PlotStyleEntry> = HashMap::new();
+    let mut style_index: usize = 1; // CTB: 1-based ACI index
+    let mut current: Option<PlotStyleEntry> = None;
+    let mut current_name: String = String::new();
+
+    for line in text.lines() {
+        let line = line.trim();
+        if line == "begin_plot_style" {
+            current = Some(PlotStyleEntry::default());
+            current_name = format!("Color_{}", style_index);
+            continue;
+        }
+        if line == "end_plot_style" {
+            if let Some(entry) = current.take() {
+                if is_stb {
+                    named_entries.insert(current_name.clone(), entry);
+                } else if style_index <= 255 {
+                    aci_entries[style_index] = entry;
+                    style_index += 1;
+                }
+            }
+            continue;
+        }
+        let Some(entry) = current.as_mut() else { continue };
+        if let Some((key, val)) = line.split_once('=') {
+            let key = key.trim();
+            let val = val.trim();
+            match key {
+                "description" => {
+                    if !val.is_empty() {
+                        entry.description = val.to_string();
+                        current_name = val.to_string();
+                    }
+                }
+                "screen" => {
+                    if let Ok(v) = val.parse::<u8>() { entry.screening = v; }
+                }
+                "lineweight" => {
+                    if let Ok(v) = val.parse::<u8>() { entry.lineweight = v; }
+                }
+                "color1" => {
+                    if val.starts_with('#') && val.len() == 7 {
+                        // #RRGGBB
+                        let r = u8::from_str_radix(&val[1..3], 16).unwrap_or(0);
+                        let g = u8::from_str_radix(&val[3..5], 16).unwrap_or(0);
+                        let b = u8::from_str_radix(&val[5..7], 16).unwrap_or(0);
+                        entry.color = Some([r, g, b]);
+                    } else if let Ok(packed) = val.parse::<i32>() {
+                        // AutoCAD packs RGB as 0xC0RRGGBB negative int.
+                        // Value 0xC2000000 (-1056964608) = use object color.
+                        if packed != -1056964608i32 {
+                            let u = packed as u32;
+                            let r = ((u >> 16) & 0xFF) as u8;
+                            let g = ((u >>  8) & 0xFF) as u8;
+                            let b = ( u        & 0xFF) as u8;
+                            entry.color = Some([r, g, b]);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    Ok(PlotStyleTable { name, is_stb, aci_entries, named_entries })
+}