@itwin/editor-frontend 3.4.1 → 3.4.3

package/lib/esm/CreateElementTool.js

@@ -1,320 +1,320 @@
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-import { Id64, IModelStatus } from "@itwin/core-bentley";
-import { Constant, Point3d, Vector3d } from "@itwin/core-geometry";
-import { IModelError, isPlacement3dProps } from "@itwin/core-common";
-import { CoordSystem, CoreTools, EventHandled, GraphicBranch, IModelApp, PrimitiveTool, readElementGraphics, ToolAssistance, ToolAssistanceImage, ToolAssistanceInputMethod } from "@itwin/core-frontend";
-function computeChordToleranceFromPointAndRadius(vp, center, radius) {
-    if (vp.view.is3d() && vp.view.isCameraOn) {
-        const nearFrontCenter = vp.getFrustum(CoordSystem.World).frontCenter;
-        const toFront = Vector3d.createStartEnd(center, nearFrontCenter);
-        const viewZ = vp.rotation.rowZ();
-        // If the sphere overlaps the near front plane just use near front point. This also handles behind eye conditions.
-        if (viewZ.dotProduct(toFront) < radius) {
-            center = nearFrontCenter;
-        }
-        else {
-            // Find point on sphere closest to eye.
-            const toEye = center.unitVectorTo(vp.view.camera.eye);
-            // Only if not already behind the eye.
-            if (toEye) {
-                toEye.scaleInPlace(radius);
-                center.addInPlace(toEye);
-            }
-        }
-    }
-    const viewPt = vp.worldToViewMap.transform0.multiplyPoint3dQuietNormalize(center);
-    const viewPt2 = new Point3d(viewPt.x + 1.0, viewPt.y, viewPt.z);
-    const pixelSize = vp.worldToViewMap.transform1.multiplyPoint3dQuietNormalize(viewPt).distance(vp.worldToViewMap.transform1.multiplyPoint3dQuietNormalize(viewPt2));
-    // Return size of a physical pixel in meters.
-    return (0.0 !== pixelSize ? vp.target.adjustPixelSizeForLOD(pixelSize) : 0.001);
-}
-/** @alpha */
-export function computeChordToleranceFromPoint(vp, pt, radius) {
-    return computeChordToleranceFromPointAndRadius(vp, pt, radius ? radius : Constant.oneCentimeter);
-}
-/** @alpha */
-export function computeChordToleranceFromRange(vp, range) {
-    return computeChordToleranceFromPointAndRadius(vp, range.center, 0.5 * range.low.distance(range.high));
-}
-/** @alpha */
-export class DynamicGraphicsProvider {
-    constructor(iModel, prefix) {
-        /** Chord tolerance to use to stroke the element's geometry in meters */
-        this.chordTolerance = 0.001;
-        this.iModel = iModel;
-        this.prefix = prefix;
-    }
-    getRequestId(id) { return `${this.prefix}-${id}`; }
-    getToleranceLog10() { return Math.floor(Math.log10(this.chordTolerance)); }
-    async createRequest(categoryId, placement, geometry) {
-        let graphicData;
-        let is3d;
-        if (is3d = isPlacement3dProps(placement)) {
-            const requestProps = {
-                id: this.getRequestId(this.elementId ? this.elementId : Id64.invalid),
-                elementId: this.elementId,
-                modelId: this.modelId,
-                toleranceLog10: this.getToleranceLog10(),
-                type: "3d",
-                placement,
-                categoryId,
-                geometry,
-            };
-            graphicData = await IModelApp.tileAdmin.requestElementGraphics(this.iModel, requestProps);
-            is3d = true;
-        }
-        else {
-            const requestProps = {
-                id: this.getRequestId(this.elementId ? this.elementId : Id64.invalid),
-                elementId: this.elementId,
-                modelId: this.modelId,
-                toleranceLog10: this.getToleranceLog10(),
-                type: "2d",
-                placement,
-                categoryId,
-                geometry,
-            };
-            graphicData = await IModelApp.tileAdmin.requestElementGraphics(this.iModel, requestProps);
-        }
-        if (undefined === graphicData)
-            return;
-        const graphic = await readElementGraphics(graphicData, this.iModel, this.modelId ? this.modelId : Id64.invalid, is3d, { noFlash: true, noHilite: true });
-        if (undefined === graphic)
-            return;
-        return IModelApp.renderSystem.createGraphicOwner(graphic);
-    }
-    /** Call to request a RenderGraphic for the supplied geometry and placement.
-     * @see [[cleanupGraphic]] Must be called when the tool exits.
-     */
-    async createGraphic(categoryId, placement, geometry) {
-        try {
-            const graphic = await this.createRequest(categoryId, placement, geometry);
-            this.cleanupGraphic();
-            return (undefined !== (this.graphic = graphic));
-        }
-        catch {
-            return false;
-        }
-    }
-    /** Call to request a RenderGraphic for the supplied geometry and trigger a dynamic update upon fulfillment.
-     * @note May be useful to update a dynamic preview outside of normal button and motion events, ex. modifier key change.
-     * @see [[cleanupGraphic]] Must be called when the tool exits.
-     */
-    createGraphicAndUpdateDynamics(ev, categoryId, placement, geometry) {
-        const promise = this._graphicPromise = this.createGraphic(categoryId, placement, geometry);
-        promise.then(() => {
-            if (promise !== this._graphicPromise)
-                return; // abandoned this request...
-            IModelApp.toolAdmin.updateDynamics(ev);
-        }).catch((_) => { });
-    }
-    /** Call to dispose of [[RenderGraphic]] held by [[RenderGraphicOwner]].
-     * @note Must be called when the tool exits to avoid leaks of graphics memory or other webgl resources.
-     */
-    cleanupGraphic() {
-        if (undefined === this.graphic)
-            return;
-        this.graphic.disposeGraphic();
-        this.graphic = undefined;
-    }
-    addGraphic(context, transform) {
-        if (undefined === this.graphic)
-            return;
-        if (undefined === transform) {
-            context.addGraphic(this.graphic);
-            return;
-        }
-        const branch = new GraphicBranch(false);
-        branch.add(this.graphic);
-        const branchGraphic = context.createBranch(branch, transform);
-        context.addGraphic(branchGraphic);
-    }
-}
-/** @alpha Placement tool base class for creating new elements. */
-export class CreateElementTool extends PrimitiveTool {
-    get targetCategory() {
-        var _a;
-        const category = (_a = this.briefcase) === null || _a === void 0 ? void 0 : _a.editorToolSettings.category;
-        if (undefined === category)
-            throw new IModelError(IModelStatus.InvalidCategory, "");
-        return category;
-    }
-    get targetModelId() {
-        var _a;
-        const model = (_a = this.briefcase) === null || _a === void 0 ? void 0 : _a.editorToolSettings.model;
-        if (undefined === model)
-            throw new IModelError(IModelStatus.BadModel, "");
-        return model;
-    }
-    isCompatibleViewport(vp, isSelectedViewChange) {
-        if (!(vp === null || vp === void 0 ? void 0 : vp.iModel.isBriefcaseConnection()))
-            return false;
-        return undefined !== vp.iModel.editorToolSettings.model && super.isCompatibleViewport(vp, isSelectedViewChange);
-    }
-    /** Whether [[setupAndPromptForNextAction]] should call [[AccuSnap.enableSnap]] for current tool phase.
-     * @return true to enable snapping to elements.
-     */
-    get wantAccuSnap() { return false; }
-    /** Whether to automatically start element dynamics on button event.
-     * @return true if tool will implement [[InteractiveTool.onDynamicFrame]] to show element dynamics.
-     */
-    get wantDynamics() { return false; }
-    /** Whether tool is ready to insert the new element.
-     * @return true to call [[createElement]].
-     */
-    isComplete(_ev) { return false; }
-    /** Orchestrates advancing the internal state of the tool on a data button event.
-     * - Gather input: Initiates element dynamics and accepts additional points as required.
-     * - Complete operation: Create new element, restart or exit tool.
-     * @returns EventHandled.Yes if onReinitialize was called to restart or exit tool.
-     */
-    async processDataButton(ev) {
-        if (this.isComplete(ev)) {
-            await this.createElement();
-            await this.onReinitialize();
-            return EventHandled.Yes;
-        }
-        this.setupAndPromptForNextAction();
-        if (!this.isDynamicsStarted && this.wantDynamics)
-            this.beginDynamics();
-        return EventHandled.No;
-    }
-    async onDataButtonDown(ev) {
-        return this.processDataButton(ev);
-    }
-    async onResetButtonUp(_ev) {
-        await this.onReinitialize();
-        return EventHandled.No;
-    }
-    /** Setup initial tool state, prompts, etc. */
-    async onPostInstall() {
-        await super.onPostInstall();
-        this.setupAndPromptForNextAction();
-    }
-    /** Restore tool assistance after no longer being suspended by either a [[ViewTool]] or [[InputCollector]]. */
-    async onUnsuspend() {
-        this.provideToolAssistance();
-    }
-    /** Setup auto-locate, AccuSnap, AccuDraw, and supply tool assistance. */
-    setupAndPromptForNextAction() {
-        IModelApp.accuSnap.enableSnap(this.wantAccuSnap);
-        this.provideToolAssistance();
-    }
-    /** Sub-classes should override to provide tool specific instructions. */
-    provideToolAssistance(mainInstrText, additionalInstr) {
-        const mainMsg = "ElementSet.Prompts.IdentifyPoint";
-        const leftMsg = "ElementSet.Inputs.AcceptPoint";
-        const rightMsg = "ElementSet.Inputs.Cancel";
-        const mouseInstructions = [];
-        const touchInstructions = [];
-        if (!ToolAssistance.createTouchCursorInstructions(touchInstructions))
-            touchInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.OneTouchTap, CoreTools.translate(leftMsg), false, ToolAssistanceInputMethod.Touch));
-        mouseInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.LeftClick, CoreTools.translate(leftMsg), false, ToolAssistanceInputMethod.Mouse));
-        touchInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.TwoTouchTap, CoreTools.translate(rightMsg), false, ToolAssistanceInputMethod.Touch));
-        mouseInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.RightClick, CoreTools.translate(rightMsg), false, ToolAssistanceInputMethod.Mouse));
-        if (undefined !== additionalInstr) {
-            for (const instr of additionalInstr) {
-                if (ToolAssistanceInputMethod.Touch === instr.inputMethod)
-                    touchInstructions.push(instr);
-                else
-                    mouseInstructions.push(instr);
-            }
-        }
-        const sections = [];
-        sections.push(ToolAssistance.createSection(mouseInstructions, ToolAssistance.inputsLabel));
-        sections.push(ToolAssistance.createSection(touchInstructions, ToolAssistance.inputsLabel));
-        const mainInstruction = ToolAssistance.createInstruction(this.iconSpec, undefined !== mainInstrText ? mainInstrText : CoreTools.translate(mainMsg));
-        const instructions = ToolAssistance.createInstructions(mainInstruction, sections);
-        IModelApp.notifications.setToolAssistance(instructions);
-    }
-}
-/** @alpha Placement tool base class for creating new elements that use dynamics to show intermediate results. */
-export class CreateElementWithDynamicsTool extends CreateElementTool {
-    get wantAccuSnap() { return true; }
-    get wantDynamics() { return true; }
-    clearGraphics() {
-        if (undefined === this._graphicsProvider)
-            return;
-        this._graphicsProvider.cleanupGraphic();
-        this._graphicsProvider = undefined;
-    }
-    async createGraphics(ev) {
-        if (!await this.updateDynamicData(ev))
-            return;
-        const placement = this.getPlacementProps();
-        if (undefined === placement)
-            return;
-        const geometry = this.getGeometryProps(placement);
-        if (undefined === geometry)
-            return;
-        if (undefined === this._graphicsProvider)
-            this._graphicsProvider = new DynamicGraphicsProvider(this.iModel, this.toolId);
-        // Set chord tolerance for curved surfaces...
-        if (ev.viewport)
-            this._graphicsProvider.chordTolerance = computeChordToleranceFromPoint(ev.viewport, ev.point);
-        await this._graphicsProvider.createGraphic(this.targetCategory, placement, geometry);
-    }
-    onDynamicFrame(_ev, context) {
-        if (undefined !== this._graphicsProvider)
-            this._graphicsProvider.addGraphic(context);
-    }
-    async onMouseMotion(ev) {
-        return this.createGraphics(ev);
-    }
-    async doCreateElement(_props, _data) { }
-    async updateElementData(_ev, _isDynamics) { }
-    async updateDynamicData(ev) {
-        if (!IModelApp.viewManager.inDynamicsMode)
-            return false; // Don't need to create graphic if dynamics aren't yet active...
-        await this.updateElementData(ev, true);
-        return true;
-    }
-    async createElement() {
-        const placement = this.getPlacementProps();
-        if (undefined === placement)
-            return;
-        const geometry = this.getGeometryProps(placement);
-        if (undefined === geometry)
-            return;
-        const elemProps = this.getElementProps(placement);
-        if (undefined === elemProps)
-            return;
-        let data;
-        if ("flatbuffer" === geometry.format) {
-            data = { entryArray: geometry.data };
-            delete elemProps.geom; // Leave unchanged until replaced by flatbuffer geometry...
-        }
-        else {
-            elemProps.geom = geometry.data;
-        }
-        return this.doCreateElement(elemProps, data);
-    }
-    setupAccuDraw() { }
-    setupAndPromptForNextAction() {
-        this.setupAccuDraw();
-        super.setupAndPromptForNextAction();
-    }
-    async acceptPoint(ev) {
-        await this.updateElementData(ev, false);
-        return true;
-    }
-    async onDataButtonDown(ev) {
-        if (!await this.acceptPoint(ev))
-            return EventHandled.Yes;
-        return super.onDataButtonDown(ev);
-    }
-    async cancelPoint(_ev) { return true; }
-    async onResetButtonUp(ev) {
-        if (!await this.cancelPoint(ev))
-            return EventHandled.Yes;
-        return super.onResetButtonUp(ev);
-    }
-    async onCleanup() {
-        this.clearGraphics();
-        return super.onCleanup();
-    }
-}
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+import { Id64, IModelStatus } from "@itwin/core-bentley";
+import { Constant, Point3d, Vector3d } from "@itwin/core-geometry";
+import { IModelError, isPlacement3dProps } from "@itwin/core-common";
+import { CoordSystem, CoreTools, EventHandled, GraphicBranch, IModelApp, PrimitiveTool, readElementGraphics, ToolAssistance, ToolAssistanceImage, ToolAssistanceInputMethod } from "@itwin/core-frontend";
+function computeChordToleranceFromPointAndRadius(vp, center, radius) {
+    if (vp.view.is3d() && vp.view.isCameraOn) {
+        const nearFrontCenter = vp.getFrustum(CoordSystem.World).frontCenter;
+        const toFront = Vector3d.createStartEnd(center, nearFrontCenter);
+        const viewZ = vp.rotation.rowZ();
+        // If the sphere overlaps the near front plane just use near front point. This also handles behind eye conditions.
+        if (viewZ.dotProduct(toFront) < radius) {
+            center = nearFrontCenter;
+        }
+        else {
+            // Find point on sphere closest to eye.
+            const toEye = center.unitVectorTo(vp.view.camera.eye);
+            // Only if not already behind the eye.
+            if (toEye) {
+                toEye.scaleInPlace(radius);
+                center.addInPlace(toEye);
+            }
+        }
+    }
+    const viewPt = vp.worldToViewMap.transform0.multiplyPoint3dQuietNormalize(center);
+    const viewPt2 = new Point3d(viewPt.x + 1.0, viewPt.y, viewPt.z);
+    const pixelSize = vp.worldToViewMap.transform1.multiplyPoint3dQuietNormalize(viewPt).distance(vp.worldToViewMap.transform1.multiplyPoint3dQuietNormalize(viewPt2));
+    // Return size of a physical pixel in meters.
+    return (0.0 !== pixelSize ? vp.target.adjustPixelSizeForLOD(pixelSize) : 0.001);
+}
+/** @alpha */
+export function computeChordToleranceFromPoint(vp, pt, radius) {
+    return computeChordToleranceFromPointAndRadius(vp, pt, radius ? radius : Constant.oneCentimeter);
+}
+/** @alpha */
+export function computeChordToleranceFromRange(vp, range) {
+    return computeChordToleranceFromPointAndRadius(vp, range.center, 0.5 * range.low.distance(range.high));
+}
+/** @alpha */
+export class DynamicGraphicsProvider {
+    constructor(iModel, prefix) {
+        /** Chord tolerance to use to stroke the element's geometry in meters */
+        this.chordTolerance = 0.001;
+        this.iModel = iModel;
+        this.prefix = prefix;
+    }
+    getRequestId(id) { return `${this.prefix}-${id}`; }
+    getToleranceLog10() { return Math.floor(Math.log10(this.chordTolerance)); }
+    async createRequest(categoryId, placement, geometry) {
+        let graphicData;
+        let is3d;
+        if (is3d = isPlacement3dProps(placement)) {
+            const requestProps = {
+                id: this.getRequestId(this.elementId ? this.elementId : Id64.invalid),
+                elementId: this.elementId,
+                modelId: this.modelId,
+                toleranceLog10: this.getToleranceLog10(),
+                type: "3d",
+                placement,
+                categoryId,
+                geometry,
+            };
+            graphicData = await IModelApp.tileAdmin.requestElementGraphics(this.iModel, requestProps);
+            is3d = true;
+        }
+        else {
+            const requestProps = {
+                id: this.getRequestId(this.elementId ? this.elementId : Id64.invalid),
+                elementId: this.elementId,
+                modelId: this.modelId,
+                toleranceLog10: this.getToleranceLog10(),
+                type: "2d",
+                placement,
+                categoryId,
+                geometry,
+            };
+            graphicData = await IModelApp.tileAdmin.requestElementGraphics(this.iModel, requestProps);
+        }
+        if (undefined === graphicData)
+            return;
+        const graphic = await readElementGraphics(graphicData, this.iModel, this.modelId ? this.modelId : Id64.invalid, is3d, { noFlash: true, noHilite: true });
+        if (undefined === graphic)
+            return;
+        return IModelApp.renderSystem.createGraphicOwner(graphic);
+    }
+    /** Call to request a RenderGraphic for the supplied geometry and placement.
+     * @see [[cleanupGraphic]] Must be called when the tool exits.
+     */
+    async createGraphic(categoryId, placement, geometry) {
+        try {
+            const graphic = await this.createRequest(categoryId, placement, geometry);
+            this.cleanupGraphic();
+            return (undefined !== (this.graphic = graphic));
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Call to request a RenderGraphic for the supplied geometry and trigger a dynamic update upon fulfillment.
+     * @note May be useful to update a dynamic preview outside of normal button and motion events, ex. modifier key change.
+     * @see [[cleanupGraphic]] Must be called when the tool exits.
+     */
+    createGraphicAndUpdateDynamics(ev, categoryId, placement, geometry) {
+        const promise = this._graphicPromise = this.createGraphic(categoryId, placement, geometry);
+        promise.then(() => {
+            if (promise !== this._graphicPromise)
+                return; // abandoned this request...
+            IModelApp.toolAdmin.updateDynamics(ev);
+        }).catch((_) => { });
+    }
+    /** Call to dispose of [[RenderGraphic]] held by [[RenderGraphicOwner]].
+     * @note Must be called when the tool exits to avoid leaks of graphics memory or other webgl resources.
+     */
+    cleanupGraphic() {
+        if (undefined === this.graphic)
+            return;
+        this.graphic.disposeGraphic();
+        this.graphic = undefined;
+    }
+    addGraphic(context, transform) {
+        if (undefined === this.graphic)
+            return;
+        if (undefined === transform) {
+            context.addGraphic(this.graphic);
+            return;
+        }
+        const branch = new GraphicBranch(false);
+        branch.add(this.graphic);
+        const branchGraphic = context.createBranch(branch, transform);
+        context.addGraphic(branchGraphic);
+    }
+}
+/** @alpha Placement tool base class for creating new elements. */
+export class CreateElementTool extends PrimitiveTool {
+    get targetCategory() {
+        var _a;
+        const category = (_a = this.briefcase) === null || _a === void 0 ? void 0 : _a.editorToolSettings.category;
+        if (undefined === category)
+            throw new IModelError(IModelStatus.InvalidCategory, "");
+        return category;
+    }
+    get targetModelId() {
+        var _a;
+        const model = (_a = this.briefcase) === null || _a === void 0 ? void 0 : _a.editorToolSettings.model;
+        if (undefined === model)
+            throw new IModelError(IModelStatus.BadModel, "");
+        return model;
+    }
+    isCompatibleViewport(vp, isSelectedViewChange) {
+        if (!(vp === null || vp === void 0 ? void 0 : vp.iModel.isBriefcaseConnection()))
+            return false;
+        return undefined !== vp.iModel.editorToolSettings.model && super.isCompatibleViewport(vp, isSelectedViewChange);
+    }
+    /** Whether [[setupAndPromptForNextAction]] should call [[AccuSnap.enableSnap]] for current tool phase.
+     * @return true to enable snapping to elements.
+     */
+    get wantAccuSnap() { return false; }
+    /** Whether to automatically start element dynamics on button event.
+     * @return true if tool will implement [[InteractiveTool.onDynamicFrame]] to show element dynamics.
+     */
+    get wantDynamics() { return false; }
+    /** Whether tool is ready to insert the new element.
+     * @return true to call [[createElement]].
+     */
+    isComplete(_ev) { return false; }
+    /** Orchestrates advancing the internal state of the tool on a data button event.
+     * - Gather input: Initiates element dynamics and accepts additional points as required.
+     * - Complete operation: Create new element, restart or exit tool.
+     * @returns EventHandled.Yes if onReinitialize was called to restart or exit tool.
+     */
+    async processDataButton(ev) {
+        if (this.isComplete(ev)) {
+            await this.createElement();
+            await this.onReinitialize();
+            return EventHandled.Yes;
+        }
+        this.setupAndPromptForNextAction();
+        if (!this.isDynamicsStarted && this.wantDynamics)
+            this.beginDynamics();
+        return EventHandled.No;
+    }
+    async onDataButtonDown(ev) {
+        return this.processDataButton(ev);
+    }
+    async onResetButtonUp(_ev) {
+        await this.onReinitialize();
+        return EventHandled.No;
+    }
+    /** Setup initial tool state, prompts, etc. */
+    async onPostInstall() {
+        await super.onPostInstall();
+        this.setupAndPromptForNextAction();
+    }
+    /** Restore tool assistance after no longer being suspended by either a [[ViewTool]] or [[InputCollector]]. */
+    async onUnsuspend() {
+        this.provideToolAssistance();
+    }
+    /** Setup auto-locate, AccuSnap, AccuDraw, and supply tool assistance. */
+    setupAndPromptForNextAction() {
+        IModelApp.accuSnap.enableSnap(this.wantAccuSnap);
+        this.provideToolAssistance();
+    }
+    /** Sub-classes should override to provide tool specific instructions. */
+    provideToolAssistance(mainInstrText, additionalInstr) {
+        const mainMsg = "ElementSet.Prompts.IdentifyPoint";
+        const leftMsg = "ElementSet.Inputs.AcceptPoint";
+        const rightMsg = "ElementSet.Inputs.Cancel";
+        const mouseInstructions = [];
+        const touchInstructions = [];
+        if (!ToolAssistance.createTouchCursorInstructions(touchInstructions))
+            touchInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.OneTouchTap, CoreTools.translate(leftMsg), false, ToolAssistanceInputMethod.Touch));
+        mouseInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.LeftClick, CoreTools.translate(leftMsg), false, ToolAssistanceInputMethod.Mouse));
+        touchInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.TwoTouchTap, CoreTools.translate(rightMsg), false, ToolAssistanceInputMethod.Touch));
+        mouseInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.RightClick, CoreTools.translate(rightMsg), false, ToolAssistanceInputMethod.Mouse));
+        if (undefined !== additionalInstr) {
+            for (const instr of additionalInstr) {
+                if (ToolAssistanceInputMethod.Touch === instr.inputMethod)
+                    touchInstructions.push(instr);
+                else
+                    mouseInstructions.push(instr);
+            }
+        }
+        const sections = [];
+        sections.push(ToolAssistance.createSection(mouseInstructions, ToolAssistance.inputsLabel));
+        sections.push(ToolAssistance.createSection(touchInstructions, ToolAssistance.inputsLabel));
+        const mainInstruction = ToolAssistance.createInstruction(this.iconSpec, undefined !== mainInstrText ? mainInstrText : CoreTools.translate(mainMsg));
+        const instructions = ToolAssistance.createInstructions(mainInstruction, sections);
+        IModelApp.notifications.setToolAssistance(instructions);
+    }
+}
+/** @alpha Placement tool base class for creating new elements that use dynamics to show intermediate results. */
+export class CreateElementWithDynamicsTool extends CreateElementTool {
+    get wantAccuSnap() { return true; }
+    get wantDynamics() { return true; }
+    clearGraphics() {
+        if (undefined === this._graphicsProvider)
+            return;
+        this._graphicsProvider.cleanupGraphic();
+        this._graphicsProvider = undefined;
+    }
+    async createGraphics(ev) {
+        if (!await this.updateDynamicData(ev))
+            return;
+        const placement = this.getPlacementProps();
+        if (undefined === placement)
+            return;
+        const geometry = this.getGeometryProps(placement);
+        if (undefined === geometry)
+            return;
+        if (undefined === this._graphicsProvider)
+            this._graphicsProvider = new DynamicGraphicsProvider(this.iModel, this.toolId);
+        // Set chord tolerance for curved surfaces...
+        if (ev.viewport)
+            this._graphicsProvider.chordTolerance = computeChordToleranceFromPoint(ev.viewport, ev.point);
+        await this._graphicsProvider.createGraphic(this.targetCategory, placement, geometry);
+    }
+    onDynamicFrame(_ev, context) {
+        if (undefined !== this._graphicsProvider)
+            this._graphicsProvider.addGraphic(context);
+    }
+    async onMouseMotion(ev) {
+        return this.createGraphics(ev);
+    }
+    async doCreateElement(_props, _data) { }
+    async updateElementData(_ev, _isDynamics) { }
+    async updateDynamicData(ev) {
+        if (!IModelApp.viewManager.inDynamicsMode)
+            return false; // Don't need to create graphic if dynamics aren't yet active...
+        await this.updateElementData(ev, true);
+        return true;
+    }
+    async createElement() {
+        const placement = this.getPlacementProps();
+        if (undefined === placement)
+            return;
+        const geometry = this.getGeometryProps(placement);
+        if (undefined === geometry)
+            return;
+        const elemProps = this.getElementProps(placement);
+        if (undefined === elemProps)
+            return;
+        let data;
+        if ("flatbuffer" === geometry.format) {
+            data = { entryArray: geometry.data };
+            delete elemProps.geom; // Leave unchanged until replaced by flatbuffer geometry...
+        }
+        else {
+            elemProps.geom = geometry.data;
+        }
+        return this.doCreateElement(elemProps, data);
+    }
+    setupAccuDraw() { }
+    setupAndPromptForNextAction() {
+        this.setupAccuDraw();
+        super.setupAndPromptForNextAction();
+    }
+    async acceptPoint(ev) {
+        await this.updateElementData(ev, false);
+        return true;
+    }
+    async onDataButtonDown(ev) {
+        if (!await this.acceptPoint(ev))
+            return EventHandled.Yes;
+        return super.onDataButtonDown(ev);
+    }
+    async cancelPoint(_ev) { return true; }
+    async onResetButtonUp(ev) {
+        if (!await this.cancelPoint(ev))
+            return EventHandled.Yes;
+        return super.onResetButtonUp(ev);
+    }
+    async onCleanup() {
+        this.clearGraphics();
+        return super.onCleanup();
+    }
+}
 //# sourceMappingURL=CreateElementTool.js.map