[SOLVE] #9273 Center and Corner rectangle tools

rust/kcl-lib/src/frontend.rs

@@ -416,15 +416,36 @@ impl SketchApi for FrontendState {
         // Deduplicate IDs.
         let mut constraint_ids_set = constraint_ids.into_iter().collect::<AhashIndexSet<_>>();
         let segment_ids_set = segment_ids.into_iter().collect::<AhashIndexSet<_>>();
+
+        // If a point is owned by a Line/Arc, we want to delete the owner, which will
+        // also delete the point, as well as other points that are owned by the owner.
+        let mut delete_ids = AhashIndexSet::default();
+
+        for segment_id in segment_ids_set.iter().copied() {
+            if let Some(segment_object) = self.scene_graph.objects.get(segment_id.0)
+                && let ObjectKind::Segment { segment } = &segment_object.kind
+                && let Segment::Point(point) = segment
+                && let Some(owner_id) = point.owner
+                && let Some(owner_object) = self.scene_graph.objects.get(owner_id.0)
+                && let ObjectKind::Segment { segment: owner_segment } = &owner_object.kind
+                && matches!(owner_segment, Segment::Line(_) | Segment::Arc(_))
+            {
+                // segment is owned -> delete the owner
+                delete_ids.insert(owner_id);
+            } else {
+                // segment is not owned by anything -> can be deleted
+                delete_ids.insert(segment_id);
+            }
+        }
         // Find constraints that reference the segments to be deleted, and add
         // those to the set to be deleted.
-        self.add_dependent_constraints_to_delete(sketch, &segment_ids_set, &mut constraint_ids_set)?;
+        self.add_dependent_constraints_to_delete(sketch, &delete_ids, &mut constraint_ids_set)?;
 
         let mut new_ast = self.program.ast.clone();
         for constraint_id in constraint_ids_set {
             self.delete_constraint(&mut new_ast, sketch, constraint_id)?;
         }
-        for segment_id in segment_ids_set {
+        for segment_id in delete_ids {
             self.delete_segment(&mut new_ast, sketch, segment_id)?;
         }
         self.execute_after_edit(

src/components/CustomIcon.tsx

@@ -1523,6 +1523,22 @@ const CustomIconMap = Object.freeze({
       />
     </svg>
   ),
+  rectangleCenter: (
+    <svg
+      viewBox="0 0 20 20"
+      fill="none"
+      xmlns="http://www.w3.org/2000/svg"
+      aria-label="rectangle center"
+    >
+      <path
+        fillRule="evenodd"
+        clipRule="evenodd"
+        d="M16 5H4V15H16V5ZM4 4H3V5V15V16H4H16H17V15V5V4H16H4Z"
+        fill="currentColor"
+      />
+      <circle cx="10" cy="10" r="1.5" fill="currentColor" />
+    </svg>
+  ),
   refresh: (
     <svg
       viewBox="0 0 20 20"

src/lib/toolbar.ts

@@ -1314,6 +1314,53 @@ export const toolbarConfig: Record<ToolbarModeName, ToolbarMode> = {
           state.matches('sketchSolveMode') &&
           state.context.sketchSolveToolName === 'centerArcTool',
       },
+      {
+        id: 'rectangles',
+        array: [
+          {
+            id: 'corner-rectangle',
+            onClick: ({ modelingSend, isActive }) =>
+              isActive
+                ? modelingSend({
+                    type: 'unequip tool',
+                  })
+                : modelingSend({
+                    type: 'equip tool',
+                    data: { tool: 'cornerRectTool' },
+                  }),
+            icon: 'rectangle',
+            status: 'available',
+            title: 'Corner Rectangle',
+            hotkey: 'Shift+R',
+            description: 'Start drawing a rectangle',
+            links: [],
+            isActive: (state) =>
+              state.matches('sketchSolveMode') &&
+              state.context.sketchSolveToolName === 'cornerRectTool',
+          },
+          {
+            id: 'center-rectangle',
+            onClick: ({ modelingSend, isActive }) =>
+              isActive
+                ? modelingSend({
+                    type: 'unequip tool',
+                  })
+                : modelingSend({
+                    type: 'equip tool',
+                    data: { tool: 'centerRectTool' },
+                  }),
+            icon: 'rectangleCenter',
+            status: 'available',
+            title: 'Center Rectangle',
+            hotkey: 'Alt+R',
+            description: 'Start drawing a rectangle from its center',
+            links: [],
+            isActive: (state) =>
+              state.matches('sketchSolveMode') &&
+              state.context.sketchSolveToolName === 'centerRectTool',
+          },
+        ],
+      },
       'break',
       {
         id: 'coincident',
@@ -1425,13 +1472,23 @@ export const toolbarConfig: Record<ToolbarModeName, ToolbarMode> = {
 export function getSketchSolveToolIconMap(): Record<string, CustomIconName> {
   const map: Record<string, CustomIconName> = {}
   const items = toolbarConfig.sketchSolve.items
+  collectItems(items, map)
+  return map
+}
 
+function collectItems(
+  items: ToolbarMode['items'],
+  map: Record<string, CustomIconName>
+) {
   for (const item of items) {
     // Skip 'break' strings
     if (typeof item === 'string') continue
 
-    // Skip dropdowns (which don't have direct icons)
-    if ('array' in item) continue
+    // dropdowns, eg. rectangles
+    if ('array' in item) {
+      collectItems(item.array, map)
+      continue
+    }
 
     // Now TypeScript knows item is ToolbarItem
     // Only process items that have an icon and an isActive function (which indicates it's a tool)
@@ -1447,6 +1504,4 @@ export function getSketchSolveToolIconMap(): Record<string, CustomIconName> {
       }
     }
   }
-
-  return map
 }

src/machines/sketchSolve/sketchSolveImpl.ts

@@ -23,7 +23,7 @@ import type { SceneEntities } from '@src/clientSideScene/sceneEntities'
 import type RustContext from '@src/lib/rustContext'
 import type { KclManager } from '@src/lang/KclManager'
 
-import { machine as centerRectTool } from '@src/machines/sketchSolve/tools/centerRectTool'
+import { machine as rectTool } from '@src/machines/sketchSolve/tools/rectTool'
 import { machine as dimensionTool } from '@src/machines/sketchSolve/tools/dimensionTool'
 import { machine as pointTool } from '@src/machines/sketchSolve/tools/pointTool'
 import { machine as lineTool } from '@src/machines/sketchSolve/tools/lineToolDiagram'
@@ -59,12 +59,7 @@ export type SpawnToolActor = <K extends EquipTool>(
   src: K,
   options?: {
     id?: string
-    input?: {
-      sceneInfra: SceneInfra
-      rustContext: RustContext
-      kclManager: KclManager
-      sketchId: number
-    }
+    input?: ToolInput
   }
 ) => ActorRefFrom<(typeof equipTools)[K]>
 
@@ -116,7 +111,7 @@ export type SketchSolveMachineEvent =
 
 type ToolActorRef =
   | ActorRefFrom<typeof dimensionTool>
-  | ActorRefFrom<typeof centerRectTool>
+  | ActorRefFrom<typeof rectTool>
   | ActorRefFrom<typeof pointTool>
   | ActorRefFrom<typeof lineTool>
   | ActorRefFrom<typeof centerArcTool>
@@ -144,7 +139,9 @@ export type SketchSolveContext = {
   kclManager: KclManager
 }
 export const equipTools = Object.freeze({
-  centerRectTool,
+  // both use the same tool, opened with a different flag
+  centerRectTool: rectTool,
+  cornerRectTool: rectTool,
   dimensionTool,
   pointTool,
   lineTool,
@@ -902,6 +899,7 @@ export function spawnTool(
       rustContext: context.rustContext,
       kclManager: context.kclManager,
       sketchId: context.sketchId,
+      toolVariant: toolVariants[nameOfToolToSpawn],
     },
   })
 
@@ -911,3 +909,16 @@ export function spawnTool(
     pendingToolName: undefined, // Clear the pending tool after spawning
   }
 }
+
+export type ToolInput = {
+  sceneInfra: SceneInfra
+  rustContext: RustContext
+  kclManager: KclManager
+  sketchId: number
+  toolVariant?: string // eg. 'corner' | 'center' for rectTool
+}
+
+const toolVariants: Record<string, string> = {
+  centerRectTool: 'center',
+  cornerRectTool: 'corner',
+}

src/machines/sketchSolve/tools/centerArcToolDiagram.ts

@@ -1,9 +1,6 @@
 import { assertEvent, assign, fromPromise, setup } from 'xstate'
 
-import type { SceneInfra } from '@src/clientSideScene/sceneInfra'
-import type RustContext from '@src/lib/rustContext'
 import type { SceneGraphDelta } from '@rust/kcl-lib/bindings/FrontendApi'
-import type { KclManager } from '@src/lang/KclManager'
 import {
   type ToolEvents,
   type ToolContext,
@@ -19,6 +16,7 @@ import {
   finalizeArcActor,
   storeCreatedArcResult,
 } from '@src/machines/sketchSolve/tools/centerArcToolImpl'
+import type { ToolInput } from '@src/machines/sketchSolve/sketchSolveImpl'
 
 // This might seem a bit redundant, but this xstate visualizer stops working
 // when TOOL_ID and constants are imported directly
@@ -32,12 +30,7 @@ export const machine = setup({
   types: {
     context: {} as ToolContext,
     events: {} as ToolEvents,
-    input: {} as {
-      sceneInfra: SceneInfra
-      rustContext: RustContext
-      kclManager: KclManager
-      sketchId: number
-    },
+    input: {} as ToolInput,
   },
   actions: {
     'show radius preview listener': showRadiusPreviewListener,

src/machines/sketchSolve/tools/lineToolDiagram.ts

@@ -1,6 +1,5 @@
 import { assertEvent, assign, fromPromise, setup } from 'xstate'
 
-import type { SceneInfra } from '@src/clientSideScene/sceneInfra'
 import type RustContext from '@src/lib/rustContext'
 import { jsAppSettings } from '@src/lib/settings/settingsUtils'
 import type {
@@ -23,6 +22,7 @@ import {
   storePendingSketchOutcome,
   sendStoredResultToParent,
 } from '@src/machines/sketchSolve/tools/lineToolImpl'
+import type { ToolInput } from '@src/machines/sketchSolve/sketchSolveImpl'
 
 // This might seem a bit redundant, but this xstate visualizer stops working
 // when TOOL_ID and constants are imported directly
@@ -35,12 +35,7 @@ export const machine = setup({
   types: {
     context: {} as ToolContext,
     events: {} as ToolEvents,
-    input: {} as {
-      sceneInfra: SceneInfra
-      rustContext: RustContext
-      kclManager: KclManager
-      sketchId: number
-    },
+    input: {} as ToolInput,
   },
   actions: {
     'animate draft segment listener': animateDraftSegmentListener,

src/machines/sketchSolve/tools/pointTool.ts

@@ -11,6 +11,7 @@ import { roundOff } from '@src/lib/utils'
 import { baseUnitToNumericSuffix } from '@src/lang/wasm'
 import type { KclManager } from '@src/lang/KclManager'
 import type { BaseToolEvent } from '@src/machines/sketchSolve/tools/sharedToolTypes'
+import type { ToolInput } from '@src/machines/sketchSolve/sketchSolveImpl'
 
 const TOOL_ID = 'Point tool'
 const CONFIRMING_DIMENSIONS = 'Confirming dimensions'
@@ -34,12 +35,7 @@ export const machine = setup({
       sketchId: number
     },
     events: {} as ToolEvents,
-    input: {} as {
-      sceneInfra: SceneInfra
-      rustContext: RustContext
-      kclManager: KclManager
-      sketchId: number
-    },
+    input: {} as ToolInput,
   },
   actions: {
     'add point listener': ({ self, context }) => {