@itwin/editor-frontend 3.0.0-dev.98 → 3.1.0-dev.0

package/lib/esm/ElementGeometryTool.js

@@ -6,10 +6,10 @@
  * @module Editing
  */
 import { Id64 } from "@itwin/core-bentley";
-import { BooleanMode, editorBuiltInCmdIds, SubEntityType } from "@itwin/editor-common";
+import { BRepEntityType, editorBuiltInCmdIds, SubEntityType } from "@itwin/editor-common";
 import { FeatureAppearance, FeatureAppearanceProvider, RgbColor } from "@itwin/core-common";
-import { Geometry, Point3d, Range3d, Transform, Vector3d } from "@itwin/core-geometry";
-import { AccuDrawHintBuilder, ElementSetTool, EventHandled, GraphicBranch, GraphicType, IModelApp, InputSource, readElementGraphics } from "@itwin/core-frontend";
+import { Point3d, Range3d, Transform } from "@itwin/core-geometry";
+import { AccuDrawHintBuilder, BeModifierKeys, CoordSource, CoreTools, ElementSetTool, EventHandled, GraphicBranch, GraphicType, IModelApp, InputSource, readElementGraphics, ToolAssistance, ToolAssistanceImage, ToolAssistanceInputMethod } from "@itwin/core-frontend";
 import { computeChordToleranceFromPoint } from "./CreateElementTool";
 import { EditTools } from "./EditTool";
 /** @alpha */
@@ -62,46 +62,51 @@ export class ElementGeometryGraphicsProvider {
     }
 }
 /** @alpha */
+export 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;
+}
+/** @alpha */
 export class SubEntityData {
-    isSame(other) {
-        if (undefined === this.info)
-            return false;
-        if (this.info.index !== other.index)
-            return false;
-        if (this.info.type !== other.type)
-            return false;
-        if (this.info.id !== other.id)
-            return false;
-        return true;
-    }
+    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) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         const color = vp.hilite.color;
         const rgb = RgbColor.fromColorDef(accepted ? color.inverse() : color);
         const transparency = 0.25;
         const emphasized = true; // Necessary for obscured sub-entities w/SceneGraphic...
         let weight;
-        switch ((_a = this.info) === null || _a === void 0 ? void 0 : _a.type) {
+        switch (this.props.type) {
             case SubEntityType.Face:
                 break;
             case SubEntityType.Edge:
-                const edgeWeight = accepted ? 5 : 3;
-                weight = ((_c = (_b = this.geom) === null || _b === void 0 ? void 0 : _b.appearance) === null || _c === void 0 ? void 0 : _c.weight) ? Math.min(this.geom.appearance.weight + edgeWeight, 31) : edgeWeight;
+                const edgeWeight = accepted ? 1 : 3;
+                weight = ((_b = (_a = this._geometry) === null || _a === void 0 ? void 0 : _a.appearance) === null || _b === void 0 ? void 0 : _b.weight) ? Math.min(this._geometry.appearance.weight + edgeWeight, 31) : edgeWeight;
                 break;
             case SubEntityType.Vertex:
-                const vertexWeight = accepted ? 12 : 10;
-                weight = ((_e = (_d = this.geom) === null || _d === void 0 ? void 0 : _d.appearance) === null || _e === void 0 ? void 0 : _e.weight) ? Math.min(this.geom.appearance.weight + vertexWeight, 31) : vertexWeight;
+                const vertexWeight = accepted ? 8 : 10;
+                weight = ((_d = (_c = this._geometry) === null || _c === void 0 ? void 0 : _c.appearance) === null || _d === void 0 ? void 0 : _d.weight) ? Math.min(this._geometry.appearance.weight + vertexWeight, 31) : vertexWeight;
                 break;
         }
         return FeatureAppearance.fromJSON({ rgb, transparency, weight, emphasized, nonLocatable: true });
     }
     async createGraphic(iModel) {
         var _a;
-        if (undefined === ((_a = this.geom) === null || _a === void 0 ? void 0 : _a.graphic))
+        if (undefined === ((_a = this._geometry) === null || _a === void 0 ? void 0 : _a.graphic))
             return false;
         if (undefined === this._graphicsProvider)
             this._graphicsProvider = new ElementGeometryGraphicsProvider(iModel);
-        return this._graphicsProvider.createGraphic(this.geom.graphic);
+        return this._graphicsProvider.createGraphic(this._geometry.graphic);
     }
     cleanupGraphic() {
         if (undefined === this._graphicsProvider)
@@ -117,16 +122,15 @@ export class SubEntityData {
         var _a, _b;
         if (undefined === ((_a = this._graphicsProvider) === null || _a === void 0 ? void 0 : _a.graphic))
             return;
-        const appearanceProvider = FeatureAppearanceProvider.supplement((app) => {
-            return app.extendAppearance(this.getAppearance(context.viewport, accepted));
-        });
-        const opts = { appearanceProvider };
-        const range = (((_b = this.geom) === null || _b === void 0 ? void 0 : _b.range) ? Range3d.fromJSON(this.geom.range) : undefined);
+        const range = (((_b = this._geometry) === null || _b === void 0 ? void 0 : _b.range) ? 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 = Transform.createTranslation(offsetDir);
-        this._graphicsProvider.addDecoration(context, GraphicType.Scene, offsetTrans, opts);
+        const appearanceProvider = FeatureAppearanceProvider.supplement((app) => {
+            return app.extendAppearance(this.getAppearance(context.viewport, accepted));
+        });
+        this._graphicsProvider.addDecoration(context, GraphicType.Scene, offsetTrans, { appearanceProvider });
     }
 }
 /** @alpha Base class for tools that want to use the backend geometry cache. */
@@ -146,14 +150,22 @@ export class ElementGeometryCacheTool extends ElementSetTool {
     static callCommand(method, ...args) {
         return EditTools.callCommand(method, ...args);
     }
-    // TODO: This looks nice as long as ViewFlags.transparency is on...
-    get agendaAppearance() { return FeatureAppearance.fromTransparency(0.90); }
+    agendaAppearance(isDynamics) {
+        if (isDynamics) {
+            if (undefined === this._agendaAppearanceDynamic)
+                this._agendaAppearanceDynamic = FeatureAppearance.fromTransparency(0.0);
+            return this._agendaAppearanceDynamic;
+        }
+        if (undefined === this._agendaAppearanceDefault)
+            this._agendaAppearanceDefault = FeatureAppearance.fromTransparency(0.9);
+        return this._agendaAppearanceDefault;
+    }
     get wantAgendaAppearanceOverride() { return false; }
     addFeatureOverrides(overrides, _vp) {
         if (this.agenda.isEmpty)
             return;
-        const app = this.agendaAppearance;
-        this.agenda.elements.forEach((id) => { overrides.overrideElement(id, app); });
+        const appearance = this.agendaAppearance(false);
+        this.agenda.elements.forEach((elementId) => { overrides.override({ elementId, appearance }); });
     }
     updateAgendaAppearanceProvider(drop) {
         if (!this.wantAgendaAppearanceOverride)
@@ -168,18 +180,25 @@ export class ElementGeometryCacheTool extends ElementSetTool {
         }
     }
     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 ElementGeometryCacheTool.callCommand("createElementGeometryCache", id, this.geometryCacheFilter);
+        }
+        catch (err) {
+            return false;
+        }
+    }
     async acceptElementForOperation(id) {
         if (Id64.isInvalid(id) || Id64.isTransient(id))
             return false;
         let accept = this._checkedIds.get(id);
         if (undefined === accept) {
-            try {
-                this._startedCmd = await this.startCommand();
-                accept = await ElementGeometryCacheTool.callCommand("createElementGeometryCache", id, this.geometryCacheFilter);
-            }
-            catch (err) {
-                accept = false;
-            }
+            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;
@@ -207,8 +226,14 @@ export class ElementGeometryCacheTool extends ElementSetTool {
         return this.postFilterIds(await super.getDragSelectCandidates(vp, origin, corner, method, overlap));
     }
     onDynamicFrame(_ev, context) {
-        if (undefined !== this._graphicsProvider)
-            this._graphicsProvider.addGraphic(context);
+        if (undefined === this._graphicsProvider)
+            return;
+        if (!this.wantAgendaAppearanceOverride)
+            return this._graphicsProvider.addGraphic(context);
+        const appearanceProvider = FeatureAppearanceProvider.supplement((app) => {
+            return app.extendAppearance(this.agendaAppearance(true));
+        });
+        this._graphicsProvider.addGraphic(context, undefined, { appearanceProvider });
     }
     async onMouseMotion(ev) {
         return this.updateGraphic(ev, IModelApp.viewManager.inDynamicsMode);
@@ -270,121 +295,126 @@ export class ElementGeometryCacheTool extends ElementSetTool {
         this.clearGraphic();
     }
 }
-/** @alpha Base class for tools that perform boolean operations on a set of elements. */
-export class BooleanOperationTool extends ElementGeometryCacheTool {
-    get allowSelectionSet() { return BooleanMode.Subtract !== this.mode; }
-    get allowDragSelect() { return BooleanMode.Subtract !== this.mode; }
-    get controlKeyContinuesSelection() { return true; }
-    get requiredElementCount() { return 2; }
-    get geometryCacheFilter() {
-        return { parts: true, curves: false, surfaces: BooleanMode.Subtract === this.mode && !this.agenda.isEmpty, solids: true, other: false };
-    }
-    async onAgendaModified() {
-        // Filter changes to allow surfaces as tools, invalidate cached accept status...
-        if (BooleanMode.Subtract === this.mode && (this.agenda.isEmpty || 1 === this.agenda.length))
-            this._checkedIds.clear();
-    }
-    async applyAgendaOperation() {
-        if (this.agenda.length < this.requiredElementCount)
-            return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const target = this.agenda.elements[0];
-            const tools = this.agenda.elements.slice(1);
-            const params = { mode: this.mode, tools };
-            const opts = { writeChanges: true };
-            return await ElementGeometryCacheTool.callCommand("booleanOperation", target, params, opts);
-        }
-        catch (err) {
-            return undefined;
+/** @alpha Base class for tools that need to locate faces, edges, and vertices. */
+export class LocateSubEntityTool extends ElementGeometryCacheTool {
+    constructor() {
+        super(...arguments);
+        this._acceptedSubEntities = [];
+        this._summaryIds = new Map();
+    }
+    provideToolAssistance(mainInstrText, additionalInstr) {
+        if (this.wantAdditionalSubEntities) {
+            const faceKey = this.wantSubEntityType(SubEntityType.Face) ? "Face" : "";
+            const edgeKey = this.wantSubEntityType(SubEntityType.Edge) ? "Edge" : "";
+            const vertexKey = this.wantSubEntityType(SubEntityType.Vertex) ? "Vertex" : "";
+            const subEntityKey = `${faceKey}${edgeKey}${vertexKey}`;
+            if (0 === subEntityKey.length) {
+                super.provideToolAssistance(mainInstrText, additionalInstr);
+                return;
+            }
+            if (undefined === mainInstrText)
+                mainInstrText = EditTools.translate(`LocateSubEntities.Identify.${subEntityKey}`);
+            const leftMsg = EditTools.translate(`LocateSubEntities.Accept.${subEntityKey}`);
+            const rightMsg = this.haveAcceptedSubEntities && this.allowSubEntitySelectNext ? EditTools.translate(`LocateSubEntities.AcceptNext.${subEntityKey}`) : CoreTools.translate("ElementSet.Inputs.Cancel");
+            const mouseInstructions = [];
+            const touchInstructions = [];
+            if (!ToolAssistance.createTouchCursorInstructions(touchInstructions))
+                touchInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.OneTouchTap, leftMsg, false, ToolAssistanceInputMethod.Touch));
+            mouseInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.LeftClick, leftMsg, false, ToolAssistanceInputMethod.Mouse));
+            touchInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.TwoTouchTap, rightMsg, false, ToolAssistanceInputMethod.Touch));
+            mouseInstructions.push(ToolAssistance.createInstruction(ToolAssistanceImage.RightClick, rightMsg, false, ToolAssistanceInputMethod.Mouse));
+            if (this.allowSubEntityControlSelect)
+                mouseInstructions.push(ToolAssistance.createModifierKeyInstruction(ToolAssistance.ctrlKey, ToolAssistanceImage.LeftClickDrag, EditTools.translate(`LocateSubEntities.IdentifyAdditional.${subEntityKey}`), 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, mainInstrText);
+            const instructions = ToolAssistance.createInstructions(mainInstruction, sections);
+            IModelApp.notifications.setToolAssistance(instructions);
+            return;
         }
+        super.provideToolAssistance(mainInstrText, additionalInstr);
     }
-    async processAgenda(_ev) {
-        const result = await this.applyAgendaOperation();
-        if (result === null || result === void 0 ? void 0 : result.elementId)
-            await this.saveChanges();
-    }
-}
-/** @alpha Perform boolean union of solid geometry. */
-export class UniteSolidElementsTool extends BooleanOperationTool {
-    get mode() { return BooleanMode.Unite; }
-    async onRestartTool() {
-        const tool = new UniteSolidElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-UniteSolidElementsTool.toolId = "UniteSolids";
-UniteSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-/** @alpha Perform boolean subtract of solid geometry. */
-export class SubtractSolidElementsTool extends BooleanOperationTool {
-    get mode() { return BooleanMode.Subtract; }
-    async onRestartTool() {
-        const tool = new SubtractSolidElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
+    get wantAgendaAppearanceOverride() { return true; }
+    get wantGeometrySummary() { return false; }
+    get wantSubEntitySnap() { return false; }
+    wantSubEntityType(type) { return 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 BRepEntityType.Invalid;
+        const index = (undefined !== subEntity.index ? subEntity.index : 0);
+        if (index >= summary.length)
+            return 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 ElementGeometryCacheTool.callCommand("summarizeElementGeometryCache", id)))
+                    return false;
+            }
+            catch (err) {
+                return false;
+            }
+            this._summaryIds.set(id, summary);
+        }
+        return true;
     }
-}
-SubtractSolidElementsTool.toolId = "SubtractSolids";
-SubtractSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-/** @alpha Perform boolean intersection of solid geometry. */
-export class IntersectSolidElementsTool extends BooleanOperationTool {
-    get mode() { return BooleanMode.Intersect; }
-    async onRestartTool() {
-        const tool = new IntersectSolidElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
+    async createElementGeometryCache(id) {
+        const accept = await super.createElementGeometryCache(id);
+        return (accept && this.wantGeometrySummary ? this.createElementGeometrySummary(id) : accept);
     }
-}
-IntersectSolidElementsTool.toolId = "IntersectSolids";
-IntersectSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-/** @alpha Perform sew operation on surface geometry. */
-export class SewSheetElementsTool extends ElementGeometryCacheTool {
-    get allowSelectionSet() { return true; }
-    get allowDragSelect() { return true; }
-    get controlKeyContinuesSelection() { return true; }
-    get requiredElementCount() { return 2; }
-    get geometryCacheFilter() {
-        return { parts: true, curves: false, surfaces: true, solids: false, other: false };
-    }
-    async applyAgendaOperation() {
-        if (this.agenda.length < this.requiredElementCount)
+    getAcceptedSubEntityData(index = -1) {
+        if (-1 === index)
+            index = this._acceptedSubEntities.length - 1;
+        if (index < 0 || index > this._acceptedSubEntities.length - 1)
             return undefined;
-        try {
-            this._startedCmd = await this.startCommand();
-            const target = this.agenda.elements[0];
-            const tools = this.agenda.elements.slice(1);
-            const params = { tools };
-            const opts = { writeChanges: true };
-            return await ElementGeometryCacheTool.callCommand("sewSheets", target, params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
+        return this._acceptedSubEntities[index];
     }
-    async processAgenda(_ev) {
-        const result = await this.applyAgendaOperation();
-        if (result === null || result === void 0 ? void 0 : result.elementId)
-            await this.saveChanges();
+    getAcceptedSubEntities() {
+        const accepted = [];
+        this._acceptedSubEntities.forEach((entry) => { accepted.push(entry.props); });
+        return accepted;
     }
-    async onRestartTool() {
-        const tool = new SewSheetElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
+    drawSubEntity(context, subEntity, accepted) {
+        subEntity.display(context, accepted);
+    }
+    drawAcceptedSubEntities(context) {
+        this._acceptedSubEntities.forEach((entry) => { this.drawSubEntity(context, entry, true); });
     }
-}
-SewSheetElementsTool.toolId = "SewSheets";
-SewSheetElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-/** @alpha Base class for tools that need to locate faces, edges, and vertices. */
-export class LocateSubEntityTool extends ElementGeometryCacheTool {
-    wantSubEntityType(type) { return SubEntityType.Face === type; }
-    getMaximumSubEntityHits(type) { return this.wantSubEntityType(type) ? 25 : 0; }
-    get wantAgendaAppearanceOverride() { return true; }
     decorate(context) {
-        if (!this.allowView(context.viewport))
+        if (this.inhibitSubEntityDisplay || !this.allowView(context.viewport))
             return;
+        if (this.haveAcceptedSubEntities)
+            this.drawAcceptedSubEntities(context);
         if (undefined !== this._currentSubEntity)
-            this._currentSubEntity.display(context, false);
+            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)
@@ -404,6 +434,19 @@ export class LocateSubEntityTool extends ElementGeometryCacheTool {
         // 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 {
@@ -433,8 +476,9 @@ export class LocateSubEntityTool extends ElementGeometryCacheTool {
             return undefined;
         const aperture = this.getLocateAperture(ev);
         const maxDistance = this.getMaxRayDistance(ev, aperture);
-        const boresite = AccuDrawHintBuilder.getBoresite(ev.point, vp);
-        const hiddenEdgesVisible = vp.viewFlags.hiddenEdgesVisible();
+        const spacePoint = this.getRayOrigin(ev);
+        const boresite = 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...
@@ -458,39 +502,103 @@ export class LocateSubEntityTool extends ElementGeometryCacheTool {
         }
         return hits;
     }
+    async createSubEntityData(id, hit) {
+        const data = new SubEntityData(hit.subEntity);
+        const chordTolerance = (this.targetView ? computeChordToleranceFromPoint(this.targetView, 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) {
+        var _a;
         if (this.agenda.isEmpty || undefined === ev.viewport)
             return false;
+        const id = this.agenda.elements[this.agenda.length - 1];
         if (newSearch) {
-            const info = await this.doPickSubEntities(this.agenda.elements[this.agenda.length - 1], ev);
-            if (undefined === info)
+            this._locatedSubEntities = await this.doPickSubEntities(id, ev);
+            if (undefined === this._locatedSubEntities || 0 === this._locatedSubEntities.length)
                 return false;
-            this._acceptedSubEntity = info[0]; // TODO: Save array for reset cyling. Do we need to support multiple elements?
-            this.clearSubEntityGraphic();
-            return true;
+            /** 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 (CoordSource.ElemSnap !== ev.coordsFrom) {
+                ev.point.setFrom(Point3d.fromJSON(this._locatedSubEntities[0].point));
+                IModelApp.toolAdmin.setAdjustedDataPoint(ev);
+            }
+        }
+        else {
+            await this.removeSubEntity(id);
         }
-        this._acceptedSubEntity = undefined;
+        const hit = (_a = this._locatedSubEntities) === null || _a === void 0 ? void 0 : _a.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);
+        }
+        IModelApp.viewManager.invalidateDecorationsAllViews();
         return true;
     }
     async chooseNextHit(ev) {
-        if (undefined === this._acceptedSubEntity)
+        if (!this.haveAcceptedSubEntities)
             return super.chooseNextHit(ev);
-        await this.doLocateSubEntity(ev, false);
-        if (undefined === this._acceptedSubEntity)
-            await this.onReinitialize();
+        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 EventHandled.No;
     }
+    get wantAdditionalSubEntities() {
+        return (this._acceptedSubEntities.length < this.requiredSubEntityCount || (this.allowSubEntityControlSelect && this.isControlDown));
+    }
     async gatherInput(ev) {
-        if (undefined === this._acceptedSubEntity)
+        if (this.wantAdditionalSubEntities) {
             await this.doLocateSubEntity(ev, true);
+            if (this.wantAdditionalSubEntities) {
+                this.setupAndPromptForNextAction();
+                return EventHandled.No;
+            }
+            this.clearCurrentSubEntity();
+        }
         return super.gatherInput(ev);
     }
-    get wantAdditionalInput() {
-        if (undefined === this._acceptedSubEntity)
-            return true;
-        return super.wantAdditionalInput;
+    getCurrentElement() {
+        if (!this.agenda.isEmpty)
+            return this.agenda.elements[this.agenda.length - 1];
+        const hit = 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, current, chordTolerance) {
+    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;
@@ -499,159 +607,95 @@ export class LocateSubEntityTool extends ElementGeometryCacheTool {
         }
         if (undefined !== this._currentSubEntity && this._currentSubEntity.hasGraphic && this._currentSubEntity.isSame(current.subEntity))
             return false;
-        if (undefined === this._currentSubEntity)
-            this._currentSubEntity = new SubEntityData();
-        else
-            this._currentSubEntity.cleanupGraphic();
-        const opts = {
-            wantGraphic: true,
-            wantRange: true,
-            wantAppearance: true,
-            chordTolerance,
-        };
-        this._currentSubEntity.info = current.subEntity;
-        this._currentSubEntity.geom = await ElementGeometryCacheTool.callCommand("getSubEntityGeometry", id, current.subEntity, opts);
-        return this._currentSubEntity.createGraphic(this.iModel);
-    }
-    clearSubEntityGraphic() {
-        if (undefined === this._currentSubEntity)
-            return;
-        this._currentSubEntity.cleanupGraphic();
-        this._currentSubEntity = undefined;
+        return this.setCurrentSubEntity(id, current, chordTolerance);
     }
-    async updateSubEntityGraphic(ev) {
+    async updateCurrentSubEntity(ev) {
         if (undefined === ev.viewport)
             return false;
-        const hit = IModelApp.accuSnap.currHit;
-        if (undefined === hit || !hit.isElementHit)
-            return this.setCurrentSubEntity();
-        const current = await this.doPickSubEntities(hit.sourceId, ev);
+        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 ? computeChordToleranceFromPoint(ev.viewport, Point3d.fromJSON(current[0].point)) : 0.0;
-        if (!await this.setCurrentSubEntity(hit.sourceId, current ? current[0] : undefined, chordTolerance))
+        const status = await this.changeCurrentSubEntity(id, current ? current[0] : undefined, chordTolerance);
+        this._subEntityGraphicPending = undefined;
+        if (status)
+            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 ElementGeometryCacheTool.callCommand("getSubEntityGeometry", id, data.props, opts);
+            return await data.createGraphic(this.iModel);
+        }
+        catch (err) {
             return false;
-        IModelApp.viewManager.invalidateDecorationsAllViews();
-        return true;
+        }
     }
     async updateGraphic(ev, isDynamics) {
         if (isDynamics)
             return super.updateGraphic(ev, isDynamics);
-        await this.updateSubEntityGraphic(ev);
+        await this.updateCurrentSubEntity(ev);
     }
-    async applyAgendaOperation(_ev, _isAccept) { return undefined; }
     async getGraphicData(ev) {
         const result = await this.applyAgendaOperation(ev, false);
         return result === null || result === void 0 ? void 0 : result.graphic;
     }
+    async applyAgendaOperation(_ev, _isAccept) { return undefined; }
     async processAgenda(ev) {
-        if (undefined === this._acceptedSubEntity)
-            return;
         const result = await this.applyAgendaOperation(ev, true);
         if (result === null || result === void 0 ? void 0 : result.elementId)
             await this.saveChanges();
     }
+    async onModifierKeyTransition(wentDown, modifier, event) {
+        if (EventHandled.Yes === await super.onModifierKeyTransition(wentDown, modifier, event))
+            return EventHandled.Yes;
+        if (BeModifierKeys.Control !== modifier)
+            return EventHandled.No;
+        if (IModelApp.toolAdmin.isLocateCircleOn === this.wantAdditionalSubEntities)
+            return EventHandled.No;
+        this.setupAndPromptForNextAction();
+        return EventHandled.Yes;
+    }
+    changeLocateState(enableLocate, enableSnap, cursor, coordLockOvr) {
+        super.changeLocateState(enableLocate, enableSnap, cursor, coordLockOvr);
+        // Keep showing locate circle when identifing sub-entities even if done locating elements...
+        if (!IModelApp.toolAdmin.isLocateCircleOn && this.wantAdditionalSubEntities)
+            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.clearSubEntityGraphic();
+        this.clearSubEntityGraphics();
         return super.onCleanup();
     }
 }
-/** @alpha Identify faces of solids and surfaces to offset. */
-export class OffsetFacesTool extends LocateSubEntityTool {
-    requireWriteableTarget() { return false; } // TODO: Testing...
-    get wantDynamics() { return true; }
-    get wantAccuSnap() { return undefined !== this._acceptedSubEntity; }
-    get geometryCacheFilter() {
-        return { minGeom: 1, maxGeom: 1, parts: true, curves: false, surfaces: true, solids: true, other: false };
-    }
-    async applyAgendaOperation(ev, isAccept) {
-        var _a, _b;
-        if (undefined === ev.viewport || this.agenda.isEmpty || undefined === ((_a = this._acceptedSubEntity) === null || _a === void 0 ? void 0 : _a.point) || undefined === ((_b = this._acceptedSubEntity) === null || _b === void 0 ? void 0 : _b.normal))
-            return undefined;
-        const facePt = Point3d.fromJSON(this._acceptedSubEntity.point);
-        const faceNormal = Vector3d.fromJSON(this._acceptedSubEntity.normal);
-        const projPt = AccuDrawHintBuilder.projectPointToLineInView(ev.point, facePt, faceNormal, ev.viewport);
-        if (undefined === projPt)
-            return undefined;
-        const offsetDir = Vector3d.createStartEnd(facePt, projPt);
-        let offset = offsetDir.magnitude();
-        if (offset < Geometry.smallMetricDistance)
-            return undefined;
-        if (offsetDir.dotProduct(faceNormal) < 0.0)
-            offset = -offset;
-        try {
-            this._startedCmd = await this.startCommand();
-            const params = { faces: this._acceptedSubEntity.subEntity, distances: offset };
-            const opts = {
-                wantGraphic: isAccept ? undefined : true,
-                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
-                requestId: `${this.toolId}:${this.agenda.elements[0]}`,
-                writeChanges: isAccept ? true : undefined,
-            };
-            return await ElementGeometryCacheTool.callCommand("offsetFaces", this.agenda.elements[0], params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    setupAccuDraw() {
-        var _a, _b;
-        if (undefined === ((_a = this._acceptedSubEntity) === null || _a === void 0 ? void 0 : _a.point) || undefined === ((_b = this._acceptedSubEntity) === null || _b === void 0 ? void 0 : _b.normal))
-            return;
-        const facePt = Point3d.fromJSON(this._acceptedSubEntity.point);
-        const faceNormal = Vector3d.fromJSON(this._acceptedSubEntity.normal);
-        const hints = new AccuDrawHintBuilder();
-        hints.setOriginFixed = true;
-        hints.setLockY = true;
-        hints.setLockZ = true;
-        hints.setModeRectangular();
-        hints.setOrigin(facePt);
-        hints.setXAxis2(faceNormal);
-        hints.sendHints();
-    }
-    async onRestartTool() {
-        const tool = new OffsetFacesTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-OffsetFacesTool.toolId = "OffsetFaces";
-OffsetFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
-/** @alpha Identify faces to offset to hollow solids. */
-export class HollowFacesTool extends LocateSubEntityTool {
-    get geometryCacheFilter() {
-        return { minGeom: 1, maxGeom: 1, parts: true, curves: false, surfaces: false, solids: true, other: false };
-    }
-    async applyAgendaOperation(ev, isAccept) {
-        if (undefined === ev.viewport || this.agenda.isEmpty || undefined === this._acceptedSubEntity)
-            return undefined;
-        // TODO: Tool settings for shell thickness and face thickness...
-        const shellThickness = 0.1;
-        const faceThickness = 0.0;
-        try {
-            this._startedCmd = await this.startCommand();
-            const params = { faces: this._acceptedSubEntity.subEntity, distances: faceThickness, defaultDistance: shellThickness };
-            const opts = {
-                wantGraphic: isAccept ? undefined : true,
-                chordTolerance: computeChordToleranceFromPoint(ev.viewport, ev.point),
-                requestId: `${this.toolId}:${this.agenda.elements[0]}`,
-                writeChanges: isAccept ? true : undefined,
-            };
-            return await ElementGeometryCacheTool.callCommand("hollowFaces", this.agenda.elements[0], params, opts);
-        }
-        catch (err) {
-            return undefined;
-        }
-    }
-    async onRestartTool() {
-        const tool = new HollowFacesTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-HollowFacesTool.toolId = "HollowFaces";
-HollowFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
 //# sourceMappingURL=ElementGeometryTool.js.map