overlay: toggle only one node at a time, prioritize active layer

src/overlay/overlay.rs

@@ -5,7 +5,7 @@ use rstar::AABB;
 
 use crate::{
     drawing::{
-        graph::{MakePrimitive, PrimitiveIndex},
+        graph::{GetLayer, MakePrimitive, PrimitiveIndex},
         primitive::MakeShape,
         rules::RulesTrait,
     },
@@ -16,35 +16,66 @@ use crate::{
 
 pub struct Overlay {
     selection: HashSet<Node<PrimitiveIndex, GenericIndex<ZoneWeight>>>,
+    active_layer: u64,
 }
 
 impl Overlay {
     pub fn new() -> Self {
         Self {
             selection: HashSet::new(),
+            active_layer: 0,
         }
     }
 
     pub fn click<R: RulesTrait>(&mut self, layout: &Layout<R>, at: Point) {
-        for geom in layout.drawing().rtree().locate_in_envelope_intersecting(
+        let geoms: Vec<_> = layout
-            &AABB::<[f64; 3]>::from_corners(
+            .drawing()
+            .rtree()
+            .locate_in_envelope_intersecting(&AABB::<[f64; 3]>::from_corners(
                 [at.x(), at.y(), -f64::INFINITY],
                 [at.x(), at.y(), f64::INFINITY],
-            ),
+            ))
-        ) {
+            .collect();
-            match geom.data {
+
-                Node::Primitive(primitive) => {
+        if let Some(geom) = geoms.iter().find(|&&geom| match geom.data {
-                    if primitive
+            Node::Primitive(primitive) => {
-                        .primitive(layout.drawing())
+                primitive.primitive(layout.drawing()).layer() == self.active_layer
-                        .shape()
+            }
-                        .contains_point(at)
+            Node::Compound(compound) => false,
-                    {
+        }) {
-                        self.toggle_selection(geom.data);
+            if self.toggle_selection_if_contains_point(layout, geom.data, at) {
-                    }
+                return;
-                }
-                Node::Compound(compound) => (), // TODO.
             }
         }
+
+        for geom in geoms {
+            if self.toggle_selection_if_contains_point(layout, geom.data, at) {
+                return;
+            }
+        }
+    }
+
+    fn toggle_selection_if_contains_point<R: RulesTrait>(
+        &mut self,
+        layout: &Layout<R>,
+        node: Node<PrimitiveIndex, GenericIndex<ZoneWeight>>,
+        p: Point,
+    ) -> bool {
+        match node {
+            Node::Primitive(primitive) => {
+                if primitive
+                    .primitive(layout.drawing())
+                    .shape()
+                    .contains_point(p)
+                {
+                    self.toggle_selection(node);
+                    return true;
+                }
+            }
+            Node::Compound(compound) => (), // TODO.
+        }
+
+        false
     }
 
     fn toggle_selection(&mut self, node: Node<PrimitiveIndex, GenericIndex<ZoneWeight>>) {