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

package/lib/esm/SolidModelingTools.js

@@ -1,1445 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Editing
- */
-import { DialogProperty, PropertyDescriptionHelper } from "@itwin/appui-abstract";
-import { ColorDef, ElementGeometry } from "@itwin/core-common";
-import { AccuDraw, AccuDrawHintBuilder, AngleDescription, EventHandled, GraphicType, IModelApp, LengthDescription, TentativeOrAccuSnap, } from "@itwin/core-frontend";
-import { Angle, Geometry, LineString3d, Matrix3d, Point3d, Vector3d } from "@itwin/core-geometry";
-import { BooleanMode, BRepEntityType, ChamferMode, CutDepthMode, CutDirectionMode, EmbossDirectionMode, ProfileClosure, SubEntityType, } from "@itwin/editor-common";
-import { computeChordToleranceFromPoint } from "./CreateElementTool";
-import { EditTools } from "./EditTool";
-import { ElementGeometryCacheTool, isSameSubEntity, LocateSubEntityTool, SubEntityData } from "./ElementGeometryTool";
-import { solidModelingIpc } from "./EditToolIpc";
-/** @alpha Base class for tools that perform boolean operations on a set of elements. */
-export class BooleanOperationTool extends ElementGeometryCacheTool {
-    get allowSelectionSet() { return BooleanMode.Subtract !== this.mode; }
-    get allowDragSelect() { return BooleanMode.Subtract !== this.mode; }
-    get controlKeyContinuesSelection() { return true; }
-    get requiredElementCount() { return 2; }
-    get geometryCacheFilter() {
-        return { parts: true, curves: false, surfaces: BooleanMode.Subtract === this.mode && !this.agenda.isEmpty, solids: true, other: false };
-    }
-    async onAgendaModified() {
-        // Filter changes to allow surfaces as tools, invalidate cached accept status...
-        if (BooleanMode.Subtract === this.mode && (this.agenda.isEmpty || 1 === this.agenda.length))
-            this.onGeometryCacheFilterChanged();
-    }
-    async applyAgendaOperation() {
-        if (this.agenda.length < this.requiredElementCount)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const target = this.agenda.elements[0];
-            const tools = this.agenda.elements.slice(1);
-            const params = { mode: this.mode, tools };
-            const opts = { writeChanges: true };
-            return await solidModelingIpc.booleanOperation(target, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async processAgenda(_ev) {
-        const result = await this.applyAgendaOperation();
-        if (result?.elementId)
-            await this.saveChanges();
-    }
-}
-/** @alpha Perform boolean union of solid geometry. */
-class UniteSolidElementsTool extends BooleanOperationTool {
-    get mode() { return BooleanMode.Unite; }
-    async onRestartTool() {
-        const tool = new UniteSolidElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-UniteSolidElementsTool.toolId = "UniteSolids";
-UniteSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { UniteSolidElementsTool };
-/** @alpha Perform boolean subtract of solid geometry. */
-class SubtractSolidElementsTool extends BooleanOperationTool {
-    get mode() { return BooleanMode.Subtract; }
-    async onRestartTool() {
-        const tool = new SubtractSolidElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-SubtractSolidElementsTool.toolId = "SubtractSolids";
-SubtractSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { SubtractSolidElementsTool };
-/** @alpha Perform boolean intersection of solid geometry. */
-class IntersectSolidElementsTool extends BooleanOperationTool {
-    get mode() { return BooleanMode.Intersect; }
-    async onRestartTool() {
-        const tool = new IntersectSolidElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-IntersectSolidElementsTool.toolId = "IntersectSolids";
-IntersectSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { IntersectSolidElementsTool };
-/** @alpha Perform sew operation on surface geometry. */
-class SewSheetElementsTool extends ElementGeometryCacheTool {
-    get allowSelectionSet() { return true; }
-    get allowDragSelect() { return true; }
-    get controlKeyContinuesSelection() { return true; }
-    get requiredElementCount() { return 2; }
-    get geometryCacheFilter() {
-        return { parts: true, curves: false, surfaces: true, solids: false, other: false };
-    }
-    async applyAgendaOperation() {
-        if (this.agenda.length < this.requiredElementCount)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const target = this.agenda.elements[0];
-            const tools = this.agenda.elements.slice(1);
-            const params = { tools };
-            const opts = { writeChanges: true };
-            return await solidModelingIpc.sewSheets(target, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async processAgenda(_ev) {
-        const result = await this.applyAgendaOperation();
-        if (result?.elementId)
-            await this.saveChanges();
-    }
-    async onRestartTool() {
-        const tool = new SewSheetElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-SewSheetElementsTool.toolId = "SewSheets";
-SewSheetElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { SewSheetElementsTool };
-/** @alpha Perform thicken operation on surface geometry. */
-class ThickenSheetElementsTool extends ElementGeometryCacheTool {
-    get frontDistanceProperty() {
-        if (!this._frontDistanceProperty)
-            this._frontDistanceProperty = new DialogProperty(new LengthDescription("thickenFront", EditTools.translate("ThickenSheets.Label.FrontDistance")), 0.1, undefined);
-        return this._frontDistanceProperty;
-    }
-    get frontDistance() { return this.frontDistanceProperty.value; }
-    set frontDistance(value) { this.frontDistanceProperty.value = value; }
-    get backDistanceProperty() {
-        if (!this._backDistanceProperty)
-            this._backDistanceProperty = new DialogProperty(new LengthDescription("thickenBack", EditTools.translate("ThickenSheets.Label.BackDistance")), 0.0, undefined);
-        return this._backDistanceProperty;
-    }
-    get backDistance() { return this.backDistanceProperty.value; }
-    set backDistance(value) { this.backDistanceProperty.value = value; }
-    get geometryCacheFilter() {
-        return { parts: true, curves: false, surfaces: true, solids: false, other: false };
-    }
-    async applyAgendaOperation() {
-        if (this.agenda.length < this.requiredElementCount)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const target = this.agenda.elements[0];
-            const params = { front: this.frontDistance, back: this.backDistance };
-            const opts = { writeChanges: true };
-            return await solidModelingIpc.thickenSheets(target, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async processAgenda(_ev) {
-        const result = await this.applyAgendaOperation();
-        if (result?.elementId)
-            await this.saveChanges();
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        return this.changeToolSettingPropertyValue(updatedValue);
-    }
-    supplyToolSettingsProperties() {
-        this.initializeToolSettingPropertyValues([this.frontDistanceProperty, this.backDistanceProperty]);
-        const toolSettings = new Array();
-        toolSettings.push(this.frontDistanceProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        toolSettings.push(this.backDistanceProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new ThickenSheetElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-ThickenSheetElementsTool.toolId = "ThickenSheets";
-ThickenSheetElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { ThickenSheetElementsTool };
-/** @alpha Perform cut operation on solid using region or path profile. */
-class CutSolidElementsTool extends ElementGeometryCacheTool {
-    get bothDirectionsProperty() {
-        if (!this._bothDirectionsProperty)
-            this._bothDirectionsProperty = new DialogProperty(PropertyDescriptionHelper.buildToggleDescription("cutBothDirections", EditTools.translate("CutSolids.Label.BothDirections")), false);
-        return this._bothDirectionsProperty;
-    }
-    get bothDirections() { return this.bothDirectionsProperty.value; }
-    set bothDirections(value) { this.bothDirectionsProperty.value = value; }
-    get outsideProperty() {
-        if (!this._outsideProperty)
-            this._outsideProperty = new DialogProperty(PropertyDescriptionHelper.buildToggleDescription("cutOutside", EditTools.translate("CutSolids.Label.Outside")), false);
-        return this._outsideProperty;
-    }
-    get outside() { return this.outsideProperty.value; }
-    set outside(value) { this.outsideProperty.value = value; }
-    get useDepthProperty() {
-        if (!this._useDepthProperty)
-            this._useDepthProperty = new DialogProperty(PropertyDescriptionHelper.buildLockPropertyDescription("useCutDepth"), false);
-        return this._useDepthProperty;
-    }
-    get useDepth() { return this.useDepthProperty.value; }
-    set useDepth(value) { this.useDepthProperty.value = value; }
-    get depthProperty() {
-        if (!this._depthProperty)
-            this._depthProperty = new DialogProperty(new LengthDescription("cutDepth", EditTools.translate("CutSolids.Label.Depth")), 0.1, undefined, !this.useDepth);
-        return this._depthProperty;
-    }
-    get depth() { return this.depthProperty.value; }
-    set depth(value) { this.depthProperty.value = value; }
-    get requiredElementCount() { return 2; }
-    get isProfilePhase() { return !this.agenda.isEmpty; }
-    get geometryCacheFilter() {
-        const profilePhase = this.isProfilePhase;
-        return { minGeom: 1, maxGeom: profilePhase ? 1 : undefined, parts: true, curves: profilePhase, surfaces: profilePhase, solids: !profilePhase, other: false };
-    }
-    async createElementGeometryCache(id) {
-        if (!await super.createElementGeometryCache(id))
-            return false;
-        if (!this.isProfilePhase)
-            return true;
-        try {
-            this._startedCmd = await this.startCommand();
-            return await solidModelingIpc.isPlanarBody(id, 0);
-        }
-        catch (err) {
-            return false;
-        }
-    }
-    async onAgendaModified() {
-        // Filter changes to allow sheets and wires as profiles, invalidate cached accept status...
-        if (this.agenda.isEmpty || 1 === this.agenda.length)
-            this.onGeometryCacheFilterChanged();
-    }
-    async applyAgendaOperation() {
-        if (this.agenda.length < this.requiredElementCount)
-            return undefined;
-        const direction = (this.bothDirections ? CutDirectionMode.Both : CutDirectionMode.Auto);
-        const depth = (this.useDepth ? CutDepthMode.Blind : CutDepthMode.All);
-        try {
-            this._startedCmd = await this.startCommand();
-            const target = this.agenda.elements[0];
-            const profile = this.agenda.elements[1];
-            const params = { profile, direction, depth, distance: this.depth, outside: this.outside ? true : undefined, closeOpen: ProfileClosure.Auto, targetPoint: this.targetPoint, toolPoint: this.toolPoint };
-            const opts = { writeChanges: true };
-            return await solidModelingIpc.cutSolid(target, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async processAgenda(_ev) {
-        const result = await this.applyAgendaOperation();
-        if (result?.elementId)
-            await this.saveChanges();
-    }
-    async buildLocateAgenda(hit) {
-        if (this.isProfilePhase)
-            this.toolPoint = hit.hitPoint;
-        else
-            this.targetPoint = hit.hitPoint;
-        return super.buildLocateAgenda(hit);
-    }
-    getToolSettingPropertyLocked(property) {
-        return (property === this.useDepthProperty ? this.depthProperty : undefined);
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        return this.changeToolSettingPropertyValue(updatedValue);
-    }
-    supplyToolSettingsProperties() {
-        this.initializeToolSettingPropertyValues([this.bothDirectionsProperty, this.outsideProperty, this.useDepthProperty, this.depthProperty]);
-        const toolSettings = new Array();
-        toolSettings.push(this.bothDirectionsProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        toolSettings.push(this.outsideProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-        // ensure controls are enabled/disabled based on current lock property state
-        this.depthProperty.isDisabled = !this.useDepth;
-        const useDepthLock = this.useDepthProperty.toDialogItem({ rowPriority: 3, columnIndex: 0 });
-        toolSettings.push(this.depthProperty.toDialogItem({ rowPriority: 3, columnIndex: 1 }, useDepthLock));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new CutSolidElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-CutSolidElementsTool.toolId = "CutSolids";
-CutSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { CutSolidElementsTool };
-/** @alpha Perform emboss operation on solid or sheet using sheet profile. */
-class EmbossSolidElementsTool extends ElementGeometryCacheTool {
-    get requiredElementCount() { return 2; }
-    get isProfilePhase() { return !this.agenda.isEmpty; }
-    get geometryCacheFilter() {
-        const profilePhase = this.isProfilePhase;
-        return { minGeom: 1, maxGeom: 1, parts: true, curves: false, surfaces: true, solids: !profilePhase, other: false };
-    }
-    async onAgendaModified() {
-        // Filter changes to disallow solids as profiles, invalidate cached accept status...
-        if (this.agenda.isEmpty || 1 === this.agenda.length)
-            this.onGeometryCacheFilterChanged();
-    }
-    async applyAgendaOperation() {
-        if (this.agenda.length < this.requiredElementCount)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const target = this.agenda.elements[0];
-            const profile = this.agenda.elements[1];
-            const params = { profile, direction: EmbossDirectionMode.Auto, targetPoint: this.targetPoint };
-            const opts = { writeChanges: true };
-            return await solidModelingIpc.embossBody(target, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async processAgenda(_ev) {
-        const result = await this.applyAgendaOperation();
-        if (result?.elementId)
-            await this.saveChanges();
-    }
-    async buildLocateAgenda(hit) {
-        if (!this.isProfilePhase)
-            this.targetPoint = hit.hitPoint;
-        return super.buildLocateAgenda(hit);
-    }
-    async onRestartTool() {
-        const tool = new EmbossSolidElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-EmbossSolidElementsTool.toolId = "EmbossSolids";
-EmbossSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { EmbossSolidElementsTool };
-/** @alpha Create a solid for sheet by sweeping a profile along a path. */
-class SweepAlongPathTool extends ElementGeometryCacheTool {
-    get requiredElementCount() { return 2; }
-    get geometryCacheFilter() {
-        return { minGeom: 1, maxGeom: 1, parts: true, curves: true, surfaces: true, solids: false, other: false };
-    }
-    async applyAgendaOperation() {
-        if (this.agenda.length < this.requiredElementCount)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const target = this.agenda.elements[0];
-            const path = this.agenda.elements[1];
-            const params = { path };
-            const opts = { writeChanges: true };
-            return await solidModelingIpc.sweepAlongPath(target, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async processAgenda(_ev) {
-        const result = await this.applyAgendaOperation();
-        if (result?.elementId)
-            await this.saveChanges();
-    }
-    async onRestartTool() {
-        const tool = new SweepAlongPathTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-SweepAlongPathTool.toolId = "SweepAlongPath";
-SweepAlongPathTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { SweepAlongPathTool };
-/** @alpha Create a new sheet or solid body by lofting through a set of profiles. */
-class LoftProfilesTool extends ElementGeometryCacheTool {
-    get requiredElementCount() { return 2; }
-    get controlKeyContinuesSelection() { return true; }
-    get geometryCacheFilter() {
-        return { minGeom: 1, maxGeom: 1, parts: true, curves: true, surfaces: true, solids: false, other: false };
-    }
-    async applyAgendaOperation() {
-        if (this.agenda.length < this.requiredElementCount)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const target = this.agenda.elements[0];
-            const tools = this.agenda.elements.slice(1);
-            const params = { tools, orderCurves: this.isSelectionSetModify ? true : undefined, orientCurves: true };
-            const opts = { writeChanges: true };
-            return await solidModelingIpc.loftProfiles(target, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async processAgenda(_ev) {
-        const result = await this.applyAgendaOperation();
-        if (result?.elementId)
-            await this.saveChanges();
-    }
-    async onRestartTool() {
-        const tool = new LoftProfilesTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-LoftProfilesTool.toolId = "LoftProfiles";
-LoftProfilesTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { LoftProfilesTool };
-/** @alpha */
-export class FaceLocationData {
-    constructor(point, normal) {
-        this.point = point;
-        this.normal = normal;
-    }
-    static create(pointProps, normalProps) {
-        const point = Point3d.fromJSON(pointProps);
-        const normal = Vector3d.fromJSON(normalProps);
-        return new FaceLocationData(point, normal);
-    }
-}
-/** @alpha Identify faces of solids and surfaces to offset. */
-class OffsetFacesTool extends LocateSubEntityTool {
-    get addSmoothProperty() {
-        if (!this._addSmoothProperty)
-            this._addSmoothProperty = new DialogProperty(PropertyDescriptionHelper.buildToggleDescription("offsetSmooth", EditTools.translate("OffsetFaces.Label.AddSmooth")), false);
-        return this._addSmoothProperty;
-    }
-    get addSmooth() { return this.addSmoothProperty.value; }
-    set addSmooth(value) { this.addSmoothProperty.value = value; }
-    get useDistanceProperty() {
-        if (!this._useDistanceProperty)
-            this._useDistanceProperty = new DialogProperty(PropertyDescriptionHelper.buildLockPropertyDescription("useOffsetDistance"), false);
-        return this._useDistanceProperty;
-    }
-    get useDistance() { return this.useDistanceProperty.value; }
-    set useDistance(value) { this.useDistanceProperty.value = value; }
-    get distanceProperty() {
-        if (!this._distanceProperty)
-            this._distanceProperty = new DialogProperty(new LengthDescription("offsetDistance", EditTools.translate("OffsetFaces.Label.Distance")), 0.1, undefined, !this.useDistance);
-        return this._distanceProperty;
-    }
-    get distance() { return this.distanceProperty.value; }
-    set distance(value) { this.distanceProperty.value = value; }
-    get wantDynamics() { return true; }
-    get wantAccuSnap() { return this.isDynamicsStarted; }
-    get geometryCacheFilter() {
-        return { parts: true, curves: false, surfaces: true, solids: true, other: false };
-    }
-    async createSubEntityData(id, hit) {
-        const data = await super.createSubEntityData(id, hit);
-        if (undefined !== hit.point && undefined !== hit.normal)
-            data.toolData = FaceLocationData.create(hit.point, hit.normal);
-        return data;
-    }
-    drawAcceptedSubEntities(context) {
-        super.drawAcceptedSubEntities(context);
-        // Show pick point on last identified face, offset direction/distance will be computed from this location...
-        const faceData = this.getAcceptedSubEntityData()?.toolData;
-        if (undefined === faceData)
-            return;
-        const builder = context.createGraphic({ type: GraphicType.WorldOverlay });
-        builder.setSymbology(context.viewport.getContrastToBackgroundColor(), ColorDef.black, 10);
-        builder.addPointString([faceData.point]);
-        context.addDecorationFromBuilder(builder);
-    }
-    async getSmoothFaces(id, face) {
-        try {
-            // NOTE: For offset, include all smoothly connected faces, not just adjacent...
-            return await solidModelingIpc.getConnectedSubEntities(id, face, SubEntityType.Face, { smoothFaces: true });
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async applyAgendaOperation(ev, isAccept) {
-        if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities)
-            return undefined;
-        const faceData = this.getAcceptedSubEntityData()?.toolData;
-        if (undefined === faceData)
-            return undefined;
-        const projPt = AccuDrawHintBuilder.projectPointToLineInView(ev.point, faceData.point, faceData.normal, ev.viewport);
-        if (undefined === projPt)
-            return undefined;
-        const offsetDir = Vector3d.createStartEnd(faceData.point, projPt);
-        if (this.useDistance && undefined === offsetDir.scaleToLength(this.distance, offsetDir))
-            return undefined;
-        let offset = offsetDir.magnitude();
-        if (offset < Geometry.smallMetricDistance)
-            return undefined;
-        if (offsetDir.dotProduct(faceData.normal) < 0.0)
-            offset = -offset;
-        if (!this.useDistance) {
-            this.distance = offset;
-            this.syncToolSettingPropertyValue(this.distanceProperty);
-            if (isAccept)
-                this.saveToolSettingPropertyValue(this.distanceProperty, this.distanceProperty.dialogItemValue);
-        }
-        try {
-            this._startedCmd = await this.startCommand();
-            const id = this.agenda.elements[0];
-            const faces = this.getAcceptedSubEntities();
-            if (this.addSmooth) {
-                const allSmoothFaces = [];
-                for (const face of faces) {
-                    const smoothFaces = await this.getSmoothFaces(id, face);
-                    if (undefined !== smoothFaces)
-                        allSmoothFaces.push(...smoothFaces);
-                }
-                for (const smooth of allSmoothFaces) {
-                    if (undefined === faces.find((selected) => isSameSubEntity(selected, smooth)))
-                        faces.unshift(smooth); // Preserve last selected entry as reference face...
-                }
-            }
-            const params = { faces, distances: offset };
-            const opts = {
-                wantGraphic: isAccept ? undefined : true,
-                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
-                requestId: `${this.toolId}:${id}`,
-                writeChanges: isAccept ? true : undefined,
-            };
-            return await solidModelingIpc.offsetFaces(id, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    setupAccuDraw() {
-        if (!this.haveAcceptedSubEntities)
-            return;
-        const faceData = this.getAcceptedSubEntityData()?.toolData;
-        if (undefined === faceData)
-            return;
-        const hints = new AccuDrawHintBuilder();
-        hints.setOriginFixed = true;
-        hints.setLockY = true;
-        hints.setLockZ = true;
-        hints.setModeRectangular();
-        hints.setOrigin(faceData.point);
-        hints.setXAxis2(faceData.normal);
-        hints.sendHints(false);
-    }
-    getToolSettingPropertyLocked(property) {
-        return (property === this.useDistanceProperty ? this.distanceProperty : undefined);
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        return this.changeToolSettingPropertyValue(updatedValue);
-    }
-    supplyToolSettingsProperties() {
-        this.initializeToolSettingPropertyValues([this.addSmoothProperty, this.useDistanceProperty, this.distanceProperty]);
-        const toolSettings = new Array();
-        // ensure controls are enabled/disabled based on current lock property state
-        this.distanceProperty.isDisabled = !this.useDistance;
-        const useDistanceLock = this.useDistanceProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 });
-        toolSettings.push(this.distanceProperty.toDialogItem({ rowPriority: 1, columnIndex: 1 }, useDistanceLock));
-        toolSettings.push(this.addSmoothProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new OffsetFacesTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-OffsetFacesTool.toolId = "OffsetFaces";
-OffsetFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { OffsetFacesTool };
-/** @alpha Identify faces to offset to hollow solids. */
-class HollowFacesTool extends LocateSubEntityTool {
-    get shellThicknessProperty() {
-        if (!this._shellThicknessProperty)
-            this._shellThicknessProperty = new DialogProperty(new LengthDescription("hollowShellThickness", EditTools.translate("HollowFaces.Label.ShellThickness")), 0.1, undefined);
-        return this._shellThicknessProperty;
-    }
-    get shellThickness() { return this.shellThicknessProperty.value; }
-    set shellThickness(value) { this.shellThicknessProperty.value = value; }
-    get faceThicknessProperty() {
-        if (!this._faceThicknessProperty)
-            this._faceThicknessProperty = new DialogProperty(new LengthDescription("hollowFaceThickness", EditTools.translate("HollowFaces.Label.FaceThickness")), 0.0, undefined);
-        return this._faceThicknessProperty;
-    }
-    get faceThickness() { return this.faceThicknessProperty.value; }
-    set faceThickness(value) { this.faceThicknessProperty.value = value; }
-    get geometryCacheFilter() {
-        return { parts: true, curves: false, surfaces: false, solids: true, other: false };
-    }
-    async applyAgendaOperation(ev, isAccept) {
-        if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const params = { faces: this.getAcceptedSubEntities(), distances: this.faceThickness, defaultDistance: this.shellThickness };
-            const opts = {
-                wantGraphic: isAccept ? undefined : true,
-                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
-                requestId: `${this.toolId}:${this.agenda.elements[0]}`,
-                writeChanges: isAccept ? true : undefined,
-            };
-            return await solidModelingIpc.hollowFaces(this.agenda.elements[0], params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        return this.changeToolSettingPropertyValue(updatedValue);
-    }
-    supplyToolSettingsProperties() {
-        this.initializeToolSettingPropertyValues([this.shellThicknessProperty, this.faceThicknessProperty]);
-        const toolSettings = new Array();
-        toolSettings.push(this.shellThicknessProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        toolSettings.push(this.faceThicknessProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new HollowFacesTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-HollowFacesTool.toolId = "HollowFaces";
-HollowFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { HollowFacesTool };
-/** @alpha Identify faces or edges for removal by growing surrounding faces. */
-class DeleteSubEntitiesTool extends LocateSubEntityTool {
-    wantSubEntityType(type) {
-        switch (type) {
-            case SubEntityType.Face:
-            case SubEntityType.Edge:
-                // Choose all faces or all edges...
-                return (0 === this._acceptedSubEntities.length || this._acceptedSubEntities[0].props.type === type);
-            default:
-                return false;
-        }
-    }
-    getMaximumSubEntityHits(type) {
-        if (!this.wantSubEntityType(type))
-            return 0;
-        // Only return single closest edge, avoids having to test for redundant edges on reset...
-        return (SubEntityType.Edge === type ? 1 : 25);
-    }
-    get geometryCacheFilter() {
-        return { parts: true, curves: false, surfaces: true, solids: true, other: false };
-    }
-    async doPickSubEntities(id, ev) {
-        const hits = await super.doPickSubEntities(id, ev);
-        if (undefined === hits)
-            return hits;
-        // Don't allow reset to select a back edge...
-        if (SubEntityType.Face === hits[0].subEntity.type)
-            return hits.filter((hit) => { return SubEntityType.Face === hit.subEntity.type; });
-        try {
-            const accept = await solidModelingIpc.isRedundantEdge(id, hits[0].subEntity);
-            if (accept)
-                return hits;
-            if (hits.length > 1 && SubEntityType.Face === hits[1].subEntity.type)
-                return hits.slice(1); // Accept face of rejected edge...
-            return undefined;
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async applyAgendaOperation(ev, isAccept) {
-        if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const params = { subEntities: this.getAcceptedSubEntities() };
-            const opts = {
-                wantGraphic: isAccept ? undefined : true,
-                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
-                requestId: `${this.toolId}:${this.agenda.elements[0]}`,
-                writeChanges: isAccept ? true : undefined,
-            };
-            return await solidModelingIpc.deleteSubEntities(this.agenda.elements[0], params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async onRestartTool() {
-        const tool = new DeleteSubEntitiesTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-DeleteSubEntitiesTool.toolId = "DeleteSubEntities";
-DeleteSubEntitiesTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { DeleteSubEntitiesTool };
-/** @alpha */
-export var ImprintSolidMethod;
-(function (ImprintSolidMethod) {
-    /** Imprint intersection with another element */
-    ImprintSolidMethod[ImprintSolidMethod["Element"] = 0] = "Element";
-    /** Imprint offset edges onto face */
-    ImprintSolidMethod[ImprintSolidMethod["Edges"] = 1] = "Edges";
-    /** Imprint line string defined by points onto face */
-    ImprintSolidMethod[ImprintSolidMethod["Points"] = 2] = "Points";
-})(ImprintSolidMethod || (ImprintSolidMethod = {}));
-/** @alpha Identify edges or elements to imprint on solid or surface. */
-class ImprintSolidElementsTool extends LocateSubEntityTool {
-    constructor() {
-        super(...arguments);
-        this.points = [];
-    }
-    static methodMessage(str) { return EditTools.translate(`ImprintSolids.Method.${str}`); }
-    get methodProperty() {
-        if (!this._methodProperty)
-            this._methodProperty = new DialogProperty(PropertyDescriptionHelper.buildEnumPicklistEditorDescription("imprintMethod", EditTools.translate("ImprintSolids.Label.Method"), ImprintSolidElementsTool.getMethodChoices()), ImprintSolidMethod.Element);
-        return this._methodProperty;
-    }
-    get method() { return this.methodProperty.value; }
-    set method(method) { this.methodProperty.value = method; }
-    get distanceProperty() {
-        if (!this._distanceProperty)
-            this._distanceProperty = new DialogProperty(new LengthDescription("imprintDistance", EditTools.translate("ImprintSolids.Label.Distance")), 0.1, undefined);
-        return this._distanceProperty;
-    }
-    get distance() { return this.distanceProperty.value; }
-    set distance(value) { this.distanceProperty.value = value; }
-    get extendProperty() {
-        if (!this._extendProperty)
-            this._extendProperty = new DialogProperty(PropertyDescriptionHelper.buildToggleDescription("imprintExtend", EditTools.translate("ImprintSolids.Label.Extend")), false);
-        return this._extendProperty;
-    }
-    get extend() { return this.extendProperty.value; }
-    set extend(value) { this.extendProperty.value = value; }
-    get requiredSubEntityCount() { return ImprintSolidMethod.Element === this.method ? 0 : 1; }
-    get requiredElementCount() { return ImprintSolidMethod.Element === this.method ? 2 : 1; }
-    get allowSubEntityControlSelect() { return ImprintSolidMethod.Edges === this.method; }
-    get inhibitSubEntityDisplay() { return ImprintSolidMethod.Points === this.method ? false : super.inhibitSubEntityDisplay; }
-    wantSubEntityType(type) {
-        switch (type) {
-            case SubEntityType.Face:
-                return ImprintSolidMethod.Points === this.method;
-            case SubEntityType.Edge:
-                return ImprintSolidMethod.Edges === this.method;
-            default:
-                return false;
-        }
-    }
-    get wantDynamics() { return ImprintSolidMethod.Points === this.method; }
-    get wantAccuSnap() { return ImprintSolidMethod.Points === this.method && this.isDynamicsStarted; }
-    get geometryCacheFilter() {
-        return { parts: true, curves: !this.agenda.isEmpty, surfaces: true, solids: true, other: false };
-    }
-    async onAgendaModified() {
-        // Filter changes to allow imprinting an open path, invalidate cached accept status...
-        if (ImprintSolidMethod.Element === this.method && (this.agenda.isEmpty || 1 === this.agenda.length))
-            this.onGeometryCacheFilterChanged();
-    }
-    async createSubEntityData(id, hit) {
-        const data = await super.createSubEntityData(id, hit);
-        if (undefined !== hit.point && undefined !== hit.normal)
-            data.toolData = FaceLocationData.create(hit.point, hit.normal);
-        return data;
-    }
-    async applyAgendaOperation(_ev, isAccept) {
-        if (!isAccept || this.agenda.length < this.requiredElementCount)
-            return undefined;
-        const id = this.agenda.elements[0];
-        try {
-            this._startedCmd = await this.startCommand();
-            let params;
-            if (ImprintSolidMethod.Points === this.method) {
-                if (!this.haveAcceptedSubEntities)
-                    return undefined;
-                const geom = ElementGeometry.fromGeometryQuery(LineString3d.create(this.points));
-                if (undefined === geom)
-                    return undefined;
-                params = { imprint: geom, face: this.getAcceptedSubEntityData(0)?.props, extend: this.extend ? true : undefined };
-            }
-            else if (ImprintSolidMethod.Edges === this.method) {
-                if (!this.haveAcceptedSubEntities)
-                    return undefined;
-                // TODO: Include all accepted edges...
-                const edge = this.getAcceptedSubEntityData(0)?.props;
-                if (undefined === edge)
-                    return undefined;
-                const edgeFaces = await solidModelingIpc.getConnectedSubEntities(id, edge, SubEntityType.Face);
-                if (undefined === edgeFaces || 0 === edgeFaces.length)
-                    return undefined;
-                // TODO: Check planar face...get preferred face from cursor location in dynamics, etc.
-                const edgeLoop = await solidModelingIpc.getConnectedSubEntities(id, edge, SubEntityType.Edge, { loopFace: edgeFaces[0] });
-                if (undefined === edgeLoop || 0 === edgeLoop.length)
-                    return undefined;
-                params = { imprint: edgeLoop, face: edgeFaces[0], distance: this.distance, extend: this.extend ? true : undefined };
-            }
-            else {
-                params = { imprint: this.agenda.elements[1], extend: this.extend ? true : undefined };
-            }
-            const opts = { writeChanges: true };
-            return await solidModelingIpc.imprintBody(id, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    onDynamicFrame(ev, context) {
-        if (ImprintSolidMethod.Points !== this.method || 0 === this.points.length)
-            return;
-        const pts = this.points.slice();
-        pts.push(ev.point.clone());
-        const builder = context.createGraphic({ type: GraphicType.WorldOverlay });
-        builder.setSymbology(context.viewport.getContrastToBackgroundColor(), ColorDef.black, 3);
-        builder.addLineString(pts);
-        context.addGraphic(builder.finish());
-    }
-    async gatherInput(ev) {
-        switch (this.method) {
-            case ImprintSolidMethod.Points: {
-                if (!this.haveAcceptedSubEntities)
-                    break;
-                this.points.push(ev.point.clone());
-                if (!ev.isControlKey)
-                    break;
-                this.setupAndPromptForNextAction();
-                return EventHandled.No;
-            }
-            default:
-                break;
-        }
-        return super.gatherInput(ev);
-    }
-    get wantAdditionalInput() {
-        switch (this.method) {
-            case ImprintSolidMethod.Element:
-                return false;
-            case ImprintSolidMethod.Edges:
-                return super.wantAdditionalInput;
-            case ImprintSolidMethod.Points:
-                return super.wantAdditionalInput || this.points.length < 2;
-        }
-    }
-    setupAccuDraw() {
-        if (ImprintSolidMethod.Points !== this.method || 0 !== this.points.length)
-            return;
-        if (!this.haveAcceptedSubEntities)
-            return;
-        const faceData = this.getAcceptedSubEntityData()?.toolData;
-        if (undefined === faceData)
-            return;
-        const hints = new AccuDrawHintBuilder();
-        hints.setModeRectangular();
-        hints.setOrigin(faceData.point);
-        hints.setNormal(faceData.normal);
-        hints.sendHints(false);
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        if (!this.changeToolSettingPropertyValue(updatedValue))
-            return false;
-        if (updatedValue.propertyName === this.methodProperty.name)
-            await this.onReinitialize();
-        return true;
-    }
-    supplyToolSettingsProperties() {
-        this.initializeToolSettingPropertyValues([this.methodProperty, this.extendProperty, this.distanceProperty]);
-        const toolSettings = new Array();
-        toolSettings.push(this.methodProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        switch (this.method) {
-            case ImprintSolidMethod.Element:
-                toolSettings.push(this.extendProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-                break;
-            case ImprintSolidMethod.Edges:
-                toolSettings.push(this.distanceProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-                break;
-            case ImprintSolidMethod.Points:
-                toolSettings.push(this.extendProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-                break;
-        }
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new ImprintSolidElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-ImprintSolidElementsTool.toolId = "ImprintSolids";
-ImprintSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-ImprintSolidElementsTool.getMethodChoices = () => {
-    return [
-        { label: ImprintSolidElementsTool.methodMessage("Element"), value: ImprintSolidMethod.Element },
-        { label: ImprintSolidElementsTool.methodMessage("Edges"), value: ImprintSolidMethod.Edges },
-        { label: ImprintSolidElementsTool.methodMessage("Points"), value: ImprintSolidMethod.Points },
-    ];
-};
-export { ImprintSolidElementsTool };
-/** @alpha Base class for tools to identify edges of solids and surfaces and apply blends. */
-export class BlendEdgesTool extends LocateSubEntityTool {
-    get addSmoothProperty() {
-        if (!this._addSmoothProperty)
-            this._addSmoothProperty = new DialogProperty(PropertyDescriptionHelper.buildToggleDescription("blendSmooth", EditTools.translate("RoundEdges.Label.AddSmooth")), false);
-        return this._addSmoothProperty;
-    }
-    get addSmooth() { return this.addSmoothProperty.value; }
-    set addSmooth(value) { this.addSmoothProperty.value = value; }
-    wantSubEntityType(type) { return SubEntityType.Edge === type; }
-    getSubEntityFilter() {
-        return { laminarEdges: true, smoothEdges: true };
-    }
-    get geometryCacheFilter() {
-        return { parts: true, curves: false, surfaces: true, solids: true, other: false };
-    }
-    async getTangentEdges(id, edge) {
-        try {
-            return await solidModelingIpc.getConnectedSubEntities(id, edge, SubEntityType.Edge, { smoothEdges: true });
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async addTangentEdges(id, edge, chordTolerance) {
-        if (undefined === edge) {
-            this._acceptedSubEntities.forEach(async (accepted) => {
-                if (undefined === accepted.toolData)
-                    await this.addTangentEdges(id, accepted.props, accepted.chordTolerance);
-            });
-            return;
-        }
-        const tangentEdges = await this.getTangentEdges(id, edge);
-        if (undefined === tangentEdges)
-            return;
-        tangentEdges.forEach(async (entry) => {
-            if (!isSameSubEntity(entry, edge)) {
-                const data = new SubEntityData(entry);
-                data.toolData = edge; // Mark edge so we know it was added as tangent edge...
-                await this.createSubEntityGraphic(id, data, chordTolerance);
-                this._acceptedSubEntities.push(data);
-            }
-        });
-    }
-    async removeTangentEdges(_id, edge) {
-        if (undefined === edge) {
-            this._acceptedSubEntities = this._acceptedSubEntities.filter((entry) => undefined === entry.toolData);
-            return;
-        }
-        const edgeData = this._acceptedSubEntities.find((entry) => isSameSubEntity(entry.props, edge));
-        if (undefined === edgeData)
-            return undefined;
-        const isTangentEdge = (other) => {
-            const primaryOther = (undefined !== other.toolData ? other.toolData : other.props);
-            return isSameSubEntity(primaryEdge, primaryOther);
-        };
-        const primaryEdge = (undefined !== edgeData.toolData ? edgeData.toolData : edgeData.props);
-        this._acceptedSubEntities = this._acceptedSubEntities.filter((entry) => !isTangentEdge(entry));
-    }
-    async syncTangentEdges() {
-        const id = this.getCurrentElement();
-        if (undefined === id)
-            return;
-        if (this.addSmooth)
-            await this.addTangentEdges(id);
-        else
-            await this.removeTangentEdges(id);
-        IModelApp.viewManager.invalidateDecorationsAllViews();
-    }
-    async addSubEntity(id, props) {
-        await super.addSubEntity(id, props);
-        if (!this.addSmooth)
-            return;
-        const chordTolerance = (this.targetView ? computeChordToleranceFromPoint(this.targetView, Point3d.fromJSON(props.point)) : undefined);
-        return this.addTangentEdges(id, props.subEntity, chordTolerance);
-    }
-    async removeSubEntity(id, props) {
-        if (!this.addSmooth)
-            return super.removeSubEntity(id, props);
-        const edge = (undefined !== props) ? props.subEntity : this.getAcceptedSubEntityData()?.props;
-        if (undefined === edge)
-            return;
-        return this.removeTangentEdges(id, edge);
-    }
-    getAcceptedSubEntities() {
-        const edges = [];
-        this._acceptedSubEntities.forEach((entry) => {
-            if (undefined === entry.toolData)
-                edges.push(entry.props);
-        });
-        return edges;
-    }
-}
-/** @alpha Identify edges of solids and surfaces to apply a rolling ball blend to. */
-class RoundEdgesTool extends BlendEdgesTool {
-    get radiusProperty() {
-        if (!this._radiusProperty)
-            this._radiusProperty = new DialogProperty(new LengthDescription("roundRadius", EditTools.translate("RoundEdges.Label.Radius")), 0.1, undefined);
-        return this._radiusProperty;
-    }
-    get radius() { return this.radiusProperty.value; }
-    set radius(value) { this.radiusProperty.value = value; }
-    async applyAgendaOperation(ev, isAccept) {
-        if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const params = { edges: this.getAcceptedSubEntities(), radii: this.radius, propagateSmooth: this.addSmooth };
-            const opts = {
-                wantGraphic: isAccept ? undefined : true,
-                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
-                requestId: `${this.toolId}:${this.agenda.elements[0]}`,
-                writeChanges: isAccept ? true : undefined,
-            };
-            return await solidModelingIpc.blendEdges(this.agenda.elements[0], params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        if (!this.changeToolSettingPropertyValue(updatedValue))
-            return false;
-        if (updatedValue.propertyName === this.addSmoothProperty.name)
-            await this.syncTangentEdges();
-        return true;
-    }
-    supplyToolSettingsProperties() {
-        this.initializeToolSettingPropertyValues([this.radiusProperty, this.addSmoothProperty]);
-        const toolSettings = new Array();
-        toolSettings.push(this.radiusProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        toolSettings.push(this.addSmoothProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new RoundEdgesTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-RoundEdgesTool.toolId = "RoundEdges";
-RoundEdgesTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { RoundEdgesTool };
-/** @alpha Identify edges of solids and surfaces to apply a rolling ball blend to. */
-class ChamferEdgesTool extends BlendEdgesTool {
-    static methodMessage(str) { return EditTools.translate(`ChamferEdges.Method.${str}`); }
-    get methodProperty() {
-        if (!this._methodProperty)
-            this._methodProperty = new DialogProperty(PropertyDescriptionHelper.buildEnumPicklistEditorDescription("chamferMethod", EditTools.translate("ChamferEdges.Label.Method"), ChamferEdgesTool.getMethodChoices()), ChamferMode.Length);
-        return this._methodProperty;
-    }
-    get method() { return this.methodProperty.value; }
-    set method(method) { this.methodProperty.value = method; }
-    get lengthProperty() {
-        if (!this._lengthProperty)
-            this._lengthProperty = new DialogProperty(new LengthDescription("chamferLength", EditTools.translate("ChamferEdges.Label.Length")), 0.1, undefined);
-        return this._lengthProperty;
-    }
-    get length() { return this.lengthProperty.value; }
-    set length(value) { this.lengthProperty.value = value; }
-    get distanceLeftProperty() {
-        if (!this._distanceLeftProperty)
-            this._distanceLeftProperty = new DialogProperty(new LengthDescription("chamferLeftDist", EditTools.translate("ChamferEdges.Label.LeftDistance")), 0.1, undefined);
-        return this._distanceLeftProperty;
-    }
-    get distanceLeft() { return this.distanceLeftProperty.value; }
-    set distanceLeft(value) { this.distanceLeftProperty.value = value; }
-    get distanceRightProperty() {
-        if (!this._distanceRightProperty)
-            this._distanceRightProperty = new DialogProperty(new LengthDescription("chamferRightDist", EditTools.translate("ChamferEdges.Label.RightDistance")), 0.1, undefined);
-        return this._distanceRightProperty;
-    }
-    get distanceRight() { return this.distanceRightProperty.value; }
-    set distanceRight(value) { this.distanceRightProperty.value = value; }
-    get angleProperty() {
-        if (!this._angleProperty)
-            this._angleProperty = new DialogProperty(new AngleDescription("chamferAngle", EditTools.translate("ChamferEdges.Label.Angle")), Angle.piOver4Radians, undefined, false);
-        return this._angleProperty;
-    }
-    get angle() { return this.angleProperty.value; }
-    set angle(value) { this.angleProperty.value = value; }
-    async applyAgendaOperation(ev, isAccept) {
-        if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            let values1;
-            let values2;
-            switch (this.method) {
-                case ChamferMode.Length:
-                    values1 = this.length;
-                    break;
-                case ChamferMode.Distances:
-                    values1 = this.distanceLeft;
-                    values2 = this.distanceRight;
-                    break;
-                case ChamferMode.DistanceAngle:
-                    values1 = this.distanceLeft;
-                    values2 = this.angle;
-                    break;
-                case ChamferMode.AngleDistance:
-                    values1 = this.angle;
-                    values2 = this.distanceRight;
-                    break;
-                default:
-                    return undefined;
-            }
-            const params = { edges: this.getAcceptedSubEntities(), mode: this.method, values1, values2, propagateSmooth: this.addSmooth };
-            const opts = {
-                wantGraphic: isAccept ? undefined : true,
-                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
-                requestId: `${this.toolId}:${this.agenda.elements[0]}`,
-                writeChanges: isAccept ? true : undefined,
-            };
-            return await solidModelingIpc.chamferEdges(this.agenda.elements[0], params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        if (!this.changeToolSettingPropertyValue(updatedValue))
-            return false;
-        if (updatedValue.propertyName === this.methodProperty.name)
-            await this.onReinitialize();
-        return true;
-    }
-    supplyToolSettingsProperties() {
-        this.initializeToolSettingPropertyValues([this.methodProperty, this.addSmoothProperty, this.lengthProperty, this.distanceLeftProperty, this.distanceRightProperty, this.angleProperty]);
-        const toolSettings = new Array();
-        toolSettings.push(this.methodProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        toolSettings.push(this.addSmoothProperty.toDialogItem({ rowPriority: ChamferMode.Length === this.method ? 3 : 4, columnIndex: 0 }));
-        switch (this.method) {
-            case ChamferMode.Length:
-                toolSettings.push(this.lengthProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-                break;
-            case ChamferMode.Distances:
-                toolSettings.push(this.distanceLeftProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-                toolSettings.push(this.distanceRightProperty.toDialogItem({ rowPriority: 3, columnIndex: 0 }));
-                break;
-            case ChamferMode.DistanceAngle:
-                toolSettings.push(this.distanceLeftProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-                toolSettings.push(this.angleProperty.toDialogItem({ rowPriority: 3, columnIndex: 0 }));
-                break;
-            case ChamferMode.AngleDistance:
-                toolSettings.push(this.distanceRightProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-                toolSettings.push(this.angleProperty.toDialogItem({ rowPriority: 3, columnIndex: 0 }));
-                break;
-        }
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new ChamferEdgesTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-ChamferEdgesTool.toolId = "ChamferEdges";
-ChamferEdgesTool.iconSpec = "icon-move"; // TODO: Need better icon...
-ChamferEdgesTool.getMethodChoices = () => {
-    return [
-        { label: ChamferEdgesTool.methodMessage("Length"), value: ChamferMode.Length },
-        { label: ChamferEdgesTool.methodMessage("Distances"), value: ChamferMode.Distances },
-        { label: ChamferEdgesTool.methodMessage("DistanceAngle"), value: ChamferMode.DistanceAngle },
-        { label: ChamferEdgesTool.methodMessage("AngleDistance"), value: ChamferMode.AngleDistance },
-    ];
-};
-export { ChamferEdgesTool };
-/** @alpha */
-export class ProfileLocationData {
-    constructor(point, orientation) {
-        this.point = point;
-        this.orientation = orientation;
-    }
-}
-/** @alpha Base class for picking profiles (open paths and regions) or faces of solids. */
-export class LocateFaceOrProfileTool extends LocateSubEntityTool {
-    get wantGeometrySummary() { return true; }
-    wantSubEntityType(type) {
-        switch (type) {
-            case SubEntityType.Face:
-            case SubEntityType.Edge:
-                // Choose all faces or all edges...
-                return (0 === this._acceptedSubEntities.length || this._acceptedSubEntities[0].props.type === type);
-            default:
-                return false;
-        }
-    }
-    get geometryCacheFilter() {
-        return { parts: true, curves: true, surfaces: true, solids: true, other: false };
-    }
-    async doPickSubEntities(id, ev) {
-        const hits = await super.doPickSubEntities(id, ev);
-        if (undefined === hits)
-            return hits;
-        // Only want edges from wire bodies...
-        const accept = (BRepEntityType.Wire === this.getBRepEntityTypeForSubEntity(id, hits[0].subEntity) ? SubEntityType.Edge : SubEntityType.Face);
-        return hits.filter((hit) => accept === hit.subEntity.type);
-    }
-    async createSubEntityData(id, hit) {
-        const data = await super.createSubEntityData(id, hit);
-        // Prefer orientation from snap to take entire path curve as well as placement z into account...
-        const snap = TentativeOrAccuSnap.getCurrentSnap(false);
-        const point = (id === snap?.sourceId && snap.isHot ? snap.snapPoint : Point3d.fromJSON(hit.point));
-        const matrix = (id === snap?.sourceId ? AccuDraw.getSnapRotation(snap, undefined) : undefined);
-        const invMatrix = matrix?.inverse(); // getSnapRotation returns row matrix...
-        if (undefined !== invMatrix)
-            data.toolData = new ProfileLocationData(point, invMatrix);
-        else
-            data.toolData = new ProfileLocationData(point, undefined !== hit.normal ? Vector3d.fromJSON(hit.normal) : Vector3d.unitZ());
-        return data;
-    }
-    drawSubEntity(context, subEntity, accepted) {
-        const id = this.getCurrentElement();
-        if (undefined !== id && BRepEntityType.Solid !== this.getBRepEntityTypeForSubEntity(id, subEntity.props))
-            return; // Operation will be applied to wire or sheet body, don't display sub-entity...
-        super.drawSubEntity(context, subEntity, accepted);
-    }
-    drawAcceptedSubEntities(context) {
-        super.drawAcceptedSubEntities(context);
-        // Show pick point on last identified face...
-        const profileData = this.getAcceptedSubEntityData()?.toolData;
-        if (undefined === profileData)
-            return;
-        const builder = context.createGraphic({ type: GraphicType.WorldOverlay });
-        builder.setSymbology(context.viewport.getContrastToBackgroundColor(), ColorDef.black, 10);
-        builder.addPointString([profileData.point]);
-        context.addDecorationFromBuilder(builder);
-    }
-}
-/** @alpha Identify faces of solids and surfaces to translate. */
-class SweepFacesTool extends LocateFaceOrProfileTool {
-    get wantDynamics() { return true; }
-    get wantAccuSnap() { return true; }
-    get wantSubEntitySnap() { return true; }
-    get addSmoothProperty() {
-        if (!this._addSmoothProperty)
-            this._addSmoothProperty = new DialogProperty(PropertyDescriptionHelper.buildToggleDescription("sweepSmooth", EditTools.translate("SweepFaces.Label.AddSmooth")), false);
-        return this._addSmoothProperty;
-    }
-    get addSmooth() { return this.addSmoothProperty.value; }
-    set addSmooth(value) { this.addSmoothProperty.value = value; }
-    get useDistanceProperty() {
-        if (!this._useDistanceProperty)
-            this._useDistanceProperty = new DialogProperty(PropertyDescriptionHelper.buildLockPropertyDescription("useOffsetDistance"), false);
-        return this._useDistanceProperty;
-    }
-    get useDistance() { return this.useDistanceProperty.value; }
-    set useDistance(value) { this.useDistanceProperty.value = value; }
-    get distanceProperty() {
-        if (!this._distanceProperty)
-            this._distanceProperty = new DialogProperty(new LengthDescription("sweepDistance", EditTools.translate("SweepFaces.Label.Distance")), 0.1, undefined, !this.useDistance);
-        return this._distanceProperty;
-    }
-    get distance() { return this.distanceProperty.value; }
-    set distance(value) { this.distanceProperty.value = value; }
-    async getSmoothFaces(id, face) {
-        try {
-            // NOTE: For sweep/translation, it makes sense to limit smooth to immediately adjacent...
-            return await solidModelingIpc.getConnectedSubEntities(id, face, SubEntityType.Face, { smoothFaces: true, adjacentFaces: true });
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async applyAgendaOperation(ev, isAccept) {
-        if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities)
-            return undefined;
-        const profileData = this.getAcceptedSubEntityData()?.toolData;
-        if (undefined === profileData)
-            return undefined;
-        const path = Vector3d.createStartEnd(profileData.point, ev.point);
-        if (this.useDistance && undefined === path.scaleToLength(this.distance, path))
-            return undefined;
-        if (path.magnitude() < Geometry.smallMetricDistance)
-            return undefined;
-        if (!this.useDistance) {
-            this.distance = path.magnitude();
-            this.syncToolSettingPropertyValue(this.distanceProperty);
-            if (isAccept)
-                this.saveToolSettingPropertyValue(this.distanceProperty, this.distanceProperty.dialogItemValue);
-        }
-        try {
-            this._startedCmd = await this.startCommand();
-            const id = this.agenda.elements[0];
-            const opts = {
-                wantGraphic: isAccept ? undefined : true,
-                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
-                requestId: `${this.toolId}:${id}`,
-                writeChanges: isAccept ? true : undefined,
-            };
-            const subEntities = this.getAcceptedSubEntities();
-            const params = { path };
-            if (SubEntityType.Edge === subEntities[0].type || BRepEntityType.Solid !== this.getBRepEntityTypeForSubEntity(id, subEntities[0])) {
-                return await solidModelingIpc.sweepFaces(id, params, opts);
-            }
-            if (this.addSmooth) {
-                const allSmoothFaces = [];
-                for (const face of subEntities) {
-                    const smoothFaces = await this.getSmoothFaces(id, face);
-                    if (undefined !== smoothFaces)
-                        allSmoothFaces.push(...smoothFaces);
-                }
-                for (const smooth of allSmoothFaces) {
-                    if (undefined === subEntities.find((selected) => isSameSubEntity(selected, smooth)))
-                        subEntities.unshift(smooth); // Preserve last selected entry as reference face...
-                }
-            }
-            params.faces = subEntities;
-            return await solidModelingIpc.sweepFaces(id, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    setupAccuDraw() {
-        if (!this.haveAcceptedSubEntities)
-            return;
-        const profileData = this.getAcceptedSubEntityData()?.toolData;
-        if (undefined === profileData)
-            return;
-        const hints = new AccuDrawHintBuilder();
-        hints.setOriginFixed = true;
-        hints.setLockY = true;
-        hints.setLockZ = true;
-        hints.setModeRectangular();
-        hints.setOrigin(profileData.point);
-        hints.setXAxis2(profileData.orientation instanceof Matrix3d ? profileData.orientation.getColumn(2) : profileData.orientation);
-        hints.sendHints(false);
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        return this.changeToolSettingPropertyValue(updatedValue);
-    }
-    supplyToolSettingsProperties() {
-        this.initializeToolSettingPropertyValues([this.addSmoothProperty, this.useDistanceProperty, this.distanceProperty]);
-        const toolSettings = new Array();
-        // ensure controls are enabled/disabled based on current lock property state
-        this.distanceProperty.isDisabled = !this.useDistance;
-        const useDistanceLock = this.useDistanceProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 });
-        toolSettings.push(this.distanceProperty.toDialogItem({ rowPriority: 1, columnIndex: 1 }, useDistanceLock));
-        toolSettings.push(this.addSmoothProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new SweepFacesTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-SweepFacesTool.toolId = "SweepFaces";
-SweepFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { SweepFacesTool };
-/** @alpha Identify faces of solids and surfaces to revolve. */
-class SpinFacesTool extends LocateFaceOrProfileTool {
-    constructor() {
-        super(...arguments);
-        this.points = [];
-    }
-    get angleProperty() {
-        if (!this._angleProperty)
-            this._angleProperty = new DialogProperty(new AngleDescription("spinAngle", EditTools.translate("SpinFaces.Label.Angle")), Angle.piOver2Radians, undefined, false);
-        return this._angleProperty;
-    }
-    get angle() { return this.angleProperty.value; }
-    set angle(value) { this.angleProperty.value = value; }
-    get wantDynamics() { return true; }
-    get wantAccuSnap() { return true; }
-    get wantSubEntitySnap() { return true; }
-    async applyAgendaOperation(ev, isAccept) {
-        if (undefined === ev.viewport || this.agenda.isEmpty || !this.haveAcceptedSubEntities || this.points.length < (isAccept ? 2 : 1))
-            return undefined;
-        const direction = Vector3d.createStartEnd(this.points[0], isAccept ? this.points[1] : ev.point);
-        if (direction.magnitude() < Geometry.smallMetricDistance)
-            return undefined;
-        const origin = this.points[0];
-        const angle = Angle.createRadians(this.angle);
-        try {
-            this._startedCmd = await this.startCommand();
-            const id = this.agenda.elements[0];
-            const opts = {
-                wantGraphic: isAccept ? undefined : true,
-                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
-                requestId: `${this.toolId}:${id}`,
-                writeChanges: isAccept ? true : undefined,
-            };
-            const subEntities = this.getAcceptedSubEntities();
-            const params = { origin, direction, angle };
-            if (SubEntityType.Edge === subEntities[0].type || BRepEntityType.Solid !== this.getBRepEntityTypeForSubEntity(id, subEntities[0])) {
-                return await solidModelingIpc.spinFaces(id, params, opts);
-            }
-            params.faces = subEntities;
-            let result = await solidModelingIpc.spinFaces(id, params, opts);
-            // Spun face can be used to create a pocket...retry with negative sweep...
-            if (undefined === result) {
-                angle.setRadians(-angle.radians);
-                result = await solidModelingIpc.spinFaces(id, params, opts);
-            }
-            return result;
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    onDynamicFrame(ev, context) {
-        if (0 === this.points.length)
-            return;
-        const pts = this.points.slice();
-        pts.push(ev.point.clone());
-        const builder = context.createGraphic({ type: GraphicType.WorldOverlay });
-        builder.setSymbology(context.viewport.getContrastToBackgroundColor(), ColorDef.black, 3);
-        builder.addLineString(pts);
-        context.addGraphic(builder.finish());
-        super.onDynamicFrame(ev, context);
-    }
-    async gatherInput(ev) {
-        if (!this.wantAdditionalSubEntities)
-            this.points.push(ev.point.clone());
-        return super.gatherInput(ev);
-    }
-    get wantAdditionalInput() {
-        return super.wantAdditionalInput || this.points.length < 2;
-    }
-    setupAccuDraw() {
-        if (!this.haveAcceptedSubEntities || 0 !== this.points.length)
-            return;
-        const profileData = this.getAcceptedSubEntityData()?.toolData;
-        if (undefined === profileData)
-            return;
-        const hints = new AccuDrawHintBuilder();
-        hints.setModeRectangular();
-        hints.setOrigin(profileData.point);
-        if (profileData.orientation instanceof Matrix3d)
-            hints.setMatrix(profileData.orientation);
-        else
-            hints.setNormal(profileData.orientation);
-        hints.sendHints(false);
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        return this.changeToolSettingPropertyValue(updatedValue);
-    }
-    supplyToolSettingsProperties() {
-        this.initializeToolSettingPropertyValues([this.angleProperty]);
-        const toolSettings = new Array();
-        toolSettings.push(this.angleProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 }));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new SpinFacesTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-SpinFacesTool.toolId = "SpinFaces";
-SpinFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
-export { SpinFacesTool };
-//# sourceMappingURL=SolidModelingTools.js.map