Adom Library

@@ -304,8 +304,8 @@ fn u16_text_record(text: &str) -> Result<Vec<u8>> { fn build_file_header(symbols: &[(String, &Symbol)]) -> Vec<u8> {     let mut s = String::from(         "|HEADER=Protel for Windows - Schematic Library Editor Binary File Version 5.0\-|Weight=0|MinorVersion=9|UniqueID=ADOMSFHX|FontIdCount=1|Size1=10\-|FontName1=Times New Roman|UseMBCS=T|IsBOC=T|SheetStyle=9|BorderOn=T\+|Weight=0|MinorVersion=9|UniqueID=ADOMSFHX|FontIdCount=2|Size1=10\+|FontName1=Times New Roman|Size2=8|Bold2=T|FontName2=Times New Roman|UseMBCS=T|IsBOC=T|SheetStyle=9|BorderOn=T\ |SheetNumberSpaceSize=12|AreaColor=16317695|SnapGridOn=T|SnapGridSize=10\ |VisibleGridOn=T|VisibleGridSize=10|CustomX=18000|CustomY=18000|UseCustomSheet=T\ |ReferenceZonesOn=T|Display_Unit=0",@@ -338,6 +338,17 @@ fn build_component_data(sym: &Symbol, lib_ref: &str) -> Result<Vec<u8>> {      // Body: emit the symbol's own graphics if it has any; otherwise a default     // body rectangle. Either way these are the records between header and pins.+    // The body box the labels and the designator/comment are placed against: the+    // first Rect graphic when there is one (adom-symbol's body), else `body`.+    let bbox = sym.graphics.iter().find_map(|g| match g {+        Graphic::Rect { x1, y1, x2, y2, .. } => Some((x1.min(*x2), y1.min(*y2), x1.max(*x2), y1.max(*y2))),+        _ => None,+    }).unwrap_or((body.x1.min(body.x2) as f64, body.y1.min(body.y2) as f64, body.x1.max(body.x2) as f64, body.y1.max(body.y2) as f64));+    // The chip drawing (every polyline) must sit in the lane between the pin-name+    // columns. KiCad laid it out for KiCad's font; Altium's Times New Roman 10 pt+    // names are wider, so measure the lane from the pins and fit the art into it+    // (uniform scale about its centre, then centred in the lane). John, 2026-09-19.+    let graphics = fit_art_to_lane(&sym.graphics, &sym.pins, bbox);     if sym.graphics.is_empty() {         out.extend(u16_text_record(&format!(             "|RECORD=14|OwnerPartId=1|Location.X={x1}|Location.Y={y1}|Corner.X={x2}|Corner.Y={y2}\@@ -349,10 +360,20 @@ fn build_component_data(sym: &Symbol, lib_ref: &str) -> Result<Vec<u8>> {             uid2 = pseudo_uid(&sym.name, 14),         ))?);     } else {-        for (gi, g) in sym.graphics.iter().enumerate() {+        for (gi, g) in graphics.iter().enumerate() {             out.extend(emit_graphic(g, &sym.name, gi)?);         }     }+    // RECORD=4 — pin-group captions (adom-symbol's "Power" / "I2C" headings).+    for (li, l) in sym.labels.iter().enumerate() {+        let just = match (l.justify_right, l.angle) { (true, _) => 5, (false, _) => 3 };+        let orient = ((l.angle / 90) % 4) as u32;+        out.extend(u16_text_record(&format!(+            "|RECORD=4|OwnerPartId=1{}{}|Color=8388608|FontID={}|Text={}|Justification={just}|Orientation={orient}|UniqueID={}",+            coord_field("Location.X", l.x), coord_field("Location.Y", l.y),+            if l.bold { 2 } else { 1 }, l.text, pseudo_uid(&sym.name, 2000 + li as u32)+        ))?);+    }      // Pin records (binary). Label visibility is symbol-level in the model;     // unknown defaults to hidden for 2-pin passives (KiCad's own R/C/L@@ -364,17 +385,23 @@ fn build_component_data(sym: &Symbol, lib_ref: &str) -> Result<Vec<u8>> {         out.extend(frame_pin(encode_pin_payload(pin, i, show_name, show_designator)?));     } -    // RECORD=34 — Designator label.+    // RECORD=34 — Designator label: centred above the body (KiCad's Reference place).+    let cx = (bbox.0 + bbox.2) / 2.0;     out.extend(u16_text_record(&format!(-        "|RECORD=34|IndexInSheet=-1|OwnerPartId=-1|Location.X=-5|Location.Y=5|Color=8388608\-|FontID=1|Text={prefix}?|Name=Designator|ReadOnlyState=1|UniqueID={uid3}",+        "|RECORD=34|IndexInSheet=-1|OwnerPartId=-1{}{}|Color=8388608\+|FontID=1|Text={prefix}?|Name=Designator|ReadOnlyState=1|Justification=1|UniqueID={uid3}",+        coord_field("Location.X", cx), coord_field("Location.Y", bbox.3 + 60.0),         uid3 = pseudo_uid(&sym.name, 34),     ))?); -    // RECORD=41 — Comment label.+    // RECORD=41 — Comment label: the part number, centred below the body (KiCad's+    // Value place). A '*' comment on a placed part reads as unfinished.+    let comment = sym.parameters.iter().find(|p| p.name == "Value" && !p.value.is_empty())+        .map(|p| p.value.clone()).unwrap_or_else(|| "*".to_string());     out.extend(u16_text_record(&format!(-        "|RECORD=41|IndexInSheet=-1|OwnerPartId=-1|Location.X=-5|Location.Y=-15|Color=8388608\-|FontID=1|Text=*|Name=Comment|UniqueID={uid4}",+        "|RECORD=41|IndexInSheet=-1|OwnerPartId=-1{}{}|Color=8388608\+|FontID=1|Text={comment}|Name=Comment|Justification=7|UniqueID={uid4}",+        coord_field("Location.X", cx), coord_field("Location.Y", bbox.1 - 60.0),         uid4 = pseudo_uid(&sym.name, 41),     ))?); @@ -383,7 +410,7 @@ fn build_component_data(sym: &Symbol, lib_ref: &str) -> Result<Vec<u8>> {     // comment), the rest carry IsHidden=T like standard metadata parameters.     for (pi, param) in sym.parameters.iter().enumerate() {         let uidp = pseudo_uid(&sym.name, 4100 + pi as u32);-        let rec = if param.visible {+        let rec = if param.visible && param.name != "Value" {             let y = -25 - (pi as i32) * 10;             format!(                 "|RECORD=41|IndexInSheet=-1|OwnerPartId=-1|Location.X=-5|Location.Y={y}\@@ -407,7 +434,7 @@ fn build_component_data(sym: &Symbol, lib_ref: &str) -> Result<Vec<u8>> {     out.extend(u16_text_record("|RECORD=44")?);     if let Some(fp) = sym.footprint.as_deref().filter(|s| !s.is_empty()) {         // record positions: R1=0, body records, pins, R34, R41-comment, params, R44.-        let body_recs = if sym.graphics.is_empty() { 1 } else { sym.graphics.len() };+        let body_recs = (if sym.graphics.is_empty() { 1 } else { sym.graphics.len() }) + sym.labels.len();         let idx_44 = pin_count + body_recs + 3 + sym.parameters.len();         let idx_45 = idx_44 + 1;         // RECORD=45 — the PCBLIB model link. ModelName + a single datafile entry@@ -453,6 +480,50 @@ fn coord_field(key: &str, mil: f64) -> String {     } } +/// Fit the chip drawing (all polylines) into the free lane between the pin-name columns.+/// Names are estimated at 62 mil per character (Times New Roman 10 pt on the 100 mil grid)+/// starting 60 mil inside the body edge. Rects/circles/arcs pass through untouched.+fn fit_art_to_lane(graphics: &[Graphic], pins: &[crate::model::Pin], bbox: (f64, f64, f64, f64)) -> Vec<Graphic> {+    const CHAR_W: f64 = 62.0;+    const NAME_GAP: f64 = 60.0;+    const MARGIN: f64 = 50.0;+    let (mut lane_l, mut lane_r) = (bbox.0 + NAME_GAP, bbox.2 - NAME_GAP);+    for p in pins {+        let len = p.length.unwrap_or(200) as f64;+        let n = p.name.chars().count() as f64;+        match (p.rotation / 90) % 4 {+            0 => lane_l = lane_l.max(p.x as f64 + len + NAME_GAP + n * CHAR_W),   // pin on the left edge+            2 => lane_r = lane_r.min(p.x as f64 - len - NAME_GAP - n * CHAR_W),   // pin on the right edge+            _ => {}+        }+    }+    let (mut ax0, mut ay0, mut ax1, mut ay1) = (f64::INFINITY, f64::INFINITY, f64::NEG_INFINITY, f64::NEG_INFINITY);+    for g in graphics {+        if let Graphic::Polyline { points, .. } = g {+            for pt in points { ax0 = ax0.min(pt[0]); ay0 = ay0.min(pt[1]); ax1 = ax1.max(pt[0]); ay1 = ay1.max(pt[1]); }+        }+    }+    if !ax0.is_finite() || lane_r - lane_l < 4.0 * MARGIN {+        return graphics.to_vec();+    }+    let art_w = (ax1 - ax0).max(1.0);+    let avail = lane_r - lane_l - 2.0 * MARGIN;+    let scale = (avail / art_w).min(1.0);+    let (acx, acy) = ((ax0 + ax1) / 2.0, (ay0 + ay1) / 2.0);+    let lane_c = (lane_l + lane_r) / 2.0;+    let fits_already = ax0 >= lane_l + MARGIN && ax1 <= lane_r - MARGIN;+    if fits_already && scale >= 1.0 {+        return graphics.to_vec();+    }+    graphics.iter().map(|g| match g {+        Graphic::Polyline { points, width } => Graphic::Polyline {+            points: points.iter().map(|pt| [lane_c + (pt[0] - acx) * scale, acy + (pt[1] - acy) * scale]).collect(),+            width: *width,+        },+        other => other.clone(),+    }).collect()+}+ /// Emit one symbol graphic as its Altium record, with sub-10-mil precision via /// `_Frac` fields. Polyline→RECORD=6, Rect→RECORD=14, Circle→RECORD=11, /// Arc→RECORD=12.@@ -462,9 +533,10 @@ fn emit_graphic(g: &Graphic, name: &str, gi: usize) -> Result<Vec<u8>> {     // RGB(0,0,255) stored as R + G*256 + B*65536 = 16711680. (Was 128 = maroon.)     const BLUE: u32 = 16711680;     match g {-        Graphic::Polyline { points, .. } => {+        Graphic::Polyline { points, width } => {             let mut s = format!(-                "|RECORD=6|OwnerPartId=1|LineWidth=1|Color={BLUE}|LocationCount={}",+                "|RECORD=6|OwnerPartId=1|LineWidth={}|Color={BLUE}|LocationCount={}",+                line_width_of(*width),                 points.len()             );             for (i, p) in points.iter().enumerate() {@@ -483,25 +555,46 @@ fn emit_graphic(g: &Graphic, name: &str, gi: usize) -> Result<Vec<u8>> {             coord_field("Corner.Y", *y2),             if *filled { "T" } else { "F" }         )),-        Graphic::Circle { cx, cy, r, .. } => u16_text_record(&format!(+        Graphic::Circle { cx, cy, r, width } => u16_text_record(&format!(             "|RECORD=11|OwnerPartId=1{}{}{}{}\-|LineWidth=1|Color={BLUE}|UniqueID={uid}",+|LineWidth={}|Color={BLUE}|UniqueID={uid}",             coord_field("Location.X", *cx),             coord_field("Location.Y", *cy),             coord_field("Radius", *r),             coord_field("SecondaryRadius", *r),+            line_width_of(*width),         )),-        Graphic::Arc { cx, cy, r, start, end, .. } => u16_text_record(&format!(+        Graphic::Arc { cx, cy, r, start, end, width } => u16_text_record(&format!(             "|RECORD=12|OwnerPartId=1{}{}{}|StartAngle={:.3}|EndAngle={:.3}\-|LineWidth=1|Color={BLUE}|UniqueID={uid}",+|LineWidth={}|Color={BLUE}|UniqueID={uid}",             coord_field("Location.X", *cx),             coord_field("Location.Y", *cy),             coord_field("Radius", *r),-            start, end+            start, end,+            line_width_of(*width),         )),     } } +/// Altium's four stroke widths from a source stroke in mils: 0 Smallest (a one-pixel+/// hairline at every zoom), 1 Small (10 mil), 2 Medium (20 mil), 3 Large (30 mil).+/// The chip-thumbnailer outline art arrives at ~6.5 mil (0.167 mm); at Small it+/// rendered as a smeared ~4 px stroke in the Symbol editor (John, 2026-09-19: "make+/// the stroke 1/2 or 1/3 as thick so it's crisper"), so anything at or under 8 mil+/// becomes the hairline. KiCad's 10 mil default stays Small, the body rectangle is+/// written separately and always Small.+fn line_width_of(width_mil: f64) -> u8 {+    if width_mil <= 8.0 {+        0+    } else if width_mil <= 15.0 {+        1+    } else if width_mil <= 25.0 {+        2+    } else {+        3+    }+}+ /// Build the 36+ byte binary pin payload (before framing). fn encode_pin_payload(pin: &Pin, _idx: usize, show_name: bool, show_designator: bool) -> Result<Vec<u8>> {     let mut p = PIN_PREFIX.to_vec();