@itwin/editor-frontend 3.0.0-dev.98 → 3.0.0

package/lib/esm/SketchTools.js

@@ -3,7 +3,7 @@
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
 import { BentleyError } from "@itwin/core-bentley";
-import { Angle, AngleSweep, Arc3d, BSplineCurve3d, BSplineCurveOps, CurveFactory, FrameBuilder, Geometry, IModelJson, LineString3d, Loop, Matrix3d, Path, Plane3dByOriginAndUnitNormal, Point3d, PointString3d, Ray3d, RegionOps, Transform, Vector3d, YawPitchRollAngles } from "@itwin/core-geometry";
+import { Angle, AngleSweep, Arc3d, BSplineCurve3d, CurveFactory, FrameBuilder, Geometry, IModelJson, InterpolationCurve3d, InterpolationCurve3dOptions, LineString3d, Loop, Matrix3d, Path, Plane3dByOriginAndUnitNormal, Point3d, PointString3d, Ray3d, RegionOps, Transform, Vector3d, YawPitchRollAngles } from "@itwin/core-geometry";
 import { Code, ColorDef, ElementGeometry, isPlacement3dProps, LinePixels } from "@itwin/core-common";
 import { AccuDrawHintBuilder, AngleDescription, BeButton, BeModifierKeys, CoreTools, EventHandled, GraphicType, IModelApp, LengthDescription, NotifyMessageDetails, OutputMessagePriority, TentativeOrAccuSnap, ToolAssistance, ToolAssistanceImage, ToolAssistanceInputMethod } from "@itwin/core-frontend";
 import { editorBuiltInCmdIds } from "@itwin/editor-common";
@@ -233,6 +233,7 @@ export class CreateOrContinuePathTool extends CreateElementTool {
             switch (curve.curvePrimitiveType) {
                 case "arc":
                 case "bsplineCurve":
+                case "interpolationCurve":
                     break;
                 default:
                     return;
@@ -267,6 +268,12 @@ export class CreateOrContinuePathTool extends CreateElementTool {
                 builder.addPointString(poles);
                 break;
             }
+            case "interpolationCurve": {
+                const fitCurve = curve;
+                builder.setSymbology(context.viewport.getContrastToBackgroundColor(), ColorDef.black, 5);
+                builder.addPointString(fitCurve.options.fitPoints); // deep copy shoulnd't be necessary...
+                break;
+            }
             default:
                 break;
         }
@@ -554,11 +561,17 @@ export class CreateOrContinuePathTool extends CreateElementTool {
         await this.updateCurveAndContinuationData(ev, false, phase);
         return true;
     }
+    async cancelPoint(_ev) { return true; }
     async onDataButtonDown(ev) {
         if (!await this.acceptPoint(ev))
             return EventHandled.Yes;
         return super.onDataButtonDown(ev);
     }
+    async onResetButtonUp(ev) {
+        if (!await this.cancelPoint(ev))
+            return EventHandled.Yes;
+        return super.onResetButtonUp(ev);
+    }
     async onUndoPreviousStep() {
         if (0 === this.accepted.length)
             return false;
@@ -617,13 +630,13 @@ export class CreateLineStringTool extends CreateOrContinuePathTool {
         const pts = (isDynamics ? [...this.accepted, ev.point] : this.accepted);
         return LineString3d.create(pts);
     }
-    async onResetButtonUp(ev) {
+    async cancelPoint(ev) {
         // NOTE: Starting another tool will not create element...require reset or closure...
         if (this.isComplete(ev)) {
             await this.updateCurveAndContinuationData(ev, false, CreateCurvePhase.DefineEnd);
             await this.createElement();
         }
-        return super.onResetButtonUp(ev);
+        return true;
     }
     async onRestartTool() {
         const tool = new CreateLineStringTool();
@@ -914,70 +927,28 @@ export class CreateArcTool extends CreateOrContinuePathTool {
                 return;
         }
         const syncData = [];
-        if (!this.useRadius) {
-            this.radiusProperty.displayValue = this.radiusProperty.description.format(this.radius);
-            this.radiusProperty.isDisabled = !this.useRadius;
+        if (!this.useRadius)
             syncData.push(this.radiusProperty.syncItem);
-        }
-        if (!this.useSweep) {
-            this.sweepProperty.displayValue = this.sweepProperty.description.format(this.sweep);
-            this.sweepProperty.isDisabled = !this.useSweep;
+        if (!this.useSweep)
             syncData.push(this.sweepProperty.syncItem);
-        }
         if (0 !== syncData.length)
             this.syncToolSettingsProperties(syncData);
     }
-    syncRadiusState() {
-        this.radiusProperty.displayValue = this.radiusProperty.description.format(this.radius);
-        this.radiusProperty.isDisabled = !this.useRadius;
-        this.syncToolSettingsProperties([this.radiusProperty.syncItem]);
-    }
-    syncSweepState() {
-        this.sweepProperty.displayValue = this.sweepProperty.description.format(this.sweep);
-        this.sweepProperty.isDisabled = !this.useSweep;
-        this.syncToolSettingsProperties([this.sweepProperty.syncItem]);
+    getToolSettingPropertyLocked(property) {
+        if (property === this.useRadiusProperty)
+            return this.radiusProperty;
+        else if (property === this.useSweepProperty)
+            return this.sweepProperty;
+        return undefined;
     }
     async applyToolSettingPropertyChange(updatedValue) {
-        if (this.methodProperty.name === updatedValue.propertyName) {
-            this.methodProperty.value = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.methodProperty.item);
+        if (!this.changeToolSettingPropertyValue(updatedValue))
+            return false;
+        if (this.methodProperty.name === updatedValue.propertyName)
             await this.onReinitialize();
-            return true;
-        }
-        else if (updatedValue.propertyName === this.useRadiusProperty.name) {
-            this.useRadius = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.useRadiusProperty.item);
-            this.syncRadiusState();
-            return true;
-        }
-        else if (updatedValue.propertyName === this.useSweepProperty.name) {
-            this.useSweep = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.useSweepProperty.item);
-            this.syncSweepState();
-            return true;
-        }
-        else if (updatedValue.propertyName === this.radiusProperty.name) {
-            if (!updatedValue.value.value) {
-                this.syncRadiusState(); // force UI to redisplay last valid value
-                return false;
-            }
-            this.radius = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.radiusProperty.item);
-            // If radius is changed when creating arc by start/center after center has been defined, back up a step to defined a new center point...
-            if (ArcMethod.StartCenter === this.method && this.useRadius && 2 === this.accepted.length)
-                await this.onUndoPreviousStep();
-            return true;
-        }
-        else if (updatedValue.propertyName === this.sweepProperty.name) {
-            if (!updatedValue.value.value) {
-                this.syncSweepState(); // force UI to redisplay last valid value
-                return false;
-            }
-            this.sweep = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.sweepProperty.item);
-            return true;
-        }
-        return false;
+        else if (updatedValue.propertyName === this.radiusProperty.name && ArcMethod.StartCenter === this.method && this.useRadius && 2 === this.accepted.length)
+            await this.onUndoPreviousStep(); // If radius is changed when creating arc by start/center after center has been defined, back up a step to defined a new center point...
+        return true;
     }
     supplyToolSettingsProperties() {
         const toolSettings = new Array();
@@ -1002,23 +973,9 @@ export class CreateArcTool extends CreateOrContinuePathTool {
         if (!await super.onInstall())
             return false;
         // Setup initial values here instead of supplyToolSettingsProperties to support keyin args w/o appui-react...
-        const methodValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.methodProperty.name);
-        if (undefined !== methodValue)
-            this.methodProperty.dialogItemValue = methodValue;
-        const radiusValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.radiusProperty.name);
-        if (undefined !== radiusValue)
-            this.radiusProperty.dialogItemValue = radiusValue;
-        const useRadiusValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.useRadiusProperty.name);
-        if (undefined !== useRadiusValue)
-            this.useRadiusProperty.dialogItemValue = useRadiusValue;
+        this.initializeToolSettingPropertyValues([this.methodProperty, this.radiusProperty, this.useRadiusProperty, this.sweepProperty, this.useSweepProperty]);
         if (!this.radius)
             this.useRadius = false;
-        const useSweepValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.useSweepProperty.name);
-        if (undefined !== useSweepValue)
-            this.useSweepProperty.dialogItemValue = useSweepValue;
-        const sweepValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.sweepProperty.name);
-        if (undefined !== sweepValue)
-            this.sweepProperty.dialogItemValue = sweepValue;
         if (!this.sweep)
             this.useSweep = false;
         return true;
@@ -1070,16 +1027,16 @@ export class CreateArcTool extends CreateOrContinuePathTool {
         }
         // Update current session values so keyin args are picked up for tool settings/restart...
         if (undefined !== arcMethod)
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.methodProperty.name, value: { value: arcMethod } });
+            this.saveToolSettingPropertyValue(this.methodProperty, { value: arcMethod });
         if (undefined !== arcRadius) {
             if (0.0 !== arcRadius)
-                IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.radiusProperty.name, value: { value: arcRadius } });
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.useRadiusProperty.name, value: { value: 0.0 !== arcRadius } });
+                this.saveToolSettingPropertyValue(this.radiusProperty, { value: arcRadius });
+            this.saveToolSettingPropertyValue(this.useRadiusProperty, { value: 0.0 !== arcRadius });
         }
         if (undefined !== arcSweep) {
             if (0.0 !== arcSweep)
-                IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.sweepProperty.name, value: { value: arcSweep } });
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.useSweepProperty.name, value: { value: 0.0 !== arcSweep } });
+                this.saveToolSettingPropertyValue(this.sweepProperty, { value: arcSweep });
+            this.saveToolSettingPropertyValue(this.useSweepProperty, { value: 0.0 !== arcSweep });
         }
         return this.run();
     }
@@ -1189,56 +1146,30 @@ export class CreateCircleTool extends CreateOrContinuePathTool {
         vector90.scaleToLength(radius, vector90);
         return Arc3d.create(center, vector0, vector90);
     }
-    async onResetButtonUp(ev) {
+    async cancelPoint(_ev) {
         if (CircleMethod.Center === this.method && this.useRadius) {
             // Exit instead of restarting to avoid having circle "stuck" on cursor...
             await this.exitTool();
-            return EventHandled.Yes;
+            return false;
         }
-        return super.onResetButtonUp(ev);
+        return true;
     }
     syncToolSettingsRadius() {
         if (this.useRadius)
             return;
-        const syncData = [];
-        if (!this.useRadius) {
-            this.radiusProperty.displayValue = this.radiusProperty.description.format(this.radius);
-            this.radiusProperty.isDisabled = !this.useRadius;
-            syncData.push(this.radiusProperty.syncItem);
-        }
-        if (0 !== syncData.length)
-            this.syncToolSettingsProperties(syncData);
-    }
-    syncRadiusState() {
-        this.radiusProperty.displayValue = this.radiusProperty.description.format(this.radius);
-        this.radiusProperty.isDisabled = !this.useRadius;
         this.syncToolSettingsProperties([this.radiusProperty.syncItem]);
     }
+    getToolSettingPropertyLocked(property) {
+        return (property === this.useRadiusProperty ? this.radiusProperty : undefined);
+    }
     async applyToolSettingPropertyChange(updatedValue) {
-        if (this.methodProperty.name === updatedValue.propertyName) {
-            this.methodProperty.value = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.methodProperty.item);
+        if (!this.changeToolSettingPropertyValue(updatedValue))
+            return false;
+        if (this.methodProperty.name === updatedValue.propertyName)
             await this.onReinitialize();
-            return true;
-        }
-        else if (updatedValue.propertyName === this.useRadiusProperty.name) {
-            this.useRadius = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.useRadiusProperty.item);
-            this.syncRadiusState();
-            if (CircleMethod.Center === this.method && this.useRadius && 0 === this.accepted.length)
-                await this.onReinitialize();
-            return true;
-        }
-        else if (updatedValue.propertyName === this.radiusProperty.name) {
-            if (!updatedValue.value.value) {
-                this.syncRadiusState(); // force UI to redisplay last valid value
-                return false;
-            }
-            this.radius = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.radiusProperty.item);
-            return true;
-        }
-        return false;
+        else if (updatedValue.propertyName === this.useRadiusProperty.name && CircleMethod.Center === this.method && this.useRadius && 0 === this.accepted.length)
+            await this.onReinitialize();
+        return true;
     }
     supplyToolSettingsProperties() {
         const toolSettings = new Array();
@@ -1278,15 +1209,7 @@ export class CreateCircleTool extends CreateOrContinuePathTool {
         if (!await super.onInstall())
             return false;
         // Setup initial values here instead of supplyToolSettingsProperties to support keyin args w/o appui-react...
-        const methodValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.methodProperty.name);
-        if (undefined !== methodValue)
-            this.methodProperty.dialogItemValue = methodValue;
-        const radiusValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.radiusProperty.name);
-        if (undefined !== radiusValue)
-            this.radiusProperty.dialogItemValue = radiusValue;
-        const useRadiusValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.useRadiusProperty.name);
-        if (undefined !== useRadiusValue)
-            this.useRadiusProperty.dialogItemValue = useRadiusValue;
+        this.initializeToolSettingPropertyValues([this.methodProperty, this.radiusProperty, this.useRadiusProperty]);
         if (!this.radius)
             this.useRadius = false;
         return true;
@@ -1324,11 +1247,11 @@ export class CreateCircleTool extends CreateOrContinuePathTool {
         }
         // Update current session values so keyin args are picked up for tool settings/restart...
         if (undefined !== circleMethod)
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.methodProperty.name, value: { value: circleMethod } });
+            this.saveToolSettingPropertyValue(this.methodProperty, { value: circleMethod });
         if (undefined !== circleRadius) {
             if (0.0 !== circleRadius)
-                IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.radiusProperty.name, value: { value: circleRadius } });
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.useRadiusProperty.name, value: { value: 0.0 !== circleRadius } });
+                this.saveToolSettingPropertyValue(this.radiusProperty, { value: circleRadius });
+            this.saveToolSettingPropertyValue(this.useRadiusProperty, { value: 0.0 !== circleRadius });
         }
         return this.run();
     }
@@ -1481,27 +1404,11 @@ export class CreateRectangleTool extends CreateOrContinuePathTool {
             return;
         return { format: "flatbuffer", data: builder.entries };
     }
-    syncRadiusState() {
-        this.radiusProperty.displayValue = this.radiusProperty.description.format(this.radius);
-        this.radiusProperty.isDisabled = !this.useRadius;
-        this.syncToolSettingsProperties([this.radiusProperty.syncItem]);
+    getToolSettingPropertyLocked(property) {
+        return (property === this.useRadiusProperty ? this.radiusProperty : undefined);
     }
     async applyToolSettingPropertyChange(updatedValue) {
-        if (updatedValue.propertyName === this.useRadiusProperty.name) {
-            this.useRadius = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.useRadiusProperty.item);
-            this.syncRadiusState();
-        }
-        else if (updatedValue.propertyName === this.radiusProperty.name) {
-            if (!updatedValue.value.value) {
-                this.syncRadiusState(); // force UI to redisplay last valid value
-                return false;
-            }
-            this.radius = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.radiusProperty.item);
-            return true;
-        }
-        return false;
+        return this.changeToolSettingPropertyValue(updatedValue);
     }
     supplyToolSettingsProperties() {
         const toolSettings = new Array();
@@ -1520,12 +1427,7 @@ export class CreateRectangleTool extends CreateOrContinuePathTool {
         if (!await super.onInstall())
             return false;
         // Setup initial values here instead of supplyToolSettingsProperties to support keyin args w/o appui-react...
-        const radiusValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.radiusProperty.name);
-        if (undefined !== radiusValue)
-            this.radiusProperty.dialogItemValue = radiusValue;
-        const useRadiusValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.useRadiusProperty.name);
-        if (undefined !== useRadiusValue)
-            this.useRadiusProperty.dialogItemValue = useRadiusValue;
+        this.initializeToolSettingPropertyValues([this.radiusProperty, this.useRadiusProperty]);
         if (!this.radius)
             this.useRadius = false;
         return true;
@@ -1549,8 +1451,8 @@ export class CreateRectangleTool extends CreateOrContinuePathTool {
         // Update current session values so keyin args are picked up for tool settings/restart...
         if (undefined !== cornerRadius) {
             if (0.0 !== cornerRadius)
-                IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.radiusProperty.name, value: { value: cornerRadius } });
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.useRadiusProperty.name, value: { value: 0.0 !== cornerRadius } });
+                this.saveToolSettingPropertyValue(this.radiusProperty, { value: cornerRadius });
+            this.saveToolSettingPropertyValue(this.useRadiusProperty, { value: 0.0 !== cornerRadius });
         }
         return this.run();
     }
@@ -1565,13 +1467,24 @@ export var BCurveMethod;
 })(BCurveMethod || (BCurveMethod = {}));
 /** @alpha Creates a bspline curve by poles or through points. Uses model and category from ToolAdmin.ActiveSettings. */
 export class CreateBCurveTool extends CreateOrContinuePathTool {
+    constructor() {
+        super(...arguments);
+        this._isPhysicallyClosedOrComplete = false;
+        this._tangentPhase = CreateCurvePhase.DefineOther;
+    }
+    static get minArgs() { return 0; }
+    static get maxArgs() { return 3; } // method, order, tangents...
     get wantPickableDynamics() { return true; } // Allow snapping to control polygon or through points...
     get showCurveConstructions() { return true; } // Display control polygon or through points...
     provideToolAssistance(_mainInstrText, _additionalInstr) {
         const nPts = this.accepted.length;
-        const mainMsg = CoreTools.translate(0 === nPts ? "ElementSet.Prompts.StartPoint" : (1 === nPts ? "ElementSet.Prompts.EndPoint" : "ElementSet.Inputs.AdditionalPoint"));
+        let mainMsg;
+        if (CreateCurvePhase.DefineOther === this._tangentPhase)
+            mainMsg = CoreTools.translate(0 === nPts ? "ElementSet.Prompts.StartPoint" : "ElementSet.Inputs.AdditionalPoint");
+        else
+            mainMsg = EditTools.translate(CreateCurvePhase.DefineStart === this._tangentPhase ? "CreateBCurve.Prompts.StartTangent" : "CreateBCurve.Prompts.EndTangent");
         const leftMsg = CoreTools.translate("ElementSet.Inputs.AcceptPoint");
-        const rightMsg = CoreTools.translate(nPts > 1 ? "ElementSet.Inputs.Complete" : "ElementSet.Inputs.Cancel");
+        const rightMsg = CoreTools.translate(CreateCurvePhase.DefineOther === this._tangentPhase && nPts >= this.requiredPointCount ? "ElementSet.Inputs.Complete" : "ElementSet.Inputs.Cancel");
         const mouseInstructions = [];
         const touchInstructions = [];
         if (!ToolAssistance.createTouchCursorInstructions(touchInstructions))
@@ -1603,43 +1516,97 @@ export class CreateBCurveTool extends CreateOrContinuePathTool {
     set order(value) { this.orderProperty.value = value; }
     get minOrder() { return 2; }
     get maxOrder() { return 16; }
+    get tangentsProperty() {
+        if (!this._tangentsProperty)
+            this._tangentsProperty = new DialogProperty(PropertyDescriptionHelper.buildToggleDescription("bcurveTangents", EditTools.translate("CreateBCurve.Label.Tangents")), false);
+        return this._tangentsProperty;
+    }
+    get tangents() { return this.tangentsProperty.value; }
+    set tangents(value) { this.tangentsProperty.value = value; }
     get wantClosure() {
         // A bcurve can support physical closure when creating a new path...
         return this.allowClosure;
     }
+    get requiredPointCount() {
+        if (BCurveMethod.ThroughPoints === this.method)
+            return 3; // Interpolation curve is always order 4 with 3 point minimum...
+        return this.order;
+    }
+    get createCurvePhase() {
+        if (CreateCurvePhase.DefineOther !== this._tangentPhase)
+            return CreateCurvePhase.DefineOther;
+        return super.createCurvePhase;
+    }
     isComplete(ev) {
         // Accept on reset with sufficient points...
         if (BeButton.Reset === ev.button)
-            return (this.accepted.length >= this.order);
+            return (this.accepted.length >= this.requiredPointCount);
         // Allow data to complete on physical closure...
-        return this.isClosed;
+        return this.isClosed || this._isPhysicallyClosedOrComplete;
+    }
+    showConstructionGraphics(ev, context) {
+        if (CreateCurvePhase.DefineOther !== this._tangentPhase && this.current) {
+            const fitCurve = this.current;
+            const builder = context.createGraphic({ type: GraphicType.WorldOverlay });
+            const color = context.viewport.getContrastToBackgroundColor();
+            builder.setSymbology(color, ColorDef.black, 1, LinePixels.Code2);
+            builder.addLineString([ev.point, fitCurve.options.fitPoints[CreateCurvePhase.DefineStart === this._tangentPhase ? 0 : fitCurve.options.fitPoints.length - 1]]);
+            builder.setSymbology(color, ColorDef.black, 8);
+            builder.addPointString([ev.point]);
+            context.addGraphic(builder.finish());
+        }
+        return super.showConstructionGraphics(ev, context);
     }
     createNewCurvePrimitive(ev, isDynamics) {
+        if (CreateCurvePhase.DefineOther !== this._tangentPhase && this.current) {
+            const fitCurve = this.current;
+            if (CreateCurvePhase.DefineStart === this._tangentPhase) {
+                const tangentS = Vector3d.createStartEnd(ev.point, fitCurve.options.fitPoints[0]);
+                if (tangentS.magnitude() > Geometry.smallMetricDistance)
+                    fitCurve.options.startTangent = tangentS;
+            }
+            else {
+                const tangentE = Vector3d.createStartEnd(ev.point, fitCurve.options.fitPoints[fitCurve.options.fitPoints.length - 1]);
+                if (tangentE.magnitude() > Geometry.smallMetricDistance)
+                    fitCurve.options.endTangent = tangentE;
+            }
+            return fitCurve;
+        }
         // Don't include current point if it's the same as the last accepted point, want dynamics to show an accurate preview of what reset will accept...
         const includeCurrPt = (isDynamics && (0 === this.accepted.length || !ev.point.isAlmostEqual(this.accepted[this.accepted.length - 1])));
         const pts = (includeCurrPt ? [...this.accepted, ev.point] : this.accepted);
-        const numRequired = this.order;
+        const numRequired = this.requiredPointCount;
         if (pts.length < numRequired) {
             // Create point/linestring construction geometry to support join...
             this.isConstruction = true;
             return LineString3d.create(1 === pts.length ? [pts[0], pts[0]] : pts);
         }
-        // TODO: Support physical closure by creating closed/rational bcurve...
-        if (BCurveMethod.ControlPoints === this.method)
+        // Create periodic-looking curve on physical closure with sufficient points even when not creating a loop/surface...
+        this._isPhysicallyClosedOrComplete = (undefined === this.continuationData && pts[0].isAlmostEqual(pts[pts.length - 1]));
+        if (BCurveMethod.ControlPoints === this.method) {
+            if (this._isPhysicallyClosedOrComplete && this.order > 2) {
+                const tmpPts = pts.slice(undefined, -1); // Don't include closure point...
+                return BSplineCurve3d.createPeriodicUniformKnots(tmpPts, this.order);
+            }
             return BSplineCurve3d.createUniformKnots(pts, this.order);
-        // TODO: InterpolationCurve3d, set end tangents using continuation curve...self-closure, etc.
-        return BSplineCurveOps.createThroughPoints(pts, this.order);
-    }
-    addConstructionGraphics(curve, showCurve, context) {
-        // TODO: Need proper Interpolation curve class to extract/show through points...
-        if (BCurveMethod.ThroughPoints === this.method && !showCurve && 0 !== this.accepted.length) {
-            const builder = context.createGraphic({ type: GraphicType.WorldOverlay });
-            builder.setSymbology(context.viewport.getContrastToBackgroundColor(), ColorDef.black, 5);
-            builder.addPointString(this.accepted);
-            context.addGraphic(builder.finish());
-            return;
         }
-        return super.addConstructionGraphics(curve, showCurve, context);
+        const interpProps = { fitPoints: pts, closed: this._isPhysicallyClosedOrComplete, isChordLenKnots: 1, isColinearTangents: 1 };
+        // Create interpolation curve tangent to continuation curve...
+        if (undefined !== this.continuationData && this.tangents) {
+            const tangentS = this.continuationData.path.children[0].fractionToPointAndUnitTangent(0.0);
+            const tangentE = this.continuationData.path.children[this.continuationData.path.children.length - 1].fractionToPointAndUnitTangent(1.0);
+            if (pts[0].isAlmostEqual(tangentS.origin))
+                interpProps.startTangent = tangentS.direction.scale(-1);
+            else if (pts[0].isAlmostEqual(tangentE.origin))
+                interpProps.startTangent = tangentE.direction;
+            if (pts[pts.length - 1].isAlmostEqual(tangentS.origin))
+                interpProps.endTangent = tangentS.direction.scale(-1);
+            else if (pts[pts.length - 1].isAlmostEqual(tangentE.origin))
+                interpProps.endTangent = tangentE.direction;
+            this._isPhysicallyClosedOrComplete = (undefined !== interpProps.startTangent && undefined !== interpProps.endTangent);
+        }
+        const interpOpts = InterpolationCurve3dOptions.create(interpProps);
+        return InterpolationCurve3d.createCapture(interpOpts);
     }
     getSnapGeometry() {
         // Only snap to through points...
@@ -1647,40 +1614,63 @@ export class CreateBCurveTool extends CreateOrContinuePathTool {
             return (this.accepted.length > 1 ? PointString3d.create(this.accepted) : undefined);
         return super.getSnapGeometry();
     }
-    async onResetButtonUp(ev) {
+    async acceptPoint(ev) {
+        switch (this._tangentPhase) {
+            case CreateCurvePhase.DefineOther:
+                return super.acceptPoint(ev);
+            case CreateCurvePhase.DefineStart:
+                this._tangentPhase = CreateCurvePhase.DefineEnd;
+                break;
+            case CreateCurvePhase.DefineEnd:
+                this._isPhysicallyClosedOrComplete = true;
+                break;
+        }
+        await this.updateCurveAndContinuationData(ev, false, CreateCurvePhase.DefineOther);
+        return true;
+    }
+    async cancelPoint(ev) {
         // NOTE: Starting another tool will not create element...require reset or closure...
         if (this.isComplete(ev)) {
+            if (BCurveMethod.ThroughPoints === this.method && this.tangents && this.current) {
+                const fitCurve = this.current;
+                switch (this._tangentPhase) {
+                    case CreateCurvePhase.DefineOther:
+                        await this.updateCurveAndContinuationData(ev, false, CreateCurvePhase.DefineEnd);
+                        this._tangentPhase = (undefined === fitCurve.options.startTangent ? CreateCurvePhase.DefineStart : CreateCurvePhase.DefineEnd);
+                        IModelApp.toolAdmin.updateDynamics();
+                        this.setupAndPromptForNextAction();
+                        return false;
+                    case CreateCurvePhase.DefineStart:
+                        fitCurve.options.startTangent = undefined; // Not accepted, compute default start tangent...
+                        this._tangentPhase = CreateCurvePhase.DefineEnd;
+                        IModelApp.toolAdmin.updateDynamics();
+                        this.setupAndPromptForNextAction();
+                        return false;
+                    case CreateCurvePhase.DefineEnd:
+                        fitCurve.options.endTangent = undefined; // Not accepted, compute default end tangent...
+                        await this.createElement();
+                        return true;
+                }
+            }
             await this.updateCurveAndContinuationData(ev, false, CreateCurvePhase.DefineEnd);
             await this.createElement();
         }
-        return super.onResetButtonUp(ev);
-    }
-    syncOrderState() {
-        this.orderProperty.displayValue = this.orderProperty.description.format(this.order);
-        this.syncToolSettingsProperties([this.orderProperty.syncItem]);
+        return true;
     }
     async applyToolSettingPropertyChange(updatedValue) {
-        if (this.methodProperty.name === updatedValue.propertyName) {
-            this.methodProperty.value = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.methodProperty.item);
+        if (!this.changeToolSettingPropertyValue(updatedValue))
+            return false;
+        if (this.methodProperty.name === updatedValue.propertyName)
             await this.onReinitialize();
-            return true;
-        }
-        else if (updatedValue.propertyName === this.orderProperty.name) {
-            if (!updatedValue.value.value) {
-                this.syncOrderState(); // force UI to redisplay last valid value
-                return false;
-            }
-            this.order = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.orderProperty.item);
-            return true;
-        }
-        return false;
+        return true;
     }
     supplyToolSettingsProperties() {
         const toolSettings = new Array();
         toolSettings.push(this.methodProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        toolSettings.push(this.orderProperty.toDialogItem({ rowPriority: 2, columnIndex: 1 }));
+        if (BCurveMethod.ThroughPoints === this.method)
+            toolSettings.push(this.tangentsProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
+        else
+            toolSettings.push(this.orderProperty.toDialogItem({ rowPriority: 2, columnIndex: 1 }));
         return toolSettings;
     }
     async onRestartTool() {
@@ -1692,21 +1682,18 @@ export class CreateBCurveTool extends CreateOrContinuePathTool {
         if (!await super.onInstall())
             return false;
         // Setup initial values here instead of supplyToolSettingsProperties to support keyin args w/o appui-react...
-        const methodValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.methodProperty.name);
-        if (undefined !== methodValue)
-            this.methodProperty.dialogItemValue = methodValue;
-        const orderValue = IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValue(this.toolId, this.orderProperty.name);
-        if (undefined !== orderValue)
-            this.orderProperty.dialogItemValue = orderValue;
+        this.initializeToolSettingPropertyValues([this.methodProperty, this.orderProperty, this.tangentsProperty]);
         return true;
     }
     /** The keyin takes the following arguments, all of which are optional:
      *  - `method=0|1` How bcurve will be defined. 0 for control points, 1 for through points.
      *  - `order=number` bcurve order from 2 to 16.
+     *  - 'tangents=0|1 Whether to specify start/end tangents for through points construction.
      */
     async parseAndRun(...inputArgs) {
         let bcurveMethod;
         let bcurveOrder;
+        let bcurveTangents;
         for (const arg of inputArgs) {
             const parts = arg.split("=");
             if (2 !== parts.length)
@@ -1730,12 +1717,18 @@ export class CreateBCurveTool extends CreateOrContinuePathTool {
                     bcurveOrder = order;
                 }
             }
+            else if (parts[0].toLowerCase().startsWith("ta")) {
+                const tangents = Number.parseInt(parts[1], 10);
+                bcurveTangents = (0 !== tangents);
+            }
         }
         // Update current session values so keyin args are picked up for tool settings/restart...
         if (undefined !== bcurveMethod)
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.methodProperty.name, value: { value: bcurveMethod } });
+            this.saveToolSettingPropertyValue(this.methodProperty, { value: bcurveMethod });
         if (undefined !== bcurveOrder)
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, { propertyName: this.orderProperty.name, value: { value: bcurveOrder } });
+            this.saveToolSettingPropertyValue(this.orderProperty, { value: bcurveOrder });
+        if (undefined !== bcurveTangents)
+            this.saveToolSettingPropertyValue(this.tangentsProperty, { value: bcurveTangents });
         return this.run();
     }
 }