feat(shell): close the measured reachability gap in the shell's panels

crates/app/src/editor.rs

@@ -290,11 +290,15 @@ pub enum AutoShape {
     Measure,
     /// `autoshape.connectorLine`.
     ConnectorLine,
+    /// `autoshape.rect` — the Rounded Rectangle tool.
+    RoundedRect,
+    /// `autoshape.rect` — the Chamfer Rectangle tool.
+    ChamferRect,
 }
 
 impl AutoShape {
     /// Menu order.
-    pub const ALL: [AutoShape; 10] = [
+    pub const ALL: [AutoShape; 12] = [
         AutoShape::Star,
         AutoShape::Polygon,
         AutoShape::Spiral,
@@ -305,6 +309,8 @@ impl AutoShape {
         AutoShape::ArrowLine,
         AutoShape::Measure,
         AutoShape::ConnectorLine,
+        AutoShape::RoundedRect,
+        AutoShape::ChamferRect,
     ];
 
     /// Menu label.
@@ -321,6 +327,8 @@ impl AutoShape {
             AutoShape::ArrowLine => "Arrow Line",
             AutoShape::Measure => "Measure",
             AutoShape::ConnectorLine => "Connector Line",
+            AutoShape::RoundedRect => "Rounded Rectangle",
+            AutoShape::ChamferRect => "Chamfer Rectangle",
         }
     }
 
@@ -338,14 +346,24 @@ impl AutoShape {
             AutoShape::ArrowLine => "autoshape.arrowLine",
             AutoShape::Measure => "autoshape.measure",
             AutoShape::ConnectorLine => "autoshape.connectorLine",
+            // The three rectangle tools share one generator and
+            // differ only in the corner treatment they ask for.
+            AutoShape::RoundedRect | AutoShape::ChamferRect => "autoshape.rect",
         }
     }
 
     /// Default-parameter payload for a completed drag: center-based
     /// shapes take the frame center + radius, frame-based shapes the
     /// normalized frame, line-based shapes the raw endpoints.
     #[must_use]
-    fn payload(self, drag: &Drag, page: usize, layer: usize, frame: usize) -> serde_json::Value {
+    fn payload(
+        self,
+        drag: &Drag,
+        page: usize,
+        layer: usize,
+        frame: usize,
+        corner: f64,
+    ) -> serde_json::Value {
         let (sx, sy) = (drag.start.x, drag.start.y);
         let (cx, cy) = (drag.current.x, drag.current.y);
         // Frame origin/size, normalized so drags in any direction
@@ -358,7 +376,7 @@ impl AutoShape {
             start: (sx, sy),
             end: (cx, cy),
         };
-        self.payload_from(&placement, page, layer, frame)
+        self.payload_from(&placement, page, layer, frame, corner)
     }
 
     /// The payload for a shape inserted without a drag — the Auto
@@ -373,6 +391,7 @@ impl AutoShape {
         x: f64,
         y: f64,
         size: f64,
+        corner: f64,
     ) -> serde_json::Value {
         let mid = y + size / 2.0;
         let placement = Placement {
@@ -383,7 +402,7 @@ impl AutoShape {
             start: (x, mid),
             end: (x + size, mid),
         };
-        self.payload_from(&placement, page, layer, frame)
+        self.payload_from(&placement, page, layer, frame, corner)
     }
 
     /// The registry payload for one shape placement. Every shape
@@ -397,6 +416,7 @@ impl AutoShape {
         page: usize,
         layer: usize,
         frame: usize,
+        corner: f64,
     ) -> serde_json::Value {
         let frame_json = serde_json::json!({
             "page": page, "layer": layer, "cell": frame, "name": null,
@@ -461,6 +481,19 @@ impl AutoShape {
                 "elbowX": cx, "elbowY": (sy + cy) / 2.0,
                 "corner1": 4.0, "corner2": 4.0, "vertical": false,
             }),
+            // The three rectangle tools share one generator; only the
+            // corner treatment differs. The radius is clamped so the
+            // cut never exceeds half the shorter side.
+            AutoShape::RoundedRect => serde_json::json!({
+                "x": x, "y": y, "width": width, "height": height,
+                "corner": corner.min(0.5 * width.min(height)).max(0.0),
+                "kind": "round",
+            }),
+            AutoShape::ChamferRect => serde_json::json!({
+                "x": x, "y": y, "width": width, "height": height,
+                "corner": corner.min(0.5 * width.min(height)).max(0.0),
+                "kind": "chamfer",
+            }),
         };
         if let (Some(object), Some(place)) = (value.as_object_mut(), frame_json.as_object()) {
             for (key, field) in place {
@@ -1014,6 +1047,9 @@ pub struct Editor {
     pub wand_tolerance: u8,
     /// The feather radius the panel's slider applies.
     pub feather_radius: u8,
+    /// The corner radius the rectangle tools cut with (view state — the
+    /// engine re-reads it from every placement's payload).
+    pub rect_corner: f64,
 }
 
 impl Editor {
@@ -1088,6 +1124,7 @@ impl Editor {
             pixel_mode: PixelSelectMode::Replace,
             wand_tolerance: 32,
             feather_radius: 2,
+            rect_corner: 12.0,
         }
     }
 
@@ -2413,7 +2450,13 @@ impl Editor {
             Tool::AutoShape(shape) => {
                 self.apply(
                     shape.command(),
-                    shape.payload(&drag, self.page, self.active_layer(), self.frame),
+                    shape.payload(
+                        &drag,
+                        self.page,
+                        self.active_layer(),
+                        self.frame,
+                        self.rect_corner,
+                    ),
                 )?;
                 true
             }

crates/app/src/shell/glyphs.rs

@@ -200,6 +200,62 @@ pub(crate) fn draw_autoshape_glyph(
                 stroke,
             ));
         }
+        AutoShape::RoundedRect => {
+            // The rounded box: four quarter-circle arcs joined by the
+            // straight edges.
+            let (half_w, half_h, radius) = (6.0f32, 6.0f32, 3.0f32);
+            let mut points = Vec::new();
+            // The four arc centers, clockwise from the top-left.
+            let centers = [
+                (c.x - half_w + radius, c.y - half_h + radius),
+                (c.x + half_w - radius, c.y - half_h + radius),
+                (c.x + half_w - radius, c.y + half_h - radius),
+                (c.x - half_w + radius, c.y + half_h - radius),
+            ];
+            // Each arc runs from its start angle to its end angle.
+            let arcs = [
+                (std::f64::consts::PI, 1.5 * std::f64::consts::PI),
+                (1.5 * std::f64::consts::PI, 2.0 * std::f64::consts::PI),
+                (0.0, 0.5 * std::f64::consts::PI),
+                (0.5 * std::f64::consts::PI, std::f64::consts::PI),
+            ];
+            for (index, (center, (start, end))) in centers.iter().zip(arcs.iter()).enumerate() {
+                for step in 0..=6 {
+                    let angle = start + (end - start) * step as f64 / 6.0;
+                    points.push(Pos2::new(
+                        (center.0 + (radius as f64 * angle.cos()) as f32),
+                        (center.1 + (radius as f64 * angle.sin()) as f32),
+                    ));
+                }
+                // The straight edge to the next arc's start.
+                let next = centers[(index + 1) % 4];
+                let next_angle = arcs[(index + 1) % 4].0;
+                points.push(Pos2::new(
+                    (next.0 + (radius as f64 * next_angle.cos()) as f32),
+                    (next.1 + (radius as f64 * next_angle.sin()) as f32),
+                ));
+            }
+            points.push(points[0]);
+            painter.add(egui::Shape::line(points, stroke));
+        }
+        AutoShape::ChamferRect => {
+            // The chamfered box: eight straight sides.
+            let (half_w, half_h, cut) = (6.0f32, 6.0f32, 3.0f32);
+            painter.add(egui::Shape::line(
+                vec![
+                    Pos2::new(c.x - half_w + cut, c.y - half_h),
+                    Pos2::new(c.x + half_w - cut, c.y - half_h),
+                    Pos2::new(c.x + half_w, c.y - half_h + cut),
+                    Pos2::new(c.x + half_w, c.y + half_h - cut),
+                    Pos2::new(c.x + half_w - cut, c.y + half_h),
+                    Pos2::new(c.x - half_w + cut, c.y + half_h),
+                    Pos2::new(c.x - half_w, c.y + half_h - cut),
+                    Pos2::new(c.x - half_w, c.y - half_h + cut),
+                    Pos2::new(c.x - half_w + cut, c.y - half_h),
+                ],
+                stroke,
+            ));
+        }
     }
 }