@itwin/editor-frontend 3.3.0-dev.48 → 3.3.0-dev.50

package/lib/cjs/SolidPrimitiveTools.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateConeTool = exports.CreateConePhase = exports.CreateCylinderTool = exports.CreateCylinderPhase = exports.CreateSphereTool = exports.SolidPrimitiveTool = void 0;
+exports.CreateTorusTool = exports.CreateTorusPhase = exports.CreateBoxTool = 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.
@@ -30,9 +30,10 @@ class SolidPrimitiveTool extends CreateElementTool_1.CreateElementWithDynamicsTo
         return EditTool_1.EditTools.callCommand(method, ...args);
     }
     getPlacementProps() {
+        var _a;
         if (undefined === this.current)
             return undefined;
-        const localToWorld = ("solid" === this.current.geometryCategory ? this.current.getConstructiveFrame() : core_geometry_1.FrameBuilder.createRightHandedFrame(undefined, this.current));
+        const localToWorld = ("solid" === this.current.geometryCategory ? this.current.getConstructiveFrame() : core_geometry_1.FrameBuilder.createRightHandedFrame((_a = this.baseRotation) === null || _a === void 0 ? void 0 : _a.getColumn(2), this.current));
         if (undefined === localToWorld)
             return undefined;
         const origin = localToWorld.getOrigin();
@@ -115,9 +116,7 @@ class CreateSphereTool extends SolidPrimitiveTool {
                 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 vector0 = core_geometry_1.Vector3d.createStartEnd(this.accepted[0], ev.point);
         const radius = (this.useRadius ? this.radius : vector0.magnitude());
         if (!this.useRadius) {
             this.radius = radius;
@@ -133,7 +132,7 @@ class CreateSphereTool extends SolidPrimitiveTool {
         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);
+        this.current = core_geometry_1.Sphere.createFromAxesAndScales(this.accepted[0], this.baseRotation, radius, radius, radius, undefined, this.capped);
         if (isDynamics || undefined === this.current)
             return;
         this.accepted.push(ev.point.clone());
@@ -268,7 +267,7 @@ class CreateCylinderTool extends SolidPrimitiveTool {
                 if (isDynamics)
                     break;
                 // Allow creating cylinder by 2 points when orthogonal and radius are locked...
-                this.accepted.push(ev.point.clone());
+                this.accepted.push(pt2.clone());
                 this.createPhase = (this.orthogonal && this.useRadius ? CreateCylinderPhase.AcceptLength : CreateCylinderPhase.AcceptRadius);
                 break;
             }
@@ -290,7 +289,7 @@ class CreateCylinderTool extends SolidPrimitiveTool {
                 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)
+                if (isDynamics)
                     break;
                 this.createPhase = CreateCylinderPhase.AcceptLength;
                 break;
@@ -488,7 +487,7 @@ class CreateConeTool extends SolidPrimitiveTool {
                 if (isDynamics)
                     break;
                 // Allow creating cone by 2 points when orthogonal and base/top radii are locked...
-                this.accepted.push(ev.point.clone());
+                this.accepted.push(pt2.clone());
                 this.createPhase = (this.orthogonal && this.useBaseRadius ? CreateConePhase.AcceptLength : CreateConePhase.AcceptBaseRadius);
                 break;
             }
@@ -510,7 +509,7 @@ class CreateConeTool extends SolidPrimitiveTool {
                 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)
+                if (isDynamics)
                     break;
                 this.createPhase = CreateConePhase.AcceptLength;
                 break;
@@ -551,14 +550,14 @@ class CreateConeTool extends SolidPrimitiveTool {
                 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 vector0 = core_geometry_1.Vector3d.createStartEnd(cone.getCenterB(), pt2);
                 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)
+                if (isDynamics)
                     break;
                 this.createPhase = CreateConePhase.AcceptResult;
                 break;
@@ -584,7 +583,7 @@ class CreateConeTool extends SolidPrimitiveTool {
         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 });
+        const useTopRadiusLock = this.useTopRadiusProperty.toDialogItem({ rowPriority: 2, 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 });
@@ -602,4 +601,464 @@ class CreateConeTool extends SolidPrimitiveTool {
 exports.CreateConeTool = CreateConeTool;
 CreateConeTool.toolId = "CreateCone";
 CreateConeTool.iconSpec = "icon-circle"; // TODO: Need better icon...
+/** @alpha Creates a bix. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
+class CreateBoxTool extends SolidPrimitiveTool {
+    provideToolAssistance(mainInstrText, additionalInstr) {
+        switch (this.accepted.length) {
+            case 0:
+                mainInstrText = EditTool_1.EditTools.translate("CreateBox.Prompts.BasePoint");
+                break;
+            case 1:
+                mainInstrText = EditTool_1.EditTools.translate("CreateBox.Prompts.LengthPoint");
+                break;
+            case 2:
+                mainInstrText = EditTool_1.EditTools.translate("CreateBox.Prompts.WidthPoint");
+                break;
+            default:
+                mainInstrText = EditTool_1.EditTools.translate("CreateBox.Prompts.HeightPoint");
+                break;
+        }
+        super.provideToolAssistance(mainInstrText, additionalInstr);
+    }
+    setupAccuDraw() {
+        const nPts = this.accepted.length;
+        if (0 === nPts)
+            return;
+        const hints = new core_frontend_1.AccuDrawHintBuilder();
+        hints.setModeRectangular();
+        hints.setOrigin(this.accepted[0]);
+        hints.setOriginFixed = true;
+        if (undefined !== this.baseRotation) {
+            if (2 === nPts) {
+                hints.setMatrix(this.baseRotation);
+                hints.setLockX = true;
+                hints.setLockZ = true;
+            }
+            else if (3 === nPts) {
+                hints.setXAxis2(this.baseRotation.getColumn(2));
+                if (this.orthogonal) {
+                    hints.setLockY = true;
+                    hints.setLockZ = true;
+                }
+            }
+        }
+        hints.sendHints();
+    }
+    get useLengthProperty() {
+        if (!this._useLengthProperty)
+            this._useLengthProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useBoxLength"), 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("boxLength", EditTool_1.EditTools.translate("CreateBox.Label.Length")), 0.1, undefined, !this.useLength);
+        return this._lengthProperty;
+    }
+    get length() { return this.lengthProperty.value; }
+    set length(value) { this.lengthProperty.value = value; }
+    get useWidthProperty() {
+        if (!this._useWidthProperty)
+            this._useWidthProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useBoxWidth"), false);
+        return this._useWidthProperty;
+    }
+    get useWidth() { return this.useWidthProperty.value; }
+    set useWidth(value) { this.useWidthProperty.value = value; }
+    get widthProperty() {
+        if (!this._widthProperty)
+            this._widthProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("boxWidth", EditTool_1.EditTools.translate("CreateBox.Label.Width")), 0.1, undefined, !this.useWidth);
+        return this._widthProperty;
+    }
+    get width() { return this.widthProperty.value; }
+    set width(value) { this.widthProperty.value = value; }
+    get useHeightProperty() {
+        if (!this._useHeightProperty)
+            this._useHeightProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useBoxHeight"), false);
+        return this._useHeightProperty;
+    }
+    get useHeight() { return this.useHeightProperty.value; }
+    set useHeight(value) { this.useHeightProperty.value = value; }
+    get heightProperty() {
+        if (!this._heightProperty)
+            this._heightProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("boxHeight", EditTool_1.EditTools.translate("CreateBox.Label.Height")), 0.1, undefined, !this.useHeight);
+        return this._heightProperty;
+    }
+    get height() { return this.heightProperty.value; }
+    set height(value) { this.heightProperty.value = value; }
+    get cappedProperty() {
+        if (!this._cappedProperty)
+            this._cappedProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildToggleDescription("boxCapped", EditTool_1.EditTools.translate("CreateBox.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("boxOrthogonal", EditTool_1.EditTools.translate("CreateBox.Label.Orthogonal")), true);
+        return this._orthogonalProperty;
+    }
+    get orthogonal() { return this.orthogonalProperty.value; }
+    set orthogonal(value) { this.orthogonalProperty.value = value; }
+    isComplete(_ev) {
+        return (4 === this.accepted.length);
+    }
+    async updateElementData(ev, isDynamics) {
+        const vp = this.targetView;
+        if (undefined === vp)
+            return;
+        switch (this.accepted.length) {
+            case 0: {
+                if (!isDynamics)
+                    this.accepted.push(ev.point.clone());
+                break;
+            }
+            case 1: {
+                const vector0 = core_geometry_1.Vector3d.createStartEnd(this.accepted[0], ev.point);
+                const length = (this.useLength ? this.length : vector0.magnitude());
+                if (!this.useLength) {
+                    this.length = length;
+                    this.syncToolSettingPropertyValue(this.lengthProperty);
+                }
+                if (undefined === vector0.scaleToLength(length, 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.LineSegment3d.create(this.accepted[0], this.accepted[0].plus(vector0));
+                if (isDynamics)
+                    return;
+                this.accepted.push(ev.point.clone());
+                break;
+            }
+            case 2: {
+                const vector90 = core_geometry_1.Vector3d.createStartEnd(this.accepted[0], ev.point);
+                const width = (this.useWidth ? this.width : vector90.magnitude());
+                if (!this.useWidth) {
+                    this.width = width;
+                    this.syncToolSettingPropertyValue(this.widthProperty);
+                }
+                const vector0 = this.baseRotation ? this.baseRotation.getColumn(0) : core_geometry_1.Vector3d.unitX();
+                const normal = vector90.crossProduct(vector0);
+                const matrix = core_geometry_1.Matrix3d.createColumns(vector0, vector90, normal);
+                if (undefined === vector90.scaleToLength(width, vector90) || undefined === core_geometry_1.Matrix3d.createRigidFromMatrix3d(matrix, undefined, matrix)) {
+                    this.current = core_geometry_1.LineSegment3d.create(this.accepted[0], this.accepted[0].plusScaled(vector0, this.length));
+                    return;
+                }
+                this.baseRotation = matrix; // Update base rotation from cross product...
+                const shapePts = [];
+                shapePts[0] = this.accepted[0].clone();
+                shapePts[1] = shapePts[0].plusScaled(this.baseRotation.getColumn(0), this.length);
+                shapePts[2] = shapePts[1].plusScaled(this.baseRotation.getColumn(1), width);
+                shapePts[3] = shapePts[0].plusScaled(this.baseRotation.getColumn(1), width);
+                shapePts[4] = shapePts[0].clone();
+                const base = core_geometry_1.LineString3d.create(shapePts);
+                this.current = (this.capped ? core_geometry_1.Loop.create(base) : base);
+                if (isDynamics)
+                    return;
+                this.accepted.push(ev.point.clone());
+                break;
+            }
+            default: {
+                if (undefined === this.baseRotation)
+                    return; // Should always have base rotation after width is defined...
+                const zAxis = core_geometry_1.Vector3d.createStartEnd(this.accepted[0], ev.point);
+                const height = (this.useHeight ? this.height : zAxis.magnitude());
+                if (!this.useHeight) {
+                    this.height = height;
+                    this.syncToolSettingPropertyValue(this.heightProperty);
+                }
+                if (undefined === zAxis.scaleToLength(height, zAxis)) {
+                    const shapePts = [];
+                    shapePts[0] = this.accepted[0].clone();
+                    shapePts[1] = shapePts[0].plusScaled(this.baseRotation.getColumn(0), this.length);
+                    shapePts[2] = shapePts[1].plusScaled(this.baseRotation.getColumn(1), this.width);
+                    shapePts[3] = shapePts[0].plusScaled(this.baseRotation.getColumn(1), this.width);
+                    shapePts[4] = shapePts[0].clone();
+                    const base = core_geometry_1.LineString3d.create(shapePts);
+                    this.current = (this.capped ? core_geometry_1.Loop.create(base) : base);
+                    return;
+                }
+                if (this.orthogonal) {
+                    const normal = this.baseRotation.getColumn(2);
+                    normal.scaleToLength(normal.dotProduct(zAxis) >= 0.0 ? height : -height, zAxis);
+                }
+                this.current = core_geometry_1.Box.createDgnBoxWithAxes(this.accepted[0], this.baseRotation, this.accepted[0].plus(zAxis), this.length, this.width, this.length, this.width, this.capped);
+                if (isDynamics || undefined === this.current)
+                    return;
+                this.accepted.push(ev.point.clone());
+                break;
+            }
+        }
+    }
+    getToolSettingPropertyLocked(property) {
+        if (property === this.useLengthProperty)
+            return this.lengthProperty;
+        else if (property === this.useWidthProperty)
+            return this.widthProperty;
+        else if (property === this.useHeightProperty)
+            return this.heightProperty;
+        return undefined;
+    }
+    async applyToolSettingPropertyChange(updatedValue) {
+        return this.changeToolSettingPropertyValue(updatedValue);
+    }
+    supplyToolSettingsProperties() {
+        this.initializeToolSettingPropertyValues([this.lengthProperty, this.useLengthProperty, this.widthProperty, this.useWidthProperty, this.heightProperty, this.useHeightProperty, this.orthogonalProperty, this.cappedProperty]);
+        const toolSettings = new Array();
+        this.lengthProperty.isDisabled = !this.useLength;
+        const useLengthLock = this.useLengthProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 });
+        toolSettings.push(this.lengthProperty.toDialogItem({ rowPriority: 1, columnIndex: 1 }, useLengthLock));
+        this.widthProperty.isDisabled = !this.useWidth;
+        const useWidthLock = this.useWidthProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 });
+        toolSettings.push(this.widthProperty.toDialogItem({ rowPriority: 2, columnIndex: 1 }, useWidthLock));
+        this.heightProperty.isDisabled = !this.useHeight;
+        const useHeightLock = this.useHeightProperty.toDialogItem({ rowPriority: 3, columnIndex: 0 });
+        toolSettings.push(this.heightProperty.toDialogItem({ rowPriority: 3, columnIndex: 1 }, useHeightLock));
+        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 CreateBoxTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+exports.CreateBoxTool = CreateBoxTool;
+CreateBoxTool.toolId = "CreateBox";
+CreateBoxTool.iconSpec = "icon-circle"; // TODO: Need better icon...
+/** @alpha Values for [[CreateTorusTool.createPhase]. */
+var CreateTorusPhase;
+(function (CreateTorusPhase) {
+    /** Current tool phase to define start point */
+    CreateTorusPhase[CreateTorusPhase["AcceptStart"] = 0] = "AcceptStart";
+    /** Current tool phase to define center point */
+    CreateTorusPhase[CreateTorusPhase["AcceptCenter"] = 1] = "AcceptCenter";
+    /** Current tool phase to define sweep angle and secondary radius */
+    CreateTorusPhase[CreateTorusPhase["AcceptAngle"] = 2] = "AcceptAngle";
+    /** Current tool phase to accept result */
+    CreateTorusPhase[CreateTorusPhase["AcceptResult"] = 3] = "AcceptResult";
+})(CreateTorusPhase = exports.CreateTorusPhase || (exports.CreateTorusPhase = {}));
+/** @alpha Creates a torus pipe. Uses model and category from [[BriefcaseConnection.editorToolSettings]]. */
+class CreateTorusTool extends SolidPrimitiveTool {
+    constructor() {
+        super(...arguments);
+        this.createPhase = CreateTorusPhase.AcceptStart;
+    }
+    provideToolAssistance(mainInstrText, additionalInstr) {
+        switch (this.createPhase) {
+            case CreateTorusPhase.AcceptStart:
+                mainInstrText = EditTool_1.EditTools.translate("CreateTorus.Prompts.StartPoint");
+                break;
+            case CreateTorusPhase.AcceptCenter:
+                mainInstrText = EditTool_1.EditTools.translate("CreateTorus.Prompts.CenterPoint");
+                break;
+            default:
+                mainInstrText = EditTool_1.EditTools.translate("CreateTorus.Prompts.AnglePoint");
+                break;
+        }
+        super.provideToolAssistance(mainInstrText, additionalInstr);
+    }
+    setupAccuDraw() {
+        const nPts = this.accepted.length;
+        if (0 === nPts)
+            return;
+        const hints = new core_frontend_1.AccuDrawHintBuilder();
+        if (CreateTorusPhase.AcceptCenter === this.createPhase) {
+            hints.setOrigin(this.accepted[0]);
+        }
+        else if (CreateTorusPhase.AcceptAngle === this.createPhase && 2 === nPts) {
+            hints.setModePolar();
+            hints.setOrigin(this.accepted[1]);
+            hints.setOriginFixed = true;
+            if (undefined !== this.baseRotation)
+                hints.setMatrix(this.baseRotation);
+        }
+        hints.sendHints();
+    }
+    get usePrimaryRadiusProperty() {
+        if (!this._usePrimaryRadiusProperty)
+            this._usePrimaryRadiusProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useTorusPrimaryRadius"), false);
+        return this._usePrimaryRadiusProperty;
+    }
+    get usePrimaryRadius() { return this.usePrimaryRadiusProperty.value; }
+    set usePrimaryRadius(value) { this.usePrimaryRadiusProperty.value = value; }
+    get primaryRadiusProperty() {
+        if (!this._primaryRadiusProperty)
+            this._primaryRadiusProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("torusPrimaryRadius", EditTool_1.EditTools.translate("CreateTorus.Label.PrimaryRadius")), 0.1, undefined, !this.usePrimaryRadius);
+        return this._primaryRadiusProperty;
+    }
+    get primaryRadius() { return this.primaryRadiusProperty.value; }
+    set primaryRadius(value) { this.primaryRadiusProperty.value = value; }
+    get useSecondaryRadiusProperty() {
+        if (!this._useSecondaryRadiusProperty)
+            this._useSecondaryRadiusProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useTorusSecondaryRadius"), false);
+        return this._useSecondaryRadiusProperty;
+    }
+    get useSecondaryRadius() { return this.useSecondaryRadiusProperty.value; }
+    set useSecondaryRadius(value) { this.useSecondaryRadiusProperty.value = value; }
+    get secondaryRadiusProperty() {
+        if (!this._secondaryRadiusProperty)
+            this._secondaryRadiusProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("torusSecondaryRadius", EditTool_1.EditTools.translate("CreateTorus.Label.SecondaryRadius")), 0.05, undefined, !this.useSecondaryRadius);
+        return this._secondaryRadiusProperty;
+    }
+    get secondaryRadius() { return this.secondaryRadiusProperty.value; }
+    set secondaryRadius(value) { this.secondaryRadiusProperty.value = value; }
+    get useAngleProperty() {
+        if (!this._useAngleProperty)
+            this._useAngleProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildLockPropertyDescription("useTorusAngle"), false);
+        return this._useAngleProperty;
+    }
+    get useAngle() { return this.useAngleProperty.value; }
+    set useAngle(value) { this.useAngleProperty.value = value; }
+    get angleProperty() {
+        if (!this._angleProperty)
+            this._angleProperty = new appui_abstract_1.DialogProperty(new core_frontend_1.AngleDescription("torusAngle", EditTool_1.EditTools.translate("CreateTorus.Label.Angle")), Math.PI / 2.0, undefined, !this.useAngle);
+        return this._angleProperty;
+    }
+    get angle() { return this.angleProperty.value; }
+    set angle(value) { this.angleProperty.value = value; }
+    get cappedProperty() {
+        if (!this._cappedProperty)
+            this._cappedProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildToggleDescription("torusCapped", EditTool_1.EditTools.translate("CreateTorus.Label.Capped")), true);
+        return this._cappedProperty;
+    }
+    get capped() { return this.cappedProperty.value; }
+    set capped(value) { this.cappedProperty.value = value; }
+    isComplete(_ev) {
+        return (CreateTorusPhase.AcceptResult === this.createPhase);
+    }
+    async updateElementData(ev, isDynamics) {
+        const vp = this.targetView;
+        if (undefined === vp)
+            return;
+        switch (this.createPhase) {
+            case CreateTorusPhase.AcceptStart: {
+                if (isDynamics)
+                    break;
+                this.accepted.push(ev.point.clone());
+                this.createPhase = CreateTorusPhase.AcceptCenter;
+                break;
+            }
+            case CreateTorusPhase.AcceptCenter: {
+                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(ev.point, this.accepted[0]);
+                const vector90 = normal.crossProduct(vector0);
+                const primaryRadius = (this.usePrimaryRadius ? this.primaryRadius : vector0.magnitude());
+                if (!this.usePrimaryRadius) {
+                    this.primaryRadius = primaryRadius;
+                    this.syncToolSettingPropertyValue(this.primaryRadiusProperty);
+                }
+                if (undefined === vector0.scaleToLength(primaryRadius, vector0) || undefined === vector90.scaleToLength(primaryRadius, vector90)) {
+                    this.current = undefined;
+                    this.clearGraphics();
+                    return;
+                }
+                const center = this.accepted[0].plus(vector0.negate());
+                const allowComplete = (this.useSecondaryRadius && this.useAngle && (2 * Math.PI) === this.angle);
+                if (allowComplete) {
+                    vector0.normalizeInPlace();
+                    vector90.normalizeInPlace();
+                    this.current = core_geometry_1.TorusPipe.createDgnTorusPipe(center, vector0, vector90, primaryRadius, this.secondaryRadius, core_geometry_1.Angle.createRadians(this.angle), this.capped);
+                    if (undefined === this.current) {
+                        this.clearGraphics();
+                        break;
+                    }
+                    if (!isDynamics)
+                        this.createPhase = CreateTorusPhase.AcceptResult;
+                    break;
+                }
+                const arc = core_geometry_1.Arc3d.create(center, vector0, vector90);
+                this.baseRotation = core_geometry_1.Matrix3d.createRigidFromMatrix3d(arc.matrixRef); // Update base rotation from result arc...
+                this.current = arc;
+                if (isDynamics)
+                    break;
+                this.accepted.push(arc.center); // Add center to accepted points for AccuDraw hints...
+                this.createPhase = CreateTorusPhase.AcceptAngle;
+                break;
+            }
+            case CreateTorusPhase.AcceptAngle: {
+                const vector90 = core_geometry_1.Vector3d.createStartEnd(this.accepted[1], ev.point);
+                const secondaryRadius = (this.useSecondaryRadius ? this.secondaryRadius : Math.min(this.primaryRadius, Math.abs(this.primaryRadius - vector90.magnitude())));
+                if (!this.useSecondaryRadius) {
+                    this.secondaryRadius = secondaryRadius;
+                    this.syncToolSettingPropertyValue(this.secondaryRadiusProperty);
+                }
+                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();
+                const zAxis = this.baseRotation ? this.baseRotation.getColumn(2) : core_geometry_1.Vector3d.unitZ();
+                const prevSweep = core_geometry_1.Angle.createRadians(this.angle);
+                const sweep = xAxis.planarAngleTo(vector90, zAxis);
+                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.useAngle) {
+                    if ((sweep.radians < 0.0 && this.angle > 0.0) || (sweep.radians > 0.0 && this.angle < 0.0))
+                        sweep.setRadians(-this.angle);
+                    else
+                        sweep.setRadians(this.angle);
+                }
+                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.angle = sweep.radians;
+                    this.syncToolSettingPropertyValue(this.angleProperty);
+                }
+                this.current = core_geometry_1.TorusPipe.createDgnTorusPipe(this.accepted[1], xAxis, yAxis, this.primaryRadius, secondaryRadius, sweep, this.capped);
+                if (undefined === this.current) {
+                    this.clearGraphics();
+                    break;
+                }
+                if (!isDynamics)
+                    this.createPhase = CreateTorusPhase.AcceptResult;
+                break;
+            }
+        }
+    }
+    getToolSettingPropertyLocked(property) {
+        if (property === this.usePrimaryRadiusProperty)
+            return this.primaryRadiusProperty;
+        else if (property === this.useSecondaryRadiusProperty)
+            return this.secondaryRadiusProperty;
+        else if (property === this.useAngleProperty)
+            return this.angleProperty;
+        return undefined;
+    }
+    async applyToolSettingPropertyChange(updatedValue) {
+        return this.changeToolSettingPropertyValue(updatedValue);
+    }
+    supplyToolSettingsProperties() {
+        this.initializeToolSettingPropertyValues([this.primaryRadiusProperty, this.usePrimaryRadiusProperty, this.secondaryRadiusProperty, this.useSecondaryRadiusProperty, this.angleProperty, this.useAngleProperty, this.cappedProperty]);
+        const toolSettings = new Array();
+        this.primaryRadiusProperty.isDisabled = !this.usePrimaryRadius;
+        const usePrimaryRadiusLock = this.usePrimaryRadiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 });
+        toolSettings.push(this.primaryRadiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 1 }, usePrimaryRadiusLock));
+        this.secondaryRadiusProperty.isDisabled = !this.useSecondaryRadius;
+        const useSecondaryRadiusLock = this.useSecondaryRadiusProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 });
+        toolSettings.push(this.secondaryRadiusProperty.toDialogItem({ rowPriority: 2, columnIndex: 1 }, useSecondaryRadiusLock));
+        this.angleProperty.isDisabled = !this.useAngle;
+        const useAngleLock = this.useAngleProperty.toDialogItem({ rowPriority: 3, columnIndex: 0 });
+        toolSettings.push(this.angleProperty.toDialogItem({ rowPriority: 3, columnIndex: 1 }, useAngleLock));
+        toolSettings.push(this.cappedProperty.toDialogItem({ rowPriority: 4, columnIndex: 0 }));
+        return toolSettings;
+    }
+    async onRestartTool() {
+        const tool = new CreateTorusTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+exports.CreateTorusTool = CreateTorusTool;
+CreateTorusTool.toolId = "CreateTorus";
+CreateTorusTool.iconSpec = "icon-circle"; // TODO: Need better icon...
 //# sourceMappingURL=SolidPrimitiveTools.js.map