@itwin/editor-frontend 4.0.0-dev.8 → 4.0.0-dev.81

package/lib/esm/TransformElementsTool.js

@@ -1,645 +1,648 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-import { DialogProperty, PropertyDescriptionHelper, PropertyEditorParamTypes, } from "@itwin/appui-abstract";
-import { BentleyError, Id64 } from "@itwin/core-bentley";
-import { Code, ColorDef, IModelStatus, isPlacement2dProps, LinePixels, Placement2d, Placement3d, } from "@itwin/core-common";
-import { AccuDrawHintBuilder, AngleDescription, CoreTools, ElementSetTool, GraphicBranch, GraphicType, IModelApp, IpcApp, ModifyElementSource, NotifyMessageDetails, OutputMessagePriority, readElementGraphics, } from "@itwin/core-frontend";
-import { Angle, Geometry, Matrix3d, Point3d, Transform, Vector3d, YawPitchRollAngles } from "@itwin/core-geometry";
-import { editorBuiltInCmdIds } from "@itwin/editor-common";
-import { EditTools } from "./EditTool";
-import { basicManipulationIpc } from "./EditToolIpc";
-/** @alpha */
-export class TransformGraphicsProvider {
-    constructor(iModel, prefix) {
-        /** Chord tolerance to use to stroke the element's geometry in meters. */
-        this.chordTolerance = 0.01;
-        this.iModel = iModel;
-        this.prefix = prefix;
-        this.data = new Array();
-        this.pending = new Map();
-    }
-    getRequestId(id) { return `${this.prefix}-${id}`; }
-    getToleranceLog10() { return Math.floor(Math.log10(this.chordTolerance)); }
-    async createRequest(id) {
-        const elementProps = (await this.iModel.elements.getProps(id));
-        if (0 === elementProps.length)
-            return;
-        const placementProps = elementProps[0].placement;
-        if (undefined === placementProps)
-            return;
-        const placement = isPlacement2dProps(placementProps) ? Placement2d.fromJSON(placementProps) : Placement3d.fromJSON(placementProps);
-        if (!placement.isValid)
-            return; // Ignore assembly parents w/o geometry, etc...
-        const requestProps = {
-            id: this.getRequestId(id),
-            elementId: id,
-            toleranceLog10: this.getToleranceLog10(),
-        };
-        this.pending.set(id, requestProps.id); // keep track of requests so they can be cancelled...
-        const graphicData = await IModelApp.tileAdmin.requestElementGraphics(this.iModel, requestProps);
-        if (undefined === graphicData)
-            return;
-        const graphic = await readElementGraphics(graphicData, this.iModel, elementProps[0].model, placement.is3d, { noFlash: true, noHilite: true });
-        if (undefined === graphic)
-            return;
-        return { id, placement, graphic: IModelApp.renderSystem.createGraphicOwner(graphic) };
-    }
-    disposeOfGraphics() {
-        this.data.forEach((data) => {
-            data.graphic.disposeGraphic();
-        });
-        this.data.length = 0;
-    }
-    async cancelPendingRequests() {
-        const requests = new Array();
-        for (const [_key, id] of this.pending)
-            requests.push(id);
-        this.pending.clear();
-        if (0 === requests.length)
-            return;
-        return IpcApp.appFunctionIpc.cancelElementGraphicsRequests(this.iModel.key, requests);
-    }
-    /** Call to request a RenderGraphic for the supplied element id.
-   * @see [[cleanupGraphics]] Must be called when the tool exits.
-   */
-    async createSingleGraphic(id) {
-        try {
-            const info = await this.createRequest(id);
-            if (undefined !== (info === null || info === void 0 ? void 0 : info.id))
-                this.pending.delete(info.id);
-            if (undefined === (info === null || info === void 0 ? void 0 : info.graphic))
-                return false;
-            this.data.push(info);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /** Call to request RenderGraphics for the supplied element ids. Does not wait for results as
-     * generating graphics for a large number of elements can take time. Instead an array of [[RenderGraphicOwner]]
-     * is populated as requests are resolved and the current dynamics frame displays what is available.
-     * @see [[cleanupGraphics]] Must be called when the tool exits.
-     */
-    createGraphics(elements) {
-        if (0 === Id64.sizeOf(elements))
-            return;
-        try {
-            for (const id of Id64.iterable(elements)) {
-                const promise = this.createRequest(id);
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                promise.then((info) => {
-                    if (undefined !== (info === null || info === void 0 ? void 0 : info.id))
-                        this.pending.delete(info.id);
-                    if (undefined !== (info === null || info === void 0 ? void 0 : info.graphic))
-                        this.data.push(info);
-                });
-            }
-        }
-        catch { }
-    }
-    /** Call to dispose of [[RenderGraphic]] held by [[RenderGraphicOwner]] and cancel requests that are still pending.
-     * @note Must be called when the tool exits to avoid leaks of graphics memory or other webgl resources.
-     */
-    async cleanupGraphics() {
-        await this.cancelPendingRequests();
-        this.disposeOfGraphics();
-    }
-    addSingleGraphic(graphic, transform, context) {
-        const branch = new GraphicBranch(false);
-        branch.add(graphic);
-        const branchGraphic = context.createBranch(branch, transform);
-        context.addGraphic(branchGraphic);
-    }
-    addGraphics(transform, context) {
-        if (0 === this.data.length)
-            return;
-        const branch = new GraphicBranch(false);
-        for (const data of this.data)
-            branch.add(data.graphic);
-        const branchGraphic = context.createBranch(branch, transform);
-        context.addGraphic(branchGraphic);
-    }
-}
-/** @alpha Base class for applying a transform to element placements. */
-export class TransformElementsTool extends ElementSetTool {
-    get allowSelectionSet() { return true; }
-    get allowGroups() { return true; }
-    get allowDragSelect() { return true; }
-    get controlKeyContinuesSelection() { return true; }
-    get wantAccuSnap() { return true; }
-    get wantDynamics() { return true; }
-    get wantMakeCopy() { return false; }
-    get wantRepeatOperation() { return this.wantMakeCopy && !this.agenda.isEmpty; }
-    async createAgendaGraphics(changed) {
-        if (changed) {
-            if (undefined === this._graphicsProvider)
-                return; // Not yet needed...
-        }
-        else {
-            if (undefined !== this._graphicsProvider)
-                return; // Use existing graphics...
-        }
-        if (undefined === this._graphicsProvider)
-            this._graphicsProvider = new TransformGraphicsProvider(this.iModel, this.toolId);
-        else
-            await this._graphicsProvider.cleanupGraphics();
-        if (1 === this.agenda.length) {
-            await this._graphicsProvider.createSingleGraphic(this.agenda.elements[0]);
-            return;
-        }
-        this._graphicsProvider.createGraphics(this.agenda.elements);
-    }
-    async clearAgendaGraphics() {
-        if (undefined === this._graphicsProvider)
-            return;
-        await this._graphicsProvider.cleanupGraphics();
-        this._graphicsProvider = undefined;
-    }
-    async onAgendaModified() {
-        await this.createAgendaGraphics(true);
-    }
-    async initAgendaDynamics() {
-        await this.createAgendaGraphics(false);
-        return super.initAgendaDynamics();
-    }
-    transformAgendaDynamics(transform, context) {
-        if (undefined !== this._graphicsProvider)
-            this._graphicsProvider.addGraphics(transform, context);
-    }
-    onDynamicFrame(ev, context) {
-        const transform = this.calculateTransform(ev);
-        if (undefined === transform)
-            return;
-        this.transformAgendaDynamics(transform, context);
-    }
-    updateAnchorLocation(transform) {
-        // Update anchor point to support creating additional copies (repeat vs. restart)...
-        if (undefined === this.anchorPoint)
-            return;
-        transform.multiplyPoint3d(this.anchorPoint, this.anchorPoint);
-        const hints = new AccuDrawHintBuilder();
-        hints.setOrigin(this.anchorPoint);
-        hints.sendHints();
-    }
-    async startCommand() {
-        if (undefined !== this._startedCmd)
-            return this._startedCmd;
-        return EditTools.startCommand({ commandId: editorBuiltInCmdIds.cmdBasicManipulation, iModelKey: this.iModel.key });
-    }
-    async replaceAgenda(newIds) {
-        this.agenda.clear();
-        if (undefined !== newIds)
-            this.agenda.add(newIds);
-        if (this.isSelectionSetModify) {
-            if (this.agenda.isEmpty)
-                this.iModel.selectionSet.emptyAll();
-            else
-                this.iModel.selectionSet.replace(this.agenda.elements);
-            this.agenda.setSource(ModifyElementSource.SelectionSet);
-            this.setPreferredElementSource(); // Update "use selection set" flag...
-        }
-        return this.onAgendaModified();
-    }
-    async transformAndCopyAgenda(_transform) {
-        return undefined;
-    }
-    async transformAgenda(transform) {
-        try {
-            this._startedCmd = await this.startCommand();
-            if (IModelStatus.Success === await basicManipulationIpc.transformPlacement(this.agenda.compressIds(), transform.toJSON()))
-                await this.saveChanges();
-        }
-        catch (err) {
-            IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Error, BentleyError.getErrorMessage(err) || "An unknown error occurred."));
-        }
-    }
-    async processAgenda(ev) {
-        const transform = this.calculateTransform(ev);
-        if (undefined === transform)
-            return;
-        if (this.wantMakeCopy)
-            await this.replaceAgenda(await this.transformAndCopyAgenda(transform));
-        else
-            await this.transformAgenda(transform);
-        this.updateAnchorLocation(transform);
-    }
-    async onProcessComplete() {
-        if (this.wantRepeatOperation)
-            return; // Continue with current agenda instead of restarting (ex. create additional copies)
-        return super.onProcessComplete();
-    }
-    async onCleanup() {
-        await this.clearAgendaGraphics();
-        return super.onCleanup();
-    }
-}
-/** @alpha Move elements by applying translation to placement. */
-export class MoveElementsTool extends TransformElementsTool {
-    calculateTransform(ev) {
-        if (undefined === this.anchorPoint)
-            return undefined;
-        return Transform.createTranslation(ev.point.minus(this.anchorPoint));
-    }
-    provideToolAssistance(_mainInstrText, _additionalInstr) {
-        let mainMsg;
-        if (!this.isSelectByPoints && !this.wantAdditionalElements)
-            mainMsg = CoreTools.translate(this.wantAdditionalInput ? "ElementSet.Prompts.StartPoint" : "ElementSet.Prompts.EndPoint");
-        super.provideToolAssistance(mainMsg);
-    }
-    async onRestartTool() {
-        const tool = new MoveElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-MoveElementsTool.toolId = "MoveElements";
-MoveElementsTool.iconSpec = "icon-move";
-/** Create new elements with translation applied to placement.
- * This is a brute force implementation strictly for example and testing purposes.
- * The new elements are Generic:PhysicalObject or BisCore:DrawingGraphic using the model and category of original.
- * Does not preserve assemblies and geometric elements without geometry are not copied.
- * Using loadProps to return json format geometry to the frontend for each element in the tool agenda is very inefficient.
- * Applications that wish to support copy are expected to sub-class TransformElementsTool and register their
- * own EditCommand that can correctly copy their application elements.
- * @alpha
- */
-export class CopyElementsTool extends MoveElementsTool {
-    static get minArgs() { return 0; }
-    static get maxArgs() { return 1; }
-    get numCopiesProperty() {
-        if (!this._numCopiesProperty)
-            this._numCopiesProperty = new DialogProperty(PropertyDescriptionHelper.buildNumberEditorDescription("numCopies", EditTools.translate("CopyElements.Label.NumCopies"), { type: PropertyEditorParamTypes.Range, minimum: 1 }), 1);
-        return this._numCopiesProperty;
-    }
-    get numCopies() { return this.numCopiesProperty.value; }
-    set numCopies(value) { this.numCopiesProperty.value = value; }
-    get wantMakeCopy() { return this.numCopies > 0; }
-    updateAnchorLocation(transform) {
-        // Account for additional copies for repeat operation anchor point...
-        for (let iCopy = 0; iCopy < this.numCopies; ++iCopy)
-            super.updateAnchorLocation(transform);
-    }
-    async doTransformedCopy(ids, transform, numCopies) {
-        if (numCopies < 1 || 0 === ids.length)
-            return undefined;
-        this._startedCmd = await this.startCommand();
-        const newIds = [];
-        for (const id of ids) {
-            // NOTE: For testing only. Using loadProps to return json format geometry to the frontend for each element in the tool agenda is very inefficient.
-            const props = await this.iModel.elements.loadProps(id, { wantGeometry: true, wantBRepData: true });
-            if (undefined === props.placement)
-                continue;
-            const placement = isPlacement2dProps(props.placement) ? Placement2d.fromJSON(props.placement) : Placement3d.fromJSON(props.placement);
-            if (!placement.isValid)
-                continue; // Ignore assembly parents w/o geometry, etc...
-            const classFullName = (placement.is3d ? "Generic:PhysicalObject" : "BisCore:DrawingGraphic");
-            const newProps = { classFullName, model: props.model, category: props.category, code: Code.createEmpty(), placement, geom: props.geom };
-            let newId;
-            for (let iCopy = 0; iCopy < numCopies; ++iCopy) {
-                placement.multiplyTransform(transform);
-                newId = await basicManipulationIpc.insertGeometricElement(newProps);
-            }
-            if (undefined !== newId)
-                newIds.push(newId); // When numCopies > 1 ids are return for just the final copy...
-        }
-        return (0 === newIds.length ? undefined : newIds);
-    }
-    async transformAndCopyAgenda(transform) {
-        try {
-            const newIds = await this.doTransformedCopy(this.agenda.elements, transform, this.numCopies);
-            if (undefined !== newIds)
-                await this.saveChanges();
-            return newIds;
-        }
-        catch (err) {
-            IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Error, BentleyError.getErrorMessage(err) || "An unknown error occurred."));
-            return undefined;
-        }
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        // NOTE: Don't call changeToolSettingPropertyValue, value of numCopies should not be saved...
-        if (updatedValue.propertyName !== this.numCopiesProperty.name || undefined === updatedValue.value.value)
-            return false;
-        this.numCopies = updatedValue.value.value;
-        return true;
-    }
-    supplyToolSettingsProperties() {
-        // NOTE: Don't call initializeToolSettingPropertyValues, value of numCopies is not saved...
-        const toolSettings = new Array();
-        toolSettings.push(this.numCopiesProperty.toDialogItem({ rowPriority: 1, columnIndex: 2 }));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new CopyElementsTool();
-        tool.numCopies = this.numCopies; // Preserve numCopies on restart...
-        if (!await tool.run())
-            return this.exitTool();
-    }
-    /** The keyin takes the following arguments, all of which are optional:
-     *  - `numCopies=number` Number of copies of each element to create, default is 1.
-     */
-    async parseAndRun(...inputArgs) {
-        for (const arg of inputArgs) {
-            const parts = arg.split("=");
-            if (2 !== parts.length)
-                continue;
-            if (parts[0].toLowerCase().startsWith("num")) {
-                const copies = Number.parseInt(parts[1], 10);
-                if (copies >= 1)
-                    this.numCopies = copies; // NOTE: Don't call saveToolSettingPropertyValue, always default to single copy...
-            }
-        }
-        return this.run();
-    }
-}
-CopyElementsTool.toolId = "CopyElements";
-CopyElementsTool.iconSpec = "icon-move"; // Need better icon...
-/** @alpha */
-export var RotateMethod;
-(function (RotateMethod) {
-    RotateMethod[RotateMethod["By3Points"] = 0] = "By3Points";
-    RotateMethod[RotateMethod["ByAngle"] = 1] = "ByAngle";
-})(RotateMethod || (RotateMethod = {}));
-/** @alpha */
-export var RotateAbout;
-(function (RotateAbout) {
-    RotateAbout[RotateAbout["Point"] = 0] = "Point";
-    RotateAbout[RotateAbout["Origin"] = 1] = "Origin";
-    RotateAbout[RotateAbout["Center"] = 2] = "Center";
-})(RotateAbout || (RotateAbout = {}));
-/** @alpha Rotate elements by applying transform to placement. */
-export class RotateElementsTool extends TransformElementsTool {
-    constructor() {
-        super(...arguments);
-        this.havePivotPoint = false;
-        this.haveFinalPoint = false;
-    }
-    static get minArgs() { return 0; }
-    static get maxArgs() { return 3; }
-    static methodMessage(str) { return EditTools.translate(`RotateElements.Method.${str}`); }
-    get methodProperty() {
-        if (!this._methodProperty)
-            this._methodProperty = new DialogProperty(PropertyDescriptionHelper.buildEnumPicklistEditorDescription("rotateMethod", EditTools.translate("RotateElements.Label.Method"), RotateElementsTool.getMethodChoices()), RotateMethod.By3Points);
-        return this._methodProperty;
-    }
-    get rotateMethod() { return this.methodProperty.value; }
-    set rotateMethod(method) { this.methodProperty.value = method; }
-    static aboutMessage(str) { return EditTools.translate(`RotateElements.About.${str}`); }
-    get aboutProperty() {
-        if (!this._aboutProperty)
-            this._aboutProperty = new DialogProperty(PropertyDescriptionHelper.buildEnumPicklistEditorDescription("rotateAbout", EditTools.translate("RotateElements.Label.About"), RotateElementsTool.getAboutChoices()), RotateAbout.Point);
-        return this._aboutProperty;
-    }
-    get rotateAbout() { return this.aboutProperty.value; }
-    set rotateAbout(method) { this.aboutProperty.value = method; }
-    get angleProperty() {
-        if (!this._angleProperty)
-            this._angleProperty = new DialogProperty(new AngleDescription("rotateAngle", EditTools.translate("RotateElements.Label.Angle")), 0.0);
-        return this._angleProperty;
-    }
-    get rotateAngle() { return this.angleProperty.value; }
-    set rotateAngle(value) { this.angleProperty.value = value; }
-    get requireAcceptForSelectionSetDynamics() { return RotateMethod.ByAngle !== this.rotateMethod; }
-    calculateTransform(ev) {
-        if (undefined === ev.viewport)
-            return undefined;
-        if (RotateMethod.ByAngle === this.rotateMethod) {
-            const rotMatrix = AccuDrawHintBuilder.getCurrentRotation(ev.viewport, true, true);
-            if (undefined === rotMatrix)
-                return undefined;
-            const invMatrix = rotMatrix.inverse();
-            if (undefined === invMatrix)
-                return undefined;
-            const angMatrix = YawPitchRollAngles.createRadians(this.rotateAngle, 0, 0).toMatrix3d();
-            if (undefined === angMatrix)
-                return undefined;
-            angMatrix.multiplyMatrixMatrix(invMatrix, invMatrix);
-            rotMatrix.multiplyMatrixMatrix(invMatrix, rotMatrix);
-            return Transform.createFixedPointAndMatrix(ev.point, rotMatrix);
-        }
-        if (undefined === this.anchorPoint || undefined === this.xAxisPoint)
-            return undefined;
-        const vec1 = Vector3d.createStartEnd(this.anchorPoint, this.xAxisPoint);
-        const vec2 = Vector3d.createStartEnd(this.anchorPoint, ev.point);
-        if (!vec1.normalizeInPlace() || !vec2.normalizeInPlace())
-            return undefined;
-        const dot = vec1.dotProduct(vec2);
-        if (dot > (1.0 - Geometry.smallAngleRadians))
-            return undefined;
-        if (dot < (-1.0 + Geometry.smallAngleRadians)) {
-            const rotMatrix = AccuDrawHintBuilder.getCurrentRotation(ev.viewport, true, true);
-            if (undefined === rotMatrix)
-                return undefined;
-            const invMatrix = rotMatrix.inverse();
-            if (undefined === invMatrix)
-                return undefined;
-            const angMatrix = YawPitchRollAngles.createRadians(Math.PI, 0, 0).toMatrix3d(); // 180 degree rotation...
-            if (undefined === angMatrix)
-                return undefined;
-            angMatrix.multiplyMatrixMatrix(invMatrix, invMatrix);
-            rotMatrix.multiplyMatrixMatrix(invMatrix, rotMatrix);
-            return Transform.createFixedPointAndMatrix(this.anchorPoint, rotMatrix);
-        }
-        const zVec = vec1.unitCrossProduct(vec2);
-        if (undefined === zVec)
-            return undefined;
-        const yVec = zVec.unitCrossProduct(vec1);
-        if (undefined === yVec)
-            return undefined;
-        const matrix1 = Matrix3d.createRows(vec1, yVec, zVec);
-        zVec.unitCrossProduct(vec2, yVec);
-        const matrix2 = Matrix3d.createColumns(vec2, yVec, zVec);
-        const matrix = matrix2.multiplyMatrixMatrix(matrix1);
-        if (undefined === matrix)
-            return undefined;
-        return Transform.createFixedPointAndMatrix(this.anchorPoint, matrix);
-    }
-    transformAgendaDynamics(transform, context) {
-        if (RotateAbout.Point === this.rotateAbout)
-            return super.transformAgendaDynamics(transform, context);
-        if (undefined === this._graphicsProvider)
-            return;
-        const rotatePoint = Point3d.create();
-        for (const data of this._graphicsProvider.data) {
-            if (RotateAbout.Origin === this.rotateAbout)
-                rotatePoint.setFrom(data.placement.origin);
-            else
-                rotatePoint.setFrom(data.placement.calculateRange().center);
-            const rotateTrans = Transform.createFixedPointAndMatrix(rotatePoint, transform.matrix);
-            this._graphicsProvider.addSingleGraphic(data.graphic, rotateTrans, context);
-        }
-    }
-    async transformAgenda(transform) {
-        if (RotateAbout.Point === this.rotateAbout)
-            return super.transformAgenda(transform);
-        try {
-            this._startedCmd = await this.startCommand();
-            if (IModelStatus.Success === await basicManipulationIpc.rotatePlacement(this.agenda.compressIds(), transform.matrix.toJSON(), RotateAbout.Center === this.rotateAbout))
-                await this.saveChanges();
-        }
-        catch (err) {
-            IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Error, BentleyError.getErrorMessage(err) || "An unknown error occurred."));
-        }
-    }
-    onDynamicFrame(ev, context) {
-        const transform = this.calculateTransform(ev);
-        if (undefined !== transform)
-            return this.transformAgendaDynamics(transform, context);
-        if (undefined === this.anchorPoint)
-            return;
-        const builder = context.createGraphic({ type: GraphicType.WorldOverlay });
-        builder.setSymbology(context.viewport.getContrastToBackgroundColor(), ColorDef.black, 1, LinePixels.Code2);
-        builder.addLineString([this.anchorPoint.clone(), ev.point.clone()]);
-        context.addGraphic(builder.finish());
-    }
-    get wantAdditionalInput() {
-        if (RotateMethod.ByAngle === this.rotateMethod)
-            return super.wantAdditionalInput;
-        return !this.haveFinalPoint;
-    }
-    wantProcessAgenda(ev) {
-        if (RotateMethod.ByAngle === this.rotateMethod)
-            return super.wantProcessAgenda(ev);
-        if (!this.havePivotPoint)
-            this.havePivotPoint = true; // Uses anchorPoint...
-        else if (undefined === this.xAxisPoint)
-            this.xAxisPoint = ev.point.clone();
-        else if (!this.haveFinalPoint)
-            this.haveFinalPoint = true; // Uses button event...
-        return super.wantProcessAgenda(ev);
-    }
-    setupAndPromptForNextAction() {
-        super.setupAndPromptForNextAction();
-        if (RotateMethod.ByAngle === this.rotateMethod)
-            return;
-        if (undefined === this.anchorPoint || undefined === this.xAxisPoint)
-            return;
-        const hints = new AccuDrawHintBuilder();
-        hints.setXAxis(Vector3d.createStartEnd(this.anchorPoint, this.xAxisPoint));
-        hints.setOrigin(this.anchorPoint);
-        hints.setModePolar();
-        hints.sendHints();
-    }
-    provideToolAssistance(_mainInstrText, _additionalInstr) {
-        let mainMsg;
-        if (RotateMethod.ByAngle === this.rotateMethod) {
-            if (!this.isSelectByPoints && !this.wantAdditionalElements && this.wantAdditionalInput)
-                mainMsg = EditTools.translate("RotateElements.Prompts.IdentifyPoint");
-        }
-        else {
-            if (!this.isSelectByPoints && !this.wantAdditionalElements) {
-                if (!this.havePivotPoint)
-                    mainMsg = EditTools.translate("RotateElements.Prompts.IdentifyPoint");
-                else if (undefined === this.xAxisPoint)
-                    mainMsg = EditTools.translate("RotateElements.Prompts.DefineStart");
-                else
-                    mainMsg = EditTools.translate("RotateElements.Prompts.DefineAmount");
-            }
-        }
-        super.provideToolAssistance(mainMsg);
-    }
-    async applyToolSettingPropertyChange(updatedValue) {
-        if (!this.changeToolSettingPropertyValue(updatedValue))
-            return false;
-        if (this.methodProperty.name === updatedValue.propertyName)
-            await this.onRestartTool(); // calling restart, not reinitialize to not exit tool for selection set...
-        return true;
-    }
-    supplyToolSettingsProperties() {
-        const toolSettings = new Array();
-        toolSettings.push(this.methodProperty.toDialogItem({ rowPriority: 1, columnIndex: 2 }));
-        toolSettings.push(this.aboutProperty.toDialogItem({ rowPriority: 2, columnIndex: 2 }));
-        if (RotateMethod.ByAngle === this.rotateMethod)
-            toolSettings.push(this.angleProperty.toDialogItem({ rowPriority: 3, columnIndex: 2 }));
-        return toolSettings;
-    }
-    async onRestartTool() {
-        const tool = new RotateElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-    async onInstall() {
-        if (!await super.onInstall())
-            return false;
-        // Setup initial values here instead of supplyToolSettingsProperties to support keyin args w/o appui-react...
-        this.initializeToolSettingPropertyValues([this.methodProperty, this.aboutProperty, this.angleProperty]);
-        return true;
-    }
-    /** The keyin takes the following arguments, all of which are optional:
-     *  - `method=0|1` How rotate angle will be specified. 0 for by 3 points, 1 for by specified angle.
-     *  - `about=0|1|2` Location to rotate about. 0 for point, 1 for placement origin, and 2 for center of range.
-     *  - `angle=number` Rotation angle in degrees when not defining angle by points.
-     */
-    async parseAndRun(...inputArgs) {
-        let rotateMethod;
-        let rotateAbout;
-        let rotateAngle;
-        for (const arg of inputArgs) {
-            const parts = arg.split("=");
-            if (2 !== parts.length)
-                continue;
-            if (parts[0].toLowerCase().startsWith("me")) {
-                const method = Number.parseInt(parts[1], 10);
-                if (!Number.isNaN(method)) {
-                    switch (method) {
-                        case 0:
-                            rotateMethod = RotateMethod.By3Points;
-                            break;
-                        case 1:
-                            rotateMethod = RotateMethod.ByAngle;
-                            break;
-                    }
-                }
-            }
-            else if (parts[0].toLowerCase().startsWith("ab")) {
-                const about = Number.parseInt(parts[1], 10);
-                if (!Number.isNaN(about)) {
-                    switch (about) {
-                        case 0:
-                            rotateAbout = RotateAbout.Point;
-                            break;
-                        case 1:
-                            rotateAbout = RotateAbout.Origin;
-                            break;
-                        case 2:
-                            rotateAbout = RotateAbout.Center;
-                            break;
-                    }
-                }
-            }
-            else if (parts[0].toLowerCase().startsWith("an")) {
-                const angle = Number.parseFloat(parts[1]);
-                if (!Number.isNaN(angle)) {
-                    rotateAngle = Angle.createDegrees(angle).radians;
-                }
-            }
-        }
-        // Update current session values so keyin args are picked up for tool settings/restart...
-        if (undefined !== rotateMethod)
-            this.saveToolSettingPropertyValue(this.methodProperty, { value: rotateMethod });
-        if (undefined !== rotateAbout)
-            this.saveToolSettingPropertyValue(this.aboutProperty, { value: rotateAbout });
-        if (undefined !== rotateAngle)
-            this.saveToolSettingPropertyValue(this.angleProperty, { value: rotateAngle });
-        return this.run();
-    }
-}
-RotateElementsTool.toolId = "RotateElements";
-RotateElementsTool.iconSpec = "icon-rotate";
-RotateElementsTool.getMethodChoices = () => {
-    return [
-        { label: RotateElementsTool.methodMessage("3Points"), value: RotateMethod.By3Points },
-        { label: RotateElementsTool.methodMessage("Angle"), value: RotateMethod.ByAngle },
-    ];
-};
-RotateElementsTool.getAboutChoices = () => {
-    return [
-        { label: RotateElementsTool.aboutMessage("Point"), value: RotateAbout.Point },
-        { label: RotateElementsTool.aboutMessage("Origin"), value: RotateAbout.Origin },
-        { label: RotateElementsTool.aboutMessage("Center"), value: RotateAbout.Center },
-    ];
-};
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { DialogProperty, PropertyDescriptionHelper, PropertyEditorParamTypes, } from "@itwin/appui-abstract";
+import { BentleyError, Id64 } from "@itwin/core-bentley";
+import { Code, ColorDef, IModelStatus, isPlacement2dProps, LinePixels, Placement2d, Placement3d, } from "@itwin/core-common";
+import { AccuDrawHintBuilder, AngleDescription, CoreTools, ElementSetTool, GraphicBranch, GraphicType, IModelApp, IpcApp, ModifyElementSource, NotifyMessageDetails, OutputMessagePriority, readElementGraphics, } from "@itwin/core-frontend";
+import { Angle, Geometry, Matrix3d, Point3d, Transform, Vector3d, YawPitchRollAngles } from "@itwin/core-geometry";
+import { editorBuiltInCmdIds } from "@itwin/editor-common";
+import { EditTools } from "./EditTool";
+import { basicManipulationIpc } from "./EditToolIpc";
+/** @alpha */
+export class TransformGraphicsProvider {
+    constructor(iModel, prefix) {
+        /** Chord tolerance to use to stroke the element's geometry in meters. */
+        this.chordTolerance = 0.01;
+        this.iModel = iModel;
+        this.prefix = prefix;
+        this.data = new Array();
+        this.pending = new Map();
+    }
+    getRequestId(id) { return `${this.prefix}-${id}`; }
+    getToleranceLog10() { return Math.floor(Math.log10(this.chordTolerance)); }
+    async createRequest(id) {
+        const elementProps = (await this.iModel.elements.getProps(id));
+        if (0 === elementProps.length)
+            return;
+        const placementProps = elementProps[0].placement;
+        if (undefined === placementProps)
+            return;
+        const placement = isPlacement2dProps(placementProps) ? Placement2d.fromJSON(placementProps) : Placement3d.fromJSON(placementProps);
+        if (!placement.isValid)
+            return; // Ignore assembly parents w/o geometry, etc...
+        const requestProps = {
+            id: this.getRequestId(id),
+            elementId: id,
+            toleranceLog10: this.getToleranceLog10(),
+        };
+        this.pending.set(id, requestProps.id); // keep track of requests so they can be cancelled...
+        const graphicData = await IModelApp.tileAdmin.requestElementGraphics(this.iModel, requestProps);
+        if (undefined === graphicData)
+            return;
+        const graphic = await readElementGraphics(graphicData, this.iModel, elementProps[0].model, placement.is3d, { noFlash: true, noHilite: true });
+        if (undefined === graphic)
+            return;
+        return { id, placement, graphic: IModelApp.renderSystem.createGraphicOwner(graphic) };
+    }
+    disposeOfGraphics() {
+        this.data.forEach((data) => {
+            data.graphic.disposeGraphic();
+        });
+        this.data.length = 0;
+    }
+    async cancelPendingRequests() {
+        const requests = new Array();
+        for (const [_key, id] of this.pending)
+            requests.push(id);
+        this.pending.clear();
+        if (0 === requests.length)
+            return;
+        return IpcApp.appFunctionIpc.cancelElementGraphicsRequests(this.iModel.key, requests);
+    }
+    /** Call to request a RenderGraphic for the supplied element id.
+   * @see [[cleanupGraphics]] Must be called when the tool exits.
+   */
+    async createSingleGraphic(id) {
+        try {
+            const info = await this.createRequest(id);
+            if (undefined !== info?.id)
+                this.pending.delete(info.id);
+            if (undefined === info?.graphic)
+                return false;
+            this.data.push(info);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Call to request RenderGraphics for the supplied element ids. Does not wait for results as
+     * generating graphics for a large number of elements can take time. Instead an array of [[RenderGraphicOwner]]
+     * is populated as requests are resolved and the current dynamics frame displays what is available.
+     * @see [[cleanupGraphics]] Must be called when the tool exits.
+     */
+    createGraphics(elements) {
+        if (0 === Id64.sizeOf(elements))
+            return;
+        try {
+            for (const id of Id64.iterable(elements)) {
+                const promise = this.createRequest(id);
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                promise.then((info) => {
+                    if (undefined !== info?.id)
+                        this.pending.delete(info.id);
+                    if (undefined !== info?.graphic)
+                        this.data.push(info);
+                });
+            }
+        }
+        catch { }
+    }
+    /** Call to dispose of [[RenderGraphic]] held by [[RenderGraphicOwner]] and cancel requests that are still pending.
+     * @note Must be called when the tool exits to avoid leaks of graphics memory or other webgl resources.
+     */
+    async cleanupGraphics() {
+        await this.cancelPendingRequests();
+        this.disposeOfGraphics();
+    }
+    addSingleGraphic(graphic, transform, context) {
+        const branch = new GraphicBranch(false);
+        branch.add(graphic);
+        const branchGraphic = context.createBranch(branch, transform);
+        context.addGraphic(branchGraphic);
+    }
+    addGraphics(transform, context) {
+        if (0 === this.data.length)
+            return;
+        const branch = new GraphicBranch(false);
+        for (const data of this.data)
+            branch.add(data.graphic);
+        const branchGraphic = context.createBranch(branch, transform);
+        context.addGraphic(branchGraphic);
+    }
+}
+/** @alpha Base class for applying a transform to element placements. */
+export class TransformElementsTool extends ElementSetTool {
+    get allowSelectionSet() { return true; }
+    get allowGroups() { return true; }
+    get allowDragSelect() { return true; }
+    get controlKeyContinuesSelection() { return true; }
+    get wantAccuSnap() { return true; }
+    get wantDynamics() { return true; }
+    get wantMakeCopy() { return false; }
+    get wantRepeatOperation() { return this.wantMakeCopy && !this.agenda.isEmpty; }
+    async createAgendaGraphics(changed) {
+        if (changed) {
+            if (undefined === this._graphicsProvider)
+                return; // Not yet needed...
+        }
+        else {
+            if (undefined !== this._graphicsProvider)
+                return; // Use existing graphics...
+        }
+        if (undefined === this._graphicsProvider)
+            this._graphicsProvider = new TransformGraphicsProvider(this.iModel, this.toolId);
+        else
+            await this._graphicsProvider.cleanupGraphics();
+        if (1 === this.agenda.length) {
+            await this._graphicsProvider.createSingleGraphic(this.agenda.elements[0]);
+            return;
+        }
+        this._graphicsProvider.createGraphics(this.agenda.elements);
+    }
+    async clearAgendaGraphics() {
+        if (undefined === this._graphicsProvider)
+            return;
+        await this._graphicsProvider.cleanupGraphics();
+        this._graphicsProvider = undefined;
+    }
+    async onAgendaModified() {
+        await this.createAgendaGraphics(true);
+    }
+    async initAgendaDynamics() {
+        await this.createAgendaGraphics(false);
+        return super.initAgendaDynamics();
+    }
+    transformAgendaDynamics(transform, context) {
+        if (undefined !== this._graphicsProvider)
+            this._graphicsProvider.addGraphics(transform, context);
+    }
+    onDynamicFrame(ev, context) {
+        const transform = this.calculateTransform(ev);
+        if (undefined === transform)
+            return;
+        this.transformAgendaDynamics(transform, context);
+    }
+    updateAnchorLocation(transform) {
+        // Update anchor point to support creating additional copies (repeat vs. restart)...
+        if (undefined === this.anchorPoint)
+            return;
+        transform.multiplyPoint3d(this.anchorPoint, this.anchorPoint);
+        const hints = new AccuDrawHintBuilder();
+        hints.setOrigin(this.anchorPoint);
+        hints.sendHints();
+    }
+    async startCommand() {
+        if (undefined !== this._startedCmd)
+            return this._startedCmd;
+        return EditTools.startCommand({ commandId: editorBuiltInCmdIds.cmdBasicManipulation, iModelKey: this.iModel.key });
+    }
+    async replaceAgenda(newIds) {
+        this.agenda.clear();
+        if (undefined !== newIds)
+            this.agenda.add(newIds);
+        if (this.isSelectionSetModify) {
+            if (this.agenda.isEmpty)
+                this.iModel.selectionSet.emptyAll();
+            else
+                this.iModel.selectionSet.replace(this.agenda.elements);
+            this.agenda.setSource(ModifyElementSource.SelectionSet);
+            this.setPreferredElementSource(); // Update "use selection set" flag...
+        }
+        return this.onAgendaModified();
+    }
+    async transformAndCopyAgenda(_transform) {
+        return undefined;
+    }
+    async transformAgenda(transform) {
+        try {
+            this._startedCmd = await this.startCommand();
+            if (IModelStatus.Success === await basicManipulationIpc.transformPlacement(this.agenda.compressIds(), transform.toJSON()))
+                await this.saveChanges();
+        }
+        catch (err) {
+            IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Error, BentleyError.getErrorMessage(err) || "An unknown error occurred."));
+        }
+    }
+    async processAgenda(ev) {
+        const transform = this.calculateTransform(ev);
+        if (undefined === transform)
+            return;
+        if (this.wantMakeCopy)
+            await this.replaceAgenda(await this.transformAndCopyAgenda(transform));
+        else
+            await this.transformAgenda(transform);
+        this.updateAnchorLocation(transform);
+    }
+    async onProcessComplete() {
+        if (this.wantRepeatOperation)
+            return; // Continue with current agenda instead of restarting (ex. create additional copies)
+        return super.onProcessComplete();
+    }
+    async onCleanup() {
+        await this.clearAgendaGraphics();
+        return super.onCleanup();
+    }
+}
+/** @alpha Move elements by applying translation to placement. */
+class MoveElementsTool extends TransformElementsTool {
+    calculateTransform(ev) {
+        if (undefined === this.anchorPoint)
+            return undefined;
+        return Transform.createTranslation(ev.point.minus(this.anchorPoint));
+    }
+    provideToolAssistance(_mainInstrText, _additionalInstr) {
+        let mainMsg;
+        if (!this.isSelectByPoints && !this.wantAdditionalElements)
+            mainMsg = CoreTools.translate(this.wantAdditionalInput ? "ElementSet.Prompts.StartPoint" : "ElementSet.Prompts.EndPoint");
+        super.provideToolAssistance(mainMsg);
+    }
+    async onRestartTool() {
+        const tool = new MoveElementsTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+}
+MoveElementsTool.toolId = "MoveElements";
+MoveElementsTool.iconSpec = "icon-move";
+export { MoveElementsTool };
+/** Create new elements with translation applied to placement.
+ * This is a brute force implementation strictly for example and testing purposes.
+ * The new elements are Generic:PhysicalObject or BisCore:DrawingGraphic using the model and category of original.
+ * Does not preserve assemblies and geometric elements without geometry are not copied.
+ * Using loadProps to return json format geometry to the frontend for each element in the tool agenda is very inefficient.
+ * Applications that wish to support copy are expected to sub-class TransformElementsTool and register their
+ * own EditCommand that can correctly copy their application elements.
+ * @alpha
+ */
+class CopyElementsTool extends MoveElementsTool {
+    static get minArgs() { return 0; }
+    static get maxArgs() { return 1; }
+    get numCopiesProperty() {
+        if (!this._numCopiesProperty)
+            this._numCopiesProperty = new DialogProperty(PropertyDescriptionHelper.buildNumberEditorDescription("numCopies", EditTools.translate("CopyElements.Label.NumCopies"), { type: PropertyEditorParamTypes.Range, minimum: 1 }), 1);
+        return this._numCopiesProperty;
+    }
+    get numCopies() { return this.numCopiesProperty.value; }
+    set numCopies(value) { this.numCopiesProperty.value = value; }
+    get wantMakeCopy() { return this.numCopies > 0; }
+    updateAnchorLocation(transform) {
+        // Account for additional copies for repeat operation anchor point...
+        for (let iCopy = 0; iCopy < this.numCopies; ++iCopy)
+            super.updateAnchorLocation(transform);
+    }
+    async doTransformedCopy(ids, transform, numCopies) {
+        if (numCopies < 1 || 0 === ids.length)
+            return undefined;
+        this._startedCmd = await this.startCommand();
+        const newIds = [];
+        for (const id of ids) {
+            // NOTE: For testing only. Using loadProps to return json format geometry to the frontend for each element in the tool agenda is very inefficient.
+            const props = await this.iModel.elements.loadProps(id, { wantGeometry: true, wantBRepData: true });
+            if (undefined === props.placement)
+                continue;
+            const placement = isPlacement2dProps(props.placement) ? Placement2d.fromJSON(props.placement) : Placement3d.fromJSON(props.placement);
+            if (!placement.isValid)
+                continue; // Ignore assembly parents w/o geometry, etc...
+            const classFullName = (placement.is3d ? "Generic:PhysicalObject" : "BisCore:DrawingGraphic");
+            const newProps = { classFullName, model: props.model, category: props.category, code: Code.createEmpty(), placement, geom: props.geom };
+            let newId;
+            for (let iCopy = 0; iCopy < numCopies; ++iCopy) {
+                placement.multiplyTransform(transform);
+                newId = await basicManipulationIpc.insertGeometricElement(newProps);
+            }
+            if (undefined !== newId)
+                newIds.push(newId); // When numCopies > 1 ids are return for just the final copy...
+        }
+        return (0 === newIds.length ? undefined : newIds);
+    }
+    async transformAndCopyAgenda(transform) {
+        try {
+            const newIds = await this.doTransformedCopy(this.agenda.elements, transform, this.numCopies);
+            if (undefined !== newIds)
+                await this.saveChanges();
+            return newIds;
+        }
+        catch (err) {
+            IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Error, BentleyError.getErrorMessage(err) || "An unknown error occurred."));
+            return undefined;
+        }
+    }
+    async applyToolSettingPropertyChange(updatedValue) {
+        // NOTE: Don't call changeToolSettingPropertyValue, value of numCopies should not be saved...
+        if (updatedValue.propertyName !== this.numCopiesProperty.name || undefined === updatedValue.value.value)
+            return false;
+        this.numCopies = updatedValue.value.value;
+        return true;
+    }
+    supplyToolSettingsProperties() {
+        // NOTE: Don't call initializeToolSettingPropertyValues, value of numCopies is not saved...
+        const toolSettings = new Array();
+        toolSettings.push(this.numCopiesProperty.toDialogItem({ rowPriority: 1, columnIndex: 2 }));
+        return toolSettings;
+    }
+    async onRestartTool() {
+        const tool = new CopyElementsTool();
+        tool.numCopies = this.numCopies; // Preserve numCopies on restart...
+        if (!await tool.run())
+            return this.exitTool();
+    }
+    /** The keyin takes the following arguments, all of which are optional:
+     *  - `numCopies=number` Number of copies of each element to create, default is 1.
+     */
+    async parseAndRun(...inputArgs) {
+        for (const arg of inputArgs) {
+            const parts = arg.split("=");
+            if (2 !== parts.length)
+                continue;
+            if (parts[0].toLowerCase().startsWith("num")) {
+                const copies = Number.parseInt(parts[1], 10);
+                if (copies >= 1)
+                    this.numCopies = copies; // NOTE: Don't call saveToolSettingPropertyValue, always default to single copy...
+            }
+        }
+        return this.run();
+    }
+}
+CopyElementsTool.toolId = "CopyElements";
+CopyElementsTool.iconSpec = "icon-move"; // Need better icon...
+export { CopyElementsTool };
+/** @alpha */
+export var RotateMethod;
+(function (RotateMethod) {
+    RotateMethod[RotateMethod["By3Points"] = 0] = "By3Points";
+    RotateMethod[RotateMethod["ByAngle"] = 1] = "ByAngle";
+})(RotateMethod || (RotateMethod = {}));
+/** @alpha */
+export var RotateAbout;
+(function (RotateAbout) {
+    RotateAbout[RotateAbout["Point"] = 0] = "Point";
+    RotateAbout[RotateAbout["Origin"] = 1] = "Origin";
+    RotateAbout[RotateAbout["Center"] = 2] = "Center";
+})(RotateAbout || (RotateAbout = {}));
+/** @alpha Rotate elements by applying transform to placement. */
+class RotateElementsTool extends TransformElementsTool {
+    constructor() {
+        super(...arguments);
+        this.havePivotPoint = false;
+        this.haveFinalPoint = false;
+    }
+    static get minArgs() { return 0; }
+    static get maxArgs() { return 3; }
+    static methodMessage(str) { return EditTools.translate(`RotateElements.Method.${str}`); }
+    get methodProperty() {
+        if (!this._methodProperty)
+            this._methodProperty = new DialogProperty(PropertyDescriptionHelper.buildEnumPicklistEditorDescription("rotateMethod", EditTools.translate("RotateElements.Label.Method"), RotateElementsTool.getMethodChoices()), RotateMethod.By3Points);
+        return this._methodProperty;
+    }
+    get rotateMethod() { return this.methodProperty.value; }
+    set rotateMethod(method) { this.methodProperty.value = method; }
+    static aboutMessage(str) { return EditTools.translate(`RotateElements.About.${str}`); }
+    get aboutProperty() {
+        if (!this._aboutProperty)
+            this._aboutProperty = new DialogProperty(PropertyDescriptionHelper.buildEnumPicklistEditorDescription("rotateAbout", EditTools.translate("RotateElements.Label.About"), RotateElementsTool.getAboutChoices()), RotateAbout.Point);
+        return this._aboutProperty;
+    }
+    get rotateAbout() { return this.aboutProperty.value; }
+    set rotateAbout(method) { this.aboutProperty.value = method; }
+    get angleProperty() {
+        if (!this._angleProperty)
+            this._angleProperty = new DialogProperty(new AngleDescription("rotateAngle", EditTools.translate("RotateElements.Label.Angle")), 0.0);
+        return this._angleProperty;
+    }
+    get rotateAngle() { return this.angleProperty.value; }
+    set rotateAngle(value) { this.angleProperty.value = value; }
+    get requireAcceptForSelectionSetDynamics() { return RotateMethod.ByAngle !== this.rotateMethod; }
+    calculateTransform(ev) {
+        if (undefined === ev.viewport)
+            return undefined;
+        if (RotateMethod.ByAngle === this.rotateMethod) {
+            const rotMatrix = AccuDrawHintBuilder.getCurrentRotation(ev.viewport, true, true);
+            if (undefined === rotMatrix)
+                return undefined;
+            const invMatrix = rotMatrix.inverse();
+            if (undefined === invMatrix)
+                return undefined;
+            const angMatrix = YawPitchRollAngles.createRadians(this.rotateAngle, 0, 0).toMatrix3d();
+            if (undefined === angMatrix)
+                return undefined;
+            angMatrix.multiplyMatrixMatrix(invMatrix, invMatrix);
+            rotMatrix.multiplyMatrixMatrix(invMatrix, rotMatrix);
+            return Transform.createFixedPointAndMatrix(ev.point, rotMatrix);
+        }
+        if (undefined === this.anchorPoint || undefined === this.xAxisPoint)
+            return undefined;
+        const vec1 = Vector3d.createStartEnd(this.anchorPoint, this.xAxisPoint);
+        const vec2 = Vector3d.createStartEnd(this.anchorPoint, ev.point);
+        if (!vec1.normalizeInPlace() || !vec2.normalizeInPlace())
+            return undefined;
+        const dot = vec1.dotProduct(vec2);
+        if (dot > (1.0 - Geometry.smallAngleRadians))
+            return undefined;
+        if (dot < (-1.0 + Geometry.smallAngleRadians)) {
+            const rotMatrix = AccuDrawHintBuilder.getCurrentRotation(ev.viewport, true, true);
+            if (undefined === rotMatrix)
+                return undefined;
+            const invMatrix = rotMatrix.inverse();
+            if (undefined === invMatrix)
+                return undefined;
+            const angMatrix = YawPitchRollAngles.createRadians(Math.PI, 0, 0).toMatrix3d(); // 180 degree rotation...
+            if (undefined === angMatrix)
+                return undefined;
+            angMatrix.multiplyMatrixMatrix(invMatrix, invMatrix);
+            rotMatrix.multiplyMatrixMatrix(invMatrix, rotMatrix);
+            return Transform.createFixedPointAndMatrix(this.anchorPoint, rotMatrix);
+        }
+        const zVec = vec1.unitCrossProduct(vec2);
+        if (undefined === zVec)
+            return undefined;
+        const yVec = zVec.unitCrossProduct(vec1);
+        if (undefined === yVec)
+            return undefined;
+        const matrix1 = Matrix3d.createRows(vec1, yVec, zVec);
+        zVec.unitCrossProduct(vec2, yVec);
+        const matrix2 = Matrix3d.createColumns(vec2, yVec, zVec);
+        const matrix = matrix2.multiplyMatrixMatrix(matrix1);
+        if (undefined === matrix)
+            return undefined;
+        return Transform.createFixedPointAndMatrix(this.anchorPoint, matrix);
+    }
+    transformAgendaDynamics(transform, context) {
+        if (RotateAbout.Point === this.rotateAbout)
+            return super.transformAgendaDynamics(transform, context);
+        if (undefined === this._graphicsProvider)
+            return;
+        const rotatePoint = Point3d.create();
+        for (const data of this._graphicsProvider.data) {
+            if (RotateAbout.Origin === this.rotateAbout)
+                rotatePoint.setFrom(data.placement.origin);
+            else
+                rotatePoint.setFrom(data.placement.calculateRange().center);
+            const rotateTrans = Transform.createFixedPointAndMatrix(rotatePoint, transform.matrix);
+            this._graphicsProvider.addSingleGraphic(data.graphic, rotateTrans, context);
+        }
+    }
+    async transformAgenda(transform) {
+        if (RotateAbout.Point === this.rotateAbout)
+            return super.transformAgenda(transform);
+        try {
+            this._startedCmd = await this.startCommand();
+            if (IModelStatus.Success === await basicManipulationIpc.rotatePlacement(this.agenda.compressIds(), transform.matrix.toJSON(), RotateAbout.Center === this.rotateAbout))
+                await this.saveChanges();
+        }
+        catch (err) {
+            IModelApp.notifications.outputMessage(new NotifyMessageDetails(OutputMessagePriority.Error, BentleyError.getErrorMessage(err) || "An unknown error occurred."));
+        }
+    }
+    onDynamicFrame(ev, context) {
+        const transform = this.calculateTransform(ev);
+        if (undefined !== transform)
+            return this.transformAgendaDynamics(transform, context);
+        if (undefined === this.anchorPoint)
+            return;
+        const builder = context.createGraphic({ type: GraphicType.WorldOverlay });
+        builder.setSymbology(context.viewport.getContrastToBackgroundColor(), ColorDef.black, 1, LinePixels.Code2);
+        builder.addLineString([this.anchorPoint.clone(), ev.point.clone()]);
+        context.addGraphic(builder.finish());
+    }
+    get wantAdditionalInput() {
+        if (RotateMethod.ByAngle === this.rotateMethod)
+            return super.wantAdditionalInput;
+        return !this.haveFinalPoint;
+    }
+    wantProcessAgenda(ev) {
+        if (RotateMethod.ByAngle === this.rotateMethod)
+            return super.wantProcessAgenda(ev);
+        if (!this.havePivotPoint)
+            this.havePivotPoint = true; // Uses anchorPoint...
+        else if (undefined === this.xAxisPoint)
+            this.xAxisPoint = ev.point.clone();
+        else if (!this.haveFinalPoint)
+            this.haveFinalPoint = true; // Uses button event...
+        return super.wantProcessAgenda(ev);
+    }
+    setupAndPromptForNextAction() {
+        super.setupAndPromptForNextAction();
+        if (RotateMethod.ByAngle === this.rotateMethod)
+            return;
+        if (undefined === this.anchorPoint || undefined === this.xAxisPoint)
+            return;
+        const hints = new AccuDrawHintBuilder();
+        hints.setXAxis(Vector3d.createStartEnd(this.anchorPoint, this.xAxisPoint));
+        hints.setOrigin(this.anchorPoint);
+        hints.setModePolar();
+        hints.sendHints();
+    }
+    provideToolAssistance(_mainInstrText, _additionalInstr) {
+        let mainMsg;
+        if (RotateMethod.ByAngle === this.rotateMethod) {
+            if (!this.isSelectByPoints && !this.wantAdditionalElements && this.wantAdditionalInput)
+                mainMsg = EditTools.translate("RotateElements.Prompts.IdentifyPoint");
+        }
+        else {
+            if (!this.isSelectByPoints && !this.wantAdditionalElements) {
+                if (!this.havePivotPoint)
+                    mainMsg = EditTools.translate("RotateElements.Prompts.IdentifyPoint");
+                else if (undefined === this.xAxisPoint)
+                    mainMsg = EditTools.translate("RotateElements.Prompts.DefineStart");
+                else
+                    mainMsg = EditTools.translate("RotateElements.Prompts.DefineAmount");
+            }
+        }
+        super.provideToolAssistance(mainMsg);
+    }
+    async applyToolSettingPropertyChange(updatedValue) {
+        if (!this.changeToolSettingPropertyValue(updatedValue))
+            return false;
+        if (this.methodProperty.name === updatedValue.propertyName)
+            await this.onRestartTool(); // calling restart, not reinitialize to not exit tool for selection set...
+        return true;
+    }
+    supplyToolSettingsProperties() {
+        const toolSettings = new Array();
+        toolSettings.push(this.methodProperty.toDialogItem({ rowPriority: 1, columnIndex: 2 }));
+        toolSettings.push(this.aboutProperty.toDialogItem({ rowPriority: 2, columnIndex: 2 }));
+        if (RotateMethod.ByAngle === this.rotateMethod)
+            toolSettings.push(this.angleProperty.toDialogItem({ rowPriority: 3, columnIndex: 2 }));
+        return toolSettings;
+    }
+    async onRestartTool() {
+        const tool = new RotateElementsTool();
+        if (!await tool.run())
+            return this.exitTool();
+    }
+    async onInstall() {
+        if (!await super.onInstall())
+            return false;
+        // Setup initial values here instead of supplyToolSettingsProperties to support keyin args w/o appui-react...
+        this.initializeToolSettingPropertyValues([this.methodProperty, this.aboutProperty, this.angleProperty]);
+        return true;
+    }
+    /** The keyin takes the following arguments, all of which are optional:
+     *  - `method=0|1` How rotate angle will be specified. 0 for by 3 points, 1 for by specified angle.
+     *  - `about=0|1|2` Location to rotate about. 0 for point, 1 for placement origin, and 2 for center of range.
+     *  - `angle=number` Rotation angle in degrees when not defining angle by points.
+     */
+    async parseAndRun(...inputArgs) {
+        let rotateMethod;
+        let rotateAbout;
+        let rotateAngle;
+        for (const arg of inputArgs) {
+            const parts = arg.split("=");
+            if (2 !== parts.length)
+                continue;
+            if (parts[0].toLowerCase().startsWith("me")) {
+                const method = Number.parseInt(parts[1], 10);
+                if (!Number.isNaN(method)) {
+                    switch (method) {
+                        case 0:
+                            rotateMethod = RotateMethod.By3Points;
+                            break;
+                        case 1:
+                            rotateMethod = RotateMethod.ByAngle;
+                            break;
+                    }
+                }
+            }
+            else if (parts[0].toLowerCase().startsWith("ab")) {
+                const about = Number.parseInt(parts[1], 10);
+                if (!Number.isNaN(about)) {
+                    switch (about) {
+                        case 0:
+                            rotateAbout = RotateAbout.Point;
+                            break;
+                        case 1:
+                            rotateAbout = RotateAbout.Origin;
+                            break;
+                        case 2:
+                            rotateAbout = RotateAbout.Center;
+                            break;
+                    }
+                }
+            }
+            else if (parts[0].toLowerCase().startsWith("an")) {
+                const angle = Number.parseFloat(parts[1]);
+                if (!Number.isNaN(angle)) {
+                    rotateAngle = Angle.createDegrees(angle).radians;
+                }
+            }
+        }
+        // Update current session values so keyin args are picked up for tool settings/restart...
+        if (undefined !== rotateMethod)
+            this.saveToolSettingPropertyValue(this.methodProperty, { value: rotateMethod });
+        if (undefined !== rotateAbout)
+            this.saveToolSettingPropertyValue(this.aboutProperty, { value: rotateAbout });
+        if (undefined !== rotateAngle)
+            this.saveToolSettingPropertyValue(this.angleProperty, { value: rotateAngle });
+        return this.run();
+    }
+}
+RotateElementsTool.toolId = "RotateElements";
+RotateElementsTool.iconSpec = "icon-rotate";
+RotateElementsTool.getMethodChoices = () => {
+    return [
+        { label: RotateElementsTool.methodMessage("3Points"), value: RotateMethod.By3Points },
+        { label: RotateElementsTool.methodMessage("Angle"), value: RotateMethod.ByAngle },
+    ];
+};
+RotateElementsTool.getAboutChoices = () => {
+    return [
+        { label: RotateElementsTool.aboutMessage("Point"), value: RotateAbout.Point },
+        { label: RotateElementsTool.aboutMessage("Origin"), value: RotateAbout.Origin },
+        { label: RotateElementsTool.aboutMessage("Center"), value: RotateAbout.Center },
+    ];
+};
+export { RotateElementsTool };
 //# sourceMappingURL=TransformElementsTool.js.map