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

package/lib/cjs/ElementGeometryTool.js

@@ -7,7 +7,7 @@
  * @module Editing
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HollowFacesTool = exports.OffsetFacesTool = exports.LocateSubEntityTool = exports.SewSheetElementsTool = exports.IntersectSolidElementsTool = exports.SubtractSolidElementsTool = exports.UniteSolidElementsTool = exports.BooleanOperationTool = exports.ElementGeometryCacheTool = exports.SubEntityData = exports.ElementGeometryGraphicsProvider = void 0;
+exports.LocateSubEntityTool = exports.ElementGeometryCacheTool = exports.SubEntityData = exports.isSameSubEntity = exports.ElementGeometryGraphicsProvider = void 0;
 const core_bentley_1 = require("@itwin/core-bentley");
 const editor_common_1 = require("@itwin/editor-common");
 const core_common_1 = require("@itwin/core-common");
@@ -66,46 +66,52 @@ class ElementGeometryGraphicsProvider {
 }
 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 {
-    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 = 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 ((_a = this.info) === null || _a === void 0 ? void 0 : _a.type) {
+        switch (this.props.type) {
             case editor_common_1.SubEntityType.Face:
                 break;
             case editor_common_1.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 editor_common_1.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 core_common_1.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)
@@ -121,16 +127,15 @@ class SubEntityData {
         var _a, _b;
         if (undefined === ((_a = this._graphicsProvider) === null || _a === void 0 ? void 0 : _a.graphic))
             return;
-        const appearanceProvider = core_common_1.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) ? core_geometry_1.Range3d.fromJSON(this.geom.range) : undefined);
+        const range = (((_b = this._geometry) === null || _b === void 0 ? void 0 : _b.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);
-        this._graphicsProvider.addDecoration(context, core_frontend_1.GraphicType.Scene, offsetTrans, opts);
+        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;
@@ -151,14 +156,22 @@ class ElementGeometryCacheTool extends core_frontend_1.ElementSetTool {
     static callCommand(method, ...args) {
         return EditTool_1.EditTools.callCommand(method, ...args);
     }
-    // TODO: This looks nice as long as ViewFlags.transparency is on...
-    get agendaAppearance() { return core_common_1.FeatureAppearance.fromTransparency(0.90); }
+    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 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)
@@ -173,18 +186,25 @@ class ElementGeometryCacheTool extends core_frontend_1.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 (core_bentley_1.Id64.isInvalid(id) || core_bentley_1.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;
@@ -212,8 +232,14 @@ class ElementGeometryCacheTool extends core_frontend_1.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 = 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);
@@ -276,126 +302,126 @@ class ElementGeometryCacheTool extends core_frontend_1.ElementSetTool {
     }
 }
 exports.ElementGeometryCacheTool = ElementGeometryCacheTool;
-/** @alpha Base class for tools that perform boolean operations on a set of elements. */
-class BooleanOperationTool extends ElementGeometryCacheTool {
-    get allowSelectionSet() { return editor_common_1.BooleanMode.Subtract !== this.mode; }
-    get allowDragSelect() { return editor_common_1.BooleanMode.Subtract !== this.mode; }
-    get controlKeyContinuesSelection() { return true; }
-    get requiredElementCount() { return 2; }
-    get geometryCacheFilter() {
-        return { parts: true, curves: false, surfaces: editor_common_1.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 (editor_common_1.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. */
+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);
     }
-    async processAgenda(_ev) {
-        const result = await this.applyAgendaOperation();
-        if (result === null || result === void 0 ? void 0 : result.elementId)
-            await this.saveChanges();
-    }
-}
-exports.BooleanOperationTool = BooleanOperationTool;
-/** @alpha Perform boolean union of solid geometry. */
-class UniteSolidElementsTool extends BooleanOperationTool {
-    get mode() { return editor_common_1.BooleanMode.Unite; }
-    async onRestartTool() {
-        const tool = new UniteSolidElementsTool();
-        if (!await tool.run())
-            return this.exitTool();
-    }
-}
-exports.UniteSolidElementsTool = UniteSolidElementsTool;
-UniteSolidElementsTool.toolId = "UniteSolids";
-UniteSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-/** @alpha Perform boolean subtract of solid geometry. */
-class SubtractSolidElementsTool extends BooleanOperationTool {
-    get mode() { return editor_common_1.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 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 ElementGeometryCacheTool.callCommand("summarizeElementGeometryCache", id)))
+                    return false;
+            }
+            catch (err) {
+                return false;
+            }
+            this._summaryIds.set(id, summary);
+        }
+        return true;
     }
-}
-exports.SubtractSolidElementsTool = SubtractSolidElementsTool;
-SubtractSolidElementsTool.toolId = "SubtractSolids";
-SubtractSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-/** @alpha Perform boolean intersection of solid geometry. */
-class IntersectSolidElementsTool extends BooleanOperationTool {
-    get mode() { return editor_common_1.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);
     }
-}
-exports.IntersectSolidElementsTool = IntersectSolidElementsTool;
-IntersectSolidElementsTool.toolId = "IntersectSolids";
-IntersectSolidElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-/** @alpha Perform sew operation on surface geometry. */
-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); });
     }
-}
-exports.SewSheetElementsTool = SewSheetElementsTool;
-SewSheetElementsTool.toolId = "SewSheets";
-SewSheetElementsTool.iconSpec = "icon-move"; // TODO: Need better icon...
-/** @alpha Base class for tools that need to locate faces, edges, and vertices. */
-class LocateSubEntityTool extends ElementGeometryCacheTool {
-    wantSubEntityType(type) { return editor_common_1.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)
@@ -415,6 +441,19 @@ 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 {
@@ -444,8 +483,9 @@ class LocateSubEntityTool extends ElementGeometryCacheTool {
             return undefined;
         const aperture = this.getLocateAperture(ev);
         const maxDistance = this.getMaxRayDistance(ev, aperture);
-        const boresite = core_frontend_1.AccuDrawHintBuilder.getBoresite(ev.point, vp);
-        const hiddenEdgesVisible = vp.viewFlags.hiddenEdgesVisible();
+        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...
@@ -469,39 +509,103 @@ class LocateSubEntityTool extends ElementGeometryCacheTool {
         }
         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) {
+        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 (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);
         }
-        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);
+        }
+        core_frontend_1.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 core_frontend_1.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 core_frontend_1.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 = 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, 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;
@@ -510,162 +614,96 @@ 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 = core_frontend_1.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 ? (0, CreateElementTool_1.computeChordToleranceFromPoint)(ev.viewport, core_geometry_1.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)
+            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 ElementGeometryCacheTool.callCommand("getSubEntityGeometry", id, data.props, opts);
+            return await data.createGraphic(this.iModel);
+        }
+        catch (err) {
             return false;
-        core_frontend_1.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 (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 identifing 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.clearSubEntityGraphic();
+        this.clearSubEntityGraphics();
         return super.onCleanup();
     }
 }
 exports.LocateSubEntityTool = LocateSubEntityTool;
-/** @alpha Identify faces of solids and surfaces to offset. */
-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 = core_geometry_1.Point3d.fromJSON(this._acceptedSubEntity.point);
-        const faceNormal = core_geometry_1.Vector3d.fromJSON(this._acceptedSubEntity.normal);
-        const projPt = core_frontend_1.AccuDrawHintBuilder.projectPointToLineInView(ev.point, facePt, faceNormal, ev.viewport);
-        if (undefined === projPt)
-            return undefined;
-        const offsetDir = core_geometry_1.Vector3d.createStartEnd(facePt, projPt);
-        let offset = offsetDir.magnitude();
-        if (offset < core_geometry_1.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: (0, CreateElementTool_1.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 = core_geometry_1.Point3d.fromJSON(this._acceptedSubEntity.point);
-        const faceNormal = core_geometry_1.Vector3d.fromJSON(this._acceptedSubEntity.normal);
-        const hints = new core_frontend_1.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();
-    }
-}
-exports.OffsetFacesTool = OffsetFacesTool;
-OffsetFacesTool.toolId = "OffsetFaces";
-OffsetFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
-/** @alpha Identify faces to offset to hollow solids. */
-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: (0, CreateElementTool_1.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();
-    }
-}
-exports.HollowFacesTool = HollowFacesTool;
-HollowFacesTool.toolId = "HollowFaces";
-HollowFacesTool.iconSpec = "icon-move"; // TODO: Need better icon...
 //# sourceMappingURL=ElementGeometryTool.js.map