Altium - the Altium Bridge

@@ -38,7 +38,7 @@ fn page_automation_id(action: &str) -> Option<&'static str> {  /// UIA first (quiet), image-space click only if UIA cannot reach the control. fn click_by_name_then_pixels(hwnd: i64, name: &str, automation_id: Option<&str>, pixel: impl FnOnce() -> Value) -> Value {-    let mut args = json!({"hwnd": hwnd, "name": name, "role": "button"});+    let mut args = json!({"hwnd": hwnd, "name": name, "role": "button", "reason": "altium licence page: click the named button"});     if let Some(id) = automation_id {         args["automationId"] = json!(id);     }@@ -57,6 +57,29 @@ fn click_by_name_then_pixels(hwnd: i64, name: &str, automation_id: Option<&str>,     out } +/// The licence-page positions in `page_coords` are pixels of a 1400-px-wide capture of the maximised+/// main window (the safe frame ab hands back). Map one onto physical screen pixels through the+/// window's own rectangle.+fn page_to_screen(rect: &Value, x: i64, y: i64) -> Option<(i64, i64)> {+    let g = |a: &str, b: &str| rect.get(a).or_else(|| rect.get(b)).and_then(|v| v.as_i64());+    let (left, top, w) = (g("left", "x")?, g("top", "y")?, g("width", "w")?);+    if w < 200 { return None; }+    let k = w as f64 / 1400.0;+    Some((left + (x as f64 * k).round() as i64, top + (y as f64 * k).round() as i64))+}++/// The shotId of a desktop_screenshot_window reply, wherever ab nests it (top level, coordMap, data).+fn find_shot_id(v: &Value) -> Option<Value> {+    match v {+        Value::Object(m) => {+            if let Some(Value::String(id)) = m.get("shotId") { return Some(json!(id)); }+            m.values().find_map(find_shot_id)+        }+        Value::Array(a) => a.iter().find_map(find_shot_id),+        _ => None,+    }+}+ /// Drive the License Management page. Every call returns a capture so the caller can see the /// state and click anything else itself. pub fn license(args: &Value) -> Value {@@ -78,22 +101,34 @@ pub fn license(args: &Value) -> Value {         agent::call_no_autostart("run_process", &[("process", "Client:MyAccount".into()), ("params", "".into())], Duration::from_secs(20));     }     std::thread::sleep(Duration::from_secs(1));-    let win = ab::call("desktop_screenshot_window", json!({"hwnd": hwnd}), &[], 20);+    // the pixel fallback clicks in THIS screenshot's coordinates, so it needs its shotId (#19: the+    // call carried no reason and came back without one, so the fallback never ran)+    let win = ab::call("desktop_screenshot_window", json!({"hwnd": hwnd, "reason": "altium licence page: the frame the pixel fallback clicks in"}), &[], 30);     let mut frame = shot::shot_of_main();-    let shot_id = win.get("coordMap").and_then(|c| c.get("shotId")).or_else(|| win.get("shotId")).cloned();+    let shot_id = find_shot_id(&win);     if frame.is_object() {         frame["shotId"] = shot_id.clone().unwrap_or(Value::Null);         frame["coordMap"] = win.get("coordMap").cloned().unwrap_or(Value::Null);     }     let mut out = json!({"success": true, "licenceState": instance::licence_state().get("state"),         "shot": frame, "windowEtiquette": "background"});+    if shot_id.is_none() {+        out["pixelFallbackUnavailable"] = json!({"screenshotSuccess": win.get("success"), "error": win.get("error"),+            "errorCode": win.get("errorCode"), "keys": win.as_object().map(|o| o.keys().cloned().collect::<Vec<_>>())});+    }     if let Some((x, y)) = page_coords(&action) {         let sid = shot_id.clone();+        let rect = instance::main_window().map(|w| instance::norm_rect(&w));         let r = click_by_name_then_pixels(hwnd, page_name(&action), page_automation_id(&action), move || {-            match sid {-                Some(id) if !id.is_null() =>-                    ab::call("desktop_click", json!({"space": "image", "shotId": id, "x": x, "y": y, "hwnd": hwnd}), &[], 20),-                _ => json!({"success": false, "error": "no shotId for the pixel fallback"}),+            let why = "altium licence page: the pixel fallback for a button UI Automation did not find";+            match (sid, rect.as_ref().and_then(|r| page_to_screen(r, x, y))) {+                (Some(id), _) if !id.is_null() =>+                    ab::call("desktop_click", json!({"space": "image", "shotId": id, "x": x, "y": y, "hwnd": hwnd, "reason": why}), &[], 20),+                // ab's direct API returns a bare image with no shotId (#19), so the bridge maps the page+                // position onto the window itself: screen = window origin + position x (window width / 1400)+                (_, Some((sx, sy))) =>+                    ab::call("desktop_click", json!({"space": "screen", "x": sx, "y": sy, "hwnd": hwnd, "reason": why}), &[], 20),+                _ => json!({"success": false, "error": "no shotId and no window rectangle for the pixel fallback"}),             }         });         out["windowEtiquette"] = r.get("windowEtiquette").cloned().unwrap_or(json!("foreground"));@@ -268,3 +303,17 @@ pub fn connect_workspace(_args: &Value) -> Value {     json!({"success": true, "picker": picker, "shot": shot, "windowEtiquette": "background",         "_hint": "The picker lists candidate workspaces; click the wanted row with ab desktop_click {space:'image', shotId, x, y}. It is a popup — it closes on focus loss."}) }++#[cfg(test)]+mod page_tests {+    use super::*;++    #[test]+    fn page_to_screen_maps_through_the_window_rect() {+        // the laptop's maximised AD 26.11.1 window: 2582 x 1550 physical px at (-11, -11), safe frame 1400 px+        let r = json!({"left": -11, "top": -11, "width": 2582, "height": 1550});+        assert_eq!(page_to_screen(&r, 1288, 178), Some((-11 + 2375, -11 + 328)));+        assert_eq!(page_to_screen(&json!({"x": 0, "y": 0, "w": 1400, "h": 840}), 700, 420), Some((700, 420)));+        assert_eq!(page_to_screen(&json!({"left": 0, "top": 0, "width": 10}), 5, 5), None);+    }+}

@@ -808,35 +808,61 @@ fn same_file_name(a: &std::path::Path, b: &std::path::Path) -> bool {     } } +/// Altium's own view of a project: the documents it holds OPEN under that project, and those of them+/// the project FILE does not list (they joined in memory only). Closing the project over an unlisted,+/// modified member raises "Save changes?" on the user's screen.+fn project_members(prj: &std::path::Path) -> (Vec<String>, Vec<String>) {+    let dir = prj.parent().unwrap_or(std::path::Path::new("."));+    let listed = std::fs::read(prj).map(|b| listed_documents(&String::from_utf8_lossy(&b), dir)).unwrap_or_default();+    let name = prj.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();+    let st = agent::call("state", &[], None, Duration::from_secs(30));+    let open: Vec<String> = st.get("data").and_then(|d| d.get("documents")).and_then(|d| d.as_array()).cloned().unwrap_or_default()+        .iter().filter(|d| d["project"].as_str().map(|p| p.eq_ignore_ascii_case(&name)).unwrap_or(false) && d["open"].as_bool() == Some(true))+        .filter_map(|d| d["path"].as_str().map(str::to_string)).collect();+    let unlisted = open.iter().filter(|o| !listed.iter().any(|l| same_file_name(l, std::path::Path::new(o.as_str())))).cloned().collect();+    (open, unlisted)+}++/// Save every open member of a project, then close them and the project: no prompt, nothing lost.+fn close_project_saved(prj: &str, open: &[String]) {+    for d in open {+        let _ = crate::surfaces::save(&json!({"filePath": d}));+    }+    for d in open.iter().map(|s| s.as_str()).chain(std::iter::once(prj)) {+        let _ = agent::call("close_document", &[("path", d.to_string())], None, Duration::from_secs(30));+    }+}+ /// A board built into a folder whose project already lists it (altium_build_schematic writes the /// project first) is created as a new document that joins the project and is then renamed onto the /// listed path: Altium holds the file twice, one entry greyed, and a second hidden view survives a-/// project close (#23). Save the project's sheets, boards and libraries, close them and the project,-/// reopen the project and show the board: one entry, one view. None when no project lists the board.-fn reopen_listing_project(pcb: &str) -> Option<String> {+/// project close (#23). Save every open member of that project, close them and the project, reopen it+/// and show the board: one entry, one view.+/// The members come from Altium's own view (the agent's state), not the file: a document that joined+/// the project in memory only is not in the file, and closing the project over it raised "Save+/// changes? battery.PcbDoc" mid-battery. When the project holds such a member the reopen is skipped+/// (the caller's documents are not this verb's to close). None when no project lists the board.+fn reopen_listing_project(pcb: &str) -> Option<Value> {     let pcb_p = std::path::Path::new(pcb);     let dir = pcb_p.parent()?;-    let (prj, docs) = std::fs::read_dir(dir).ok()?.flatten().map(|e| e.path())+    let (prj, listed) = std::fs::read_dir(dir).ok()?.flatten().map(|e| e.path())         .filter(|p| p.extension().map(|x| x.eq_ignore_ascii_case("prjpcb")).unwrap_or(false))         .find_map(|prj| {             let text = String::from_utf8_lossy(&std::fs::read(&prj).ok()?).to_string();             let docs = listed_documents(&text, dir);             docs.iter().any(|d| same_file_name(d, pcb_p)).then_some((prj, docs))         })?;-    const KINDS: [&str; 4] = ["schdoc", "pcbdoc", "schlib", "pcblib"];-    let docs: Vec<String> = docs.iter()-        .filter(|d| d.extension().map(|x| KINDS.contains(&x.to_string_lossy().to_lowercase().as_str())).unwrap_or(false))-        .map(|d| d.display().to_string()).collect();-    for d in &docs {-        let _ = crate::surfaces::save(&json!({"filePath": d}));-    }-    for d in docs.iter().chain(std::iter::once(&prj.display().to_string())) {-        let _ = agent::call("close_document", &[("path", d.clone())], None, Duration::from_secs(30));-    }     let prj_s = prj.display().to_string();+    let _ = listed;+    let (open, unlisted) = project_members(&prj);+    if !unlisted.is_empty() {+        return Some(json!({"project": prj_s, "reopened": false,+            "skipped": format!("the open project also holds documents its file does not list ({}); they are not this verb's to close", unlisted.join(", "))}));+    }+    close_project_saved(&prj_s, &open);     let _ = crate::support::agent_open(&prj_s, 90);     let _ = crate::support::agent_open(pcb, 90);-    Some(prj_s)+    Some(json!({"project": prj_s, "reopened": true, "closed": open})) }  pub fn build_board(args: &Value) -> Value {@@ -1162,8 +1188,18 @@ pub fn build_schematic(args: &Value) -> Value {     // written only when it changes: rewriting an OPEN project's file makes Altium ask to reload it     // (a modal that blocked the next verb, measured 2026-10-15)     if std::fs::read_to_string(&prj).ok().as_deref() != Some(text.as_str()) {-        // an open project closes first, so the new file opens clean instead of asking to reload-        if std::path::Path::new(&prj).exists() { agent::call("close_document", &[("path", prj.clone())], None, Duration::from_secs(60)); }+        // an open project closes first, so the new file opens clean instead of asking to reload; its+        // open members are saved and closed with it (closing it over a modified one raised "Save+        // changes?", then the rewrite raised "Reload?", mid-battery 2026-10-16). Documents that joined+        // it in memory only are the caller's: refuse rather than close them.+        if std::path::Path::new(&prj).exists() {+            let (open, unlisted) = project_members(std::path::Path::new(&prj));+            if !unlisted.is_empty() {+                return err("project_has_unlisted_documents", format!("{prj} is open in Altium with documents its file does not list: {}", unlisted.join(", ")),+                    "Save or close those documents (or the project) first: altium_save / altium_close_document, then call again. The bridge will not close documents it did not make.");+            }+            close_project_saved(&prj, &open);+        }         if let Err(e) = std::fs::write(&prj, &text) { return err("write_failed", format!("could not write {prj}: {e}"), ""); }     }     // the project open first, so the sheet the agent opens is the project's