Added debug output

Added GUI

src/gui/state.rs

@@ -0,0 +1,169 @@
+//! # GUI State Management
+//!
+//! This module manages the state of the GUI application, including system status,
+//! component states, and user interface state. It provides thread-safe access
+//! to emulator state for real-time GUI updates.
+
+use crate::system_config::ConfigurableSystem;
+use std::sync::{Arc, Mutex};
+
+/// GUI state structure containing all UI-relevant data
+#[derive(Debug, Clone)]
+pub struct GuiState {
+    /// Whether a system is currently loaded
+    pub system_loaded: bool,
+    /// Whether the system is currently running
+    pub system_running: bool,
+    /// Current cycle count
+    pub cycle_count: u64,
+    /// System information
+    pub system_info: Option<SystemInfo>,
+    /// Component states
+    pub component_states: ComponentStates,
+    /// Memory state
+    pub memory_state: MemoryState,
+    /// CPU register state
+    pub register_state: RegisterState,
+    /// Last error message
+    pub last_error: Option<String>,
+}
+
+/// System information for display
+#[derive(Debug, Clone)]
+pub struct SystemInfo {
+    pub name: String,
+    pub description: String,
+    pub component_count: usize,
+    pub cpu_speed: f64,
+    pub rom_size: usize,
+    pub ram_size: usize,
+}
+
+/// Component states for monitoring
+#[derive(Debug, Clone)]
+pub struct ComponentStates {
+    pub cpu_running: bool,
+    pub ram_running: bool,
+    pub rom_running: bool,
+    pub clock_running: bool,
+}
+
+/// Memory state for display
+#[derive(Debug, Clone)]
+pub struct MemoryState {
+    pub ram_contents: Vec<[u8; 4]>, // 4 banks of RAM data
+    pub selected_bank: usize,
+    pub selected_address: usize,
+}
+
+/// CPU register state for display
+#[derive(Debug, Clone)]
+pub struct RegisterState {
+    pub accumulator: u8,
+    pub carry_flag: bool,
+    pub program_counter: u16,
+    pub index_registers: [u8; 16], // 16 index registers (R0-R15)
+    pub stack_pointer: u8,
+}
+
+impl GuiState {
+    /// Create a new GUI state instance
+    pub fn new() -> Self {
+        Self {
+            system_loaded: false,
+            system_running: false,
+            cycle_count: 0,
+            system_info: None,
+            component_states: ComponentStates {
+                cpu_running: false,
+                ram_running: false,
+                rom_running: false,
+                clock_running: false,
+            },
+            memory_state: MemoryState {
+                ram_contents: vec![[0; 4]; 4], // Initialize 4 banks with 4 bytes each
+                selected_bank: 0,
+                selected_address: 0,
+            },
+            register_state: RegisterState {
+                accumulator: 0,
+                carry_flag: false,
+                program_counter: 0,
+                index_registers: [0; 16],
+                stack_pointer: 0,
+            },
+            last_error: None,
+        }
+    }
+
+    /// Update state from the current system
+    pub fn update_from_system(&mut self, system: &Arc<Mutex<ConfigurableSystem>>) {
+        if let Ok(system_guard) = system.lock() {
+            // Update basic system state
+            self.system_running = system_guard.is_running();
+
+            // Update system info if not already set
+            if self.system_info.is_none() {
+                self.system_info = Some(system_guard.get_system_info().into());
+            }
+
+            // Update component states
+            self.update_component_states(&system_guard);
+
+            // Update cycle count (simulate for now)
+            if self.system_running {
+                self.cycle_count += 1;
+            }
+        }
+    }
+
+    /// Update component running states
+    fn update_component_states(&mut self, system: &ConfigurableSystem) {
+        let components = system.get_components();
+
+        self.component_states.cpu_running = components
+            .get("CPU_4004")
+            .map_or(false, |comp| comp.lock().map_or(false, |c| c.is_running()));
+
+        self.component_states.ram_running = components
+            .get("RAM_4002")
+            .map_or(false, |comp| comp.lock().map_or(false, |c| c.is_running()));
+
+        self.component_states.rom_running = components
+            .get("ROM_4001_1")
+            .or_else(|| components.get("ROM_4001_2"))
+            .map_or(false, |comp| comp.lock().map_or(false, |c| c.is_running()));
+
+        self.component_states.clock_running = components
+            .get("SYSTEM_CLOCK")
+            .map_or(false, |comp| comp.lock().map_or(false, |c| c.is_running()));
+    }
+
+    /// Set an error message
+    pub fn set_error(&mut self, error: String) {
+        self.last_error = Some(error);
+    }
+
+    /// Clear the error message
+    pub fn clear_error(&mut self) {
+        self.last_error = None;
+    }
+
+    /// Get the current error message
+    pub fn get_error(&self) -> Option<&str> {
+        self.last_error.as_deref()
+    }
+}
+
+impl From<crate::system_config::SystemInfo> for SystemInfo {
+    fn from(info: crate::system_config::SystemInfo) -> Self {
+        Self {
+            name: info.name,
+            description: info.description,
+            component_count: info.component_count,
+            cpu_speed: info.cpu_speed,
+            rom_size: info.rom_size,
+            ram_size: info.ram_size,
+        }
+    }
+}