@itwin/editor-frontend 3.3.0-dev.4 → 3.3.0-dev.40

package/lib/cjs/SolidPrimitiveTools.js

@@ -0,0 +1,605 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateConeTool = exports.CreateConePhase = exports.CreateCylinderTool = exports.CreateCylinderPhase = exports.CreateSphereTool = exports.SolidPrimitiveTool = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+const core_bentley_1 = require("@itwin/core-bentley");
+const core_geometry_1 = require("@itwin/core-geometry");
+const core_common_1 = require("@itwin/core-common");
+const core_frontend_1 = require("@itwin/core-frontend");
+const editor_common_1 = require("@itwin/editor-common");
+const CreateElementTool_1 = require("./CreateElementTool");
+const EditTool_1 = require("./EditTool");
+const appui_abstract_1 = require("@itwin/appui-abstract");
+/** @alpha Base class for creating a capped or uncapped SolidPrimitive. */
+class SolidPrimitiveTool extends CreateElementTool_1.CreateElementWithDynamicsTool {
+    constructor() {
+        super(...arguments);
+        this.accepted = [];
+    }
+    allowView(vp) { return vp.view.is3d(); }
+    isCompatibleViewport(vp, isSelectedViewChange) { return (super.isCompatibleViewport(vp, isSelectedViewChange) && undefined !== vp && this.allowView(vp)); }
+    async startCommand() {
+        if (undefined !== this._startedCmd)
+            return this._startedCmd;
+        return EditTool_1.EditTools.startCommand(editor_common_1.editorBuiltInCmdIds.cmdBasicManipulation, this.iModel.key);
+    }
+    static callCommand(method, ...args) {
+        return EditTool_1.EditTools.callCommand(method, ...args);
+    }
+    getPlacementProps() {
+        if (undefined === this.current)
+            return undefined;
+        const localToWorld = ("solid" === this.current.geometryCategory ? this.current.getConstructiveFrame() : core_geometry_1.FrameBuilder.createRightHandedFrame(undefined, this.current));
+        if (undefined === localToWorld)
+            return undefined;
+        const origin = localToWorld.getOrigin();
+        const angles = new core_geometry_1.YawPitchRollAngles();
+        core_geometry_1.YawPitchRollAngles.createFromMatrix3d(localToWorld.matrix, angles);
+        return { origin, angles };
+    }
+    getGeometryProps(placement) {
+        if (undefined === this.current)
+            return undefined;
+        const builder = new core_common_1.ElementGeometry.Builder();
+        builder.setLocalToWorldFromPlacement(placement);
+        if (!builder.appendGeometryQuery(this.current))
+            return;
+        return { format: "flatbuffer", data: builder.entries };
+    }
+    getElementProps(placement) {
+        const model = this.targetModelId;
+        const category = this.targetCategory;
+        return { classFullName: "Generic:PhysicalObject", model, category, code: core_common_1.Code.createEmpty(), placement };
+    }
+    async doCreateElement(props, data) {
+        try {
+            this._startedCmd = await this.startCommand();
+            await SolidPrimitiveTool.callCommand("insertGeometricElement", 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."));
+        }
+    }
+}
+exports.SolidPrimitiveTool = SolidPrimitiveTool;
+/** @alpha Creates a sphere. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
+class CreateSphereTool extends SolidPrimitiveTool {
+    provideToolAssistance(mainInstrText, additionalInstr) {
+        mainInstrText = EditTool_1.EditTools.translate(0 === this.accepted.length ? "CreateSphere.Prompts.CenterPoint" : "CreateSphere.Prompts.RadiusPoint");
+        super.provideToolAssistance(mainInstrText, additionalInstr);
+    }
+    setupAccuDraw() {
+        const nPts = this.accepted.length;
+        if (0 === nPts)
+            return;
+        const hints = new core_frontend_1.AccuDrawHintBuilder();
+        hints.setModePolar();
+        hints.setOrigin(this.accepted[0]);
+        hints.setOriginFixed = true;
+        hints.sendHints();
+    }
+    get useRadiusProperty() {
+        if (!this._useRadiusProperty)
+            this._useRadiusProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useSphereRadius"), 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("sphereRadius", EditTool_1.EditTools.translate("CreateSphere.Label.Radius")), 0.1, undefined, !this.useRadius);
+        return this._radiusProperty;
+    }
+    get radius() { return this.radiusProperty.value; }
+    set radius(value) { this.radiusProperty.value = value; }
+    get cappedProperty() {
+        if (!this._cappedProperty)
+            this._cappedProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildToggleDescription("sphereCapped", EditTool_1.EditTools.translate("CreateSphere.Label.Capped")), true);
+        return this._cappedProperty;
+    }
+    get capped() { return this.cappedProperty.value; }
+    set capped(value) { this.cappedProperty.value = value; }
+    isComplete(_ev) {
+        return (2 === this.accepted.length);
+    }
+    async updateElementData(ev, isDynamics) {
+        const vp = this.targetView;
+        if (undefined === vp)
+            return;
+        if (0 === this.accepted.length) {
+            if (!isDynamics)
+                this.accepted.push(ev.point.clone());
+            return;
+        }
+        const pt1 = this.accepted[0];
+        const pt2 = ev.point;
+        const vector0 = core_geometry_1.Vector3d.createStartEnd(pt1, pt2);
+        const radius = (this.useRadius ? this.radius : vector0.magnitude());
+        if (!this.useRadius) {
+            this.radius = radius;
+            this.syncToolSettingPropertyValue(this.radiusProperty);
+        }
+        if (undefined === vector0.scaleToLength(radius, vector0)) {
+            this.current = undefined;
+            this.clearGraphics();
+            return;
+        }
+        this.baseRotation = core_frontend_1.AccuDrawHintBuilder.getCurrentRotation(vp, true, true);
+        const normal = this.baseRotation ? this.baseRotation.getColumn(2) : core_geometry_1.Vector3d.unitZ();
+        const vector90 = normal.crossProduct(vector0);
+        const matrix = core_geometry_1.Matrix3d.createColumns(vector0, vector90, normal);
+        this.baseRotation = core_geometry_1.Matrix3d.createRigidFromMatrix3d(matrix);
+        this.current = core_geometry_1.Sphere.createFromAxesAndScales(pt1, this.baseRotation, radius, radius, radius, undefined, this.capped);
+        if (isDynamics || undefined === this.current)
+            return;
+        this.accepted.push(ev.point.clone());
+    }
+    getToolSettingPropertyLocked(property) {
+        return (property === this.useRadiusProperty ? this.radiusProperty : undefined);
+    }
+    async applyToolSettingPropertyChange(updatedValue) {
+        return this.changeToolSettingPropertyValue(updatedValue);
+    }
+    supplyToolSettingsProperties() {
+        this.initializeToolSettingPropertyValues([this.radiusProperty, this.useRadiusProperty, this.cappedProperty]);
+        const toolSettings = new Array();
+        this.radiusProperty.isDisabled = !this.useRadius;
+        const useRadiusLock = this.useRadiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 });
+        toolSettings.push(this.radiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 1 }, useRadiusLock));
+        toolSettings.push(this.cappedProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
+        return toolSettings;
+    }
+    async onRestartTool() {
+        const tool = new CreateSphereTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+exports.CreateSphereTool = CreateSphereTool;
+CreateSphereTool.toolId = "CreateSphere";
+CreateSphereTool.iconSpec = "icon-circle"; // TODO: Need better icon...
+/** @alpha Values for [[CreateCylinderTool.createPhase]. */
+var CreateCylinderPhase;
+(function (CreateCylinderPhase) {
+    /** Current tool phase to define center of base */
+    CreateCylinderPhase[CreateCylinderPhase["AcceptBase"] = 0] = "AcceptBase";
+    /** Current tool phase to define radius or base axes */
+    CreateCylinderPhase[CreateCylinderPhase["AcceptRadius"] = 1] = "AcceptRadius";
+    /** Current tool phase to define length or axis */
+    CreateCylinderPhase[CreateCylinderPhase["AcceptLength"] = 2] = "AcceptLength";
+    /** Current tool phase to accept result */
+    CreateCylinderPhase[CreateCylinderPhase["AcceptResult"] = 3] = "AcceptResult";
+})(CreateCylinderPhase = exports.CreateCylinderPhase || (exports.CreateCylinderPhase = {}));
+/** @alpha Creates a cylinder. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
+class CreateCylinderTool extends SolidPrimitiveTool {
+    constructor() {
+        super(...arguments);
+        this.createPhase = CreateCylinderPhase.AcceptBase;
+    }
+    provideToolAssistance(mainInstrText, additionalInstr) {
+        switch (this.createPhase) {
+            case CreateCylinderPhase.AcceptBase:
+                mainInstrText = EditTool_1.EditTools.translate("CreateCylinder.Prompts.BasePoint");
+                break;
+            case CreateCylinderPhase.AcceptRadius:
+                mainInstrText = EditTool_1.EditTools.translate("CreateCylinder.Prompts.RadiusPoint");
+                break;
+            default:
+                mainInstrText = EditTool_1.EditTools.translate("CreateCylinder.Prompts.LengthPoint");
+                break;
+        }
+        super.provideToolAssistance(mainInstrText, additionalInstr);
+    }
+    setupAccuDraw() {
+        const nPts = this.accepted.length;
+        if (0 === nPts)
+            return;
+        const hints = new core_frontend_1.AccuDrawHintBuilder();
+        hints.setModePolar();
+        hints.setOrigin(this.accepted[0]);
+        hints.setOriginFixed = true;
+        if (CreateCylinderPhase.AcceptLength === this.createPhase && undefined !== this.baseRotation) {
+            hints.setXAxis2(this.baseRotation.getColumn(2));
+            if (this.orthogonal) {
+                hints.setModeRectangular();
+                hints.setLockY = true;
+                hints.setLockZ = true;
+            }
+        }
+        hints.sendHints();
+    }
+    get useRadiusProperty() {
+        if (!this._useRadiusProperty)
+            this._useRadiusProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useCylinderRadius"), 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("cylinderRadius", EditTool_1.EditTools.translate("CreateCylinder.Label.Radius")), 0.1, undefined, !this.useRadius);
+        return this._radiusProperty;
+    }
+    get radius() { return this.radiusProperty.value; }
+    set radius(value) { this.radiusProperty.value = value; }
+    get useLengthProperty() {
+        if (!this._useLengthProperty)
+            this._useLengthProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useCylinderLength"), false);
+        return this._useLengthProperty;
+    }
+    get useLength() { return this.useLengthProperty.value; }
+    set useLength(value) { this.useLengthProperty.value = value; }
+    get lengthProperty() {
+        if (!this._lengthProperty)
+            this._lengthProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("cylinderLength", EditTool_1.EditTools.translate("CreateCylinder.Label.Length")), 0.1, undefined, !this.useLength);
+        return this._lengthProperty;
+    }
+    get length() { return this.lengthProperty.value; }
+    set length(value) { this.lengthProperty.value = value; }
+    get cappedProperty() {
+        if (!this._cappedProperty)
+            this._cappedProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildToggleDescription("cylinderCapped", EditTool_1.EditTools.translate("CreateCylinder.Label.Capped")), true);
+        return this._cappedProperty;
+    }
+    get capped() { return this.cappedProperty.value; }
+    set capped(value) { this.cappedProperty.value = value; }
+    get orthogonalProperty() {
+        if (!this._orthogonalProperty)
+            this._orthogonalProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildToggleDescription("cylinderOrthogonal", EditTool_1.EditTools.translate("CreateCylinder.Label.Orthogonal")), true);
+        return this._orthogonalProperty;
+    }
+    get orthogonal() { return this.orthogonalProperty.value; }
+    set orthogonal(value) { this.orthogonalProperty.value = value; }
+    isComplete(_ev) {
+        return (CreateCylinderPhase.AcceptResult === this.createPhase);
+    }
+    async updateElementData(ev, isDynamics) {
+        const vp = this.targetView;
+        if (undefined === vp)
+            return;
+        const pt1 = (0 === this.accepted.length ? ev.point : this.accepted[0]);
+        const pt2 = ev.point;
+        switch (this.createPhase) {
+            case CreateCylinderPhase.AcceptBase: {
+                if (isDynamics)
+                    break;
+                // Allow creating cylinder by 2 points when orthogonal and radius are locked...
+                this.accepted.push(ev.point.clone());
+                this.createPhase = (this.orthogonal && this.useRadius ? CreateCylinderPhase.AcceptLength : CreateCylinderPhase.AcceptRadius);
+                break;
+            }
+            case CreateCylinderPhase.AcceptRadius: {
+                this.baseRotation = core_frontend_1.AccuDrawHintBuilder.getCurrentRotation(vp, true, true);
+                const normal = this.baseRotation ? this.baseRotation.getColumn(2) : core_geometry_1.Vector3d.unitZ();
+                const vector0 = core_geometry_1.Vector3d.createStartEnd(pt1, pt2);
+                const vector90 = normal.crossProduct(vector0);
+                const radius = (this.useRadius ? this.radius : vector0.magnitude());
+                if (!this.useRadius) {
+                    this.radius = radius;
+                    this.syncToolSettingPropertyValue(this.radiusProperty);
+                }
+                if (undefined === vector0.scaleToLength(radius, vector0) || undefined === vector90.scaleToLength(radius, vector90)) {
+                    this.current = undefined;
+                    this.clearGraphics();
+                    return;
+                }
+                const arc = core_geometry_1.Arc3d.create(pt1, vector0, vector90);
+                this.baseRotation = core_geometry_1.Matrix3d.createRigidFromMatrix3d(arc.matrixRef); // Update base rotation from result arc...
+                this.current = (this.capped ? core_geometry_1.Loop.create(arc) : arc);
+                if (isDynamics || undefined === this.current)
+                    break;
+                this.createPhase = CreateCylinderPhase.AcceptLength;
+                break;
+            }
+            case CreateCylinderPhase.AcceptLength: {
+                const zAxis = core_geometry_1.Vector3d.createStartEnd(pt1, pt2);
+                const length = (this.useLength ? this.length : zAxis.magnitude());
+                if (!this.useLength) {
+                    this.length = length;
+                    this.syncToolSettingPropertyValue(this.lengthProperty);
+                }
+                // Establish base rotation when creating cylinder by 2 points...
+                if (undefined === this.baseRotation)
+                    this.baseRotation = core_frontend_1.AccuDrawHintBuilder.getCurrentRotation(vp, true, true);
+                const xAxis = this.baseRotation ? this.baseRotation.getColumn(0) : core_geometry_1.Vector3d.unitX();
+                const yAxis = this.baseRotation ? this.baseRotation.getColumn(1) : core_geometry_1.Vector3d.unitY();
+                if (undefined === zAxis.scaleToLength(length, zAxis)) {
+                    xAxis.scaleToLength(this.radius, xAxis);
+                    yAxis.scaleToLength(this.radius, yAxis);
+                    const baseArc = core_geometry_1.Arc3d.create(pt1, xAxis, yAxis);
+                    this.current = (this.capped ? core_geometry_1.Loop.create(baseArc) : baseArc);
+                    return;
+                }
+                if (this.orthogonal)
+                    this.current = core_geometry_1.Cone.createAxisPoints(pt1, pt1.plus(zAxis), this.radius, this.radius, this.capped);
+                else
+                    this.current = core_geometry_1.Cone.createBaseAndTarget(pt1, pt1.plus(zAxis), xAxis, yAxis, this.radius, this.radius, this.capped);
+                if (isDynamics || undefined === this.current)
+                    break;
+                this.createPhase = CreateCylinderPhase.AcceptResult;
+                break;
+            }
+        }
+    }
+    getToolSettingPropertyLocked(property) {
+        if (property === this.useRadiusProperty)
+            return this.radiusProperty;
+        else if (property === this.useLengthProperty)
+            return this.lengthProperty;
+        return undefined;
+    }
+    async applyToolSettingPropertyChange(updatedValue) {
+        return this.changeToolSettingPropertyValue(updatedValue);
+    }
+    supplyToolSettingsProperties() {
+        this.initializeToolSettingPropertyValues([this.radiusProperty, this.useRadiusProperty, this.lengthProperty, this.useLengthProperty, this.orthogonalProperty, this.cappedProperty]);
+        const toolSettings = new Array();
+        this.radiusProperty.isDisabled = !this.useRadius;
+        const useRadiusLock = this.useRadiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 });
+        toolSettings.push(this.radiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 1 }, useRadiusLock));
+        this.lengthProperty.isDisabled = !this.useLength;
+        const useLengthLock = this.useLengthProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 });
+        toolSettings.push(this.lengthProperty.toDialogItem({ rowPriority: 2, columnIndex: 1 }, useLengthLock));
+        toolSettings.push(this.orthogonalProperty.toDialogItem({ rowPriority: 3, columnIndex: 0 }));
+        toolSettings.push(this.cappedProperty.toDialogItem({ rowPriority: 4, columnIndex: 0 }));
+        return toolSettings;
+    }
+    async onRestartTool() {
+        const tool = new CreateCylinderTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+exports.CreateCylinderTool = CreateCylinderTool;
+CreateCylinderTool.toolId = "CreateCylinder";
+CreateCylinderTool.iconSpec = "icon-circle"; // TODO: Need better icon...
+/** @alpha Values for [[CreateConeTool.createPhase]. */
+var CreateConePhase;
+(function (CreateConePhase) {
+    /** Current tool phase to define center of base */
+    CreateConePhase[CreateConePhase["AcceptBase"] = 0] = "AcceptBase";
+    /** Current tool phase to define base radius or base axes */
+    CreateConePhase[CreateConePhase["AcceptBaseRadius"] = 1] = "AcceptBaseRadius";
+    /** Current tool phase to define length or axis */
+    CreateConePhase[CreateConePhase["AcceptLength"] = 2] = "AcceptLength";
+    /** Current tool phase to define top radius */
+    CreateConePhase[CreateConePhase["AcceptTopRadius"] = 3] = "AcceptTopRadius";
+    /** Current tool phase to accept result */
+    CreateConePhase[CreateConePhase["AcceptResult"] = 4] = "AcceptResult";
+})(CreateConePhase = exports.CreateConePhase || (exports.CreateConePhase = {}));
+/** @alpha Creates a cone. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
+class CreateConeTool extends SolidPrimitiveTool {
+    constructor() {
+        super(...arguments);
+        this.createPhase = CreateConePhase.AcceptBase;
+    }
+    provideToolAssistance(mainInstrText, additionalInstr) {
+        switch (this.createPhase) {
+            case CreateConePhase.AcceptBase:
+                mainInstrText = EditTool_1.EditTools.translate("CreateCone.Prompts.BasePoint");
+                break;
+            case CreateConePhase.AcceptBaseRadius:
+                mainInstrText = EditTool_1.EditTools.translate("CreateCone.Prompts.BaseRadiusPoint");
+                break;
+            case CreateConePhase.AcceptTopRadius:
+                mainInstrText = EditTool_1.EditTools.translate("CreateCone.Prompts.TopRadiusPoint");
+                break;
+            default:
+                mainInstrText = EditTool_1.EditTools.translate("CreateCone.Prompts.LengthPoint");
+                break;
+        }
+        super.provideToolAssistance(mainInstrText, additionalInstr);
+    }
+    setupAccuDraw() {
+        const nPts = this.accepted.length;
+        if (0 === nPts)
+            return;
+        const hints = new core_frontend_1.AccuDrawHintBuilder();
+        hints.setModePolar();
+        hints.setOrigin(this.accepted[0]);
+        hints.setOriginFixed = true;
+        if (CreateConePhase.AcceptTopRadius === this.createPhase && 2 === nPts) {
+            hints.setOrigin(this.accepted[1]);
+            if (undefined !== this.baseRotation)
+                hints.setMatrix(this.baseRotation);
+        }
+        else if (CreateConePhase.AcceptLength === this.createPhase && undefined !== this.baseRotation) {
+            hints.setXAxis2(this.baseRotation.getColumn(2));
+            if (this.orthogonal) {
+                hints.setModeRectangular();
+                hints.setLockY = true;
+                hints.setLockZ = true;
+            }
+        }
+        hints.sendHints();
+    }
+    get useBaseRadiusProperty() {
+        if (!this._useBaseRadiusProperty)
+            this._useBaseRadiusProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useConeBaseRadius"), false);
+        return this._useBaseRadiusProperty;
+    }
+    get useBaseRadius() { return this.useBaseRadiusProperty.value; }
+    set useBaseRadius(value) { this.useBaseRadiusProperty.value = value; }
+    get baseRadiusProperty() {
+        if (!this._baseRadiusProperty)
+            this._baseRadiusProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("coneBaseRadius", EditTool_1.EditTools.translate("CreateCone.Label.BaseRadius")), 0.1, undefined, !this.useBaseRadius);
+        return this._baseRadiusProperty;
+    }
+    get baseRadius() { return this.baseRadiusProperty.value; }
+    set baseRadius(value) { this.baseRadiusProperty.value = value; }
+    get useTopRadiusProperty() {
+        if (!this._useTopRadiusProperty)
+            this._useTopRadiusProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useConeTopRadius"), false);
+        return this._useTopRadiusProperty;
+    }
+    get useTopRadius() { return this.useTopRadiusProperty.value; }
+    set useTopRadius(value) { this.useTopRadiusProperty.value = value; }
+    get topRadiusProperty() {
+        if (!this._topRadiusProperty)
+            this._topRadiusProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("coneTopRadius", EditTool_1.EditTools.translate("CreateCone.Label.TopRadius")), 0.1, undefined, !this.useTopRadius);
+        return this._topRadiusProperty;
+    }
+    get topRadius() { return this.topRadiusProperty.value; }
+    set topRadius(value) { this.topRadiusProperty.value = value; }
+    get useLengthProperty() {
+        if (!this._useLengthProperty)
+            this._useLengthProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useConeLength"), false);
+        return this._useLengthProperty;
+    }
+    get useLength() { return this.useLengthProperty.value; }
+    set useLength(value) { this.useLengthProperty.value = value; }
+    get lengthProperty() {
+        if (!this._lengthProperty)
+            this._lengthProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("coneLength", EditTool_1.EditTools.translate("CreateCone.Label.Length")), 0.1, undefined, !this.useLength);
+        return this._lengthProperty;
+    }
+    get length() { return this.lengthProperty.value; }
+    set length(value) { this.lengthProperty.value = value; }
+    get cappedProperty() {
+        if (!this._cappedProperty)
+            this._cappedProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildToggleDescription("coneCapped", EditTool_1.EditTools.translate("CreateCone.Label.Capped")), true);
+        return this._cappedProperty;
+    }
+    get capped() { return this.cappedProperty.value; }
+    set capped(value) { this.cappedProperty.value = value; }
+    get orthogonalProperty() {
+        if (!this._orthogonalProperty)
+            this._orthogonalProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildToggleDescription("coneOrthogonal", EditTool_1.EditTools.translate("CreateCone.Label.Orthogonal")), true);
+        return this._orthogonalProperty;
+    }
+    get orthogonal() { return this.orthogonalProperty.value; }
+    set orthogonal(value) { this.orthogonalProperty.value = value; }
+    isComplete(_ev) {
+        return (CreateConePhase.AcceptResult === this.createPhase);
+    }
+    async updateElementData(ev, isDynamics) {
+        var _a;
+        const vp = this.targetView;
+        if (undefined === vp)
+            return;
+        const pt1 = (0 === this.accepted.length ? ev.point : this.accepted[0]);
+        const pt2 = ev.point;
+        switch (this.createPhase) {
+            case CreateConePhase.AcceptBase: {
+                if (isDynamics)
+                    break;
+                // Allow creating cone by 2 points when orthogonal and base/top radii are locked...
+                this.accepted.push(ev.point.clone());
+                this.createPhase = (this.orthogonal && this.useBaseRadius ? CreateConePhase.AcceptLength : CreateConePhase.AcceptBaseRadius);
+                break;
+            }
+            case CreateConePhase.AcceptBaseRadius: {
+                this.baseRotation = core_frontend_1.AccuDrawHintBuilder.getCurrentRotation(vp, true, true);
+                const normal = this.baseRotation ? this.baseRotation.getColumn(2) : core_geometry_1.Vector3d.unitZ();
+                const vector0 = core_geometry_1.Vector3d.createStartEnd(pt1, pt2);
+                const vector90 = normal.crossProduct(vector0);
+                const radius = (this.useBaseRadius ? this.baseRadius : vector0.magnitude());
+                if (!this.useBaseRadius) {
+                    this.baseRadius = radius;
+                    this.syncToolSettingPropertyValue(this.baseRadiusProperty);
+                }
+                if (undefined === vector0.scaleToLength(radius, vector0) || undefined === vector90.scaleToLength(radius, vector90)) {
+                    this.current = undefined;
+                    this.clearGraphics();
+                    return;
+                }
+                const arc = core_geometry_1.Arc3d.create(pt1, vector0, vector90);
+                this.baseRotation = core_geometry_1.Matrix3d.createRigidFromMatrix3d(arc.matrixRef); // Update base rotation from result arc...
+                this.current = (this.capped ? core_geometry_1.Loop.create(arc) : arc);
+                if (isDynamics || undefined === this.current)
+                    break;
+                this.createPhase = CreateConePhase.AcceptLength;
+                break;
+            }
+            case CreateConePhase.AcceptLength: {
+                const zAxis = core_geometry_1.Vector3d.createStartEnd(pt1, pt2);
+                const length = (this.useLength ? this.length : zAxis.magnitude());
+                if (!this.useLength) {
+                    this.length = length;
+                    this.syncToolSettingPropertyValue(this.lengthProperty);
+                }
+                // Establish base rotation when creating cone by 2 points...
+                if (undefined === this.baseRotation)
+                    this.baseRotation = core_frontend_1.AccuDrawHintBuilder.getCurrentRotation(vp, true, true);
+                const xAxis = this.baseRotation ? this.baseRotation.getColumn(0) : core_geometry_1.Vector3d.unitX();
+                const yAxis = this.baseRotation ? this.baseRotation.getColumn(1) : core_geometry_1.Vector3d.unitY();
+                if (undefined === zAxis.scaleToLength(length, zAxis)) {
+                    xAxis.scaleToLength(this.baseRadius, xAxis);
+                    yAxis.scaleToLength(this.baseRadius, yAxis);
+                    const baseArc = core_geometry_1.Arc3d.create(pt1, xAxis, yAxis);
+                    this.current = (this.capped ? core_geometry_1.Loop.create(baseArc) : baseArc);
+                    return;
+                }
+                if (this.orthogonal)
+                    this.current = core_geometry_1.Cone.createAxisPoints(pt1, pt1.plus(zAxis), this.baseRadius, this.useTopRadius ? this.topRadius : 0.0, this.capped);
+                else
+                    this.current = core_geometry_1.Cone.createBaseAndTarget(pt1, pt1.plus(zAxis), xAxis, yAxis, this.baseRadius, this.useTopRadius ? this.topRadius : 0.0, this.capped);
+                if (isDynamics || undefined === this.current)
+                    break;
+                const localToWorld = this.current.getConstructiveFrame();
+                if (undefined !== localToWorld)
+                    this.baseRotation = localToWorld.matrix; // Update base rotation from result for AccuDraw hints...
+                this.accepted.push(this.current.getCenterB()); // Add top center to accepted points for AccuDraw hints...
+                this.createPhase = this.useTopRadius ? CreateConePhase.AcceptResult : CreateConePhase.AcceptTopRadius;
+                break;
+            }
+            case CreateConePhase.AcceptTopRadius: {
+                const cone = ("solid" === ((_a = this.current) === null || _a === void 0 ? void 0 : _a.geometryCategory) ? this.current : undefined);
+                if (undefined === cone)
+                    break;
+                const vector0 = core_geometry_1.Vector3d.createStartEnd(cone.getCenterB(), ev.point);
+                const radius = (this.useTopRadius ? this.topRadius : vector0.magnitude());
+                if (!this.useTopRadius) {
+                    this.topRadius = radius;
+                    this.syncToolSettingPropertyValue(this.topRadiusProperty);
+                }
+                this.current = core_geometry_1.Cone.createBaseAndTarget(cone.getCenterA(), cone.getCenterB(), cone.getVectorX(), cone.getVectorY(), cone.getRadiusA(), radius, this.capped);
+                if (isDynamics || undefined === this.current)
+                    break;
+                this.createPhase = CreateConePhase.AcceptResult;
+                break;
+            }
+        }
+    }
+    getToolSettingPropertyLocked(property) {
+        if (property === this.useBaseRadiusProperty)
+            return this.baseRadiusProperty;
+        else if (property === this.useTopRadiusProperty)
+            return this.topRadiusProperty;
+        else if (property === this.useLengthProperty)
+            return this.lengthProperty;
+        return undefined;
+    }
+    async applyToolSettingPropertyChange(updatedValue) {
+        return this.changeToolSettingPropertyValue(updatedValue);
+    }
+    supplyToolSettingsProperties() {
+        this.initializeToolSettingPropertyValues([this.baseRadiusProperty, this.useBaseRadiusProperty, this.topRadiusProperty, this.useTopRadiusProperty, this.lengthProperty, this.useLengthProperty, this.orthogonalProperty, this.cappedProperty]);
+        const toolSettings = new Array();
+        this.baseRadiusProperty.isDisabled = !this.useBaseRadius;
+        const useBaseRadiusLock = this.useBaseRadiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 });
+        toolSettings.push(this.baseRadiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 1 }, useBaseRadiusLock));
+        this.topRadiusProperty.isDisabled = !this.useTopRadius;
+        const useTopRadiusLock = this.useTopRadiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 });
+        toolSettings.push(this.topRadiusProperty.toDialogItem({ rowPriority: 2, columnIndex: 1 }, useTopRadiusLock));
+        this.lengthProperty.isDisabled = !this.useLength;
+        const useLengthLock = this.useLengthProperty.toDialogItem({ rowPriority: 3, columnIndex: 0 });
+        toolSettings.push(this.lengthProperty.toDialogItem({ rowPriority: 3, columnIndex: 1 }, useLengthLock));
+        toolSettings.push(this.orthogonalProperty.toDialogItem({ rowPriority: 4, columnIndex: 0 }));
+        toolSettings.push(this.cappedProperty.toDialogItem({ rowPriority: 5, columnIndex: 0 }));
+        return toolSettings;
+    }
+    async onRestartTool() {
+        const tool = new CreateConeTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+exports.CreateConeTool = CreateConeTool;
+CreateConeTool.toolId = "CreateCone";
+CreateConeTool.iconSpec = "icon-circle"; // TODO: Need better icon...
+//# sourceMappingURL=SolidPrimitiveTools.js.map