Fix d latch simulation

Glyphack · Glyphack · commit 5a411fdb5ab4 · 2025-12-09T17:46:44.000+01:00
diff --git a/src/app.rs b/src/app.rs
@@ -324,6 +324,7 @@ impl App {
     }
 
     fn is_on(&self, pin: Pin) -> bool {
+        let pin = pin.is_passthrough(&self.db).unwrap_or(pin);
         let Some(v) = self.simulator.current.get(&pin) else {
             return false;
         };
@@ -448,6 +449,7 @@ impl App {
                 self.draw_panel_button(ui, InstanceKind::Gate(GateKind::Nor));
                 self.draw_panel_button(ui, InstanceKind::Gate(GateKind::Xor));
                 self.draw_panel_button(ui, InstanceKind::Gate(GateKind::Xnor));
+                self.draw_panel_button(ui, InstanceKind::Gate(GateKind::Not));
                 self.draw_panel_button(ui, InstanceKind::Power);
                 self.draw_panel_button(ui, InstanceKind::Lamp);
                 self.draw_panel_button(ui, InstanceKind::Clock);
@@ -726,7 +728,7 @@ impl App {
         Self::draw_grid(ui, canvas_rect, self.viewport_offset);
 
         let mouse_clicked_canvas = resp.clicked();
-        let mouse_dragging_canvas = resp.dragged();
+        let mouse_dragging_canvas = resp.dragged_by(egui::PointerButton::Primary);
         let double_clicked = ui.input(|i| {
             i.pointer
                 .button_double_clicked(egui::PointerButton::Primary)
@@ -949,7 +951,7 @@ impl App {
         }
     }
 
-    fn draw_instance_graphics_new(
+    fn draw_instance_graphics(
         &mut self,
         ui: &mut Ui,
         graphics: assets::InstanceGraphics,
@@ -1024,15 +1026,15 @@ impl App {
             let gate = self.db.circuit.get_gate(id);
             (gate.pos, gate.kind)
         };
-        self.draw_instance_graphics_new(ui, kind.graphics(), self.adjusted_pos(pos), id);
+        self.draw_instance_graphics(ui, kind.graphics(), self.adjusted_pos(pos), id);
     }
 
     fn draw_power(&mut self, ui: &mut Ui, id: InstanceId) {
         let (pos, graphics) = {
             let power = self.db.circuit.get_power(id);
             (power.pos, power.graphics())
         };
-        self.draw_instance_graphics_new(ui, graphics, self.adjusted_pos(pos), id);
+        self.draw_instance_graphics(ui, graphics, self.adjusted_pos(pos), id);
     }
 
     fn draw_lamp(&mut self, ui: &mut Ui, id: InstanceId) {
@@ -1058,7 +1060,7 @@ impl App {
             }
         }
 
-        self.draw_instance_graphics_new(ui, graphics, pos, id);
+        self.draw_instance_graphics(ui, graphics, pos, id);
     }
 
     fn draw_clock(&mut self, ui: &mut Ui, id: InstanceId) {
@@ -1067,7 +1069,7 @@ impl App {
             (clock.pos, clock.graphics())
         };
         let pos = self.adjusted_pos(pos);
-        self.draw_instance_graphics_new(ui, graphics, pos, id);
+        self.draw_instance_graphics(ui, graphics, pos, id);
     }
 
     fn draw_module(&mut self, ui: &mut Ui, id: InstanceId) {
@@ -1253,7 +1255,7 @@ impl App {
                 && let Some(split_point) = self.wire_branching_action_point(mouse, id)
             {
                 ui.painter().circle_filled(
-                    split_point,
+                    self.adjusted_pos(split_point),
                     PIN_HOVER_THRESHOLD,
                     COLOR_HOVER_PIN_TO_WIRE,
                 );
@@ -1267,7 +1269,7 @@ impl App {
                     && let Some(split_point) = self.wire_branching_action_point(mouse, id)
                 {
                     ui.painter().circle_filled(
-                        split_point,
+                        self.adjusted_pos(split_point),
                         PIN_HOVER_THRESHOLD,
                         COLOR_HOVER_PIN_TO_WIRE,
                     );
@@ -1869,7 +1871,7 @@ impl App {
         pos - self.viewport_offset
     }
 
-    fn mouse_pos_world(&self, ui: &Ui) -> Option<Pos2> {
+    pub fn mouse_pos_world(&self, ui: &Ui) -> Option<Pos2> {
         ui.ctx()
             .pointer_interact_pos()
             .map(|p| p + self.viewport_offset)
diff --git a/src/assets.rs b/src/assets.rs
@@ -141,6 +141,20 @@ pub static XNOR_GRAPHICS: InstanceGraphics = InstanceGraphics {
     ],
 };
 
+pub static NOT_GRAPHICS: InstanceGraphics = InstanceGraphics {
+    svg: include_image!("../assets/not.svg"),
+    pins: &[
+        PinGraphics {
+            kind: PinKind::Input,
+            offset: Vec2::new(-40.0, 0.0),
+        },
+        PinGraphics {
+            kind: PinKind::Output,
+            offset: Vec2::new(40.0, 0.0),
+        },
+    ],
+};
+
 pub static POWER_ON_GRAPHICS: InstanceGraphics = InstanceGraphics {
     svg: include_image!("../assets/switch-on.svg"),
     pins: &[PinGraphics {
diff --git a/src/db.rs b/src/db.rs
@@ -6,6 +6,7 @@ use egui::{Pos2, Vec2, pos2};
 use slotmap::{SecondaryMap, SlotMap};
 
 use crate::assets::PinKind;
+use crate::connection_manager::ConnectionKind;
 use crate::{
     assets::{self},
     config::CanvasConfig,
@@ -297,6 +298,82 @@ impl Circuit {
                 )
                 .ok();
             }
+
+            // Show instance members for modules with indentation
+            if let InstanceKind::Module(_) = kind {
+                let module = self.get_module(*id);
+                let member_count = module.instance_members.len();
+                for (member_idx, member_id) in module.instance_members.iter().enumerate() {
+                    let is_last_member = member_idx == member_count - 1;
+                    let member_branch = if is_last_member { "`-" } else { "|-" };
+                    let member_cont = if is_last_member {
+                        format!("{cont}   ")
+                    } else {
+                        format!("{cont}|  ")
+                    };
+
+                    // Member header
+                    let member_kind = self.ty(*member_id);
+                    let member_header = self.instance_header(*member_id, member_kind, db);
+                    writeln!(out, "{cont}{member_branch} {member_header}").ok();
+
+                    // Get pins for this member
+                    let member_pins = self.pins_of(*member_id, db);
+                    let member_pin_count = member_pins.len();
+
+                    for (member_pin_idx, member_pin) in member_pins.iter().enumerate() {
+                        let is_last_member_pin = member_pin_idx == member_pin_count - 1;
+                        let member_pin_branch = if is_last_member_pin { "`-" } else { "|-" };
+
+                        // Get connections for this member pin
+                        let member_connected = self.connected_pins(*member_pin);
+                        let member_kind_str = match member_pin.kind {
+                            PinKind::Input => "In",
+                            PinKind::Output => "Out",
+                        };
+                        let member_arrow = match member_pin.kind {
+                            PinKind::Input => "<-",
+                            PinKind::Output => "->",
+                        };
+
+                        let member_conn_str = if member_connected.is_empty() {
+                            "(unconnected)".to_owned()
+                        } else {
+                            member_connected
+                                .iter()
+                                .map(|p| p.display_short(self, db))
+                                .collect::<Vec<_>>()
+                                .join(", ")
+                        };
+
+                        // Get pin state if simulator is available
+                        let member_state_str = if let Some(sim) = simulator {
+                            if let Some(&value) = sim.current.get(member_pin) {
+                                match value {
+                                    crate::simulator::Value::One => " O",
+                                    crate::simulator::Value::Zero => " N",
+                                    crate::simulator::Value::X => " X",
+                                }
+                            } else {
+                                ""
+                            }
+                        } else {
+                            ""
+                        };
+
+                        writeln!(
+                            out,
+                            "{member_cont}{member_pin_branch} #{} ({})  {} {}{}",
+                            member_pin.index,
+                            member_kind_str,
+                            member_arrow,
+                            member_conn_str,
+                            member_state_str
+                        )
+                        .ok();
+                    }
+                }
+            }
         }
 
         writeln!(out).ok();
@@ -873,6 +950,7 @@ pub enum GateKind {
     Nor,
     Xor,
     Xnor,
+    Not,
 }
 
 #[derive(serde::Deserialize, serde::Serialize, Copy, Debug, Clone)]
@@ -890,6 +968,7 @@ impl GateKind {
             Self::Nor => assets::NOR_GRAPHICS.clone(),
             Self::Xor => assets::XOR_GRAPHICS.clone(),
             Self::Xnor => assets::XNOR_GRAPHICS.clone(),
+            Self::Not => assets::NOT_GRAPHICS.clone(),
         }
     }
 }
@@ -1110,4 +1189,17 @@ impl Pin {
     pub fn new(ins: InstanceId, index: u32, kind: PinKind) -> Self {
         Self { ins, index, kind }
     }
+
+    pub fn is_passthrough(&self, db: &DB) -> Option<Self> {
+        let conns = db.circuit.connections_containing(*self);
+
+        for conn in conns {
+            if conn.kind != ConnectionKind::BI {
+                continue;
+            }
+            let connected_pin = conn.get_other_pin(*self);
+            return Some(connected_pin);
+        }
+        None
+    }
 }
diff --git a/src/drag.rs b/src/drag.rs
@@ -4,6 +4,7 @@ use egui::{CornerRadius, Pos2, Rect, Stroke, StrokeKind, Ui, Vec2, pos2};
 
 use crate::app::{App, COLOR_HOVER_PIN_TO_WIRE, COLOR_SELECTION_BOX, MIN_WIRE_SIZE};
 
+use crate::assets::PinKind;
 use crate::db::{InstanceId, InstanceKind, LabelId, Pin, Wire};
 
 #[derive(serde::Deserialize, serde::Serialize, Debug, Clone, Copy)]
@@ -172,26 +173,33 @@ impl App {
                     self.connection_manager.mark_instance_dirty(id);
                 }
             }
-            // TODO: There is an issue with non zero viewport_offset. It causes the wire to start
-            // from wrong place and distance to calculate wrong
             Some(Drag::PinToWire { source_pin }) => {
-                let start = self.adjusted_pos(source_pin.pos(&self.db, &self.canvas_config));
+                let start = source_pin.pos(&self.db, &self.canvas_config);
                 let end_abs = mouse;
                 let drag_distance = start.distance(end_abs);
 
                 if drag_distance >= MIN_WIRE_SIZE {
-                    let wire = Wire::new(start, mouse);
+                    // Start is input so if the current pin is input we need to reverse the wire
+                    let (new_w_start, new_w_end) = if source_pin.kind == PinKind::Input {
+                        (mouse, start)
+                    } else {
+                        (start, mouse)
+                    };
+                    let wire = Wire::new(new_w_start, new_w_end);
                     let wire_id = self.db.circuit.new_wire(wire);
 
                     self.drag = Some(Drag::Resize {
                         id: wire_id,
-                        start: false,
+                        start: source_pin.kind == PinKind::Input,
                     });
 
                     self.connection_manager.mark_instance_dirty(wire_id);
                 } else {
-                    ui.painter()
-                        .line_segment([start, mouse], Stroke::new(2.0, COLOR_HOVER_PIN_TO_WIRE));
+                    // TODO: There is an issue with non zero viewport_offset.
+                    ui.painter().line_segment(
+                        [self.adjusted_pos(start), self.adjusted_pos(mouse)],
+                        Stroke::new(2.0, COLOR_HOVER_PIN_TO_WIRE),
+                    );
                 }
             }
             Some(Drag::BranchWire {
diff --git a/src/simulator.rs b/src/simulator.rs
@@ -4,11 +4,10 @@ use log;
 
 use crate::{
     assets::PinKind,
-    connection_manager::ConnectionKind,
     db::{Circuit, DB, GateKind, InstanceId, InstanceKind, Pin},
 };
 
-const MAX_ITERATIONS: usize = 1000;
+const MAX_ITERATIONS: usize = 10;
 const STABILIZATION_THRESHOLD: usize = 3;
 
 #[derive(serde::Deserialize, serde::Serialize, Debug, Clone, Copy, PartialEq, Eq)]
@@ -223,6 +222,16 @@ impl Simulator {
             return;
         };
 
+        // Not has one input so handle specially
+        if matches!(kind, GateKind::Not) {
+            let inp1 = gate_inp1(id);
+            let out = Pin::new(id, 1, PinKind::Output);
+            let a = self.get_pin_value(db, circuit, inp1);
+            let out_val = a.not();
+            self.current.insert(out, out_val);
+            return;
+        }
+
         let inp1 = gate_inp1(id);
         let inp2 = gate_inp2(id);
         let out = gate_output(id);
@@ -237,6 +246,7 @@ impl Simulator {
             GateKind::Nor => a.or(b).not(),
             GateKind::Xor => a.xor(b),
             GateKind::Xnor => a.xnor(b),
+            GateKind::Not => unreachable!("Handled above"),
         };
 
         self.current.insert(out, out_val);
@@ -249,16 +259,17 @@ impl Simulator {
     }
 
     fn get_pin_value(&self, db: &DB, circuit: &Circuit, pin: Pin) -> Value {
+        let pin = pin.is_passthrough(db).unwrap_or(pin);
         let conns = circuit.connections_containing(pin);
 
         let mut result = Value::Zero;
         for conn in conns {
-            let other = conn.get_other_pin(pin);
-            if other.kind != PinKind::Output && conn.kind != ConnectionKind::BI {
+            let connected_pin = conn.get_other_pin(pin);
+            if connected_pin.kind != PinKind::Output {
                 continue;
             }
 
-            if let Some(&val) = self.current.get(&other) {
+            if let Some(&val) = self.current.get(&connected_pin) {
                 result = result.or(val);
             }
         }
