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

package/lib/cjs/ElementGeometryTool.js

@@ -1,705 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-/** @packageDocumentation
- * @module Editing
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocateSubEntityTool = exports.ElementGeometryCacheTool = exports.SubEntityData = exports.isSameSubEntity = exports.ElementGeometryGraphicsProvider = void 0;
-const core_bentley_1 = require("@itwin/core-bentley");
-const core_common_1 = require("@itwin/core-common");
-const core_frontend_1 = require("@itwin/core-frontend");
-const core_geometry_1 = require("@itwin/core-geometry");
-const editor_common_1 = require("@itwin/editor-common");
-const CreateElementTool_1 = require("./CreateElementTool");
-const EditTool_1 = require("./EditTool");
-const EditToolIpc_1 = require("./EditToolIpc");
-/** @alpha */
-class ElementGeometryGraphicsProvider {
-    constructor(iModel) {
-        this.iModel = iModel;
-    }
-    /** Call to request a RenderGraphic for the supplied graphic data.
-     * @see [[cleanupGraphic]] Must be called when the tool exits.
-     */
-    async createGraphic(graphicData) {
-        try {
-            const graphic = await (0, core_frontend_1.readElementGraphics)(graphicData, this.iModel, core_bentley_1.Id64.invalid, true, { noFlash: true, noHilite: true });
-            const graphicOwner = graphic ? core_frontend_1.IModelApp.renderSystem.createGraphicOwner(graphic) : undefined;
-            this.cleanupGraphic();
-            return (undefined !== (this.graphic = graphicOwner));
-        }
-        catch {
-            return false;
-        }
-    }
-    /** 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, opts) {
-        if (undefined === this.graphic)
-            return;
-        if (undefined === transform && undefined === opts) {
-            context.addGraphic(this.graphic);
-            return;
-        }
-        const branch = new core_frontend_1.GraphicBranch(false);
-        branch.add(this.graphic);
-        const branchGraphic = context.createGraphicBranch(branch, transform ? transform : core_geometry_1.Transform.createIdentity(), opts);
-        context.addGraphic(branchGraphic);
-    }
-    addDecoration(context, type, transform, opts) {
-        if (undefined === this.graphic)
-            return;
-        const branch = new core_frontend_1.GraphicBranch(false);
-        branch.add(this.graphic);
-        const branchGraphic = context.createGraphicBranch(branch, transform ? transform : core_geometry_1.Transform.createIdentity(), opts);
-        context.addDecoration(type, branchGraphic);
-    }
-}
-exports.ElementGeometryGraphicsProvider = ElementGeometryGraphicsProvider;
-/** @alpha */
-function isSameSubEntity(a, b) {
-    if (a.type !== b.type)
-        return false;
-    if (a.id !== b.id)
-        return false;
-    if ((undefined !== a.index ? a.index : 0) !== (undefined !== b.index ? b.index : 0))
-        return false;
-    return true;
-}
-exports.isSameSubEntity = isSameSubEntity;
-/** @alpha */
-class SubEntityData {
-    constructor(props) { this._props = props; }
-    get props() { return this._props; }
-    set props(value) {
-        this.cleanupGraphic();
-        this._props = value;
-    }
-    get geometry() { return this._geometry; }
-    set geometry(value) { this._geometry = value; }
-    isSame(other) { return isSameSubEntity(this._props, other); }
-    getAppearance(vp, accepted) {
-        const color = vp.hilite.color;
-        const rgb = core_common_1.RgbColor.fromColorDef(accepted ? color.inverse() : color);
-        const transparency = 0.25;
-        const emphasized = true; // Necessary for obscured sub-entities w/SceneGraphic...
-        let weight;
-        switch (this.props.type) {
-            case editor_common_1.SubEntityType.Face:
-                break;
-            case editor_common_1.SubEntityType.Edge:
-                const edgeWeight = accepted ? 1 : 3;
-                weight = this._geometry?.appearance?.weight ? Math.min(this._geometry.appearance.weight + edgeWeight, 31) : edgeWeight;
-                break;
-            case editor_common_1.SubEntityType.Vertex:
-                const vertexWeight = accepted ? 8 : 10;
-                weight = this._geometry?.appearance?.weight ? Math.min(this._geometry.appearance.weight + vertexWeight, 31) : vertexWeight;
-                break;
-        }
-        return core_common_1.FeatureAppearance.fromJSON({ rgb, transparency, weight, emphasized, nonLocatable: true });
-    }
-    async createGraphic(iModel) {
-        if (undefined === this._geometry?.graphic)
-            return false;
-        if (undefined === this._graphicsProvider)
-            this._graphicsProvider = new ElementGeometryGraphicsProvider(iModel);
-        return this._graphicsProvider.createGraphic(this._geometry.graphic);
-    }
-    cleanupGraphic() {
-        if (undefined === this._graphicsProvider)
-            return;
-        this._graphicsProvider.cleanupGraphic();
-        this._graphicsProvider = undefined;
-    }
-    get hasGraphic() {
-        return (undefined !== this._graphicsProvider?.graphic);
-    }
-    display(context, accepted) {
-        if (undefined === this._graphicsProvider?.graphic)
-            return;
-        const range = (this._geometry?.range ? core_geometry_1.Range3d.fromJSON(this._geometry.range) : undefined);
-        const pixelSize = context.viewport.getPixelSizeAtPoint(range ? range.center : undefined);
-        const offsetDir = context.viewport.view.getZVector();
-        offsetDir.scaleToLength(3 * pixelSize, offsetDir);
-        const offsetTrans = core_geometry_1.Transform.createTranslation(offsetDir);
-        const appearanceProvider = core_common_1.FeatureAppearanceProvider.supplement((app) => {
-            return app.extendAppearance(this.getAppearance(context.viewport, accepted));
-        });
-        this._graphicsProvider.addDecoration(context, core_frontend_1.GraphicType.Scene, offsetTrans, { appearanceProvider });
-    }
-}
-exports.SubEntityData = SubEntityData;
-/** @alpha Base class for tools that want to use the backend geometry cache. */
-class ElementGeometryCacheTool extends core_frontend_1.ElementSetTool {
-    constructor() {
-        super(...arguments);
-        this._checkedIds = new Map();
-        this._firstResult = true;
-    }
-    allowView(vp) { return vp.view.is3d(); }
-    isCompatibleViewport(vp, isSelectedViewChange) { return (super.isCompatibleViewport(vp, isSelectedViewChange) && undefined !== vp && this.allowView(vp)); }
-    async startCommand() {
-        if (undefined !== this._startedCmd)
-            return this._startedCmd;
-        return EditTool_1.EditTools.startCommand({ commandId: editor_common_1.editorBuiltInCmdIds.cmdSolidModeling, iModelKey: this.iModel.key });
-    }
-    agendaAppearance(isDynamics) {
-        if (isDynamics) {
-            if (undefined === this._agendaAppearanceDynamic)
-                this._agendaAppearanceDynamic = core_common_1.FeatureAppearance.fromTransparency(0.0);
-            return this._agendaAppearanceDynamic;
-        }
-        if (undefined === this._agendaAppearanceDefault)
-            this._agendaAppearanceDefault = core_common_1.FeatureAppearance.fromTransparency(0.9);
-        return this._agendaAppearanceDefault;
-    }
-    get wantAgendaAppearanceOverride() { return false; }
-    addFeatureOverrides(overrides, _vp) {
-        if (this.agenda.isEmpty)
-            return;
-        const appearance = this.agendaAppearance(false);
-        this.agenda.elements.forEach((elementId) => overrides.override({ elementId, appearance }));
-    }
-    updateAgendaAppearanceProvider(drop) {
-        if (!this.wantAgendaAppearanceOverride)
-            return;
-        for (const vp of core_frontend_1.IModelApp.viewManager) {
-            if (!this.allowView(vp))
-                continue;
-            if (drop || this.agenda.isEmpty)
-                vp.dropFeatureOverrideProvider(this);
-            else if (!vp.addFeatureOverrideProvider(this))
-                vp.setFeatureOverrideProviderChanged();
-        }
-    }
-    get geometryCacheFilter() { return undefined; }
-    onGeometryCacheFilterChanged() { this._checkedIds.clear(); }
-    async createElementGeometryCache(id) {
-        // NOTE: Creates cache if it doesn't already exist then test new or existing cache against filter...
-        try {
-            this._startedCmd = await this.startCommand();
-            return await EditToolIpc_1.solidModelingIpc.createElementGeometryCache(id, this.geometryCacheFilter);
-        }
-        catch (err) {
-            return false;
-        }
-    }
-    async acceptElementForOperation(id) {
-        if (core_bentley_1.Id64.isInvalid(id) || core_bentley_1.Id64.isTransient(id))
-            return false;
-        let accept = this._checkedIds.get(id);
-        if (undefined === accept) {
-            if (this.agenda.isEmpty && this._checkedIds.size > 1000)
-                this._checkedIds.clear(); // Limit auto-locate cache size to something reasonable...
-            accept = await this.createElementGeometryCache(id);
-            this._checkedIds.set(id, accept);
-        }
-        return accept;
-    }
-    async isElementValidForOperation(hit, out) {
-        if (!await super.isElementValidForOperation(hit, out))
-            return false;
-        return this.acceptElementForOperation(hit.sourceId);
-    }
-    async postFilterIds(arg) {
-        const ids = [];
-        for (const id of core_bentley_1.Id64.iterable(arg)) {
-            if (await this.acceptElementForOperation(id))
-                ids.push(id);
-        }
-        return ids;
-    }
-    async getGroupIds(id) {
-        return this.postFilterIds(await super.getGroupIds(id));
-    }
-    async getSelectionSetCandidates(ss) {
-        return this.postFilterIds(await super.getSelectionSetCandidates(ss));
-    }
-    async getDragSelectCandidates(vp, origin, corner, method, overlap) {
-        return this.postFilterIds(await super.getDragSelectCandidates(vp, origin, corner, method, overlap));
-    }
-    onDynamicFrame(_ev, context) {
-        if (undefined === this._graphicsProvider)
-            return;
-        if (!this.wantAgendaAppearanceOverride)
-            return this._graphicsProvider.addGraphic(context);
-        const appearanceProvider = core_common_1.FeatureAppearanceProvider.supplement((app) => {
-            return app.extendAppearance(this.agendaAppearance(true));
-        });
-        this._graphicsProvider.addGraphic(context, undefined, { appearanceProvider });
-    }
-    async onMouseMotion(ev) {
-        return this.updateGraphic(ev, core_frontend_1.IModelApp.viewManager.inDynamicsMode);
-    }
-    async getGraphicData(_ev) { return undefined; }
-    async updateGraphic(ev, isDynamics) {
-        if (!isDynamics || this._graphicsPending)
-            return; // Continue displaying previous graphic if new graphic is still pending...
-        this._graphicsPending = true;
-        const graphicData = await this.getGraphicData(ev);
-        this._graphicsPending = undefined;
-        if (undefined !== graphicData) {
-            if (this._firstResult) {
-                this.updateAgendaAppearanceProvider();
-                this._firstResult = false;
-            }
-            return this.createGraphic(graphicData);
-        }
-        if (undefined !== this._graphicsProvider)
-            this._graphicsProvider.cleanupGraphic();
-    }
-    async createGraphic(graphicData) {
-        if (undefined === this._graphicsProvider)
-            this._graphicsProvider = new ElementGeometryGraphicsProvider(this.iModel);
-        await this._graphicsProvider.createGraphic(graphicData);
-    }
-    clearGraphic() {
-        if (undefined === this._graphicsProvider)
-            return;
-        this._graphicsProvider.cleanupGraphic();
-        this._graphicsProvider = undefined;
-    }
-    async clearElementGeometryCache() {
-        try {
-            this._startedCmd = await this.startCommand();
-            await EditToolIpc_1.solidModelingIpc.clearElementGeometryCache();
-        }
-        catch (err) { }
-    }
-    async onUnsuspend() {
-        if (!this._firstResult)
-            this.updateAgendaAppearanceProvider();
-        return super.onUnsuspend();
-    }
-    async onSuspend() {
-        if (!this._firstResult)
-            this.updateAgendaAppearanceProvider(true);
-        return super.onSuspend();
-    }
-    async onPostInstall() {
-        await super.onPostInstall();
-        if (this.wantAgendaAppearanceOverride)
-            this.agenda.manageHiliteState = false;
-    }
-    async onCleanup() {
-        await super.onCleanup();
-        await this.clearElementGeometryCache();
-        this.updateAgendaAppearanceProvider(true);
-        this.clearGraphic();
-    }
-}
-exports.ElementGeometryCacheTool = ElementGeometryCacheTool;
-/** @alpha Base class for tools that need to locate faces, edges, and vertices. */
-class LocateSubEntityTool extends ElementGeometryCacheTool {
-    constructor() {
-        super(...arguments);
-        this._acceptedSubEntities = [];
-        this._summaryIds = new Map();
-    }
-    provideToolAssistance(mainInstrText, additionalInstr) {
-        if (this.wantAdditionalSubEntities) {
-            const faceKey = this.wantSubEntityType(editor_common_1.SubEntityType.Face) ? "Face" : "";
-            const edgeKey = this.wantSubEntityType(editor_common_1.SubEntityType.Edge) ? "Edge" : "";
-            const vertexKey = this.wantSubEntityType(editor_common_1.SubEntityType.Vertex) ? "Vertex" : "";
-            const subEntityKey = `${faceKey}${edgeKey}${vertexKey}`;
-            if (0 === subEntityKey.length) {
-                super.provideToolAssistance(mainInstrText, additionalInstr);
-                return;
-            }
-            if (undefined === mainInstrText)
-                mainInstrText = EditTool_1.EditTools.translate(`LocateSubEntities.Identify.${subEntityKey}`);
-            const leftMsg = EditTool_1.EditTools.translate(`LocateSubEntities.Accept.${subEntityKey}`);
-            const rightMsg = this.haveAcceptedSubEntities && this.allowSubEntitySelectNext ? EditTool_1.EditTools.translate(`LocateSubEntities.AcceptNext.${subEntityKey}`) : core_frontend_1.CoreTools.translate("ElementSet.Inputs.Cancel");
-            const mouseInstructions = [];
-            const touchInstructions = [];
-            if (!core_frontend_1.ToolAssistance.createTouchCursorInstructions(touchInstructions))
-                touchInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.OneTouchTap, leftMsg, false, core_frontend_1.ToolAssistanceInputMethod.Touch));
-            mouseInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.LeftClick, leftMsg, false, core_frontend_1.ToolAssistanceInputMethod.Mouse));
-            touchInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.TwoTouchTap, rightMsg, false, core_frontend_1.ToolAssistanceInputMethod.Touch));
-            mouseInstructions.push(core_frontend_1.ToolAssistance.createInstruction(core_frontend_1.ToolAssistanceImage.RightClick, rightMsg, false, core_frontend_1.ToolAssistanceInputMethod.Mouse));
-            if (this.allowSubEntityControlSelect)
-                mouseInstructions.push(core_frontend_1.ToolAssistance.createModifierKeyInstruction(core_frontend_1.ToolAssistance.ctrlKey, core_frontend_1.ToolAssistanceImage.LeftClickDrag, EditTool_1.EditTools.translate(`LocateSubEntities.IdentifyAdditional.${subEntityKey}`), false, core_frontend_1.ToolAssistanceInputMethod.Mouse));
-            if (undefined !== additionalInstr) {
-                for (const instr of additionalInstr) {
-                    if (core_frontend_1.ToolAssistanceInputMethod.Touch === instr.inputMethod)
-                        touchInstructions.push(instr);
-                    else
-                        mouseInstructions.push(instr);
-                }
-            }
-            const sections = [];
-            sections.push(core_frontend_1.ToolAssistance.createSection(mouseInstructions, core_frontend_1.ToolAssistance.inputsLabel));
-            sections.push(core_frontend_1.ToolAssistance.createSection(touchInstructions, core_frontend_1.ToolAssistance.inputsLabel));
-            const mainInstruction = core_frontend_1.ToolAssistance.createInstruction(this.iconSpec, mainInstrText);
-            const instructions = core_frontend_1.ToolAssistance.createInstructions(mainInstruction, sections);
-            core_frontend_1.IModelApp.notifications.setToolAssistance(instructions);
-            return;
-        }
-        super.provideToolAssistance(mainInstrText, additionalInstr);
-    }
-    get wantAgendaAppearanceOverride() { return true; }
-    get wantGeometrySummary() { return false; }
-    get wantSubEntitySnap() { return false; }
-    wantSubEntityType(type) { return editor_common_1.SubEntityType.Face === type; }
-    getMaximumSubEntityHits(type) { return this.wantSubEntityType(type) ? 25 : 0; }
-    get requiredSubEntityCount() { return 1; }
-    get haveAcceptedSubEntities() { return (0 !== this._acceptedSubEntities.length); }
-    get inhibitSubEntityDisplay() { return this.isDynamicsStarted; }
-    get allowSubEntityControlSelect() { return true; }
-    get allowSubEntityControlDeselect() { return this.allowSubEntityControlSelect; }
-    get allowSubEntitySelectNext() { return !this.isDynamicsStarted; }
-    getBRepEntityTypeForSubEntity(id, subEntity) {
-        const summary = this._summaryIds.get(id);
-        if (undefined === summary)
-            return editor_common_1.BRepEntityType.Invalid;
-        const index = (undefined !== subEntity.index ? subEntity.index : 0);
-        if (index >= summary.length)
-            return editor_common_1.BRepEntityType.Invalid;
-        return summary[index];
-    }
-    async createElementGeometrySummary(id) {
-        let summary = this._summaryIds.get(id);
-        if (undefined === summary) {
-            if (this.agenda.isEmpty && this._summaryIds.size > 1000)
-                this._summaryIds.clear(); // Limit auto-locate cache size to something reasonable...
-            try {
-                this._startedCmd = await this.startCommand();
-                if (undefined === (summary = await EditToolIpc_1.solidModelingIpc.summarizeElementGeometryCache(id)))
-                    return false;
-            }
-            catch (err) {
-                return false;
-            }
-            this._summaryIds.set(id, summary);
-        }
-        return true;
-    }
-    async createElementGeometryCache(id) {
-        const accept = await super.createElementGeometryCache(id);
-        return (accept && this.wantGeometrySummary ? this.createElementGeometrySummary(id) : accept);
-    }
-    getAcceptedSubEntityData(index = -1) {
-        if (-1 === index)
-            index = this._acceptedSubEntities.length - 1;
-        if (index < 0 || index > this._acceptedSubEntities.length - 1)
-            return undefined;
-        return this._acceptedSubEntities[index];
-    }
-    getAcceptedSubEntities() {
-        const accepted = [];
-        this._acceptedSubEntities.forEach((entry) => accepted.push(entry.props));
-        return accepted;
-    }
-    drawSubEntity(context, subEntity, accepted) {
-        subEntity.display(context, accepted);
-    }
-    drawAcceptedSubEntities(context) {
-        this._acceptedSubEntities.forEach((entry) => this.drawSubEntity(context, entry, true));
-    }
-    decorate(context) {
-        if (this.inhibitSubEntityDisplay || !this.allowView(context.viewport))
-            return;
-        if (this.haveAcceptedSubEntities)
-            this.drawAcceptedSubEntities(context);
-        if (undefined !== this._currentSubEntity)
-            this.drawSubEntity(context, this._currentSubEntity, false);
-    }
-    decorateSuspended(context) {
-        if (this.inhibitSubEntityDisplay || !this.allowView(context.viewport))
-            return;
-        if (this.haveAcceptedSubEntities)
-            this.drawAcceptedSubEntities(context);
-    }
-    getLocateAperture(ev) {
-        if (undefined === ev.viewport)
-            return 0.0;
-        return ev.viewport.pixelsFromInches(core_frontend_1.InputSource.Touch === ev.inputSource ? core_frontend_1.IModelApp.locateManager.touchApertureInches : core_frontend_1.IModelApp.locateManager.apertureInches);
-    }
-    getMaxRayDistance(ev, aperture) {
-        if (undefined === ev.viewport)
-            return 0.0;
-        // NOTE: Compute a world coordinate radius for ray test, try getting aperture size at point on element...
-        const hit = core_frontend_1.IModelApp.accuSnap.currHit;
-        const vec = [];
-        vec[0] = ev.viewport.worldToView(hit ? hit.hitPoint : ev.point);
-        vec[1] = vec[0].clone();
-        vec[1].x += 1;
-        ev.viewport.viewToWorldArray(vec);
-        // The edge and vertex hits get post-filtered on xy distance, so this is fine for perspective views...
-        return (aperture * vec[0].distance(vec[1]));
-    }
-    getRayOrigin(ev) {
-        const spacePoint = ev.point.clone();
-        const vp = ev.viewport;
-        if (undefined === vp)
-            return spacePoint;
-        vp.worldToNpc(spacePoint, spacePoint);
-        spacePoint.z = 1.0;
-        vp.npcToWorld(spacePoint, spacePoint);
-        return spacePoint;
-    }
-    wantHiddenEdges(vp) {
-        return vp.viewFlags.hiddenEdgesVisible();
-    }
-    getSubEntityFilter() { return undefined; }
-    async pickSubEntities(id, boresite, maxFace, maxEdge, maxVertex, maxDistance, hiddenEdgesVisible, filter) {
-        try {
-            this._startedCmd = await this.startCommand();
-            const opts = {
-                maxFace,
-                maxEdge,
-                maxVertex,
-                maxDistance,
-                hiddenEdgesVisible,
-                filter,
-            };
-            return await EditToolIpc_1.solidModelingIpc.locateSubEntities(id, boresite.origin, boresite.direction, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async doPickSubEntities(id, ev) {
-        const vp = ev.viewport;
-        if (undefined === vp)
-            return undefined;
-        const maxFace = this.getMaximumSubEntityHits(editor_common_1.SubEntityType.Face);
-        const maxEdge = this.getMaximumSubEntityHits(editor_common_1.SubEntityType.Edge);
-        const maxVertex = this.getMaximumSubEntityHits(editor_common_1.SubEntityType.Vertex);
-        if (0 === maxFace && 0 === maxEdge && 0 === maxVertex)
-            return undefined;
-        const aperture = this.getLocateAperture(ev);
-        const maxDistance = this.getMaxRayDistance(ev, aperture);
-        const spacePoint = this.getRayOrigin(ev);
-        const boresite = core_frontend_1.AccuDrawHintBuilder.getBoresite(spacePoint, vp);
-        const hiddenEdgesVisible = this.wantHiddenEdges(vp);
-        const filter = this.getSubEntityFilter();
-        let hits = await this.pickSubEntities(id, boresite, maxFace, maxEdge, maxVertex, maxDistance, hiddenEdgesVisible, filter);
-        // NOTE: Remove erroneous edge/vertex hits in perspective views by checking real xy distance to hit point...
-        if (undefined === hits || !vp.isCameraOn)
-            return hits;
-        if (maxEdge > 0 && hits.length > 1) {
-            const edgeApertureSquared = (aperture * aperture);
-            const vertexApertureSquared = ((aperture * 2.0) * (aperture * 2.0));
-            const e2 = Math.pow(aperture, 2);
-            const v2 = Math.pow(aperture * 2.0, 2);
-            if (e2 !== edgeApertureSquared || v2 !== vertexApertureSquared)
-                return hits;
-            const rayOrigin = vp.worldToView(boresite.origin);
-            hits = hits.filter((hit) => {
-                if (editor_common_1.SubEntityType.Face === hit.subEntity.type)
-                    return true;
-                const hitPoint = vp.worldToView(core_geometry_1.Point3d.fromJSON(hit.point));
-                const distance = hitPoint.distanceSquaredXY(rayOrigin);
-                return (distance <= (editor_common_1.SubEntityType.Edge === hit.subEntity.type ? edgeApertureSquared : vertexApertureSquared));
-            });
-        }
-        return hits;
-    }
-    async createSubEntityData(id, hit) {
-        const data = new SubEntityData(hit.subEntity);
-        const chordTolerance = (this.targetView ? (0, CreateElementTool_1.computeChordToleranceFromPoint)(this.targetView, core_geometry_1.Point3d.fromJSON(hit.point)) : undefined);
-        await this.createSubEntityGraphic(id, data, chordTolerance);
-        return data;
-    }
-    /** Append specified sub-entity to accepted array. */
-    async addSubEntity(id, props) {
-        this._acceptedSubEntities.push(await this.createSubEntityData(id, props));
-    }
-    /** Remove specified sub-entity from accepted array, or pop last sub-entity if undefined. */
-    async removeSubEntity(_id, props) {
-        if (undefined !== props)
-            this._acceptedSubEntities = this._acceptedSubEntities.filter((entry) => !isSameSubEntity(entry.props, props.subEntity));
-        else
-            this._acceptedSubEntities.pop();
-    }
-    /** Locate sub-entities for the most recently added (last) agenda entry. Tool sub-classes that wish to identity
-     * sub-entities from multiple elements are responsible for maintaining the sub-entities per-element.
-     */
-    async doLocateSubEntity(ev, newSearch) {
-        if (this.agenda.isEmpty || undefined === ev.viewport)
-            return false;
-        const id = this.agenda.elements[this.agenda.length - 1];
-        if (newSearch) {
-            this._locatedSubEntities = await this.doPickSubEntities(id, ev);
-            if (undefined === this._locatedSubEntities || 0 === this._locatedSubEntities.length)
-                return false;
-            /** NOTE: Set last button location to point on sub-entity when not snapping.
-              * If dynamics are enabled on this event, onDynamicFrame is called with this location.
-              */
-            if (core_frontend_1.CoordSource.ElemSnap !== ev.coordsFrom) {
-                ev.point.setFrom(core_geometry_1.Point3d.fromJSON(this._locatedSubEntities[0].point));
-                core_frontend_1.IModelApp.toolAdmin.setAdjustedDataPoint(ev);
-            }
-        }
-        else {
-            await this.removeSubEntity(id);
-        }
-        const hit = this._locatedSubEntities?.shift();
-        if (undefined !== hit) {
-            if (undefined === this._acceptedSubEntities.find((entry) => isSameSubEntity(entry.props, hit.subEntity)))
-                await this.addSubEntity(id, hit);
-            else if (this.allowSubEntityControlDeselect)
-                await this.removeSubEntity(id, hit);
-        }
-        core_frontend_1.IModelApp.viewManager.invalidateDecorationsAllViews();
-        return true;
-    }
-    async chooseNextHit(ev) {
-        if (!this.haveAcceptedSubEntities)
-            return super.chooseNextHit(ev);
-        if (!this.allowSubEntitySelectNext) {
-            await this.onReinitialize(); // Don't cycle through hits after starting dynamics...
-        }
-        else {
-            await this.doLocateSubEntity(ev, false);
-            if (!this.haveAcceptedSubEntities)
-                await this.onReinitialize();
-        }
-        return core_frontend_1.EventHandled.No;
-    }
-    get wantAdditionalSubEntities() {
-        return (this._acceptedSubEntities.length < this.requiredSubEntityCount || (this.allowSubEntityControlSelect && this.isControlDown));
-    }
-    async gatherInput(ev) {
-        if (this.wantAdditionalSubEntities) {
-            await this.doLocateSubEntity(ev, true);
-            if (this.wantAdditionalSubEntities) {
-                this.setupAndPromptForNextAction();
-                return core_frontend_1.EventHandled.No;
-            }
-            this.clearCurrentSubEntity();
-        }
-        return super.gatherInput(ev);
-    }
-    getCurrentElement() {
-        if (!this.agenda.isEmpty)
-            return this.agenda.elements[this.agenda.length - 1];
-        const hit = core_frontend_1.IModelApp.accuSnap.currHit;
-        return (undefined !== hit && hit.isElementHit ? hit.sourceId : undefined);
-    }
-    clearCurrentSubEntity() {
-        if (undefined === this._currentSubEntity)
-            return;
-        this._currentSubEntity.cleanupGraphic();
-        this._currentSubEntity = undefined;
-    }
-    async setCurrentSubEntity(id, hit, chordTolerance) {
-        if (undefined === this._currentSubEntity)
-            this._currentSubEntity = new SubEntityData(hit.subEntity);
-        else
-            this._currentSubEntity.props = hit.subEntity;
-        return this.createSubEntityGraphic(id, this._currentSubEntity, chordTolerance);
-    }
-    async changeCurrentSubEntity(id, current, chordTolerance) {
-        if (undefined === id || undefined === current) {
-            if (undefined === this._currentSubEntity || !this._currentSubEntity.hasGraphic)
-                return false;
-            this._currentSubEntity.cleanupGraphic();
-            return true;
-        }
-        if (undefined !== this._currentSubEntity && this._currentSubEntity.hasGraphic && this._currentSubEntity.isSame(current.subEntity))
-            return false;
-        return this.setCurrentSubEntity(id, current, chordTolerance);
-    }
-    async updateCurrentSubEntity(ev) {
-        if (undefined === ev.viewport)
-            return false;
-        const id = this.wantAdditionalSubEntities ? this.getCurrentElement() : undefined;
-        if (undefined === id)
-            return this.changeCurrentSubEntity();
-        if (this._subEntityGraphicPending)
-            return false;
-        this._subEntityGraphicPending = true;
-        const current = await this.doPickSubEntities(id, ev);
-        const chordTolerance = current ? (0, CreateElementTool_1.computeChordToleranceFromPoint)(ev.viewport, core_geometry_1.Point3d.fromJSON(current[0].point)) : 0.0;
-        const status = await this.changeCurrentSubEntity(id, current ? current[0] : undefined, chordTolerance);
-        this._subEntityGraphicPending = undefined;
-        if (status)
-            core_frontend_1.IModelApp.viewManager.invalidateDecorationsAllViews();
-        return status;
-    }
-    async createSubEntityGraphic(id, data, chordTolerance) {
-        try {
-            const opts = {
-                wantGraphic: true,
-                wantRange: true,
-                wantAppearance: true,
-                chordTolerance,
-            };
-            data.chordTolerance = chordTolerance;
-            data.geometry = await EditToolIpc_1.solidModelingIpc.getSubEntityGeometry(id, data.props, opts);
-            return await data.createGraphic(this.iModel);
-        }
-        catch (err) {
-            return false;
-        }
-    }
-    async updateGraphic(ev, isDynamics) {
-        if (isDynamics)
-            return super.updateGraphic(ev, isDynamics);
-        await this.updateCurrentSubEntity(ev);
-    }
-    async getGraphicData(ev) {
-        const result = await this.applyAgendaOperation(ev, false);
-        return result?.graphic;
-    }
-    async applyAgendaOperation(_ev, _isAccept) { return undefined; }
-    async processAgenda(ev) {
-        const result = await this.applyAgendaOperation(ev, true);
-        if (result?.elementId)
-            await this.saveChanges();
-    }
-    async onModifierKeyTransition(wentDown, modifier, event) {
-        if (core_frontend_1.EventHandled.Yes === await super.onModifierKeyTransition(wentDown, modifier, event))
-            return core_frontend_1.EventHandled.Yes;
-        if (core_frontend_1.BeModifierKeys.Control !== modifier)
-            return core_frontend_1.EventHandled.No;
-        if (core_frontend_1.IModelApp.toolAdmin.isLocateCircleOn === this.wantAdditionalSubEntities)
-            return core_frontend_1.EventHandled.No;
-        this.setupAndPromptForNextAction();
-        return core_frontend_1.EventHandled.Yes;
-    }
-    changeLocateState(enableLocate, enableSnap, cursor, coordLockOvr) {
-        super.changeLocateState(enableLocate, enableSnap, cursor, coordLockOvr);
-        // Keep showing locate circle when identifying sub-entities even if done locating elements...
-        if (!core_frontend_1.IModelApp.toolAdmin.isLocateCircleOn && this.wantAdditionalSubEntities)
-            core_frontend_1.IModelApp.toolAdmin.setLocateCircleOn(true);
-    }
-    get shouldEnableSnap() {
-        if (this.isSelectByPoints || !this.wantAccuSnap)
-            return false;
-        if (this.isDynamicsStarted)
-            return true;
-        const isCtrlSelect = (this.isControlDown && (this.controlKeyContinuesSelection || this.allowSubEntityControlSelect));
-        if (isCtrlSelect || this.wantAdditionalElements || this.wantAdditionalSubEntities)
-            return this.wantSubEntitySnap;
-        return !this.wantSubEntitySnap;
-    }
-    setupAccuDraw() { }
-    setupAndPromptForNextAction() {
-        this.setupAccuDraw();
-        super.setupAndPromptForNextAction();
-    }
-    clearSubEntityGraphics() {
-        if (undefined !== this._currentSubEntity)
-            this._currentSubEntity.cleanupGraphic();
-        this._acceptedSubEntities.forEach((entry) => entry.cleanupGraphic());
-    }
-    async onCleanup() {
-        this.clearSubEntityGraphics();
-        return super.onCleanup();
-    }
-}
-exports.LocateSubEntityTool = LocateSubEntityTool;
-//# sourceMappingURL=ElementGeometryTool.js.map