@itwin/editor-frontend 3.2.0-dev.5 → 3.2.0-dev.50

package/lib/cjs/ModifyCurveTools.js

@@ -0,0 +1,669 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendCurveTool = exports.BreakCurveTool = exports.OffsetCurveTool = exports.ModifyCurveTool = exports.CurveData = void 0;
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+const core_frontend_1 = require("@itwin/core-frontend");
+const core_common_1 = require("@itwin/core-common");
+const EditTool_1 = require("./EditTool");
+const core_geometry_1 = require("@itwin/core-geometry");
+const editor_common_1 = require("@itwin/editor-common");
+const CreateElementTool_1 = require("./CreateElementTool");
+const appui_abstract_1 = require("@itwin/appui-abstract");
+const core_bentley_1 = require("@itwin/core-bentley");
+/** @alpha */
+class CurveData {
+    constructor(props, params, geom) {
+        this.props = props;
+        this.params = params;
+        this.geom = geom;
+    }
+}
+exports.CurveData = CurveData;
+/** @alpha Base class for applying an offset to path and loops. */
+class ModifyCurveTool extends core_frontend_1.ElementSetTool {
+    constructor() {
+        super(...arguments);
+        this._checkedIds = new Map();
+        this._firstResult = true;
+    }
+    allowView(_vp) { return true; }
+    isCompatibleViewport(vp, isSelectedViewChange) { return (super.isCompatibleViewport(vp, isSelectedViewChange) && undefined !== vp && this.allowView(vp)); }
+    async startCommand() {
+        if (undefined !== this._startedCmd)
+            return this._startedCmd;
+        return EditTool_1.EditTools.startCommand(editor_common_1.editorBuiltInCmdIds.cmdBasicManipulation, this.iModel.key);
+    }
+    static callCommand(method, ...args) {
+        return EditTool_1.EditTools.callCommand(method, ...args);
+    }
+    agendaAppearance(isDynamics) {
+        if (isDynamics) {
+            if (undefined === this._agendaAppearanceDynamic)
+                this._agendaAppearanceDynamic = core_common_1.FeatureAppearance.fromTransparency(0.0);
+            return this._agendaAppearanceDynamic;
+        }
+        if (undefined === this._agendaAppearanceDefault)
+            this._agendaAppearanceDefault = core_common_1.FeatureAppearance.fromTransparency(0.9);
+        return this._agendaAppearanceDefault;
+    }
+    get wantAgendaAppearanceOverride() { return false; }
+    addFeatureOverrides(overrides, _vp) {
+        if (this.agenda.isEmpty)
+            return;
+        const appearance = this.agendaAppearance(false);
+        this.agenda.elements.forEach((elementId) => { overrides.override({ elementId, appearance }); });
+    }
+    updateAgendaAppearanceProvider(drop) {
+        if (!this.wantAgendaAppearanceOverride)
+            return;
+        for (const vp of core_frontend_1.IModelApp.viewManager) {
+            if (!this.allowView(vp))
+                continue;
+            if (drop || this.agenda.isEmpty)
+                vp.dropFeatureOverrideProvider(this);
+            else if (!vp.addFeatureOverrideProvider(this))
+                vp.setFeatureOverrideProviderChanged();
+        }
+    }
+    clearGraphics() {
+        if (undefined === this._graphicsProvider)
+            return;
+        this._graphicsProvider.cleanupGraphic();
+        this._graphicsProvider = undefined;
+    }
+    async createGraphics(ev) {
+        if (!core_frontend_1.IModelApp.viewManager.inDynamicsMode)
+            return; // Don't need to create graphic if dynamics aren't yet active...
+        const geometry = this.getGeometryProps(ev, false);
+        if (undefined === geometry)
+            return;
+        const elemProps = this.getElementProps(ev);
+        if (undefined === (elemProps === null || elemProps === void 0 ? void 0 : elemProps.placement))
+            return;
+        if (undefined === this._graphicsProvider) {
+            if (this._firstResult) {
+                this.updateAgendaAppearanceProvider();
+                this._firstResult = false;
+            }
+            this._graphicsProvider = new CreateElementTool_1.DynamicGraphicsProvider(this.iModel, this.toolId);
+        }
+        // Set chord tolerance for non-linear curve primitives...
+        if (ev.viewport)
+            this._graphicsProvider.chordTolerance = (0, CreateElementTool_1.computeChordToleranceFromPoint)(ev.viewport, ev.point);
+        await this._graphicsProvider.createGraphic(elemProps.category, elemProps.placement, geometry);
+    }
+    static isSingleCurve(info) {
+        const it = new core_common_1.ElementGeometry.Iterator(info);
+        it.requestWorldCoordinates();
+        for (const entry of it) {
+            const geom = entry.toGeometryQuery();
+            if (undefined === geom)
+                return;
+            if ("curvePrimitive" === geom.geometryCategory) {
+                return { curve: geom, params: entry.geomParams };
+            }
+            else if ("curveCollection" === geom.geometryCategory) {
+                return { curve: geom, params: entry.geomParams };
+            }
+            break;
+        }
+        return;
+    }
+    acceptCurve(_curve) { return true; }
+    modifyCurve(_ev, _isAccept) { return undefined; }
+    async getCurveData(id) {
+        try {
+            this._startedCmd = await this.startCommand();
+            const reject = [core_common_1.ElementGeometryOpcode.Polyface, core_common_1.ElementGeometryOpcode.SolidPrimitive, core_common_1.ElementGeometryOpcode.BsplineSurface, core_common_1.ElementGeometryOpcode.BRep];
+            const info = await ModifyCurveTool.callCommand("requestElementGeometry", id, { maxDisplayable: 1, reject, geometry: { curves: true, surfaces: true, solids: false } });
+            if (undefined === info)
+                return undefined;
+            const data = ModifyCurveTool.isSingleCurve(info);
+            if (undefined === data)
+                return undefined;
+            if (!this.acceptCurve(data.curve))
+                return undefined;
+            const props = await this.iModel.elements.loadProps(id);
+            if (undefined === props)
+                return undefined;
+            return new CurveData(props, data.params, data.curve);
+        }
+        catch (err) {
+            core_frontend_1.IModelApp.notifications.outputMessage(new core_frontend_1.NotifyMessageDetails(core_frontend_1.OutputMessagePriority.Error, core_common_1.BentleyError.getErrorMessage(err)));
+            return undefined;
+        }
+    }
+    onGeometryFilterChanged() { this._checkedIds.clear(); }
+    async acceptElementForOperation(id) {
+        if (core_bentley_1.Id64.isInvalid(id) || core_bentley_1.Id64.isTransient(id))
+            return false;
+        let accept = this._checkedIds.get(id);
+        if (undefined === accept) {
+            if (this.agenda.isEmpty && this._checkedIds.size > 1000)
+                this._checkedIds.clear(); // Limit auto-locate cache size to something reasonable...
+            accept = (undefined !== await this.getCurveData(id));
+            this._checkedIds.set(id, accept);
+        }
+        return accept;
+    }
+    async isElementValidForOperation(hit, out) {
+        if (!await super.isElementValidForOperation(hit, out))
+            return false;
+        return this.acceptElementForOperation(hit.sourceId);
+    }
+    async onAgendaModified() {
+        this.curveData = undefined;
+        if (this.agenda.isEmpty)
+            return;
+        const id = this.agenda.elements[this.agenda.length - 1];
+        this.curveData = await this.getCurveData(id);
+    }
+    onDynamicFrame(_ev, context) {
+        if (undefined !== this._graphicsProvider)
+            this._graphicsProvider.addGraphic(context);
+    }
+    async onMouseMotion(ev) {
+        return this.createGraphics(ev);
+    }
+    setupAccuDraw() {
+        const hints = new core_frontend_1.AccuDrawHintBuilder();
+        hints.enableSmartRotation = true;
+        hints.sendHints(false);
+    }
+    setupAndPromptForNextAction() {
+        this.setupAccuDraw();
+        super.setupAndPromptForNextAction();
+    }
+    getGeometryProps(ev, isAccept) {
+        if (undefined === this.curveData)
+            return;
+        const offset = this.modifyCurve(ev, isAccept);
+        if (undefined === offset)
+            return;
+        const builder = new core_common_1.ElementGeometry.Builder();
+        builder.setLocalToWorldFromPlacement(this.curveData.props.placement);
+        if (!builder.appendGeometryParamsChange(this.curveData.params))
+            return;
+        if (!builder.appendGeometryQuery(offset))
+            return;
+        return { format: "flatbuffer", data: builder.entries };
+    }
+    getElementProps(ev) {
+        var _a;
+        if (undefined === this.curveData)
+            return;
+        if (!this.wantModifyOriginal) {
+            // Create result as new element with same model and category as original...
+            const classFullName = (((_a = ev.viewport) === null || _a === void 0 ? void 0 : _a.view.is3d()) ? "Generic:PhysicalObject" : "BisCore:DrawingGraphic");
+            return { classFullName, model: this.curveData.props.model, category: this.curveData.props.category, code: core_common_1.Code.createEmpty(), placement: this.curveData.props.placement };
+        }
+        return this.curveData.props;
+    }
+    async applyAgendaOperation(ev) {
+        const geometry = this.getGeometryProps(ev, true);
+        if (undefined === geometry)
+            return false;
+        const elemProps = this.getElementProps(ev);
+        if (undefined === elemProps)
+            return false;
+        if ("flatbuffer" === geometry.format)
+            elemProps.elementGeometryBuilderParams = { entryArray: geometry.data };
+        else
+            elemProps.geom = geometry.data;
+        try {
+            this._startedCmd = await this.startCommand();
+            if (undefined === elemProps.id) {
+                const repeatOperation = this.wantContinueWithPreviousResult;
+                if (repeatOperation)
+                    this.agenda.clear();
+                const newId = await ModifyCurveTool.callCommand("insertGeometricElement", elemProps);
+                if (repeatOperation && this.agenda.add(newId))
+                    await this.onAgendaModified();
+            }
+            else {
+                await ModifyCurveTool.callCommand("updateGeometricElement", elemProps);
+            }
+            return true;
+        }
+        catch (err) {
+            core_frontend_1.IModelApp.notifications.outputMessage(new core_frontend_1.NotifyMessageDetails(core_frontend_1.OutputMessagePriority.Error, core_common_1.BentleyError.getErrorMessage(err) || "An unknown error occurred."));
+            return false;
+        }
+    }
+    async processAgenda(ev) {
+        if (await this.applyAgendaOperation(ev))
+            return this.saveChanges();
+    }
+    get wantModifyOriginal() { return true; }
+    get wantContinueWithPreviousResult() { return false; }
+    async onProcessComplete() {
+        // Don't restart tool want to continue operation using previous result...
+        if (this.wantContinueWithPreviousResult && !this.agenda.isEmpty && undefined !== this.curveData)
+            return;
+        return super.onProcessComplete();
+    }
+    async onUnsuspend() {
+        if (!this._firstResult)
+            this.updateAgendaAppearanceProvider();
+        return super.onUnsuspend();
+    }
+    async onSuspend() {
+        if (!this._firstResult)
+            this.updateAgendaAppearanceProvider(true);
+        return super.onSuspend();
+    }
+    async onPostInstall() {
+        await super.onPostInstall();
+        if (this.wantAgendaAppearanceOverride)
+            this.agenda.manageHiliteState = false;
+    }
+    async onCleanup() {
+        this.clearGraphics();
+        this.updateAgendaAppearanceProvider(true);
+        return super.onCleanup();
+    }
+}
+exports.ModifyCurveTool = ModifyCurveTool;
+/** @alpha Tool for applying an offset to paths and loops. */
+class OffsetCurveTool extends ModifyCurveTool {
+    get wantAccuSnap() { return true; }
+    get wantDynamics() { return true; }
+    get useDistanceProperty() {
+        if (!this._useDistanceProperty)
+            this._useDistanceProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.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 appui_abstract_1.DialogProperty(new core_frontend_1.LengthDescription("offsetDistance", EditTool_1.EditTools.translate("OffsetCurve.Label.Distance")), 0.1, undefined, !this.useDistance);
+        return this._distanceProperty;
+    }
+    get distance() { return this.distanceProperty.value; }
+    set distance(value) { this.distanceProperty.value = value; }
+    get makeCopyProperty() {
+        if (!this._makeCopyProperty)
+            this._makeCopyProperty = new appui_abstract_1.DialogProperty(appui_abstract_1.PropertyDescriptionHelper.buildToggleDescription("offsetCopy", EditTool_1.EditTools.translate("OffsetCurve.Label.MakeCopy")), false);
+        return this._makeCopyProperty;
+    }
+    get makeCopy() { return this.makeCopyProperty.value; }
+    set makeCopy(value) { this.makeCopyProperty.value = value; }
+    getToolSettingPropertyLocked(property) {
+        return (property === this.useDistanceProperty ? this.distanceProperty : undefined);
+    }
+    async applyToolSettingPropertyChange(updatedValue) {
+        return this.changeToolSettingPropertyValue(updatedValue);
+    }
+    supplyToolSettingsProperties() {
+        this.initializeToolSettingPropertyValues([this.makeCopyProperty, 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.makeCopyProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 }));
+        return toolSettings;
+    }
+    acceptCurve(curve) {
+        if ("curvePrimitive" === curve.geometryCategory)
+            return true;
+        switch (curve.curveCollectionType) {
+            case "path":
+            case "loop":
+                return true;
+            default:
+                return false;
+        }
+    }
+    modifyCurve(ev, isAccept) {
+        var _a;
+        if (undefined === ev.viewport)
+            return undefined;
+        const geom = (_a = this.curveData) === null || _a === void 0 ? void 0 : _a.geom;
+        if (undefined === geom)
+            return undefined;
+        const matrix = core_frontend_1.AccuDrawHintBuilder.getCurrentRotation(ev.viewport, true, true);
+        const localToWorld = core_geometry_1.FrameBuilder.createRightHandedFrame(matrix === null || matrix === void 0 ? void 0 : matrix.getColumn(2), geom);
+        if (undefined === localToWorld)
+            return undefined;
+        const worldToLocal = localToWorld.inverse();
+        if (undefined === worldToLocal)
+            return undefined;
+        const geomXY = ((geom instanceof core_geometry_1.CurvePrimitive) ? core_geometry_1.Path.create(geom) : geom).cloneTransformed(worldToLocal);
+        if (undefined === geomXY)
+            return undefined;
+        const spacePoint = core_frontend_1.AccuDrawHintBuilder.projectPointToPlaneInView(ev.point, localToWorld.getOrigin(), localToWorld.matrix.getColumn(2), ev.viewport);
+        if (undefined === spacePoint)
+            return undefined;
+        worldToLocal.multiplyPoint3d(spacePoint, spacePoint);
+        spacePoint.z = 0.0;
+        const closeDetail = geomXY.closestPoint(spacePoint);
+        if (undefined === (closeDetail === null || closeDetail === void 0 ? void 0 : closeDetail.curve))
+            return undefined;
+        const unitZ = core_geometry_1.Vector3d.unitZ();
+        const unitX = closeDetail.curve.fractionToPointAndUnitTangent(closeDetail.fraction).direction;
+        const unitY = unitZ.unitCrossProduct(unitX);
+        if (undefined === unitY)
+            return undefined;
+        let distance = closeDetail.point.distance(spacePoint);
+        const refDir = core_geometry_1.Vector3d.createStartEnd(closeDetail.point, spacePoint);
+        if (refDir.dotProduct(unitY) < 0.0)
+            distance = -distance;
+        let offset = 0.0;
+        if (this.useDistance) {
+            offset = this.distance;
+            if ((offset < 0.0 && distance > 0.0) || (offset > 0.0 && distance < 0.0))
+                offset = -offset;
+        }
+        else {
+            offset = distance;
+        }
+        if (Math.abs(offset) < core_geometry_1.Geometry.smallMetricDistance)
+            return undefined;
+        if (offset !== this.distance) {
+            this.distance = offset;
+            this.syncToolSettingPropertyValue(this.distanceProperty);
+            if (isAccept)
+                this.saveToolSettingPropertyValue(this.distanceProperty, this.distanceProperty.dialogItemValue);
+        }
+        const jointOptions = new core_geometry_1.JointOptions(offset);
+        jointOptions.preserveEllipticalArcs = true;
+        const offsetGeom = core_geometry_1.RegionOps.constructCurveXYOffset(geomXY, jointOptions);
+        if (undefined === offsetGeom)
+            return undefined;
+        if (!offsetGeom.tryTransformInPlace(localToWorld))
+            return undefined;
+        if (geom instanceof core_geometry_1.CurvePrimitive && offsetGeom instanceof core_geometry_1.Path && 1 === offsetGeom.children.length)
+            return offsetGeom.getChild(0); // Don't create path for offset of single open curve...
+        return offsetGeom;
+    }
+    get wantModifyOriginal() {
+        return !this.makeCopy;
+    }
+    get wantContinueWithPreviousResult() {
+        return !this.wantModifyOriginal;
+    }
+    setupAccuDraw() {
+        var _a;
+        const hints = new core_frontend_1.AccuDrawHintBuilder();
+        if (this.agenda.isEmpty) {
+            hints.enableSmartRotation = true;
+        }
+        else if (undefined !== this.anchorPoint && undefined !== this.targetView) {
+            const geom = (_a = this.curveData) === null || _a === void 0 ? void 0 : _a.geom;
+            const closeDetail = (geom instanceof core_geometry_1.CurvePrimitive) ? geom.closestPoint(this.anchorPoint, false) : geom === null || geom === void 0 ? void 0 : geom.closestPoint(this.anchorPoint);
+            if (undefined !== (closeDetail === null || closeDetail === void 0 ? void 0 : closeDetail.curve)) {
+                const unitX = closeDetail.curve.fractionToPointAndUnitTangent(closeDetail.fraction).direction;
+                if (undefined !== unitX) {
+                    const matrix = core_frontend_1.AccuDrawHintBuilder.getCurrentRotation(this.targetView, true, true);
+                    const localToWorld = core_geometry_1.FrameBuilder.createRightHandedFrame(matrix === null || matrix === void 0 ? void 0 : matrix.getColumn(2), geom);
+                    if (undefined !== localToWorld) {
+                        const unitZ = localToWorld.matrix.getColumn(2);
+                        const frame = core_geometry_1.Matrix3d.createRigidFromColumns(unitX, unitZ, core_geometry_1.AxisOrder.XZY);
+                        if (undefined !== frame) {
+                            hints.setOrigin(closeDetail.point);
+                            hints.setMatrix(frame);
+                        }
+                    }
+                }
+            }
+        }
+        hints.sendHints(false);
+    }
+    provideToolAssistance(_mainInstrText, _additionalInstr) {
+        let mainMsg;
+        if (!this.agenda.isEmpty)
+            mainMsg = EditTool_1.EditTools.translate("OffsetCurve.Prompts.DefineOffset");
+        super.provideToolAssistance(mainMsg);
+    }
+    async onRestartTool() {
+        const tool = new OffsetCurveTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+exports.OffsetCurveTool = OffsetCurveTool;
+OffsetCurveTool.toolId = "OffsetCurve";
+OffsetCurveTool.iconSpec = "icon-scale"; // Need better icon...
+/** @alpha Tool for opening loops and splitting paths. */
+class BreakCurveTool extends ModifyCurveTool {
+    constructor() {
+        super(...arguments);
+        this.modifyOriginal = true;
+    }
+    get wantAccuSnap() { return true; }
+    get wantModifyOriginal() { return this.modifyOriginal; }
+    acceptCurve(curve) {
+        if ("curvePrimitive" === curve.geometryCategory)
+            return true;
+        switch (curve.curveCollectionType) {
+            case "path":
+            case "loop":
+                return true;
+            default:
+                return false;
+        }
+    }
+    doBreakCurve(ev) {
+        var _a;
+        this.resultA = this.resultB = undefined;
+        if (undefined === ev.viewport)
+            return;
+        const geom = (_a = this.curveData) === null || _a === void 0 ? void 0 : _a.geom;
+        if (undefined === geom)
+            return;
+        const closeDetail = (geom instanceof core_geometry_1.CurvePrimitive) ? geom.closestPoint(ev.point, false) : geom.closestPoint(ev.point);
+        if (undefined === (closeDetail === null || closeDetail === void 0 ? void 0 : closeDetail.curve))
+            return;
+        const selectedStart = (closeDetail.fraction <= core_geometry_1.Geometry.smallFraction);
+        const selectedEnd = (closeDetail.fraction >= (1.0 - core_geometry_1.Geometry.smallFraction));
+        if (geom instanceof core_geometry_1.CurvePrimitive) {
+            if (selectedStart || selectedEnd)
+                return; // split is no-op...
+            this.resultA = geom.clonePartialCurve(0.0, closeDetail.fraction);
+            this.resultB = geom.clonePartialCurve(closeDetail.fraction, 1.0);
+            return;
+        }
+        else if (geom instanceof core_geometry_1.Path) {
+            const firstCurve = geom.children[0];
+            const lastCurve = geom.children[geom.children.length - 1];
+            if ((closeDetail.curve === firstCurve && selectedStart) || (closeDetail.curve === lastCurve && selectedEnd))
+                return; // split is no-op...
+            let beforeCurve = true;
+            const resultA = core_geometry_1.Path.create();
+            const resultB = core_geometry_1.Path.create();
+            for (const curve of geom.children) {
+                if (curve === closeDetail.curve) {
+                    if (selectedStart) {
+                        resultB.children.push(curve.clone());
+                    }
+                    else if (selectedEnd) {
+                        resultA.children.push(curve.clone());
+                    }
+                    else {
+                        const curveA = curve.clonePartialCurve(0.0, closeDetail.fraction);
+                        if (undefined !== curveA)
+                            resultA.children.push(curveA);
+                        const curveB = curve.clonePartialCurve(closeDetail.fraction, 1.0);
+                        if (undefined !== curveB)
+                            resultB.children.push(curveB);
+                    }
+                    beforeCurve = false;
+                }
+                else {
+                    if (beforeCurve)
+                        resultA.children.push(curve.clone());
+                    else
+                        resultB.children.push(curve.clone());
+                }
+            }
+            this.resultA = resultA;
+            this.resultB = resultB;
+        }
+        else if (geom instanceof core_geometry_1.Loop) {
+            const closeIndex = geom.children.findIndex((child) => child === closeDetail.curve);
+            if (-1 === closeIndex)
+                return;
+            const endIndex = closeIndex + geom.children.length;
+            const resultA = core_geometry_1.Path.create(); // Result is always a single path...
+            if (selectedStart) {
+                resultA.children.push(closeDetail.curve.clone());
+            }
+            else if (!selectedEnd) {
+                const curveB = closeDetail.curve.clonePartialCurve(closeDetail.fraction, 1.0);
+                if (undefined !== curveB)
+                    resultA.children.push(curveB);
+            }
+            for (let index = closeIndex; index < endIndex; ++index) {
+                const curve = geom.cyclicCurvePrimitive(index);
+                if (undefined === curve || curve === closeDetail.curve)
+                    continue;
+                resultA.children.push(curve.clone());
+            }
+            if (selectedEnd) {
+                resultA.children.push(closeDetail.curve.clone());
+            }
+            else if (!selectedStart) {
+                const curveA = closeDetail.curve.clonePartialCurve(0.0, closeDetail.fraction);
+                if (undefined !== curveA)
+                    resultA.children.push(curveA);
+            }
+            this.resultA = resultA;
+        }
+    }
+    modifyCurve(_ev, _isAccept) {
+        return (this.wantModifyOriginal ? this.resultA : this.resultB);
+    }
+    async processAgenda(ev) {
+        this.doBreakCurve(ev);
+        if (undefined === this.resultA || !await this.applyAgendaOperation(ev))
+            return;
+        if (undefined !== this.resultB) {
+            this.modifyOriginal = false;
+            await this.applyAgendaOperation(ev);
+        }
+        return this.saveChanges();
+    }
+    provideToolAssistance(_mainInstrText, _additionalInstr) {
+        let mainMsg;
+        if (this.agenda.isEmpty)
+            mainMsg = EditTool_1.EditTools.translate("BreakCurve.Prompts.IdentifyBreak");
+        super.provideToolAssistance(mainMsg);
+    }
+    async onRestartTool() {
+        const tool = new BreakCurveTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+exports.BreakCurveTool = BreakCurveTool;
+BreakCurveTool.toolId = "BreakCurve";
+BreakCurveTool.iconSpec = "icon-scale"; // Need better icon...
+/** @alpha Tool for extending/shortening curves. */
+class ExtendCurveTool extends ModifyCurveTool {
+    get wantAccuSnap() { return true; }
+    get wantDynamics() { return true; }
+    get wantAgendaAppearanceOverride() { return true; }
+    acceptCurve(curve) {
+        if ("curvePrimitive" !== curve.geometryCategory)
+            return false;
+        return curve.isExtensibleFractionSpace;
+    }
+    modifyCurve(ev, _isAccept) {
+        var _a;
+        if (undefined === ev.viewport || undefined === this.anchorPoint)
+            return undefined;
+        const geom = (_a = this.curveData) === null || _a === void 0 ? void 0 : _a.geom;
+        if (undefined === geom)
+            return undefined;
+        const matrix = core_frontend_1.AccuDrawHintBuilder.getCurrentRotation(ev.viewport, true, true);
+        const localToWorld = core_geometry_1.FrameBuilder.createRightHandedFrame(matrix === null || matrix === void 0 ? void 0 : matrix.getColumn(2), geom);
+        if (undefined === localToWorld)
+            return undefined;
+        const worldToLocal = localToWorld.inverse();
+        if (undefined === worldToLocal)
+            return undefined;
+        const spacePoint = core_frontend_1.AccuDrawHintBuilder.projectPointToPlaneInView(ev.point, localToWorld.getOrigin(), localToWorld.matrix.getColumn(2), ev.viewport);
+        if (undefined === spacePoint)
+            return undefined;
+        const pickDetail = geom.closestPoint(this.anchorPoint, false);
+        if (undefined === (pickDetail === null || pickDetail === void 0 ? void 0 : pickDetail.curve))
+            return undefined;
+        const closeDetail = geom.closestPoint(spacePoint, true);
+        if (undefined === (closeDetail === null || closeDetail === void 0 ? void 0 : closeDetail.curve))
+            return undefined;
+        if (closeDetail.curve instanceof core_geometry_1.Arc3d) {
+            if (pickDetail.fraction > 0.5 && closeDetail.fraction < 0.0) {
+                const smallArc = closeDetail.curve.clonePartialCurve(closeDetail.fraction, 0.0);
+                smallArc.sweep.cloneComplement(false, smallArc.sweep);
+                return smallArc;
+            }
+            else if (pickDetail.fraction <= 0.5 && closeDetail.fraction > 1.0) {
+                const smallArc = closeDetail.curve.clonePartialCurve(1.0, closeDetail.fraction);
+                smallArc.sweep.cloneComplement(false, smallArc.sweep);
+                return smallArc;
+            }
+            else if (Math.abs(pickDetail.fraction > 0.5 ? closeDetail.fraction : 1.0 - closeDetail.fraction) < core_geometry_1.Geometry.smallFraction) {
+                const fullArc = closeDetail.curve.clone();
+                fullArc.sweep = core_geometry_1.AngleSweep.create360();
+                return fullArc;
+            }
+        }
+        return closeDetail.curve.clonePartialCurve(pickDetail.fraction > 0.5 ? 0.0 : 1.0, closeDetail.fraction);
+    }
+    setupAccuDraw() {
+        var _a;
+        const hints = new core_frontend_1.AccuDrawHintBuilder();
+        if (this.agenda.isEmpty) {
+            hints.enableSmartRotation = true;
+        }
+        else {
+            const geom = (_a = this.curveData) === null || _a === void 0 ? void 0 : _a.geom;
+            if (undefined === geom || "curvePrimitive" !== geom.geometryCategory)
+                return;
+            if (geom instanceof core_geometry_1.Arc3d) {
+                const matrix = geom.matrixClone();
+                matrix.normalizeColumnsInPlace();
+                hints.setOrigin(geom.center);
+                hints.setMatrix(matrix);
+                hints.setModePolar();
+            }
+            else if (geom instanceof core_geometry_1.LineSegment3d) {
+                const pickDetail = (undefined !== this.anchorPoint ? geom.closestPoint(this.anchorPoint, false) : undefined);
+                if (undefined !== (pickDetail === null || pickDetail === void 0 ? void 0 : pickDetail.curve)) {
+                    hints.setOrigin(pickDetail.fraction > 0.5 ? geom.point0Ref : geom.point1Ref);
+                    hints.setXAxis(core_geometry_1.Vector3d.createStartEnd(pickDetail.fraction > 0.5 ? geom.point0Ref : geom.point1Ref, pickDetail.fraction > 0.5 ? geom.point1Ref : geom.point0Ref));
+                }
+                hints.setModeRectangular();
+            }
+            else if (geom instanceof core_geometry_1.LineString3d) {
+                const pickDetail = (undefined !== this.anchorPoint ? geom.closestPoint(this.anchorPoint, false) : undefined);
+                if (undefined !== (pickDetail === null || pickDetail === void 0 ? void 0 : pickDetail.curve) && geom.numPoints() > 1) {
+                    hints.setOrigin(geom.packedPoints.getPoint3dAtUncheckedPointIndex(pickDetail.fraction > 0.5 ? geom.numPoints() - 2 : 1));
+                    hints.setXAxis(core_geometry_1.Vector3d.createStartEnd(geom.packedPoints.getPoint3dAtUncheckedPointIndex(pickDetail.fraction > 0.5 ? geom.numPoints() - 2 : 1), geom.packedPoints.getPoint3dAtUncheckedPointIndex(pickDetail.fraction > 0.5 ? geom.numPoints() - 1 : 0)));
+                }
+                hints.setModeRectangular();
+            }
+        }
+        hints.sendHints(false);
+    }
+    provideToolAssistance(_mainInstrText, _additionalInstr) {
+        let mainMsg;
+        if (this.agenda.isEmpty)
+            mainMsg = EditTool_1.EditTools.translate("ExtendCurve.Prompts.IdentifyEnd");
+        super.provideToolAssistance(mainMsg);
+    }
+    async onRestartTool() {
+        const tool = new ExtendCurveTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+exports.ExtendCurveTool = ExtendCurveTool;
+ExtendCurveTool.toolId = "ExtendCurve";
+ExtendCurveTool.iconSpec = "icon-scale"; // Need better icon...
+//# sourceMappingURL=ModifyCurveTools.js.map