@itwin/core-frontend 5.1.0-dev.9 → 5.2.0-dev.1

package/lib/esm/tools/ViewTool.js

@@ -128,11 +128,13 @@ export class ViewingToolHandle {
     }
     // if we have a valid depth point, set the focus distance to
     changeFocusFromDepthPoint() {
-        if (undefined !== this._depthPoint) {
-            const view = this.viewTool.viewport.view;
-            if (view.is3d() && view.isCameraOn)
-                view.changeFocusFromPoint(this._depthPoint); // set the focus distance to the depth point
-        }
+        if (undefined === this._depthPoint)
+            return;
+        const view = this.viewTool.viewport?.view;
+        if (undefined === view)
+            return;
+        if (view.is3d() && view.isCameraOn)
+            view.changeFocusFromPoint(this._depthPoint); // set the focus distance to the depth point
     }
 }
 /** @internal */
@@ -622,11 +624,15 @@ export class ViewManip extends ViewTool {
         return inDynamics || (doUpdate && hitHandle.checkOneShot());
     }
     lensAngleMatches(angle, tolerance) {
-        const cameraView = this.viewport.view;
+        const cameraView = this.viewport?.view;
+        if (undefined === cameraView)
+            return false;
         return !cameraView.is3d() ? false : Math.abs(cameraView.calcLensAngle().radians - angle.radians) < tolerance;
     }
     get isZUp() {
-        const view = this.viewport.view;
+        const view = this.viewport?.view;
+        if (undefined === view)
+            return true;
         const viewX = view.getXVector();
         const viewY = view.getXVector();
         const zVec = Vector3d.unitZ();
@@ -769,9 +775,12 @@ class ViewTargetCenter extends ViewingToolHandle {
     testHandleForHit(ptScreen, out) {
         if (this.viewTool.isDraggingRequired)
             return false; // Target center handle is not movable in this mode, but it's still nice to display the point we're rotating about...
-        const targetPt = this.viewTool.viewport.worldToView(this.viewTool.targetCenterWorld);
+        const vp = this.viewTool.viewport;
+        if (undefined === vp)
+            return false;
+        const targetPt = vp.worldToView(this.viewTool.targetCenterWorld);
         const distance = targetPt.distanceXY(ptScreen);
-        const locateThreshold = this.viewTool.viewport.pixelsFromInches(0.15);
+        const locateThreshold = vp.pixelsFromInches(0.15);
         if (distance > locateThreshold)
             return false;
         out.distance = distance;
@@ -848,7 +857,10 @@ class HandleWithInertia extends ViewingToolHandle {
     doManipulation(ev, inDynamics) {
         if (ToolSettings.viewingInertia.enabled && !inDynamics && undefined !== this._inertiaVec)
             return this.beginAnimation();
-        const thisPtNpc = ev.viewport.worldToNpc(ev.point);
+        const vp = ev.viewport;
+        if (undefined === vp)
+            return false;
+        const thisPtNpc = vp.worldToNpc(ev.point);
         thisPtNpc.z = this._lastPtNpc.z;
         this._inertiaVec = undefined;
         if (this._lastPtNpc.isAlmostEqual(thisPtNpc, 1.0e-10))
@@ -861,7 +873,9 @@ class HandleWithInertia extends ViewingToolHandle {
         this._duration = ToolSettings.viewingInertia.duration;
         if (this._duration.isTowardsFuture) { // ensure duration is towards future. Otherwise, don't start animation
             this._end = BeTimePoint.fromNow(this._duration);
-            this.viewTool.viewport.setAnimator(this);
+            const vp = this.viewTool.viewport;
+            if (undefined !== vp)
+                vp.setAnimator(this);
         }
         return true;
     }
@@ -875,7 +889,10 @@ class HandleWithInertia extends ViewingToolHandle {
         const pt = this._lastPtNpc.plusScaled(this._inertiaVec, remaining);
         // if we're not moving any more, or if the duration has elapsed, we're done
         if (remaining <= 0 || (this._lastPtNpc.minus(pt).magnitudeSquared() < .000001)) {
-            this.viewTool.viewport.saveViewUndo();
+            const vp = this.viewTool.viewport;
+            if (undefined === vp)
+                return false;
+            vp.saveViewUndo();
             return true; // remove this as the animator
         }
         this.perform(pt); // perform the viewing operation
@@ -889,10 +906,12 @@ class ViewPan extends HandleWithInertia {
     get handleType() { return ViewHandleType.Pan; }
     getHandleCursor() { return this.viewTool.inHandleModify ? IModelApp.viewManager.grabbingCursor : IModelApp.viewManager.grabCursor; }
     firstPoint(ev) {
+        this._inertiaVec = undefined;
         const tool = this.viewTool;
         const vp = tool.viewport;
+        if (undefined === vp)
+            return false;
         vp.worldToNpc(ev.point, this._lastPtNpc);
-        this._inertiaVec = undefined;
         // if the camera is on, we need to find the element under the starting point to get the z
         if (this.needDepthPoint(ev, false)) {
             this.pickDepthPoint(ev);
@@ -914,6 +933,8 @@ class ViewPan extends HandleWithInertia {
     perform(thisPtNpc) {
         const tool = this.viewTool;
         const vp = tool.viewport;
+        if (undefined === vp)
+            return false;
         const view = vp.view;
         const lastWorld = vp.npcToWorld(this._lastPtNpc);
         const thisWorld = vp.npcToWorld(thisPtNpc);
@@ -932,7 +953,10 @@ class ViewPan extends HandleWithInertia {
     }
     /** @internal */
     needDepthPoint(ev, _isPreview) {
-        return ev.viewport.isCameraOn && CoordSource.User === ev.coordsFrom;
+        const vp = ev.viewport;
+        if (undefined === vp)
+            return false;
+        return vp.isCameraOn && CoordSource.User === ev.coordsFrom;
     }
 }
 /** ViewingToolHandle for performing the "rotate view" operation */
@@ -951,6 +975,8 @@ class ViewRotate extends HandleWithInertia {
         this._inertiaVec = undefined;
         const tool = this.viewTool;
         const vp = ev.viewport;
+        if (undefined === vp)
+            return false;
         this.pickDepthPoint(ev);
         if (undefined !== this._depthPoint)
             tool.setTargetCenterWorld(this._depthPoint, false, false);
@@ -965,6 +991,8 @@ class ViewRotate extends HandleWithInertia {
     perform(ptNpc) {
         const tool = this.viewTool;
         const vp = tool.viewport;
+        if (undefined === vp)
+            return false;
         if (this._anchorPtNpc.isAlmostEqual(ptNpc, 1.0e-2)) // too close to anchor pt
             ptNpc.setFrom(this._anchorPtNpc);
         const currentFrustum = vp.getFrustum(CoordSystem.World, false);
@@ -1000,8 +1028,8 @@ class ViewRotate extends HandleWithInertia {
             const xAxis = ToolSettings.preserveWorldUp && !vp.viewingGlobe ? (undefined !== this._depthPoint ? vp.view.getUpVector(this._depthPoint) : Vector3d.unitZ()) : vp.rotation.getRow(1);
             // Movement in screen y == rotation about screen X...
             const yAxis = vp.rotation.getRow(0);
-            const xRMatrix = xDelta ? Matrix3d.createRotationAroundVector(xAxis, Angle.createRadians(Math.PI / (viewRect.width / xDelta))) : Matrix3d.identity;
-            const yRMatrix = yDelta ? Matrix3d.createRotationAroundVector(yAxis, Angle.createRadians(Math.PI / (viewRect.height / yDelta))) : Matrix3d.identity;
+            const xRMatrix = (xDelta ? Matrix3d.createRotationAroundVector(xAxis, Angle.createRadians(Math.PI / (viewRect.width / xDelta))) : undefined) ?? Matrix3d.identity;
+            const yRMatrix = (yDelta ? Matrix3d.createRotationAroundVector(yAxis, Angle.createRadians(Math.PI / (viewRect.height / yDelta))) : undefined) ?? Matrix3d.identity;
             const worldRMatrix = yRMatrix.multiplyMatrixMatrix(xRMatrix);
             const result = worldRMatrix.getAxisAndAngleOfRotation();
             angle = Angle.createRadians(-result.angle.radians);
@@ -1032,11 +1060,14 @@ class ViewRotate extends HandleWithInertia {
     }
     /** @internal */
     needDepthPoint(ev, _isPreview) {
-        return (!this.viewTool.targetCenterLocked && ev.viewport.view.allow3dManipulations());
+        const vp = ev.viewport;
+        if (undefined === vp)
+            return false;
+        return (!this.viewTool.targetCenterLocked && vp.view.allow3dManipulations());
     }
     /** @internal */
     adjustDepthPoint(isValid, vp, plane, source) {
-        if (vp.viewingGlobe && this.viewTool.isPointVisible(vp.iModel.ecefLocation.earthCenter)) {
+        if (vp.viewingGlobe && vp.iModel.ecefLocation && this.viewTool.isPointVisible(vp.iModel.ecefLocation.earthCenter)) {
             plane.getOriginRef().setFrom(vp.iModel.ecefLocation.earthCenter);
             plane.getNormalRef().setFrom(vp.view.getZVector());
             return true;
@@ -1063,6 +1094,8 @@ class ViewLook extends ViewingToolHandle {
     firstPoint(ev) {
         const tool = this.viewTool;
         const vp = ev.viewport;
+        if (undefined === vp)
+            return true;
         const view = vp.view;
         if (!view || !view.is3d() || !view.allow3dManipulations())
             return false;
@@ -1087,11 +1120,13 @@ class ViewLook extends ViewingToolHandle {
     doManipulation(ev, _inDynamics) {
         const tool = this.viewTool;
         const viewport = tool.viewport;
+        if (undefined === viewport)
+            return false;
         if (ev.viewport !== viewport)
             return false;
         const worldTransform = this.getLookTransform(viewport, this._firstPtView, ev.viewPoint);
         const frustum = this._frustum.transformBy(worldTransform);
-        this.viewTool.viewport.setupViewFromFrustum(frustum);
+        viewport.setupViewFromFrustum(frustum);
         return true;
     }
     getLookTransform(vp, firstPt, currPt) {
@@ -1164,7 +1199,8 @@ class AnimatedHandle extends ViewingToolHandle {
         }
         this._lastPtView.setFrom(this._anchorPtView);
         this._lastMotionTime = Date.now();
-        tool.viewport.setAnimator(this);
+        if (undefined !== tool.viewport)
+            tool.viewport.setAnimator(this);
         return true;
     }
     getDirection() {
@@ -1173,10 +1209,13 @@ class AnimatedHandle extends ViewingToolHandle {
         return dir.magnitudeSquared() < this._deadZone ? undefined : dir; // dead zone around starting point
     }
     getInputVector() {
+        const vp = this.viewTool.viewport;
+        if (undefined === vp)
+            return undefined;
         const dir = this.getDirection();
         if (undefined === dir)
             return undefined;
-        const viewRect = this.viewTool.viewport.viewRect;
+        const viewRect = vp.viewRect;
         return new Vector3d(dir.x * (2.0 / viewRect.width), dir.y * (2.0 / viewRect.height));
     }
     onReinitialize() {
@@ -1252,6 +1291,8 @@ class ViewScroll extends AnimatedHandle {
         dist.scaleInPlace(ToolSettings.scrollSpeed * this.getElapsedTime());
         const tool = this.viewTool;
         const viewport = tool.viewport;
+        if (undefined === viewport)
+            return false;
         if (viewport.isCameraOn) {
             const points = new Array(2);
             points[0] = this._anchorPtView.clone();
@@ -1272,7 +1313,10 @@ class ViewScroll extends AnimatedHandle {
     }
     /** @internal */
     needDepthPoint(ev, _isPreview) {
-        return ev.viewport.isCameraOn && CoordSource.User === ev.coordsFrom;
+        const vp = ev.viewport;
+        if (undefined === vp)
+            return false;
+        return vp.isCameraOn && CoordSource.User === ev.coordsFrom;
     }
 }
 /** ViewingToolHandle for performing the "zoom view" operation */
@@ -1322,6 +1366,8 @@ class ViewZoom extends ViewingToolHandle {
     }
     firstPoint(ev) {
         const vp = ev.viewport;
+        if (undefined === vp)
+            return false;
         this.viewTool.inDynamicUpdate = true;
         if (this.needDepthPoint(ev, false)) {
             this.pickDepthPoint(ev);
@@ -1366,6 +1412,8 @@ class ViewZoom extends ViewingToolHandle {
         if (undefined === this._startFrust || undefined === this.getDirection()) // on anchor point?
             return false;
         const viewport = this.viewTool.viewport;
+        if (undefined === viewport)
+            return false;
         const view = viewport.view;
         const thisPtNpc = viewport.viewToNpc(this._lastPtView);
         const dist = this._anchorPtNpc.minus(thisPtNpc);
@@ -1392,7 +1440,10 @@ class ViewZoom extends ViewingToolHandle {
     }
     /** @internal */
     needDepthPoint(ev, _isPreview) {
-        return ev.viewport.isCameraOn && CoordSource.User === ev.coordsFrom;
+        const vp = ev.viewport;
+        if (undefined === vp)
+            return false;
+        return vp.isCameraOn && CoordSource.User === ev.coordsFrom;
     }
 }
 /** @internal */
@@ -1456,11 +1507,17 @@ class NavigateMotion {
         const yAngle = -(accumulator.y / yExtent) * Math.PI;
         const viewRot = vp.rotation;
         const invViewRot = viewRot.inverse();
+        if (undefined === invViewRot)
+            return Transform.createIdentity();
         const pitchAngle = Angle.createRadians(this.modifyPitchAngleToPreventInversion(yAngle));
         const pitchMatrix = Matrix3d.createRotationAroundVector(Vector3d.unitX(), pitchAngle);
+        if (undefined === pitchMatrix)
+            return Transform.createIdentity();
         const pitchTimesView = pitchMatrix.multiplyMatrixMatrix(viewRot);
         const inverseViewTimesPitchTimesView = invViewRot.multiplyMatrixMatrix(pitchTimesView);
         const yawMatrix = Matrix3d.createRotationAroundVector(Vector3d.unitZ(), Angle.createRadians(xAngle));
+        if (undefined === yawMatrix)
+            return Transform.createIdentity();
         const yawTimesInverseViewTimesPitchTimesView = yawMatrix.multiplyMatrixMatrix(inverseViewTimesPitchTimesView);
         return Transform.createFixedPointAndMatrix(view.getEyePoint(), yawTimesInverseViewTimesPitchTimesView, result);
     }
@@ -1471,11 +1528,17 @@ class NavigateMotion {
             return Transform.createIdentity();
         const viewRot = vp.rotation;
         const invViewRot = viewRot.inverse();
+        if (undefined === invViewRot)
+            return Transform.createIdentity();
         const pitchAngle = Angle.createRadians(this.modifyPitchAngleToPreventInversion(pitchRate * this._seconds));
         const pitchMatrix = Matrix3d.createRotationAroundVector(Vector3d.unitX(), pitchAngle);
+        if (undefined === pitchMatrix)
+            return Transform.createIdentity();
         const pitchTimesView = pitchMatrix.multiplyMatrixMatrix(viewRot);
         const inverseViewTimesPitchTimesView = invViewRot.multiplyMatrixMatrix(pitchTimesView);
         const yawMatrix = Matrix3d.createRotationAroundVector(Vector3d.unitZ(), Angle.createRadians(yawRate * this._seconds));
+        if (undefined === yawMatrix)
+            return Transform.createIdentity();
         const yawTimesInverseViewTimesPitchTimesView = yawMatrix.multiplyMatrixMatrix(inverseViewTimesPitchTimesView);
         return Transform.createFixedPointAndMatrix(view.getEyePoint(), yawTimesInverseViewTimesPitchTimesView, result);
     }
@@ -1533,6 +1596,8 @@ class NavigateMotion {
         if (!view.is3d() || !view.isCameraOn)
             return;
         const angles = YawPitchRollAngles.createFromMatrix3d(this.viewport.rotation);
+        if (undefined === angles)
+            return;
         angles.pitch.setRadians(0); // reset pitch to zero
         Transform.createFixedPointAndMatrix(view.getEyePoint(), angles.toMatrix3d(), this.transform);
     }
@@ -1545,7 +1610,7 @@ class ViewNavigate extends AnimatedHandle {
     getMaxAngularVelocity() { return Math.PI / 4; }
     getNavigateMode() {
         const state = IModelApp.toolAdmin.currentInputState;
-        return (state.isShiftDown || !this.viewTool.viewport.isCameraOn) ? 0 /* NavigateMode.Pan */ :
+        return (state.isShiftDown || (false === this.viewTool.viewport?.isCameraOn)) ? 0 /* NavigateMode.Pan */ :
             state.isControlDown ? 1 /* NavigateMode.Look */ : 2 /* NavigateMode.Travel */;
     }
     // called in animation loop
@@ -1555,6 +1620,8 @@ class ViewNavigate extends AnimatedHandle {
         const motion = this.getNavigateMotion(this.getElapsedTime());
         if (undefined !== motion) {
             const vp = this.viewTool.viewport;
+            if (undefined === vp)
+                return false;
             const frust = vp.getWorldFrustum();
             frust.multiply(motion.transform);
             vp.setupViewFromFrustum(frust);
@@ -1626,6 +1693,7 @@ class ViewLookAndMove extends ViewNavigate {
     _pointerLockKeyEngagementListener;
     constructor(viewManip) {
         super(viewManip);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         this._navigateMotion = new NavigateMotion(this.viewTool.viewport);
     }
     get handleType() { return ViewHandleType.LookAndMove; }
@@ -1748,10 +1816,10 @@ class ViewLookAndMove extends ViewNavigate {
     getMaxAngularVelocityY() { return this.getMaxAngularVelocity(); }
     getLinearVelocity() {
         const positionInput = Vector3d.create();
-        const vp = this.viewTool.viewport;
         const position = this.getTouchStartPosition(this._touchStartL);
         if (undefined !== position) {
-            const outerRadius = this.getTouchControlRadius(vp);
+            const vp = this.viewTool.viewport;
+            const outerRadius = vp ? this.getTouchControlRadius(vp) : 1;
             const offset = this.getTouchOffset(this._touchStartL, outerRadius);
             const inputL = new Vector3d(offset.x * (1.0 / outerRadius), offset.y * (1.0 / outerRadius));
             positionInput.x = inputL.x * this.getMaxLinearVelocity();
@@ -1766,10 +1834,10 @@ class ViewLookAndMove extends ViewNavigate {
     }
     getAngularVelocity() {
         const angularInput = Vector3d.create();
-        const vp = this.viewTool.viewport;
         const position = this.getTouchStartPosition(this._touchStartR);
         if (undefined !== position) {
-            const outerRadius = this.getTouchControlRadius(vp);
+            const vp = this.viewTool.viewport;
+            const outerRadius = vp ? this.getTouchControlRadius(vp) : 1;
             const offset = this.getTouchOffset(this._touchStartR, outerRadius);
             const inputA = new Vector3d(offset.x * (1.0 / outerRadius), offset.y * (1.0 / outerRadius));
             angularInput.x = inputA.x * -this.getMaxAngularVelocityX();
@@ -2022,7 +2090,8 @@ class ViewLookAndMove extends ViewNavigate {
         if (tool.inDynamicUpdate)
             return;
         tool.changeViewport(vp);
-        tool.viewport.setAnimator(this);
+        if (undefined !== tool.viewport)
+            tool.viewport.setAnimator(this);
         tool.inDynamicUpdate = true;
         tool.inHandleModify = true;
         vp.npcToView(NpcCenter, this._anchorPtView);
@@ -2187,6 +2256,8 @@ class ViewLookAndMove extends ViewNavigate {
         const position = this.getTouchStartPosition(touchStart);
         if (undefined === position)
             return offset;
+        if (undefined === touchStart?.viewport)
+            return offset;
         const lastTouch = BeTouchEvent.findTouchById(this._touchLast.touchEvent.targetTouches, touchStart.touchEvent.changedTouches[0].identifier);
         if (undefined === lastTouch)
             return offset;
@@ -2402,6 +2473,7 @@ class ViewWalk extends ViewNavigate {
     _navigateMotion;
     constructor(viewManip) {
         super(viewManip);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         this._navigateMotion = new NavigateMotion(this.viewTool.viewport);
     }
     get handleType() { return ViewHandleType.Walk; }
@@ -2436,6 +2508,7 @@ class ViewFly extends ViewNavigate {
     _navigateMotion;
     constructor(viewManip) {
         super(viewManip);
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         this._navigateMotion = new NavigateMotion(this.viewTool.viewport);
     }
     get handleType() { return ViewHandleType.Fly; }
@@ -3002,6 +3075,8 @@ export class WindowAreaTool extends ViewTool {
     }
     computeWindowCorners() {
         const vp = this.viewport;
+        if (undefined === vp)
+            return undefined;
         const corners = this._corners;
         corners[0].setFrom(this._firstPtWorld);
         corners[1].setFrom(this._secondPtWorld);
@@ -3090,13 +3165,15 @@ export class WindowAreaTool extends ViewTool {
         const corners = this.computeWindowCorners();
         if (undefined === corners)
             return;
-        let delta;
         const vp = this.viewport;
+        if (undefined === vp)
+            return;
         const view = vp.view;
         vp.viewToWorldArray(corners);
         const opts = {
             onExtentsError: (stat) => view.outputStatusMessage(stat),
         };
+        let delta;
         let globalAlignment;
         if (view.is3d() && view.isCameraOn) {
             const windowArray = [corners[0].clone(), corners[1].clone()];
@@ -3168,7 +3245,10 @@ export class DefaultViewTouchTool extends ViewManip {
         const vec = this._lastPtView.minus(pt);
         // if we're not moving any more, or if the duration has elapsed, we're done
         if (remaining <= 0 || (vec.magnitudeSquared() < .000001)) {
-            this.viewport.saveViewUndo();
+            const vp = this.viewport;
+            if (undefined === vp)
+                return false;
+            vp.saveViewUndo();
             return true; // remove this as the animator
         }
         this._lastPtView.setFrom(pt);
@@ -3184,6 +3264,8 @@ export class DefaultViewTouchTool extends ViewManip {
     }
     onStart(ev) {
         const vp = this.viewport;
+        if (undefined === vp)
+            return;
         vp.getWorldFrustum(this._frustum);
         const visiblePoint = vp.pickNearestVisibleGeometry(ev.rawPoint);
         if (undefined !== visiblePoint) {
@@ -3206,8 +3288,10 @@ export class DefaultViewTouchTool extends ViewManip {
         if (undefined === ev || 0.0 === this._startDistance)
             return 1.0;
         const vp = this.viewport;
+        if (undefined === vp)
+            return 1.0;
         const distance = (2 === ev.touchCount ? BeTouchEvent.getTouchPosition(ev.touchEvent.targetTouches[0], vp).distance(BeTouchEvent.getTouchPosition(ev.touchEvent.targetTouches[1], vp)) : 0.0);
-        const threshold = this.viewport.pixelsFromInches(ToolSettings.touchZoomChangeThresholdInches);
+        const threshold = vp.pixelsFromInches(ToolSettings.touchZoomChangeThresholdInches);
         if (0.0 === distance || Math.abs(this._startDistance - distance) < threshold)
             return 1.0;
         // Remove inertia if the viewing operation includes zoom, only use it for pan and rotate.
@@ -3219,6 +3303,8 @@ export class DefaultViewTouchTool extends ViewManip {
         if (undefined === ev || ev.touchCount < 2 || this._rotate2dDisabled)
             return Angle.createDegrees(0.0);
         const vp = this.viewport;
+        if (undefined === vp)
+            return Angle.createDegrees(0.0);
         const direction = Vector2d.createStartEnd(BeTouchEvent.getTouchPosition(ev.touchEvent.targetTouches[0], vp), BeTouchEvent.getTouchPosition(ev.touchEvent.targetTouches[1], vp));
         const rotation = this._startDirection.angleTo(direction);
         if (undefined === this._rotate2dThreshold) {
@@ -3238,15 +3324,18 @@ export class DefaultViewTouchTool extends ViewManip {
     }
     handle2dPan() {
         const screenDist = Point2d.create(this._startPtView.x - this._lastPtView.x, this._startPtView.y - this._lastPtView.y);
-        this.viewport.scroll(screenDist, { noSaveInUndo: true });
+        if (undefined !== this.viewport)
+            this.viewport.scroll(screenDist, { noSaveInUndo: true });
     }
     handle2dRotateZoom(ev) {
         const vp = this.viewport;
+        if (undefined === vp)
+            return;
         const rotation = this.computeRotation(ev);
         const zoomRatio = this.computeZoomRatio(ev);
         const targetWorld = vp.viewToWorld(this._lastPtView);
         const translateTransform = Transform.createTranslation(this._startPtWorld.minus(targetWorld));
-        const rotationTransform = Transform.createFixedPointAndMatrix(targetWorld, Matrix3d.createRotationAroundVector(vp.view.getZVector(), rotation));
+        const rotationTransform = Transform.createFixedPointAndMatrix(targetWorld, Matrix3d.createRotationAroundVector(vp.view.getZVector(), rotation) ?? Matrix3d.identity);
         const scaleTransform = Transform.createScaleAboutPoint(this._startPtWorld, zoomRatio);
         const transform = translateTransform.multiplyTransformTransform(rotationTransform);
         scaleTransform.multiplyTransformTransform(transform, transform);
@@ -3255,6 +3344,8 @@ export class DefaultViewTouchTool extends ViewManip {
     }
     handle3dRotate() {
         const vp = this.viewport;
+        if (undefined === vp)
+            return;
         const viewRect = vp.viewRect;
         const xExtent = viewRect.width;
         const yExtent = viewRect.height;
@@ -3262,8 +3353,8 @@ export class DefaultViewTouchTool extends ViewManip {
         const yDelta = this._lastPtView.y - this._startPtView.y;
         const xAxis = ToolSettings.preserveWorldUp ? Vector3d.unitZ() : vp.rotation.getRow(1);
         const yAxis = vp.rotation.getRow(0);
-        const xRMatrix = (0.0 !== xDelta) ? Matrix3d.createRotationAroundVector(xAxis, Angle.createRadians(Math.PI / (xExtent / xDelta))) : Matrix3d.identity;
-        const yRMatrix = (0.0 !== yDelta) ? Matrix3d.createRotationAroundVector(yAxis, Angle.createRadians(Math.PI / (yExtent / yDelta))) : Matrix3d.identity;
+        const xRMatrix = (xDelta ? Matrix3d.createRotationAroundVector(xAxis, Angle.createRadians(Math.PI / (xExtent / xDelta))) : undefined) ?? Matrix3d.identity;
+        const yRMatrix = (yDelta ? Matrix3d.createRotationAroundVector(yAxis, Angle.createRadians(Math.PI / (yExtent / yDelta))) : undefined) ?? Matrix3d.identity;
         const worldRMatrix = yRMatrix.multiplyMatrixMatrix(xRMatrix);
         const result = worldRMatrix.getAxisAndAngleOfRotation();
         const radians = Angle.createRadians(-result.angle.radians);
@@ -3277,6 +3368,8 @@ export class DefaultViewTouchTool extends ViewManip {
     }
     handle3dPanZoom(ev) {
         const vp = this.viewport;
+        if (undefined === vp)
+            return;
         const zoomRatio = this.computeZoomRatio(ev);
         if (vp.isCameraOn) {
             const targetWorld = vp.viewToWorld(this._lastPtView);
@@ -3335,6 +3428,8 @@ export class DefaultViewTouchTool extends ViewManip {
     }
     perform(ev) {
         const vp = this.viewport;
+        if (undefined === vp)
+            return;
         vp.setupViewFromFrustum(this._frustum);
         const singleTouch = this._singleTouch;
         return (!this._only2dManipulations && vp.view.allow3dManipulations()) ?
@@ -3357,7 +3452,8 @@ export class DefaultViewTouchTool extends ViewManip {
             this._duration = ToolSettings.viewingInertia.duration;
             if (this._duration.isTowardsFuture) { // ensure duration is towards future. Otherwise, don't start animation
                 this._end = BeTimePoint.fromNow(this._duration);
-                this.viewport.setAnimator(this);
+                if (undefined !== this.viewport)
+                    this.viewport.setAnimator(this);
             }
         }
         return this.exitTool();
@@ -3589,7 +3685,7 @@ export class SetupCameraTool extends PrimitiveTool {
     _cameraHeightProperty;
     get cameraHeightProperty() {
         if (!this._cameraHeightProperty)
-            this._cameraHeightProperty = new DialogProperty(new LengthDescription("cameraHeight", ViewTool.translate("SetupCamera.Labels.CameraHeight")), 0.0, undefined, !this.useCameraHeight);
+            this._cameraHeightProperty = new DialogProperty(new LengthDescription("cameraHeight", ViewTool.translate("SetupCamera.Labels.CameraHeight")), 0.0);
         return this._cameraHeightProperty;
     }
     get cameraHeight() { return this.cameraHeightProperty.value; }
@@ -3605,60 +3701,23 @@ export class SetupCameraTool extends PrimitiveTool {
     _targetHeightProperty;
     get targetHeightProperty() {
         if (!this._targetHeightProperty)
-            this._targetHeightProperty = new DialogProperty(new LengthDescription("targetHeight", ViewTool.translate("SetupCamera.Labels.TargetHeight")), 0.0, undefined, !this.useTargetHeight);
+            this._targetHeightProperty = new DialogProperty(new LengthDescription("targetHeight", ViewTool.translate("SetupCamera.Labels.TargetHeight")), 0.0);
         return this._targetHeightProperty;
     }
     get targetHeight() { return this.targetHeightProperty.value; }
     set targetHeight(value) { this.targetHeightProperty.value = value; }
-    syncCameraHeightState() {
-        this.cameraHeightProperty.displayValue = this.cameraHeightProperty.description.format(this.cameraHeight);
-        this.cameraHeightProperty.isDisabled = !this.useCameraHeight;
-        this.syncToolSettingsProperties([this.cameraHeightProperty.syncItem]);
-    }
-    syncTargetHeightState() {
-        this.targetHeightProperty.displayValue = this.targetHeightProperty.description.format(this.targetHeight);
-        this.targetHeightProperty.isDisabled = !this.useTargetHeight;
-        this.syncToolSettingsProperties([this.targetHeightProperty.syncItem]);
+    getToolSettingLockProperty(property) {
+        if (property === this.cameraHeightProperty)
+            return this.useCameraHeightProperty;
+        else if (property === this.targetHeightProperty)
+            return this.useTargetHeightProperty;
+        return undefined;
     }
     async applyToolSettingPropertyChange(updatedValue) {
-        if (updatedValue.propertyName === this.useCameraHeightProperty.name) {
-            this.useCameraHeight = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.useCameraHeightProperty.item);
-            this.syncCameraHeightState();
-        }
-        else if (updatedValue.propertyName === this.useTargetHeightProperty.name) {
-            this.useTargetHeight = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.useTargetHeightProperty.item);
-            this.syncTargetHeightState();
-        }
-        else if (updatedValue.propertyName === this.cameraHeightProperty.name) {
-            this.cameraHeight = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.cameraHeightProperty.item);
-        }
-        else if (updatedValue.propertyName === this.targetHeightProperty.name) {
-            this.targetHeight = updatedValue.value.value;
-            IModelApp.toolAdmin.toolSettingsState.saveToolSettingProperty(this.toolId, this.targetHeightProperty.item);
-        }
-        return true;
+        return this.changeToolSettingPropertyValue(updatedValue);
     }
     supplyToolSettingsProperties() {
-        // load latest values from session
-        IModelApp.toolAdmin.toolSettingsState.getInitialToolSettingValues(this.toolId, [
-            this.useCameraHeightProperty.name, this.useTargetHeightProperty.name, this.cameraHeightProperty.name, this.targetHeightProperty.name,
-        ])
-            ?.forEach((value) => {
-            if (value.propertyName === this.useCameraHeightProperty.name)
-                this.useCameraHeightProperty.dialogItemValue = value.value;
-            else if (value.propertyName === this.cameraHeightProperty.name)
-                this.cameraHeightProperty.dialogItemValue = value.value;
-            else if (value.propertyName === this.useTargetHeightProperty.name)
-                this.useTargetHeightProperty.dialogItemValue = value.value;
-            else if (value.propertyName === this.targetHeightProperty.name)
-                this.targetHeightProperty.dialogItemValue = value.value;
-        });
-        // ensure controls are enabled/disabled base on current lock property state
-        this.targetHeightProperty.isDisabled = !this.useTargetHeight;
-        this.cameraHeightProperty.isDisabled = !this.useCameraHeight;
+        this.initializeToolSettingPropertyValues([this.useCameraHeightProperty, this.useTargetHeightProperty, this.cameraHeightProperty, this.targetHeightProperty]);
         const cameraHeightLock = this.useCameraHeightProperty.toDialogItem({ rowPriority: 1, columnIndex: 0 });
         const targetHeightLock = this.useTargetHeightProperty.toDialogItem({ rowPriority: 2, columnIndex: 0 });
         const toolSettings = new Array();