Loading files
This file is pinned to the selected release. Download the original to open it in your design tool.
// Note: Using placeholder types until kicad-api-rs is available
// The actual crate might have different module structure
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
use egui_lens::{ReactiveEventLogger, ReactiveEventLoggerState, LogColors};
use egui_mobius_reactive::Dynamic;
// Placeholder types until we can import the actual kicad-api-rs
pub struct KiCad;
pub struct KiCadConnectionConfig {
pub socket_path: String,
pub token: String,
}
impl KiCad {
pub fn new(_config: KiCadConnectionConfig) -> Result<Self, String> {
// Placeholder implementation
Err("KiCad API not yet available - waiting for crate publication".to_string())
}
}
pub struct KiCadConnection {
kicad: Option<KiCad>,
is_connected: bool,
last_error: Option<String>,
}
impl KiCadConnection {
pub fn new() -> Self {
Self {
kicad: None,
is_connected: false,
last_error: None,
}
}
pub fn connect(&mut self, client_name: &str) -> Result<(), String> {
match KiCad::new(KiCadConnectionConfig {
socket_path: format!("/tmp/kicad-{}", client_name),
token: String::new(),
}) {
Ok(kicad) => {
self.kicad = Some(kicad);
self.is_connected = true;
self.last_error = None;
Ok(())
}
Err(e) => {
let error_msg = format!("Failed to connect to KiCad: {:?}", e);
self.last_error = Some(error_msg.clone());
self.is_connected = false;
Err(error_msg)
}
}
}
pub fn disconnect(&mut self) {
self.kicad = None;
self.is_connected = false;
}
pub fn is_connected(&self) -> bool {
self.is_connected
}
pub fn get_gerber_data(&mut self, _layer_name: &str) -> Result<String, String> {
if let Some(ref mut _kicad) = self.kicad {
// TODO: Implement actual Gerber export via KiCad API
// For now, return placeholder
Err("Gerber export not yet implemented".to_string())
} else {
Err("Not connected to KiCad".to_string())
}
}
pub fn get_board_info(&mut self) -> Result<BoardInfo, String> {
if let Some(ref mut _kicad) = self.kicad {
// TODO: Get actual board info from KiCad
// For now, return placeholder
Ok(BoardInfo {
filename: "Unknown".to_string(),
layer_count: 0,
board_outline: None,
})
} else {
Err("Not connected to KiCad".to_string())
}
}
}
#[derive(Debug, Clone)]
pub struct BoardInfo {
pub filename: String,
pub layer_count: usize,
pub board_outline: Option<Vec<(f64, f64)>>,
}
pub struct KiCadMonitor {
connection: Arc<Mutex<KiCadConnection>>,
update_callback: Option<Box<dyn Fn() + Send + Sync>>,
monitor_thread: Option<thread::JoinHandle<()>>,
should_stop: Arc<Mutex<bool>>,
}
impl KiCadMonitor {
pub fn new() -> Self {
Self {
connection: Arc::new(Mutex::new(KiCadConnection::new())),
update_callback: None,
monitor_thread: None,
should_stop: Arc::new(Mutex::new(false)),
}
}
pub fn connect(&self, client_name: &str) -> Result<(), String> {
let mut conn = self.connection.lock().unwrap();
conn.connect(client_name)
}
pub fn disconnect(&mut self) {
*self.should_stop.lock().unwrap() = true;
if let Some(thread) = self.monitor_thread.take() {
thread.join().ok();
}
let mut conn = self.connection.lock().unwrap();
conn.disconnect();
}
pub fn start_monitoring(&mut self, update_interval: Duration) {
let _connection = Arc::clone(&self.connection);
let should_stop = Arc::clone(&self.should_stop);
// Can't clone Box<dyn Fn()>, so we'll handle this differently
*should_stop.lock().unwrap() = false;
self.monitor_thread = Some(thread::spawn(move || {
while !*should_stop.lock().unwrap() {
// Check for updates from KiCad
// TODO: Implement actual update detection
// Callback will be handled differently
thread::sleep(update_interval);
}
}));
}
pub fn set_update_callback<F>(&mut self, callback: F)
where
F: Fn() + Send + Sync + 'static,
{
self.update_callback = Some(Box::new(callback));
}
pub fn is_connected(&self) -> bool {
let conn = self.connection.lock().unwrap();
conn.is_connected()
}
pub fn get_connection(&self) -> Arc<Mutex<KiCadConnection>> {
Arc::clone(&self.connection)
}
}
impl Drop for KiCadMonitor {
fn drop(&mut self) {
self.disconnect();
}
}
/// UI helper functions for KiCad connection status
pub fn show_kicad_status(
ui: &mut egui::Ui,
monitor: &mut KiCadMonitor,
logger_state: &Dynamic<ReactiveEventLoggerState>,
log_colors: &Dynamic<LogColors>,
) {
let logger = ReactiveEventLogger::with_colors(logger_state, log_colors);
ui.horizontal(|ui| {
ui.label("KiCad Status:");
if monitor.is_connected() {
ui.colored_label(egui::Color32::GREEN, "● Connected");
if ui.button("Disconnect").clicked() {
monitor.disconnect();
logger.log_info("Disconnected from KiCad");
}
if ui.button("Refresh").clicked() {
logger.log_info("Refreshing data from KiCad...");
// TODO: Trigger manual refresh
}
} else {
ui.colored_label(egui::Color32::RED, "● Disconnected");
if ui.button("Connect").clicked() {
match monitor.connect("KiForge") {
Ok(_) => {
logger.log_info("Connected to KiCad successfully");
}
Err(e) => {
logger.log_error(&format!("Failed to connect: {}", e));
}
}
}
}
});
}97dbefef4This file is pinned to the selected release. Download the original to open it in your design tool.