@itwin/editor-frontend 4.5.0-dev.9 → 4.6.0-dev.0

package/lib/cjs/SketchTools.js

@@ -1,1708 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateBCurveTool = exports.BCurveMethod = exports.CreateRectangleTool = exports.CreateEllipseTool = exports.CreateCircleTool = exports.CircleMethod = exports.CreateArcTool = exports.ArcMethod = exports.CreateLineStringTool = exports.CreateOrContinuePathTool = exports.CreateCurvePhase = void 0;
-/** @packageDocumentation
- * @module Editing
- */
-const appui_abstract_1 = require("@itwin/appui-abstract");
-const core_bentley_1 = require("@itwin/core-bentley");
-const core_common_1 = require("@itwin/core-common");
-const core_frontend_1 = require("@itwin/core-frontend");
-const core_geometry_1 = require("@itwin/core-geometry");
-const editor_common_1 = require("@itwin/editor-common");
-const CreateElementTool_1 = require("./CreateElementTool");
-const EditTool_1 = require("./EditTool");
-const EditToolIpc_1 = require("./EditToolIpc");
-/** @alpha Values for [[CreateOrContinueTool.createCurvePhase] to support join and closure. */
-var CreateCurvePhase;
-(function (CreateCurvePhase) {
-    /** Current tool phase changes CurvePrimitive startPoint.
-     * ex. Arc defined by center, start would return this when accepted length is 1.
-     */
-    CreateCurvePhase[CreateCurvePhase["DefineStart"] = 0] = "DefineStart";
-    /** Current tool phase changes CurvePrimitive endPoint.
-     * ex. Arc defined by start, end, mid would return this when accepted length is 1.
-     */
-    CreateCurvePhase[CreateCurvePhase["DefineEnd"] = 1] = "DefineEnd";
-    /** Current tool phase does NOT change CurvePrimitive startPoint or endPoint.
-     * ex. When defining arc mid point, or start and end tangents for a bcurve return this.
-     */
-    CreateCurvePhase[CreateCurvePhase["DefineOther"] = 2] = "DefineOther";
-})(CreateCurvePhase = exports.CreateCurvePhase || (exports.CreateCurvePhase = {}));
-/** @alpha Base class for creating open and closed paths. */
-class CreateOrContinuePathTool extends CreateElementTool_1.CreateElementWithDynamicsTool {
-    constructor() {
-        super(...arguments);
-        this._createCurvePhase = CreateCurvePhase.DefineOther;
-        this.accepted = [];
-        this.isClosed = false;
-        this.isConstruction = false; // Sub-classes can set in createNewCurvePrimitive to bypass creating element graphics...
-    }
-    async startCommand() {
-        if (undefined !== this._startedCmd)
-            return this._startedCmd;
-        return EditTool_1.EditTools.startCommand({ commandId: editor_common_1.editorBuiltInCmdIds.cmdBasicManipulation, iModelKey: this.iModel.key });
-    }
-    get allowJoin() { return this.isControlDown; }
-    get allowClosure() { return this.isControlDown; }
-    get allowSimplify() { return true; }
-    get wantSmartRotation() { return this.isContinueExistingPath || this.isControlDown; }
-    get wantPickableDynamics() { return false; }
-    get wantJoin() { return this.allowJoin; }
-    get wantClosure() { return this.isContinueExistingPath && this.allowClosure; }
-    get wantSimplify() { return this.allowSimplify; }
-    get showCurveConstructions() { return false; }
-    get showJoin() { return this.isContinueExistingPath && CreateCurvePhase.DefineStart === this.createCurvePhase; }
-    get showClosure() { return this.isClosed && CreateCurvePhase.DefineEnd === this.createCurvePhase; }
-    get createCurvePhase() { return this._createCurvePhase; }
-    /** Sub-classes should override unless they don't support join or closure. */
-    updateCurvePhase() { }
-    getCurrentRotation(ev) {
-        const matrix = (undefined !== ev.viewport ? core_frontend_1.AccuDrawHintBuilder.getCurrentRotation(ev.viewport, true, true) : undefined);
-        return (undefined !== matrix ? matrix : core_geometry_1.Matrix3d.createIdentity());
-    }
-    getUpVector(ev) {
-        return this.getCurrentRotation(ev).getColumn(2);
-    }
-    async updateCurveAndContinuationData(ev, isDynamics) {
-        this.isConstruction = false;
-        this.current = this.createNewCurvePrimitive(ev, isDynamics);
-        if (CreateCurvePhase.DefineStart === this.createCurvePhase)
-            await this.isValidForJoin(); // Updates this.continuationData...
-        else if (CreateCurvePhase.DefineEnd === this.createCurvePhase)
-            await this.isValidForClosure(); // Updates this.isClosed...
-    }
-    async updateElementData(ev, isDynamics) {
-        if (!isDynamics)
-            this.accepted.push(ev.point.clone());
-        await this.updateCurveAndContinuationData(ev, isDynamics);
-        if (!isDynamics)
-            this.updateCurvePhase();
-    }
-    async updateDynamicData(ev) {
-        // Need to update continuation data for first data point before dynamics has started...
-        await this.updateCurveAndContinuationData(ev, true);
-        // Don't need to create graphic if dynamics aren't yet active or showing construction geometry...
-        return (core_frontend_1.IModelApp.viewManager.inDynamicsMode && !this.isConstruction);
-    }
-    get isContinueExistingPath() { return undefined !== this.continuationData; }
-    async isValidForContinue(snap) {
-        if (!snap.isElementHit)
-            return;
-        const snapCurve = snap.getCurvePrimitive();
-        if (undefined === snapCurve)
-            return;
-        const curveS = snapCurve.startPoint();
-        const curveE = snapCurve.endPoint();
-        if (curveS.isAlmostEqual(curveE))
-            return; // Reject snap to single physically closed curve primitive...
-        const snapPt = snap.adjustedPoint;
-        if (!(snapPt.isAlmostEqual(curveS) || snapPt.isAlmostEqual(curveE)))
-            return; // No point to further checks if snap wasn't to endpoint of curve primitive...
-        try {
-            this._startedCmd = await this.startCommand();
-            const info = await EditToolIpc_1.basicManipulationIpc.requestElementGeometry(snap.sourceId, { maxDisplayable: 1, geometry: { curves: true, surfaces: false, solids: false } });
-            if (undefined === info)
-                return;
-            const data = CreateOrContinuePathTool.isSingleOpenPath(info);
-            if (undefined === data)
-                return;
-            const props = await this.iModel.elements.loadProps(snap.sourceId);
-            if (undefined === props)
-                return;
-            return { props, path: data.path, params: data.params };
-        }
-        catch (err) {
-            core_frontend_1.IModelApp.notifications.outputMessage(new core_frontend_1.NotifyMessageDetails(core_frontend_1.OutputMessagePriority.Error, core_bentley_1.BentleyError.getErrorMessage(err) || "An unknown error occurred."));
-            return;
-        }
-    }
-    async isValidForJoin() {
-        this.continuationData = undefined;
-        if (!this.wantJoin)
-            return false;
-        if (undefined === this.current)
-            return false;
-        const snap = core_frontend_1.TentativeOrAccuSnap.getCurrentSnap();
-        if (undefined === snap)
-            return false;
-        const data = await this.isValidForContinue(snap);
-        if (undefined === data)
-            return false;
-        if (!CreateOrContinuePathTool.isPathEndPoint(this.current, data.path))
-            return false;
-        this.continuationData = data;
-        return true;
-    }
-    async isValidForClosure() {
-        this.isClosed = false;
-        if (!this.wantClosure)
-            return false;
-        if (undefined === this.current)
-            return false;
-        return (this.isClosed = CreateOrContinuePathTool.isPathClosurePoint(this.current, this.continuationData?.path));
-    }
-    static isSingleOpenPath(info) {
-        const it = new core_common_1.ElementGeometry.Iterator(info);
-        it.requestWorldCoordinates();
-        for (const entry of it) {
-            const geom = entry.toGeometryQuery();
-            if (undefined === geom)
-                return;
-            if ("curvePrimitive" === geom.geometryCategory) {
-                const curve = geom;
-                const curveS = curve.startPoint();
-                const curveE = curve.endPoint();
-                if (curveS.isAlmostEqual(curveE))
-                    return; // Reject zero length lines, physically closed arcs, linestrings, etc...
-                return { path: core_geometry_1.Path.create(curve), params: entry.geomParams };
-            }
-            else if ("curveCollection" === geom.geometryCategory) {
-                const curves = geom;
-                if (!curves.isOpenPath)
-                    return;
-                const path = curves;
-                const curveS = path.children[0].startPoint();
-                const curveE = path.children[path.children.length - 1].endPoint();
-                if (curveS.isAlmostEqual(curveE))
-                    return; // Reject physically closed path...
-                return { path, params: entry.geomParams };
-            }
-            break;
-        }
-        return;
-    }
-    static isPathEndPoint(curve, path) {
-        const curveS = curve.startPoint();
-        const pathS = path.children[0].startPoint();
-        const pathE = path.children[path.children.length - 1].endPoint();
-        if (!(curveS.isAlmostEqual(pathS) || curveS.isAlmostEqual(pathE)))
-            return false;
-        return true;
-    }
-    static isPathClosurePoint(curve, path) {
-        const length = curve.quickLength();
-        if (length < core_geometry_1.Geometry.smallMetricDistance)
-            return false;
-        const curveS = curve.startPoint();
-        const curveE = curve.endPoint();
-        if (undefined === path) {
-            if (!curveS.isAlmostEqual(curveE))
-                return false;
-            const curveLocalToWorld = core_geometry_1.FrameBuilder.createRightHandedFrame(undefined, curve);
-            if (undefined === curveLocalToWorld)
-                return false;
-            // Don't create a Loop unless new CurvePrimitive is planar...
-            const curvePlane = core_geometry_1.Plane3dByOriginAndUnitNormal.create(curveLocalToWorld.getOrigin(), curveLocalToWorld.matrix.getColumn(2));
-            return (undefined !== curvePlane && curve.isInPlane(curvePlane));
-        }
-        const pathS = path.children[0].startPoint();
-        const pathE = path.children[path.children.length - 1].endPoint();
-        if (!(curveS.isAlmostEqual(pathS) && curveE.isAlmostEqual(pathE) || curveS.isAlmostEqual(pathE) && curveE.isAlmostEqual(pathS)))
-            return false;
-        const pathLocalToWorld = core_geometry_1.FrameBuilder.createRightHandedFrame(undefined, [curve, path]);
-        if (undefined === pathLocalToWorld)
-            return false;
-        // Don't create a Loop unless new CurvePrimitive + existing Path is planar...
-        const pathPlane = core_geometry_1.Plane3dByOriginAndUnitNormal.create(pathLocalToWorld.getOrigin(), pathLocalToWorld.matrix.getColumn(2));
-        if (undefined === pathPlane)
-            return false;
-        if (!curve.isInPlane(pathPlane))
-            return false;
-        for (const child of path.children) {
-            if (!child.isInPlane(pathPlane))
-                return false;
-        }
-        return true;
-    }
-    addConstructionGraphics(curve, showCurve, context) {
-        if (!showCurve) {
-            switch (curve.curvePrimitiveType) {
-                case "arc":
-                case "bsplineCurve":
-                case "interpolationCurve":
-                    break;
-                default:
-                    return;
-            }
-        }
-        const builder = context.createGraphic({ type: core_frontend_1.GraphicType.WorldOverlay });
-        builder.setSymbology(context.viewport.getContrastToBackgroundColor(), core_common_1.ColorDef.black, 1, core_common_1.LinePixels.Code2);
-        if (showCurve)
-            builder.addPath(core_geometry_1.Path.create(curve));
-        switch (curve.curvePrimitiveType) {
-            case "arc": {
-                const arc = curve;
-                const start = arc.startPoint();
-                const end = arc.endPoint();
-                builder.addLineString([arc.center, start]);
-                if (!start.isAlmostEqual(end))
-                    builder.addLineString([arc.center, end]);
-                builder.setSymbology(context.viewport.getContrastToBackgroundColor(), core_common_1.ColorDef.black, 5);
-                builder.addPointString([arc.center]);
-                break;
-            }
-            case "bsplineCurve": {
-                const bcurve = curve;
-                const poles = [];
-                for (let iPole = 0; iPole < bcurve.numPoles; ++iPole) {
-                    const polePt = bcurve.getPolePoint3d(iPole);
-                    if (undefined !== polePt)
-                        poles.push(polePt);
-                }
-                builder.addLineString(poles);
-                builder.setSymbology(context.viewport.getContrastToBackgroundColor(), core_common_1.ColorDef.black, 5);
-                builder.addPointString(poles);
-                break;
-            }
-            case "interpolationCurve": {
-                const fitCurve = curve;
-                builder.setSymbology(context.viewport.getContrastToBackgroundColor(), core_common_1.ColorDef.black, 5);
-                builder.addPointString(fitCurve.options.fitPoints); // deep copy shoulnd't be necessary...
-                break;
-            }
-            default:
-                break;
-        }
-        context.addGraphic(builder.finish());
-    }
-    showConstructionGraphics(_ev, context) {
-        if (undefined === this.current)
-            return false;
-        if (!this.isConstruction) {
-            if (this.showCurveConstructions)
-                this.addConstructionGraphics(this.current, false, context);
-            return false;
-        }
-        this.addConstructionGraphics(this.current, true, context);
-        return true;
-    }
-    onDynamicFrame(ev, context) {
-        if (this.showConstructionGraphics(ev, context))
-            return; // Don't display element graphics...
-        super.onDynamicFrame(ev, context);
-    }
-    showJoinIndicator(context, pt) {
-        const lengthX = Math.floor(context.viewport.pixelsFromInches(0.08)) + 0.5;
-        const lengthY = Math.floor(lengthX * 0.6) + 0.5;
-        const offsetX = lengthX * 3;
-        const offsetY = lengthY * 3;
-        const position = context.viewport.worldToView(pt);
-        position.x = Math.floor(position.x - offsetX) + 0.5;
-        position.y = Math.floor(position.y + offsetY) + 0.5;
-        const drawDecoration = (ctx) => {
-            ctx.beginPath();
-            ctx.strokeStyle = "rgba(0,0,0,.8)";
-            ctx.lineWidth = 3;
-            ctx.lineCap = "round";
-            ctx.moveTo(-lengthX, lengthY);
-            ctx.lineTo(0, lengthY);
-            ctx.lineTo(0, -lengthY);
-            ctx.lineTo(lengthX, -lengthY);
-            ctx.stroke();
-            ctx.beginPath();
-            ctx.strokeStyle = "rgba(255,255,255,.8)";
-            ctx.lineWidth = 1;
-            ctx.moveTo(-lengthX, lengthY);
-            ctx.lineTo(0, lengthY);
-            ctx.lineTo(0, -lengthY);
-            ctx.lineTo(lengthX, -lengthY);
-            ctx.stroke();
-            ctx.beginPath();
-            ctx.strokeStyle = "rgba(0,0,0,.8)";
-            ctx.fillStyle = "rgba(0,255,255,.8)";
-            ctx.arc(0, -lengthY, 2.5, 0, 2 * Math.PI);
-            ctx.fill();
-            ctx.stroke();
-        };
-        context.addCanvasDecoration({ position, drawDecoration }, true);
-    }
-    showClosureIndicator(context, pt) {
-        const radius = Math.floor(context.viewport.pixelsFromInches(0.06)) + 0.5;
-        const offset = radius * 2.5;
-        const position = context.viewport.worldToView(pt);
-        position.x = Math.floor(position.x - offset) + 0.5;
-        position.y = Math.floor(position.y + offset) + 0.5;
-        const drawDecoration = (ctx) => {
-            ctx.beginPath();
-            ctx.strokeStyle = "rgba(255,255,255,.8)";
-            ctx.lineWidth = 1;
-            ctx.fillStyle = "rgba(0,0,255,.2)";
-            ctx.arc(0, 0, radius, 0, 2 * Math.PI);
-            ctx.fill();
-            ctx.stroke();
-            ctx.beginPath();
-            ctx.strokeStyle = "rgba(0,0,0,.8)";
-            ctx.arc(0, 0, radius + 1, 0, 2 * Math.PI);
-            ctx.stroke();
-            ctx.beginPath();
-            ctx.strokeStyle = "rgba(0,0,0,.8)";
-            ctx.fillStyle = "rgba(0,255,255,.8)";
-            ctx.arc(-radius, 0, 2.5, 0, 2 * Math.PI);
-            ctx.fill();
-            ctx.stroke();
-        };
-        context.addCanvasDecoration({ position, drawDecoration }, true);
-    }
-    testDecorationHit(id) {
-        return id === this._snapGeomId;
-    }
-    async getToolTip(hit) {
-        if (this.testDecorationHit(hit.sourceId))
-            return this.description;
-        return super.getToolTip(hit);
-    }
-    getSnapGeometry() {
-        if (this.accepted.length < 2)
-            return;
-        // Treat accepted points as linear segments by default...
-        return core_geometry_1.LineString3d.create(this.accepted);
-    }
-    getDecorationGeometry(_hit) {
-        const geomQuery = this.getSnapGeometry();
-        if (undefined === geomQuery)
-            return;
-        const geomJson = core_geometry_1.IModelJson.Writer.toIModelJson(geomQuery);
-        return geomJson ? [geomJson] : undefined;
-    }
-    addPickableGraphics(context) {
-        const geomQuery = this.getSnapGeometry();
-        if (undefined === geomQuery)
-            return;
-        if (undefined === this._snapGeomId)
-            this._snapGeomId = this.iModel.transientIds.getNext();
-        const builder = context.createGraphic({ type: core_frontend_1.GraphicType.WorldDecoration, pickable: { id: this._snapGeomId, locateOnly: true } });
-        builder.setSymbology(core_common_1.ColorDef.white, core_common_1.ColorDef.white, 1);
-        switch (geomQuery.geometryCategory) {
-            case "pointCollection": {
-                const pointString = geomQuery;
-                builder.addPointString(pointString.points);
-                break;
-            }
-            case "curvePrimitive": {
-                const curvePrimitive = geomQuery;
-                switch (curvePrimitive.curvePrimitiveType) {
-                    case "lineString": {
-                        const lineString = geomQuery;
-                        builder.addLineString(lineString.points);
-                        break;
-                    }
-                    default:
-                        return; // Don't need to support other types of CurvePrimitive currently...
-                }
-                break;
-            }
-            default:
-                return; // Don't need to support other types of GeometryQuery currently...
-        }
-        context.addDecorationFromBuilder(builder);
-    }
-    decorate(context) {
-        if (this.wantPickableDynamics)
-            this.addPickableGraphics(context);
-        if (undefined === this.current)
-            return;
-        if (this.showJoin)
-            this.showJoinIndicator(context, this.current.startPoint());
-        else if (this.showClosure)
-            this.showClosureIndicator(context, this.current.endPoint());
-    }
-    async onModifierKeyTransition(_wentDown, modifier, _event) {
-        if (core_frontend_1.BeModifierKeys.Control !== modifier)
-            return core_frontend_1.EventHandled.No;
-        // Update display for join/closure change w/o waiting for a motion event...
-        return core_frontend_1.EventHandled.Yes;
-    }
-    getPlacementProps() {
-        if (undefined !== this.continuationData)
-            return this.continuationData.props.placement;
-        if (undefined === this.current)
-            return;
-        const vp = this.targetView;
-        if (undefined === vp)
-            return;
-        const matrix = core_frontend_1.AccuDrawHintBuilder.getCurrentRotation(vp, true, true);
-        const localToWorld = core_geometry_1.FrameBuilder.createRightHandedFrame(matrix?.getColumn(2), this.current);
-        if (undefined === localToWorld)
-            return;
-        const origin = localToWorld.getOrigin();
-        const angles = new core_geometry_1.YawPitchRollAngles();
-        core_geometry_1.YawPitchRollAngles.createFromMatrix3d(localToWorld.matrix, angles);
-        if (vp.view.is3d())
-            return { origin, angles };
-        return { origin, angle: angles.yaw };
-    }
-    createNewPath(placement) {
-        if (undefined === this.current)
-            return;
-        const builder = new core_common_1.ElementGeometry.Builder();
-        builder.setLocalToWorldFromPlacement(placement);
-        const geometry = (this.isClosed ? core_geometry_1.Loop.create(this.current) : this.current);
-        if (!builder.appendGeometryQuery(geometry))
-            return;
-        return { format: "flatbuffer", data: builder.entries };
-    }
-    continueExistingPath(placement) {
-        if (undefined === this.current || undefined === this.continuationData)
-            return;
-        const length = this.current.quickLength();
-        if (length < core_geometry_1.Geometry.smallMetricDistance)
-            return;
-        const curveS = this.current.startPoint();
-        const pathS = this.continuationData.path.children[0].startPoint();
-        const pathE = this.continuationData.path.children[this.continuationData.path.children.length - 1].endPoint();
-        const append = pathE.isAlmostEqual(curveS);
-        if (!append && !pathS.isAlmostEqual(curveS))
-            return;
-        const continuePath = this.continuationData.path.clone();
-        if (undefined === continuePath)
-            return;
-        const current = this.current.clone();
-        if (undefined === current)
-            return;
-        if (append) {
-            continuePath.tryAddChild(current);
-        }
-        else {
-            current.reverseInPlace();
-            continuePath.children.splice(0, 0, current);
-        }
-        const geometry = (this.isClosed ? core_geometry_1.Loop.create(...continuePath.children) : continuePath);
-        if (this.wantSimplify)
-            core_geometry_1.RegionOps.consolidateAdjacentPrimitives(geometry);
-        const builder = new core_common_1.ElementGeometry.Builder();
-        builder.setLocalToWorldFromPlacement(placement);
-        builder.appendGeometryParamsChange(this.continuationData.params);
-        if (!builder.appendGeometryQuery(geometry))
-            return;
-        return { format: "flatbuffer", data: builder.entries };
-    }
-    getGeometryProps(placement) {
-        if (this.isContinueExistingPath)
-            return this.continueExistingPath(placement);
-        return this.createNewPath(placement);
-    }
-    getElementProps(placement) {
-        if (undefined !== this.continuationData)
-            return this.continuationData.props;
-        const model = this.targetModelId;
-        const category = this.targetCategory;
-        if ((0, core_common_1.isPlacement3dProps)(placement))
-            return { classFullName: "Generic:PhysicalObject", model, category, code: core_common_1.Code.createEmpty(), placement };
-        return { classFullName: "BisCore:DrawingGraphic", model, category, code: core_common_1.Code.createEmpty(), placement };
-    }
-    async doCreateElement(props, data) {
-        try {
-            this._startedCmd = await this.startCommand();
-            if (undefined === props.id)
-                await EditToolIpc_1.basicManipulationIpc.insertGeometricElement(props, data);
-            else
-                await EditToolIpc_1.basicManipulationIpc.updateGeometricElement(props, data);
-            await this.saveChanges();
-        }
-        catch (err) {
-            core_frontend_1.IModelApp.notifications.outputMessage(new core_frontend_1.NotifyMessageDetails(core_frontend_1.OutputMessagePriority.Error, core_bentley_1.BentleyError.getErrorMessage(err) || "An unknown error occurred."));
-        }
-    }
-    setupAccuDraw() {
-        const nPts = this.accepted.length;
-        if (0 === nPts)
-            return;
-        const hints = new core_frontend_1.AccuDrawHintBuilder();
-        if (this.wantSmartRotation)
-            hints.enableSmartRotation = true;
-        // Rotate AccuDraw to last segment...
-        if (nPts > 1 && !this.accepted[nPts - 1].isAlmostEqual(this.accepted[nPts - 2]))
-            hints.setXAxis(core_geometry_1.Vector3d.createStartEnd(this.accepted[nPts - 2], this.accepted[nPts - 1]));
-        hints.setOrigin(this.accepted[nPts - 1]);
-        hints.sendHints();
-    }
-    async onUndoPreviousStep() {
-        if (0 === this.accepted.length)
-            return false;
-        this.accepted.pop();
-        if (0 === this.accepted.length) {
-            await this.onReinitialize();
-        }
-        else {
-            this.updateCurvePhase();
-            this.setupAndPromptForNextAction();
-        }
-        return true;
-    }
-    async onPostInstall() {
-        await super.onPostInstall();
-        this.updateCurvePhase();
-    }
-}
-exports.CreateOrContinuePathTool = CreateOrContinuePathTool;
-/** @alpha Creates a line string or shape. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
-class CreateLineStringTool extends CreateOrContinuePathTool {
-    get wantPickableDynamics() { return true; } // Allow snapping to accepted segments...
-    provideToolAssistance(_mainInstrText, _additionalInstr) {
-        const nPts = this.accepted.length;
-        const mainMsg = core_frontend_1.CoreTools.translate(0 === nPts ? "ElementSet.Prompts.StartPoint" : (1 === nPts ? "ElementSet.Prompts.EndPoint" : "ElementSet.Inputs.AdditionalPoint"));
-        const leftMsg = core_frontend_1.CoreTools.translate("ElementSet.Inputs.AcceptPoint");
-        const rightMsg = core_frontend_1.CoreTools.translate(nPts > 1 ? "ElementSet.Inputs.Complete" : "ElementSet.Inputs.Cancel");
-        const mouseInstructions = [];
-        const touchInstructions = [];
-        if (!core_frontend_1.ToolAssistance.createTouchCursorInstructions(touchInstructions))
-            touchInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.OneTouchTap, leftMsg, false, core_frontend_1.ToolAssistanceInputMethod.Touch));
-        mouseInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.LeftClick, leftMsg, false, core_frontend_1.ToolAssistanceInputMethod.Mouse));
-        touchInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.TwoTouchTap, rightMsg, false, core_frontend_1.ToolAssistanceInputMethod.Touch));
-        mouseInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.RightClick, rightMsg, false, core_frontend_1.ToolAssistanceInputMethod.Mouse));
-        const sections = [];
-        sections.push(core_frontend_1.ToolAssistance.createSection(mouseInstructions, core_frontend_1.ToolAssistance.inputsLabel));
-        sections.push(core_frontend_1.ToolAssistance.createSection(touchInstructions, core_frontend_1.ToolAssistance.inputsLabel));
-        const mainInstruction = core_frontend_1.ToolAssistance.createInstruction(this.iconSpec, mainMsg);
-        const instructions = core_frontend_1.ToolAssistance.createInstructions(mainInstruction, sections);
-        core_frontend_1.IModelApp.notifications.setToolAssistance(instructions);
-    }
-    get wantClosure() {
-        // A linestring can support physical closure when creating a new path...
-        return this.allowClosure;
-    }
-    updateCurvePhase() {
-        // The first point changes startPoint and last point changes endPoint.
-        this._createCurvePhase = (0 === this.accepted.length ? CreateCurvePhase.DefineStart : CreateCurvePhase.DefineEnd);
-    }
-    isComplete(ev) {
-        // Accept on reset with at least 2 points...
-        if (core_frontend_1.BeButton.Reset === ev.button)
-            return (this.accepted.length > 1);
-        // Allow data to complete on physical closure (creates Loop)...
-        return this.isClosed;
-    }
-    createNewCurvePrimitive(ev, isDynamics) {
-        const numRequired = (isDynamics ? 1 : 2);
-        if (this.accepted.length < numRequired) {
-            this.isConstruction = true; // Create zero length line as construction geometry to support join...
-            const pt = (0 !== this.accepted.length ? this.accepted[0] : ev.point);
-            return core_geometry_1.LineString3d.create([pt, pt]);
-        }
-        const pts = (isDynamics ? [...this.accepted, ev.point] : this.accepted);
-        return core_geometry_1.LineString3d.create(pts);
-    }
-    async cancelPoint(ev) {
-        // NOTE: Starting another tool will not create element...require reset or closure...
-        if (this.isComplete(ev)) {
-            this._createCurvePhase = CreateCurvePhase.DefineEnd;
-            await this.updateCurveAndContinuationData(ev, false);
-            await this.createElement();
-        }
-        return true;
-    }
-    async onRestartTool() {
-        const tool = new CreateLineStringTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-CreateLineStringTool.toolId = "CreateLineString";
-CreateLineStringTool.iconSpec = "icon-snaps"; // Need better icon...
-exports.CreateLineStringTool = CreateLineStringTool;
-/** @alpha */
-var ArcMethod;
-(function (ArcMethod) {
-    ArcMethod[ArcMethod["CenterStart"] = 0] = "CenterStart";
-    ArcMethod[ArcMethod["StartCenter"] = 1] = "StartCenter";
-    ArcMethod[ArcMethod["StartMidEnd"] = 2] = "StartMidEnd";
-    ArcMethod[ArcMethod["StartEndMid"] = 3] = "StartEndMid";
-})(ArcMethod = exports.ArcMethod || (exports.ArcMethod = {}));
-/** @alpha Creates an arc. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
-class CreateArcTool extends CreateOrContinuePathTool {
-    static get minArgs() { return 0; }
-    static get maxArgs() { return 3; } // method, radius, sweep - zero value unlocks associated "use" toggle...
-    get showCurveConstructions() { return true; } // Display lines from center to start/end...
-    provideToolAssistance(mainInstrText, additionalInstr) {
-        const nPts = this.accepted.length;
-        switch (this.method) {
-            case ArcMethod.CenterStart:
-                mainInstrText = (0 === nPts ? EditTool_1.EditTools.translate("CreateArc.Prompts.CenterPoint") : (1 === nPts ? core_frontend_1.CoreTools.translate("ElementSet.Prompts.StartPoint") : core_frontend_1.CoreTools.translate("ElementSet.Prompts.EndPoint")));
-                break;
-            case ArcMethod.StartCenter:
-                mainInstrText = (0 === nPts ? core_frontend_1.CoreTools.translate("ElementSet.Prompts.StartPoint") : (1 === nPts ? EditTool_1.EditTools.translate("CreateArc.Prompts.CenterPoint") : core_frontend_1.CoreTools.translate("ElementSet.Prompts.EndPoint")));
-                break;
-            case ArcMethod.StartMidEnd:
-                mainInstrText = (0 === nPts ? core_frontend_1.CoreTools.translate("ElementSet.Prompts.StartPoint") : (1 === nPts ? EditTool_1.EditTools.translate("CreateArc.Prompts.MidPoint") : core_frontend_1.CoreTools.translate("ElementSet.Prompts.EndPoint")));
-                break;
-            case ArcMethod.StartEndMid:
-                mainInstrText = (0 === nPts ? core_frontend_1.CoreTools.translate("ElementSet.Prompts.StartPoint") : (1 === nPts ? core_frontend_1.CoreTools.translate("ElementSet.Prompts.EndPoint") : EditTool_1.EditTools.translate("CreateArc.Prompts.MidPoint")));
-                break;
-        }
-        super.provideToolAssistance(mainInstrText, additionalInstr);
-    }
-    setupAccuDraw() {
-        const nPts = this.accepted.length;
-        if (0 === nPts)
-            return;
-        const hints = new core_frontend_1.AccuDrawHintBuilder();
-        if (this.wantSmartRotation)
-            hints.enableSmartRotation = true;
-        switch (this.accepted.length) {
-            case 1:
-                hints.setOrigin(this.accepted[0]);
-                if (ArcMethod.CenterStart !== this.method)
-                    break;
-                hints.setOriginFixed = true;
-                hints.setModePolar();
-                break;
-            case 2:
-                switch (this.method) {
-                    case ArcMethod.CenterStart:
-                        if (!this.accepted[0].isAlmostEqual(this.accepted[1]))
-                            hints.setXAxis(core_geometry_1.Vector3d.createStartEnd(this.accepted[0], this.accepted[1])); // Rotate AccuDraw to major axis...
-                        break;
-                    case ArcMethod.StartCenter:
-                        let center = this.accepted[1];
-                        const start = this.accepted[0];
-                        const vector0 = center.unitVectorTo(start);
-                        if (undefined === vector0)
-                            break;
-                        if (this.useRadius)
-                            center = start.plusScaled(vector0, -this.radius);
-                        hints.setOrigin(center);
-                        hints.setOriginFixed = true;
-                        hints.setModePolar();
-                        hints.setXAxis(vector0);
-                        break;
-                    default:
-                        hints.setOrigin(this.accepted[1]);
-                        break;
-                }
-                break;
-        }
-        hints.sendHints();
-    }
-    static methodMessage(str) { return EditTool_1.EditTools.translate(`CreateArc.Method.${str}`); }
-    get methodProperty() {
-        if (!this._methodProperty)
-            this._methodProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildEnumPicklistEditorDescription("arcMethod", EditTool_1.EditTools.translate("CreateArc.Label.Method"), CreateArcTool.getMethodChoices()), ArcMethod.StartCenter);
-        return this._methodProperty;
-    }
-    get method() { return this.methodProperty.value; }
-    set method(method) { this.methodProperty.value = method; }
-    get useRadiusProperty() {
-        if (!this._useRadiusProperty)
-            this._useRadiusProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useArcRadius"), false);
-        return this._useRadiusProperty;
-    }
-    get useRadius() { return this.useRadiusProperty.value; }
-    set useRadius(value) { this.useRadiusProperty.value = value; }
-    get radiusProperty() {
-        if (!this._radiusProperty)
-            this._radiusProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("arcRadius", EditTool_1.EditTools.translate("CreateArc.Label.Radius")), 0.1, undefined, !this.useRadius);
-        return this._radiusProperty;
-    }
-    get radius() { return this.radiusProperty.value; }
-    set radius(value) { this.radiusProperty.value = value; }
-    get useSweepProperty() {
-        if (!this._useSweepProperty)
-            this._useSweepProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useArcSweep"), false);
-        return this._useSweepProperty;
-    }
-    get useSweep() { return this.useSweepProperty.value; }
-    set useSweep(value) { this.useSweepProperty.value = value; }
-    get sweepProperty() {
-        if (!this._sweepProperty)
-            this._sweepProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.AngleDescription("arcSweep", EditTool_1.EditTools.translate("CreateArc.Label.Sweep")), Math.PI / 2.0, undefined, !this.useSweep);
-        return this._sweepProperty;
-    }
-    get sweep() { return this.sweepProperty.value; }
-    set sweep(value) { this.sweepProperty.value = value; }
-    isComplete(_ev) {
-        return (3 === this.accepted.length);
-    }
-    updateCurvePhase() {
-        switch (this.accepted.length) {
-            case 0:
-                this._createCurvePhase = ArcMethod.CenterStart === this.method ? CreateCurvePhase.DefineOther : CreateCurvePhase.DefineStart;
-                break;
-            case 1:
-                if (ArcMethod.CenterStart === this.method)
-                    this._createCurvePhase = CreateCurvePhase.DefineStart;
-                else if (ArcMethod.StartEndMid === this.method)
-                    this._createCurvePhase = CreateCurvePhase.DefineEnd;
-                else
-                    this._createCurvePhase = CreateCurvePhase.DefineOther;
-                break;
-            default:
-                this._createCurvePhase = ArcMethod.StartEndMid === this.method ? CreateCurvePhase.DefineOther : CreateCurvePhase.DefineEnd;
-                break;
-        }
-    }
-    createConstructionCurve(ev, isDynamics) {
-        switch (this.accepted.length) {
-            case 0: {
-                if (ArcMethod.CenterStart === this.method)
-                    return undefined;
-                return core_geometry_1.LineString3d.create([ev.point, ev.point]);
-            }
-            case 1: {
-                const pt1 = this.accepted[0];
-                const pt2 = (isDynamics ? ev.point : pt1);
-                switch (this.method) {
-                    case ArcMethod.CenterStart:
-                    case ArcMethod.StartCenter: {
-                        if (pt1.isAlmostEqual(pt2))
-                            return (ArcMethod.StartCenter === this.method ? core_geometry_1.LineString3d.create([pt1, pt2]) : undefined);
-                        let center = (ArcMethod.CenterStart === this.method ? pt1 : pt2);
-                        const start = (ArcMethod.CenterStart === this.method ? pt2 : pt1);
-                        const normal = this.getUpVector(ev);
-                        const vector0 = core_geometry_1.Vector3d.createStartEnd(center, start);
-                        const vector90 = normal.crossProduct(vector0);
-                        const radius = (this.useRadius ? this.radius : vector0.magnitude());
-                        if (this.useRadius) {
-                            if (ArcMethod.StartCenter === this.method) {
-                                vector0.normalizeInPlace();
-                                center = start.plusScaled(vector0, -radius);
-                            }
-                        }
-                        else {
-                            this.radius = radius;
-                            this.syncToolSettingsRadiusAndSweep();
-                        }
-                        vector0.scaleToLength(radius, vector0);
-                        vector90.scaleToLength(radius, vector90);
-                        return core_geometry_1.Arc3d.create(center, vector0, vector90);
-                    }
-                    case ArcMethod.StartMidEnd:
-                    case ArcMethod.StartEndMid: {
-                        return core_geometry_1.LineString3d.create([pt1, pt2]);
-                    }
-                    default:
-                        return undefined;
-                }
-            }
-            case 2: {
-                switch (this.method) {
-                    case ArcMethod.CenterStart:
-                        return core_geometry_1.LineString3d.create([this.accepted[1], this.accepted[0]]);
-                    case ArcMethod.StartCenter:
-                    case ArcMethod.StartMidEnd:
-                    case ArcMethod.StartEndMid:
-                        return core_geometry_1.LineString3d.create([this.accepted[0], this.accepted[1]]);
-                    default:
-                        return undefined;
-                }
-            }
-            default:
-                return undefined;
-        }
-    }
-    createNewCurvePrimitive(ev, isDynamics) {
-        const numRequired = (isDynamics ? 2 : 3);
-        if (this.accepted.length < numRequired) {
-            this.isConstruction = true; // Create construction geometry to support join...
-            return this.createConstructionCurve(ev, isDynamics);
-        }
-        const final = (isDynamics ? ev.point : this.accepted[2]);
-        const start = (ArcMethod.CenterStart === this.method ? this.accepted[1] : this.accepted[0]);
-        const end = (ArcMethod.StartEndMid === this.method ? this.accepted[1] : final);
-        switch (this.method) {
-            case ArcMethod.CenterStart:
-            case ArcMethod.StartCenter:
-                let center = (ArcMethod.CenterStart === this.method ? this.accepted[0] : this.accepted[1]);
-                if (center.isAlmostEqual(start))
-                    return undefined; // Don't create 0 radius arc...
-                const vector0 = core_geometry_1.Vector3d.createStartEnd(center, start);
-                const vector90 = core_geometry_1.Vector3d.create();
-                const radius = (this.useRadius ? this.radius : vector0.magnitude());
-                const sweep = core_geometry_1.Angle.createRadians(this.useSweep ? this.sweep : core_geometry_1.Angle.pi2Radians);
-                if (this.useRadius) {
-                    if (ArcMethod.StartCenter === this.method) {
-                        vector0.normalizeInPlace();
-                        center = start.plusScaled(vector0, -radius);
-                    }
-                }
-                else {
-                    this.radius = radius;
-                }
-                let defaultArc = (undefined !== this.current && "arc" === this.current.curvePrimitiveType ? this.current : undefined);
-                if (undefined === defaultArc) {
-                    this.getUpVector(ev).crossProduct(vector0, vector90);
-                    vector0.scaleToLength(radius, vector0);
-                    vector90.scaleToLength(radius, vector90);
-                    // Create default arc that follows continuation path start/end tangent...
-                    if (undefined !== this.continuationData) {
-                        const pathS = this.continuationData.path.children[0].startPoint();
-                        if (start.isAlmostEqual(pathS)) {
-                            const tangentS = this.continuationData.path.children[0].fractionToPointAndUnitTangent(0.0);
-                            if (vector90.dotProduct(tangentS.direction) > 0.0)
-                                sweep.setRadians(-sweep.radians);
-                        }
-                        else {
-                            const tangentE = this.continuationData.path.children[this.continuationData.path.children.length - 1].fractionToPointAndUnitTangent(1.0);
-                            if (vector90.dotProduct(tangentE.direction) < 0.0)
-                                sweep.setRadians(-sweep.radians);
-                        }
-                    }
-                    defaultArc = core_geometry_1.Arc3d.create(center, vector0, vector90, core_geometry_1.AngleSweep.create(sweep));
-                }
-                // Don't have well defined minor axis, continue using previous or default arc...
-                if (start.isAlmostEqual(end))
-                    return defaultArc;
-                const prevSweep = core_geometry_1.Angle.createRadians(defaultArc.sweep.sweepRadians);
-                core_geometry_1.Vector3d.createStartEnd(center, end, vector90);
-                sweep.setFrom(vector0.planarAngleTo(vector90, defaultArc.perpendicularVector));
-                defaultArc.perpendicularVector.crossProduct(vector0, vector90);
-                vector0.scaleToLength(radius, vector0);
-                vector90.scaleToLength(radius, vector90);
-                if (Math.abs(sweep.radians) < core_geometry_1.Angle.createDegrees(30.0).radians && prevSweep.isFullCircle && ((sweep.radians < 0.0 && prevSweep.radians > 0.0) || (sweep.radians > 0.0 && prevSweep.radians < 0.0)))
-                    prevSweep.setRadians(-prevSweep.radians); // Reverse direction...
-                if (sweep.isAlmostZero)
-                    sweep.setDegrees(prevSweep.radians < 0.0 ? -360.0 : 360.0); // Create full sweep...
-                if (this.useSweep) {
-                    if ((sweep.radians < 0.0 && this.sweep > 0.0) || (sweep.radians > 0.0 && this.sweep < 0.0))
-                        sweep.setRadians(-this.sweep);
-                    else
-                        sweep.setRadians(this.sweep);
-                }
-                else {
-                    if (sweep.radians < 0.0 && prevSweep.radians > 0.0)
-                        sweep.setRadians(core_geometry_1.Angle.pi2Radians + sweep.radians);
-                    else if (sweep.radians > 0.0 && prevSweep.radians < 0.0)
-                        sweep.setRadians(-(core_geometry_1.Angle.pi2Radians - sweep.radians));
-                    this.sweep = sweep.radians;
-                }
-                if (!this.useRadius || !this.useSweep)
-                    this.syncToolSettingsRadiusAndSweep();
-                return core_geometry_1.Arc3d.create(center, vector0, vector90, core_geometry_1.AngleSweep.create(sweep));
-            case ArcMethod.StartMidEnd:
-            case ArcMethod.StartEndMid:
-                const mid = (ArcMethod.StartEndMid === this.method ? final : this.accepted[1]);
-                return core_geometry_1.Arc3d.createCircularStartMiddleEnd(start, mid, end);
-        }
-    }
-    syncToolSettingsRadiusAndSweep() {
-        switch (this.method) {
-            case ArcMethod.CenterStart:
-            case ArcMethod.StartCenter:
-                if (this.useRadius && this.useSweep)
-                    return;
-                break;
-            default:
-                return;
-        }
-        const syncData = [];
-        if (!this.useRadius)
-            syncData.push(this.radiusProperty.syncItem);
-        if (!this.useSweep)
-            syncData.push(this.sweepProperty.syncItem);
-        if (0 !== syncData.length)
-            this.syncToolSettingsProperties(syncData);
-    }
-    getToolSettingPropertyLocked(property) {
-        if (property === this.useRadiusProperty)
-            return this.radiusProperty;
-        else if (property === this.useSweepProperty)
-            return this.sweepProperty;
-        return undefined;
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        if (!this.changeToolSettingPropertyValue(updatedValue))
-            return false;
-        if (this.methodProperty.name === updatedValue.propertyName)
-            await this.onReinitialize();
-        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();
-        toolSettings.push(this.methodProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        if (ArcMethod.CenterStart === this.method || ArcMethod.StartCenter === this.method) {
-            // ensure controls are enabled/disabled base on current lock property state
-            this.radiusProperty.isDisabled = !this.useRadius;
-            this.sweepProperty.isDisabled = !this.useSweep;
-            const useRadiusLock = this.useRadiusProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 });
-            const useSweepLock = this.useSweepProperty.toDialogItem({ rowPriority: 3, columnIndex: 0 });
-            toolSettings.push(this.radiusProperty.toDialogItem({ rowPriority: 2, columnIndex: 1 }, useRadiusLock));
-            toolSettings.push(this.sweepProperty.toDialogItem({ rowPriority: 3, columnIndex: 1 }, useSweepLock));
-        }
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new CreateArcTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-    async onInstall() {
-        if (!await super.onInstall())
-            return false;
-        // Setup initial values here instead of supplyToolSettingsProperties to support keyin args w/o appui-react...
-        this.initializeToolSettingPropertyValues([this.methodProperty, this.radiusProperty, this.useRadiusProperty, this.sweepProperty, this.useSweepProperty]);
-        if (!this.radius)
-            this.useRadius = false;
-        if (!this.sweep)
-            this.useSweep = false;
-        return true;
-    }
-    /** The keyin takes the following arguments, all of which are optional:
-     *  - `method=0|1|2|3` How arc will be defined. 0 for center/start, 1 for start/center, 2 for start/mid/end, and 3 for start/end/mid.
-     *  - `radius=number` Arc radius for start/center or center/start, 0 to define by points.
-     *  - `sweep=number` Arc sweep angle in degrees for start/center or center/start, 0 to define by points.
-     */
-    async parseAndRun(...inputArgs) {
-        let arcMethod;
-        let arcRadius;
-        let arcSweep;
-        for (const arg of inputArgs) {
-            const parts = arg.split("=");
-            if (2 !== parts.length)
-                continue;
-            if (parts[0].toLowerCase().startsWith("me")) {
-                const method = Number.parseInt(parts[1], 10);
-                if (!Number.isNaN(method)) {
-                    switch (method) {
-                        case 0:
-                            arcMethod = ArcMethod.CenterStart;
-                            break;
-                        case 1:
-                            arcMethod = ArcMethod.StartCenter;
-                            break;
-                        case 2:
-                            arcMethod = ArcMethod.StartMidEnd;
-                            break;
-                        case 3:
-                            arcMethod = ArcMethod.StartEndMid;
-                            break;
-                    }
-                }
-            }
-            else if (parts[0].toLowerCase().startsWith("ra")) {
-                const radius = Number.parseFloat(parts[1]);
-                if (!Number.isNaN(radius)) {
-                    arcRadius = radius;
-                }
-            }
-            else if (parts[0].toLowerCase().startsWith("sw")) {
-                const sweep = Number.parseFloat(parts[1]);
-                if (!Number.isNaN(sweep)) {
-                    arcSweep = core_geometry_1.Angle.createDegrees(sweep).radians;
-                }
-            }
-        }
-        // Update current session values so keyin args are picked up for tool settings/restart...
-        if (undefined !== arcMethod)
-            this.saveToolSettingPropertyValue(this.methodProperty, { value: arcMethod });
-        if (undefined !== arcRadius) {
-            if (0.0 !== arcRadius)
-                this.saveToolSettingPropertyValue(this.radiusProperty, { value: arcRadius });
-            this.saveToolSettingPropertyValue(this.useRadiusProperty, { value: 0.0 !== arcRadius });
-        }
-        if (undefined !== arcSweep) {
-            if (0.0 !== arcSweep)
-                this.saveToolSettingPropertyValue(this.sweepProperty, { value: arcSweep });
-            this.saveToolSettingPropertyValue(this.useSweepProperty, { value: 0.0 !== arcSweep });
-        }
-        return this.run();
-    }
-}
-CreateArcTool.toolId = "CreateArc";
-CreateArcTool.iconSpec = "icon-three-points-circular-arc";
-CreateArcTool.getMethodChoices = () => {
-    return [
-        { label: CreateArcTool.methodMessage("CenterStart"), value: ArcMethod.CenterStart },
-        { label: CreateArcTool.methodMessage("StartCenter"), value: ArcMethod.StartCenter },
-        { label: CreateArcTool.methodMessage("StartMidEnd"), value: ArcMethod.StartMidEnd },
-        { label: CreateArcTool.methodMessage("StartEndMid"), value: ArcMethod.StartEndMid },
-    ];
-};
-exports.CreateArcTool = CreateArcTool;
-/** @alpha */
-var CircleMethod;
-(function (CircleMethod) {
-    CircleMethod[CircleMethod["Center"] = 0] = "Center";
-    CircleMethod[CircleMethod["Edge"] = 1] = "Edge";
-})(CircleMethod = exports.CircleMethod || (exports.CircleMethod = {}));
-/** @alpha Creates a circle. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
-class CreateCircleTool extends CreateOrContinuePathTool {
-    static get minArgs() { return 0; }
-    static get maxArgs() { return 2; } // method, radius - zero value unlocks associated "use" toggle...
-    get showCurveConstructions() { return !(CircleMethod.Center === this.method && this.useRadius); }
-    provideToolAssistance(mainInstrText, additionalInstr) {
-        const nPts = this.accepted.length;
-        switch (this.method) {
-            case CircleMethod.Center:
-                mainInstrText = EditTool_1.EditTools.translate(0 === nPts ? "CreateCircle.Prompts.CenterPoint" : "CreateCircle.Prompts.EdgePoint");
-                break;
-            case CircleMethod.Edge:
-                mainInstrText = EditTool_1.EditTools.translate(0 === nPts ? "CreateCircle.Prompts.EdgePoint" : "CreateCircle.Prompts.CenterPoint");
-                break;
-        }
-        super.provideToolAssistance(mainInstrText, additionalInstr);
-    }
-    setupAccuDraw() {
-        const nPts = this.accepted.length;
-        if (0 === nPts)
-            return;
-        const hints = new core_frontend_1.AccuDrawHintBuilder();
-        if (this.wantSmartRotation)
-            hints.enableSmartRotation = true;
-        if (CircleMethod.Center === this.method && 1 === this.accepted.length) {
-            hints.setOrigin(this.accepted[0]);
-            hints.setOriginFixed = true;
-            hints.setModePolar();
-        }
-        hints.sendHints();
-    }
-    static methodMessage(str) { return EditTool_1.EditTools.translate(`CreateCircle.Method.${str}`); }
-    get methodProperty() {
-        if (!this._methodProperty)
-            this._methodProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildEnumPicklistEditorDescription("circleMethod", EditTool_1.EditTools.translate("CreateCircle.Label.Method"), CreateCircleTool.getMethodChoices()), CircleMethod.Center);
-        return this._methodProperty;
-    }
-    get method() { return this.methodProperty.value; }
-    set method(method) { this.methodProperty.value = method; }
-    get useRadiusProperty() {
-        if (!this._useRadiusProperty)
-            this._useRadiusProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useCircleRadius"), false);
-        return this._useRadiusProperty;
-    }
-    get useRadius() { return this.useRadiusProperty.value; }
-    set useRadius(value) { this.useRadiusProperty.value = value; }
-    get radiusProperty() {
-        if (!this._radiusProperty)
-            this._radiusProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("circleRadius", EditTool_1.EditTools.translate("CreateCircle.Label.Radius")), 0.1, undefined, !this.useRadius);
-        return this._radiusProperty;
-    }
-    get radius() { return this.radiusProperty.value; }
-    set radius(value) { this.radiusProperty.value = value; }
-    isComplete(_ev) {
-        if (CircleMethod.Center === this.method && this.useRadius)
-            return (this.accepted.length >= 1); // Could be 2 if radius locked after 1st data point...
-        return (2 === this.accepted.length);
-    }
-    createNewCurvePrimitive(ev, isDynamics) {
-        this.isClosed = true; // Always closed...
-        const numRequired = (isDynamics ? 1 : 2);
-        if (this.accepted.length < numRequired) {
-            if (CircleMethod.Center === this.method && this.useRadius)
-                return core_geometry_1.Arc3d.createCenterNormalRadius(isDynamics ? ev.point : this.accepted[0], this.getUpVector(ev), this.radius);
-            return undefined;
-        }
-        const pt1 = this.accepted[0];
-        const pt2 = (isDynamics ? ev.point : this.accepted[1]);
-        let center = (CircleMethod.Center === this.method ? pt1 : pt2);
-        const edge = (CircleMethod.Center === this.method ? pt2 : pt1);
-        const normal = this.getUpVector(ev);
-        const vector0 = core_geometry_1.Vector3d.createStartEnd(center, edge);
-        const vector90 = normal.crossProduct(vector0);
-        const radius = (this.useRadius ? this.radius : vector0.magnitude());
-        if (this.useRadius) {
-            if (CircleMethod.Edge === this.method) {
-                vector0.normalizeInPlace();
-                center = edge.plusScaled(vector0, -radius);
-            }
-        }
-        else {
-            this.radius = radius;
-            this.syncToolSettingPropertyValue(this.radiusProperty);
-        }
-        vector0.scaleToLength(radius, vector0);
-        vector90.scaleToLength(radius, vector90);
-        return core_geometry_1.Arc3d.create(center, vector0, vector90);
-    }
-    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 false;
-        }
-        return true;
-    }
-    getToolSettingPropertyLocked(property) {
-        return (property === this.useRadiusProperty ? this.radiusProperty : undefined);
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        if (!this.changeToolSettingPropertyValue(updatedValue))
-            return false;
-        if (this.methodProperty.name === updatedValue.propertyName)
-            await this.onReinitialize();
-        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();
-        toolSettings.push(this.methodProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        // ensure controls are enabled/disabled base on current lock property state
-        this.radiusProperty.isDisabled = !this.useRadius;
-        const useRadiusLock = this.useRadiusProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 });
-        toolSettings.push(this.radiusProperty.toDialogItem({ rowPriority: 2, columnIndex: 1 }, useRadiusLock));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new CreateCircleTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-    async onReinitialize() {
-        if (CircleMethod.Center === this.method && this.useRadius) {
-            // Don't install a new tool instance, we want to preserve current AccuDraw state...
-            this.accepted.length = 0;
-            this.setupAndPromptForNextAction();
-            this.beginDynamics();
-            return;
-        }
-        return super.onReinitialize();
-    }
-    async onPostInstall() {
-        await super.onPostInstall();
-        if (CircleMethod.Center === this.method && this.useRadius) {
-            // Start dynamics before 1st data point when placing by center w/locked radius value.
-            // Require the user to explicitly enable AccuDraw so that the compass location can be adjusted for changes
-            // to locks or view ACS (as opposed to appearing at it's previous or default location).
-            core_frontend_1.AccuDrawHintBuilder.deactivate();
-            this.beginDynamics();
-        }
-    }
-    async onInstall() {
-        if (!await super.onInstall())
-            return false;
-        // Setup initial values here instead of supplyToolSettingsProperties to support keyin args w/o appui-react...
-        this.initializeToolSettingPropertyValues([this.methodProperty, this.radiusProperty, this.useRadiusProperty]);
-        if (!this.radius)
-            this.useRadius = false;
-        return true;
-    }
-    /** The keyin takes the following arguments, all of which are optional:
-     *  - `method=0|1` How circle will be defined. 0 for center, 1 for edge.
-     *  - `radius=number` Circle radius, 0 to define by points.
-     */
-    async parseAndRun(...inputArgs) {
-        let circleMethod;
-        let circleRadius;
-        for (const arg of inputArgs) {
-            const parts = arg.split("=");
-            if (2 !== parts.length)
-                continue;
-            if (parts[0].toLowerCase().startsWith("me")) {
-                const method = Number.parseInt(parts[1], 10);
-                if (!Number.isNaN(method)) {
-                    switch (method) {
-                        case 0:
-                            circleMethod = CircleMethod.Center;
-                            break;
-                        case 1:
-                            circleMethod = CircleMethod.Edge;
-                            break;
-                    }
-                }
-            }
-            else if (parts[0].toLowerCase().startsWith("ra")) {
-                const radius = Number.parseFloat(parts[1]);
-                if (!Number.isNaN(radius)) {
-                    circleRadius = radius;
-                }
-            }
-        }
-        // Update current session values so keyin args are picked up for tool settings/restart...
-        if (undefined !== circleMethod)
-            this.saveToolSettingPropertyValue(this.methodProperty, { value: circleMethod });
-        if (undefined !== circleRadius) {
-            if (0.0 !== circleRadius)
-                this.saveToolSettingPropertyValue(this.radiusProperty, { value: circleRadius });
-            this.saveToolSettingPropertyValue(this.useRadiusProperty, { value: 0.0 !== circleRadius });
-        }
-        return this.run();
-    }
-}
-CreateCircleTool.toolId = "CreateCircle";
-CreateCircleTool.iconSpec = "icon-circle";
-CreateCircleTool.getMethodChoices = () => {
-    return [
-        { label: CreateCircleTool.methodMessage("Center"), value: CircleMethod.Center },
-        { label: CreateCircleTool.methodMessage("Edge"), value: CircleMethod.Edge },
-    ];
-};
-exports.CreateCircleTool = CreateCircleTool;
-/** @alpha Creates an ellipse. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
-class CreateEllipseTool extends CreateOrContinuePathTool {
-    isComplete(_ev) {
-        return (3 === this.accepted.length);
-    }
-    provideToolAssistance(mainInstrText, additionalInstr) {
-        const nPts = this.accepted.length;
-        switch (nPts) {
-            case 0:
-                mainInstrText = EditTool_1.EditTools.translate("CreateEllipse.Prompts.CenterPoint");
-                break;
-            case 1:
-                mainInstrText = EditTool_1.EditTools.translate("CreateEllipse.Prompts.MajorAxis");
-                break;
-            case 2:
-                mainInstrText = EditTool_1.EditTools.translate("CreateEllipse.Prompts.MinorAxis");
-                break;
-        }
-        super.provideToolAssistance(mainInstrText, additionalInstr);
-    }
-    setupAccuDraw() {
-        const nPts = this.accepted.length;
-        if (0 === nPts)
-            return;
-        const hints = new core_frontend_1.AccuDrawHintBuilder();
-        if (this.wantSmartRotation)
-            hints.enableSmartRotation = true;
-        switch (nPts) {
-            case 1:
-                hints.setOrigin(this.accepted[0]);
-                hints.setOriginFixed = true;
-                break;
-            case 2:
-                hints.setXAxis(core_geometry_1.Vector3d.createStartEnd(this.accepted[0], this.accepted[1]));
-                hints.setLockX = true;
-                break;
-        }
-        hints.sendHints();
-    }
-    createNewCurvePrimitive(ev, isDynamics) {
-        const numRequired = (isDynamics ? 2 : 3);
-        if (this.accepted.length < numRequired) {
-            if (this.accepted.length < (numRequired - 1))
-                return undefined;
-            this.isConstruction = true; // Create construction geometry to show  major axis...
-            return core_geometry_1.LineString3d.create([this.accepted[0], (isDynamics ? ev.point : this.accepted[1])]);
-        }
-        this.isClosed = true; // Always closed...
-        const center = this.accepted[0];
-        const major = this.accepted[1];
-        const normal = this.getUpVector(ev);
-        const vector0 = core_geometry_1.Vector3d.createStartEnd(center, major);
-        const vector90 = normal.crossProduct(vector0);
-        const dir = core_geometry_1.Ray3d.create(center, vector90);
-        const minor = dir.projectPointToRay(isDynamics ? ev.point : this.accepted[2]);
-        vector90.scaleToLength(center.distance(minor), vector90);
-        return core_geometry_1.Arc3d.create(center, vector0, vector90);
-    }
-    async onRestartTool() {
-        const tool = new CreateEllipseTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-CreateEllipseTool.toolId = "CreateEllipse";
-CreateEllipseTool.iconSpec = "icon-ellipse";
-exports.CreateEllipseTool = CreateEllipseTool;
-/** @alpha Creates a rectangle by corner points. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
-class CreateRectangleTool extends CreateOrContinuePathTool {
-    constructor() {
-        super(...arguments);
-        this.localToWorld = core_geometry_1.Transform.createIdentity();
-    }
-    static get minArgs() { return 0; }
-    static get maxArgs() { return 1; } // radius - zero value unlocks associated "use" toggle...
-    provideToolAssistance(mainInstrText, additionalInstr) {
-        mainInstrText = core_frontend_1.CoreTools.translate(0 === this.accepted.length ? "ElementSet.Prompts.StartCorner" : "ElementSet.Prompts.OppositeCorner");
-        super.provideToolAssistance(mainInstrText, additionalInstr);
-    }
-    setupAccuDraw() {
-        const nPts = this.accepted.length;
-        if (0 === nPts)
-            return;
-        const hints = new core_frontend_1.AccuDrawHintBuilder();
-        if (this.wantSmartRotation)
-            hints.enableSmartRotation = true;
-        hints.setOrigin(this.accepted[0]);
-        hints.sendHints();
-    }
-    get useRadiusProperty() {
-        if (!this._useRadiusProperty)
-            this._useRadiusProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useCornerRadius"), false);
-        return this._useRadiusProperty;
-    }
-    get useRadius() { return this.useRadiusProperty.value; }
-    set useRadius(value) { this.useRadiusProperty.value = value; }
-    get radiusProperty() {
-        if (!this._radiusProperty)
-            this._radiusProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("cornerRadius", EditTool_1.EditTools.translate("CreateRectangle.Label.CornerRadius")), 0.1, undefined, !this.useRadius);
-        return this._radiusProperty;
-    }
-    get radius() { return this.radiusProperty.value; }
-    set radius(value) { this.radiusProperty.value = value; }
-    isComplete(_ev) {
-        return (2 === this.accepted.length);
-    }
-    createNewCurvePrimitive(ev, isDynamics) {
-        const numRequired = (isDynamics ? 1 : 2);
-        if (this.accepted.length < numRequired)
-            return undefined;
-        const origin = this.accepted[0];
-        const corner = (isDynamics ? ev.point : this.accepted[1]);
-        const matrix = this.getCurrentRotation(ev);
-        core_geometry_1.Transform.createOriginAndMatrix(core_geometry_1.Point3d.createZero(), matrix, this.localToWorld);
-        this.originLocal = this.localToWorld.multiplyInversePoint3d(origin);
-        this.cornerLocal = this.localToWorld.multiplyInversePoint3d(corner);
-        if (undefined === this.originLocal || undefined === this.cornerLocal)
-            return undefined;
-        const shapePts = [];
-        shapePts[0] = core_geometry_1.Point3d.create(this.originLocal.x, this.originLocal.y, this.originLocal.z);
-        shapePts[1] = core_geometry_1.Point3d.create(this.cornerLocal.x, this.originLocal.y, this.cornerLocal.z);
-        shapePts[2] = core_geometry_1.Point3d.create(this.cornerLocal.x, this.cornerLocal.y, this.cornerLocal.z);
-        shapePts[3] = core_geometry_1.Point3d.create(this.originLocal.x, this.cornerLocal.y, this.originLocal.z);
-        shapePts[4] = shapePts[0].clone();
-        this.localToWorld.multiplyPoint3dArrayInPlace(shapePts);
-        this.isClosed = true; // Always closed...
-        return core_geometry_1.LineString3d.create(shapePts);
-    }
-    createNewPath(placement) {
-        if (!this.useRadius || 0.0 === this.radius || undefined === this.originLocal || undefined === this.cornerLocal)
-            return super.createNewPath(placement);
-        const builder = new core_common_1.ElementGeometry.Builder();
-        builder.setLocalToWorldFromPlacement(placement);
-        const loop = core_geometry_1.CurveFactory.createRectangleXY(this.originLocal.x, this.originLocal.y, this.cornerLocal.x, this.cornerLocal.y, this.originLocal.z, this.radius);
-        loop.tryTransformInPlace(this.localToWorld);
-        if (!builder.appendGeometryQuery(loop))
-            return;
-        return { format: "flatbuffer", data: builder.entries };
-    }
-    getToolSettingPropertyLocked(property) {
-        return (property === this.useRadiusProperty ? this.radiusProperty : undefined);
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        return this.changeToolSettingPropertyValue(updatedValue);
-    }
-    supplyToolSettingsProperties() {
-        const toolSettings = new Array();
-        // ensure controls are enabled/disabled base on current lock property state
-        this.radiusProperty.isDisabled = !this.useRadius;
-        const useRadiusLock = this.useRadiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 });
-        toolSettings.push(this.radiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 1 }, useRadiusLock));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new CreateRectangleTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-    async onInstall() {
-        if (!await super.onInstall())
-            return false;
-        // Setup initial values here instead of supplyToolSettingsProperties to support keyin args w/o appui-react...
-        this.initializeToolSettingPropertyValues([this.radiusProperty, this.useRadiusProperty]);
-        if (!this.radius)
-            this.useRadius = false;
-        return true;
-    }
-    /** The keyin takes the following arguments, all of which are optional:
-     *  - `radius=number` Corner radius, 0 for sharp corners.
-     */
-    async parseAndRun(...inputArgs) {
-        let cornerRadius;
-        for (const arg of inputArgs) {
-            const parts = arg.split("=");
-            if (2 !== parts.length)
-                continue;
-            if (parts[0].toLowerCase().startsWith("ra")) {
-                const radius = Number.parseFloat(parts[1]);
-                if (!Number.isNaN(radius)) {
-                    cornerRadius = radius;
-                }
-            }
-        }
-        // Update current session values so keyin args are picked up for tool settings/restart...
-        if (undefined !== cornerRadius) {
-            if (0.0 !== cornerRadius)
-                this.saveToolSettingPropertyValue(this.radiusProperty, { value: cornerRadius });
-            this.saveToolSettingPropertyValue(this.useRadiusProperty, { value: 0.0 !== cornerRadius });
-        }
-        return this.run();
-    }
-}
-CreateRectangleTool.toolId = "CreateRectangle";
-CreateRectangleTool.iconSpec = "icon-rectangle";
-exports.CreateRectangleTool = CreateRectangleTool;
-/** @alpha */
-var BCurveMethod;
-(function (BCurveMethod) {
-    BCurveMethod[BCurveMethod["ControlPoints"] = 0] = "ControlPoints";
-    BCurveMethod[BCurveMethod["ThroughPoints"] = 1] = "ThroughPoints";
-})(BCurveMethod = exports.BCurveMethod || (exports.BCurveMethod = {}));
-/** @alpha Creates a bspline curve by poles or through points. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
-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;
-        let mainMsg;
-        if (CreateCurvePhase.DefineOther === this._tangentPhase)
-            mainMsg = core_frontend_1.CoreTools.translate(0 === nPts ? "ElementSet.Prompts.StartPoint" : "ElementSet.Inputs.AdditionalPoint");
-        else
-            mainMsg = EditTool_1.EditTools.translate(CreateCurvePhase.DefineStart === this._tangentPhase ? "CreateBCurve.Prompts.StartTangent" : "CreateBCurve.Prompts.EndTangent");
-        const leftMsg = core_frontend_1.CoreTools.translate("ElementSet.Inputs.AcceptPoint");
-        const rightMsg = core_frontend_1.CoreTools.translate(CreateCurvePhase.DefineOther === this._tangentPhase && nPts >= this.requiredPointCount ? "ElementSet.Inputs.Complete" : "ElementSet.Inputs.Cancel");
-        const mouseInstructions = [];
-        const touchInstructions = [];
-        if (!core_frontend_1.ToolAssistance.createTouchCursorInstructions(touchInstructions))
-            touchInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.OneTouchTap, leftMsg, false, core_frontend_1.ToolAssistanceInputMethod.Touch));
-        mouseInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.LeftClick, leftMsg, false, core_frontend_1.ToolAssistanceInputMethod.Mouse));
-        touchInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.TwoTouchTap, rightMsg, false, core_frontend_1.ToolAssistanceInputMethod.Touch));
-        mouseInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.RightClick, rightMsg, false, core_frontend_1.ToolAssistanceInputMethod.Mouse));
-        const sections = [];
-        sections.push(core_frontend_1.ToolAssistance.createSection(mouseInstructions, core_frontend_1.ToolAssistance.inputsLabel));
-        sections.push(core_frontend_1.ToolAssistance.createSection(touchInstructions, core_frontend_1.ToolAssistance.inputsLabel));
-        const mainInstruction = core_frontend_1.ToolAssistance.createInstruction(this.iconSpec, mainMsg);
-        const instructions = core_frontend_1.ToolAssistance.createInstructions(mainInstruction, sections);
-        core_frontend_1.IModelApp.notifications.setToolAssistance(instructions);
-    }
-    static methodMessage(str) { return EditTool_1.EditTools.translate(`CreateBCurve.Method.${str}`); }
-    get methodProperty() {
-        if (!this._methodProperty)
-            this._methodProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildEnumPicklistEditorDescription("bcurveMethod", EditTool_1.EditTools.translate("CreateBCurve.Label.Method"), CreateBCurveTool.getMethodChoices()), BCurveMethod.ControlPoints);
-        return this._methodProperty;
-    }
-    get method() { return this.methodProperty.value; }
-    set method(method) { this.methodProperty.value = method; }
-    get orderProperty() {
-        if (!this._orderProperty)
-            this._orderProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildNumberEditorDescription("bcurveOrder", EditTool_1.EditTools.translate("CreateBCurve.Label.Order"), { type: appui_abstract_1.PropertyEditorParamTypes.Range, minimum: this.minOrder, maximum: this.maxOrder }), 3);
-        return this._orderProperty;
-    }
-    get order() { return this.orderProperty.value; }
-    set order(value) { this.orderProperty.value = value; }
-    get minOrder() { return 2; }
-    get maxOrder() { return 16; }
-    get tangentsProperty() {
-        if (!this._tangentsProperty)
-            this._tangentsProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildToggleDescription("bcurveTangents", EditTool_1.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;
-    }
-    updateCurvePhase() {
-        // The first point changes startPoint and last point changes endPoint.
-        this._createCurvePhase = (0 === this.accepted.length ? CreateCurvePhase.DefineStart : CreateCurvePhase.DefineEnd);
-    }
-    isComplete(ev) {
-        // Accept on reset with sufficient points...
-        if (core_frontend_1.BeButton.Reset === ev.button)
-            return (this.accepted.length >= this.requiredPointCount);
-        // Allow data to complete on physical closure...
-        return this.isClosed || this._isPhysicallyClosedOrComplete;
-    }
-    showConstructionGraphics(ev, context) {
-        if (CreateCurvePhase.DefineOther !== this._tangentPhase && this.current) {
-            const fitCurve = this.current;
-            const builder = context.createGraphic({ type: core_frontend_1.GraphicType.WorldOverlay });
-            const color = context.viewport.getContrastToBackgroundColor();
-            builder.setSymbology(color, core_common_1.ColorDef.black, 1, core_common_1.LinePixels.Code2);
-            builder.addLineString([ev.point, fitCurve.options.fitPoints[CreateCurvePhase.DefineStart === this._tangentPhase ? 0 : fitCurve.options.fitPoints.length - 1]]);
-            builder.setSymbology(color, core_common_1.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 = core_geometry_1.Vector3d.createStartEnd(ev.point, fitCurve.options.fitPoints[0]);
-                if (tangentS.magnitude() > core_geometry_1.Geometry.smallMetricDistance)
-                    fitCurve.options.startTangent = tangentS;
-            }
-            else {
-                const tangentE = core_geometry_1.Vector3d.createStartEnd(ev.point, fitCurve.options.fitPoints[fitCurve.options.fitPoints.length - 1]);
-                if (tangentE.magnitude() > core_geometry_1.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.requiredPointCount;
-        if (pts.length < numRequired) {
-            // Create point/linestring construction geometry to support join...
-            this.isConstruction = true;
-            return core_geometry_1.LineString3d.create(1 === pts.length ? [pts[0], pts[0]] : pts);
-        }
-        // 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 core_geometry_1.BSplineCurve3d.createPeriodicUniformKnots(tmpPts, this.order);
-            }
-            return core_geometry_1.BSplineCurve3d.createUniformKnots(pts, this.order);
-        }
-        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 = core_geometry_1.InterpolationCurve3dOptions.create(interpProps);
-        return core_geometry_1.InterpolationCurve3d.createCapture(interpOpts);
-    }
-    getSnapGeometry() {
-        // Only snap to through points...
-        if (BCurveMethod.ThroughPoints === this.method)
-            return (this.accepted.length > 1 ? core_geometry_1.PointString3d.create(this.accepted) : undefined);
-        return super.getSnapGeometry();
-    }
-    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);
-        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:
-                        this._createCurvePhase = CreateCurvePhase.DefineEnd;
-                        await this.updateCurveAndContinuationData(ev, false);
-                        this._tangentPhase = (undefined === fitCurve.options.startTangent ? CreateCurvePhase.DefineStart : CreateCurvePhase.DefineEnd);
-                        core_frontend_1.IModelApp.toolAdmin.updateDynamics();
-                        this.setupAndPromptForNextAction();
-                        return false;
-                    case CreateCurvePhase.DefineStart:
-                        fitCurve.options.startTangent = undefined; // Not accepted, compute default start tangent...
-                        this._tangentPhase = CreateCurvePhase.DefineEnd;
-                        core_frontend_1.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;
-                }
-            }
-            this._createCurvePhase = CreateCurvePhase.DefineEnd;
-            await this.updateCurveAndContinuationData(ev, false);
-            await this.createElement();
-        }
-        return true;
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        if (!this.changeToolSettingPropertyValue(updatedValue))
-            return false;
-        if (this.methodProperty.name === updatedValue.propertyName)
-            await this.onReinitialize();
-        return true;
-    }
-    supplyToolSettingsProperties() {
-        const toolSettings = new Array();
-        toolSettings.push(this.methodProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        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() {
-        const tool = new CreateBCurveTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-    async onInstall() {
-        if (!await super.onInstall())
-            return false;
-        // Setup initial values here instead of supplyToolSettingsProperties to support keyin args w/o appui-react...
-        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)
-                continue;
-            if (parts[0].toLowerCase().startsWith("me")) {
-                const method = Number.parseInt(parts[1], 10);
-                if (!Number.isNaN(method)) {
-                    switch (method) {
-                        case 0:
-                            bcurveMethod = BCurveMethod.ControlPoints;
-                            break;
-                        case 1:
-                            bcurveMethod = BCurveMethod.ThroughPoints;
-                            break;
-                    }
-                }
-            }
-            else if (parts[0].toLowerCase().startsWith("or")) {
-                const order = Number.parseInt(parts[1], 10);
-                if (order >= this.minOrder && order <= this.maxOrder) {
-                    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)
-            this.saveToolSettingPropertyValue(this.methodProperty, { value: bcurveMethod });
-        if (undefined !== bcurveOrder)
-            this.saveToolSettingPropertyValue(this.orderProperty, { value: bcurveOrder });
-        if (undefined !== bcurveTangents)
-            this.saveToolSettingPropertyValue(this.tangentsProperty, { value: bcurveTangents });
-        return this.run();
-    }
-}
-CreateBCurveTool.toolId = "CreateBCurve";
-CreateBCurveTool.iconSpec = "icon-snaps-nearest"; // Need better icon...
-CreateBCurveTool.getMethodChoices = () => {
-    return [
-        { label: CreateBCurveTool.methodMessage("ControlPoints"), value: BCurveMethod.ControlPoints },
-        { label: CreateBCurveTool.methodMessage("ThroughPoints"), value: BCurveMethod.ThroughPoints },
-    ];
-};
-exports.CreateBCurveTool = CreateBCurveTool;
-//# sourceMappingURL=SketchTools.js.map