refactor(drawing,layout): move 'is_node_in_layer' from Layout to Drawing

crates/topola-egui/src/overlay.rs

@@ -131,6 +131,7 @@ impl Overlay {
             board.layout().node_shape(geom.data).contains_point(at)
                 && board
                     .layout()
+                    .drawing()
                     .is_node_in_layer(geom.data, self.active_layer)
         }) {
             self.selection.toggle_at_node(board, geom.data);

src/autorouter/selection.rs

@@ -208,7 +208,7 @@ impl Selection {
                         &AABB::<[f64; 3]>::from_corners([-INF, -INF, -INF], [INF, INF, INF]),
                     ) {
                         let node = geom.data;
-                        if layout.is_node_in_layer(node, active_layer) {
+                        if layout.drawing().is_node_in_layer(node, active_layer) {
                             if let Some(rsel) = ResolvedSelector::try_from_node(board, node) {
                                 let rseli = selectors.entry(rsel).or_default();
                                 rseli.0.insert(node);
@@ -236,7 +236,7 @@ impl Selection {
                         ),
                     ) {
                         let node = geom.data;
-                        if layout.is_node_in_layer(node, active_layer)
+                        if layout.drawing().is_node_in_layer(node, active_layer)
                             && kind.matches(aabb, &layout.node_shape(node))
                         {
                             if let Some(rsel) = ResolvedSelector::try_from_node(board, node) {

src/drawing/drawing.rs

@@ -1022,6 +1022,23 @@ impl<CW: Copy, R: AccessRules> Drawing<CW, R> {
         self.recording_geometry_with_rtree.compounds(node)
     }
 
+    pub fn is_node_in_layer(
+        &self,
+        index: GenericNode<PrimitiveIndex, GenericIndex<CW>>,
+        active_layer: usize,
+    ) -> bool
+    where
+        CW: super::graph::IsInLayer,
+    {
+        use super::graph::GetLayer;
+        match index {
+            GenericNode::Primitive(primitive) => primitive.primitive(self).layer() == active_layer,
+            GenericNode::Compound(compound) => {
+                self.compound_weight(compound).is_in_layer(active_layer)
+            }
+        }
+    }
+
     fn are_connectable(&self, node1: PrimitiveIndex, node2: PrimitiveIndex) -> bool {
         if let (Some(node1_net_id), Some(node2_net_id)) = (
             node1.primitive(self).maybe_net(),

src/drawing/graph.rs

@@ -28,6 +28,18 @@ pub trait GetLayer {
     fn layer(&self) -> usize;
 }
 
+#[enum_dispatch]
+pub trait IsInLayer {
+    fn is_in_layer(&self, layer: usize) -> bool;
+}
+
+impl<T: GetLayer> IsInLayer for T {
+    #[inline]
+    fn is_in_layer(&self, layer: usize) -> bool {
+        self.layer() == layer
+    }
+}
+
 #[enum_dispatch]
 pub trait GetMaybeNet {
     fn maybe_net(&self) -> Option<usize>;

src/layout/layout.rs

@@ -15,7 +15,7 @@ use crate::{
         cane::Cane,
         dot::{DotIndex, DotWeight, FixedDotIndex, FixedDotWeight, LooseDotIndex, LooseDotWeight},
         gear::GearIndex,
-        graph::{GetMaybeNet, MakePrimitive, PrimitiveIndex, PrimitiveWeight},
+        graph::{GetMaybeNet, IsInLayer, MakePrimitive, PrimitiveIndex, PrimitiveWeight},
         primitive::MakePrimitiveShape,
         rules::AccessRules,
         seg::{
@@ -34,7 +34,7 @@ use crate::{
 
 /// Represents a weight for various compounds
 #[derive(Debug, Clone, Copy)]
-#[enum_dispatch(GetMaybeNet)]
+#[enum_dispatch(GetMaybeNet, IsInLayer)]
 pub enum CompoundWeight {
     /// Represents the weight of a polygon compound, includes its basic [`Layout`] information
     Poly(PolyWeight),
@@ -318,25 +318,6 @@ impl<R: AccessRules> Layout<R> {
             .compound_members(GenericIndex::new(poly.petgraph_index()))
     }
 
-    pub fn is_node_in_layer(&self, index: NodeIndex, active_layer: usize) -> bool {
-        use crate::drawing::graph::GetLayer;
-        match index {
-            NodeIndex::Primitive(primitive) => {
-                primitive.primitive(&self.drawing).layer() == active_layer
-            }
-            NodeIndex::Compound(compound) => match self.drawing.compound_weight(compound) {
-                CompoundWeight::Poly(_) => {
-                    self.poly(GenericIndex::<PolyWeight>::new(compound.petgraph_index()))
-                        .layer()
-                        == active_layer
-                }
-                CompoundWeight::Via(weight) => {
-                    weight.from_layer >= active_layer && weight.to_layer <= active_layer
-                }
-            },
-        }
-    }
-
     pub fn node_shape(&self, index: NodeIndex) -> Shape {
         match index {
             NodeIndex::Primitive(primitive) => primitive.primitive(&self.drawing).shape().into(),

src/layout/via.rs

@@ -7,7 +7,11 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    drawing::{graph::GetMaybeNet, primitive::MakePrimitiveShape, rules::AccessRules},
+    drawing::{
+        graph::{GetMaybeNet, IsInLayer},
+        primitive::MakePrimitiveShape,
+        rules::AccessRules,
+    },
     geometry::primitive::{DotShape, PrimitiveShape},
     graph::{GenericIndex, GetPetgraphIndex},
     layout::{CompoundWeight, Layout},
@@ -67,6 +71,12 @@ impl GetMaybeNet for ViaWeight {
     }
 }
 
+impl IsInLayer for ViaWeight {
+    fn is_in_layer(&self, layer: usize) -> bool {
+        self.from_layer >= layer && self.to_layer <= layer
+    }
+}
+
 impl MakePrimitiveShape for ViaWeight {
     fn shape(&self) -> PrimitiveShape {
         DotShape {