@vcmap/core 5.1.6 → 5.2.0

package/src/util/editor/editGeometrySession.ts

@@ -19,6 +19,7 @@ import {
   setupScratchLayer,
 } from './editorSessionHelpers.js';
 import InteractionChain from '../../interaction/interactionChain.js';
+import type AbstractInteraction from '../../interaction/abstractInteraction.js';
 import VcsEvent from '../../vcsEvent.js';
 import TranslateVertexInteraction from './interactions/translateVertexInteraction.js';
 import RemoveVertexInteraction from './interactions/removeVertexInteraction.js';
@@ -59,6 +60,11 @@ function assignVectorProperty<
   props[key] = value;
 }
 
+type EditGeometrySessionOptions = {
+  denyInsertion?: boolean;
+  denyRemoval?: boolean;
+};
+
 /**
  * Create the editing interaction for a feature with a line geometry
  * @param  feature
@@ -68,6 +74,7 @@ function assignVectorProperty<
 function createEditLineStringGeometryInteraction(
   feature: Feature<LineString>,
   scratchLayer: VectorLayer,
+  options: EditGeometrySessionOptions,
 ): EditGeometryInteraction {
   const geometry =
     feature[obliqueGeometry] ?? (feature.getGeometry() as LineString);
@@ -84,28 +91,32 @@ function createEditLineStringGeometryInteraction(
   const translateVertex = new TranslateVertexInteraction(feature);
   translateVertex.vertexChanged.addEventListener(resetGeometry);
 
-  const insertVertex = new InsertVertexInteraction(feature, geometry);
-  insertVertex.vertexInserted.addEventListener(({ vertex, index }) => {
-    scratchLayer.addFeatures([vertex]);
-    vertices.splice(index, 0, vertex);
-    resetGeometry();
-  });
+  const interactions: AbstractInteraction[] = [translateVertex];
 
-  const removeVertex = new RemoveVertexInteraction();
-  removeVertex.vertexRemoved.addEventListener((vertex) => {
-    scratchLayer.removeFeaturesById([vertex.getId() as string]);
-    const index = vertices.indexOf(vertex);
-    if (index > -1) {
-      vertices.splice(index, 1);
+  if (!options.denyInsertion) {
+    const insertVertex = new InsertVertexInteraction(feature, geometry);
+    insertVertex.vertexInserted.addEventListener(({ vertex, index }) => {
+      scratchLayer.addFeatures([vertex]);
+      vertices.splice(index, 0, vertex);
       resetGeometry();
-    }
-  });
+    });
+    interactions.push(insertVertex);
+  }
+
+  if (!options.denyRemoval) {
+    const removeVertex = new RemoveVertexInteraction();
+    removeVertex.vertexRemoved.addEventListener((vertex) => {
+      scratchLayer.removeFeaturesById([vertex.getId() as string]);
+      const index = vertices.indexOf(vertex);
+      if (index > -1) {
+        vertices.splice(index, 1);
+        resetGeometry();
+      }
+    });
+    interactions.push(removeVertex);
+  }
 
-  const interactionChain = new InteractionChain([
-    translateVertex,
-    insertVertex,
-    removeVertex,
-  ]);
+  const interactionChain = new InteractionChain(interactions);
 
   return {
     interactionChain,
@@ -250,6 +261,7 @@ function createEditBBoxGeometryInteraction(
 function createEditSimplePolygonInteraction(
   feature: Feature<Polygon>,
   scratchLayer: VectorLayer,
+  options: EditGeometrySessionOptions,
 ): EditGeometryInteraction {
   const geometry =
     feature[obliqueGeometry] ?? (feature.getGeometry() as Polygon);
@@ -271,28 +283,32 @@ function createEditSimplePolygonInteraction(
   const translateVertex = new TranslateVertexInteraction(feature);
   translateVertex.vertexChanged.addEventListener(resetGeometry);
 
-  const insertVertex = new InsertVertexInteraction(feature, linearRing);
-  insertVertex.vertexInserted.addEventListener(({ vertex, index }) => {
-    scratchLayer.addFeatures([vertex]);
-    vertices.splice(index, 0, vertex);
-    resetGeometry();
-  });
+  const interactions: AbstractInteraction[] = [translateVertex];
 
-  const removeVertex = new RemoveVertexInteraction();
-  removeVertex.vertexRemoved.addEventListener((vertex) => {
-    scratchLayer.removeFeaturesById([vertex.getId() as string]);
-    const index = vertices.indexOf(vertex);
-    if (index > -1) {
-      vertices.splice(index, 1);
+  if (!options.denyInsertion) {
+    const insertVertex = new InsertVertexInteraction(feature, linearRing);
+    insertVertex.vertexInserted.addEventListener(({ vertex, index }) => {
+      scratchLayer.addFeatures([vertex]);
+      vertices.splice(index, 0, vertex);
       resetGeometry();
-    }
-  });
+    });
+    interactions.push(insertVertex);
+  }
+
+  if (!options.denyRemoval) {
+    const removeVertex = new RemoveVertexInteraction();
+    removeVertex.vertexRemoved.addEventListener((vertex) => {
+      scratchLayer.removeFeaturesById([vertex.getId() as string]);
+      const index = vertices.indexOf(vertex);
+      if (index > -1) {
+        vertices.splice(index, 1);
+        resetGeometry();
+      }
+    });
+    interactions.push(removeVertex);
+  }
 
-  const interactionChain = new InteractionChain([
-    translateVertex,
-    insertVertex,
-    removeVertex,
-  ]);
+  const interactionChain = new InteractionChain(interactions);
 
   return {
     interactionChain,
@@ -350,11 +366,13 @@ function createEditPointInteraction(
  * @param  app
  * @param  layer
  * @param  [interactionId] id for registering mutliple exclusive interaction. Needed to run a selection session at the same time as a edit features session.
+ * @param  [editVertexOptions={}]
  */
 function startEditGeometrySession(
   app: VcsApp,
   layer: VectorLayer,
   interactionId?: string,
+  editVertexOptions: EditGeometrySessionOptions = {},
 ): EditGeometrySession {
   const {
     interactionChain,
@@ -367,7 +385,9 @@ function startEditGeometrySession(
   const mapInteractionController = new MapInteractionController();
   interactionChain.addInteraction(mapInteractionController);
 
-  const mouseOverInteraction = new EditGeometryMouseOverInteraction();
+  const mouseOverInteraction = new EditGeometryMouseOverInteraction(
+    editVertexOptions.denyRemoval,
+  );
   interactionChain.addInteraction(mouseOverInteraction);
 
   const stopped = new VcsEvent<void>();
@@ -463,12 +483,14 @@ function startEditGeometrySession(
           currentInteractionSet = createEditSimplePolygonInteraction(
             feature as Feature<Polygon>,
             scratchLayer,
+            editVertexOptions,
           );
         }
       } else if (geometryType === GeometryType.LineString) {
         currentInteractionSet = createEditLineStringGeometryInteraction(
           feature as Feature<LineString>,
           scratchLayer,
+          editVertexOptions,
         );
       } else if (geometryType === GeometryType.Point) {
         currentInteractionSet = createEditPointInteraction(

package/src/util/editor/interactions/editGeometryMouseOverInteraction.ts

@@ -43,8 +43,13 @@ class EditGeometryMouseOverInteraction extends AbstractInteraction {
 
   cursorStyle: CSSStyleDeclaration | undefined;
 
-  constructor() {
-    super(EventType.MOVE, ModificationKeyType.NONE | ModificationKeyType.SHIFT);
+  constructor(denyRemoval?: boolean) {
+    super(
+      EventType.MOVE,
+      denyRemoval
+        ? ModificationKeyType.NONE
+        : ModificationKeyType.NONE | ModificationKeyType.SHIFT,
+    );
 
     this.setActive();
   }

package/src/util/editor/interactions/rightClickInteraction.ts

@@ -0,0 +1,42 @@
+import AbstractInteraction, {
+  InteractionEvent,
+} from '../../../interaction/abstractInteraction.js';
+import {
+  EventType,
+  ModificationKeyType,
+  PointerKeyType,
+} from '../../../interaction/interactionType.js';
+import VcsEvent from '../../../vcsEvent.js';
+
+function timeout(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+export default class RightClickInteraction extends AbstractInteraction {
+  rightClicked = new VcsEvent<void>();
+
+  eventChainFinished = new VcsEvent<void>();
+
+  constructor() {
+    super(EventType.CLICK, ModificationKeyType.NONE, PointerKeyType.RIGHT);
+  }
+
+  async pipe(event: InteractionEvent): Promise<InteractionEvent> {
+    this.rightClicked.raiseEvent();
+    event.chainEnded?.addEventListener(() => {
+      this.eventChainFinished.raiseEvent();
+    });
+    // we need to wait a bit, otherwise the changing features in the rightClicked Event do not take effect before
+    // the next interaction.
+    await timeout(0);
+    return event;
+  }
+
+  destroy(): void {
+    this.rightClicked.destroy();
+    this.eventChainFinished.destroy();
+    super.destroy();
+  }
+}

package/src/util/flight/flightPlayer.ts

@@ -5,7 +5,6 @@ import {
   LinearSpline,
   QuaternionSpline,
   Scene,
-  ScreenSpaceCameraController,
 } from '@vcmap-cesium/engine';
 import { getLogger } from '@vcsuite/logger';
 import { check } from '@vcsuite/check';
@@ -86,9 +85,9 @@ export async function createFlightPlayer(
 
   let postRenderListener: (() => void) | undefined;
 
-  let backedBeforeTimeout: number | undefined;
+  let resetMapControls: (() => void) | undefined;
 
-  let screenSpaceCameraController: ScreenSpaceCameraController | undefined;
+  let backedBeforeTimeout: number | undefined;
 
   const stop = (): void => {
     if (playerState !== 'stopped') {
@@ -97,8 +96,9 @@ export async function createFlightPlayer(
         postRenderListener = undefined;
       }
 
-      if (screenSpaceCameraController) {
-        screenSpaceCameraController.enableInputs = true;
+      if (resetMapControls) {
+        resetMapControls();
+        resetMapControls = undefined;
       }
 
       setState('stopped');
@@ -167,8 +167,9 @@ export async function createFlightPlayer(
     const seconds = time - clock.currentSystemTime;
     clock.currentSystemTime = time;
     if (playerState === 'paused') {
-      if (screenSpaceCameraController) {
-        screenSpaceCameraController.enableInputs = true;
+      if (resetMapControls) {
+        resetMapControls();
+        resetMapControls = undefined;
       }
       return;
     }
@@ -196,10 +197,11 @@ export async function createFlightPlayer(
       scene.camera.setView(view);
     }
 
-    if (playerState === 'playing') {
-      if (screenSpaceCameraController) {
-        screenSpaceCameraController.enableInputs = false;
-      }
+    if (playerState === 'playing' && !resetMapControls) {
+      resetMapControls = app.maps.requestExclusiveMapControls(
+        { apiCalls: true, keyEvents: true, pointerEvents: true },
+        stop,
+      );
     }
   };
 
@@ -228,11 +230,15 @@ export async function createFlightPlayer(
       postRenderListener = undefined;
     }
 
+    if (resetMapControls) {
+      resetMapControls();
+      resetMapControls = undefined;
+    }
+
     const scene = cesiumMap.getScene();
     if (!scene) {
       return;
     }
-    ({ screenSpaceCameraController } = scene);
     postRenderListener = scene.postRender.addEventListener(cesiumPostRender);
     clock.currentSystemTime = undefined;
 
@@ -266,9 +272,9 @@ export async function createFlightPlayer(
       postRenderListener = undefined;
     }
 
-    if (screenSpaceCameraController) {
-      screenSpaceCameraController.enableInputs = true;
-      screenSpaceCameraController = undefined;
+    if (resetMapControls) {
+      resetMapControls();
+      resetMapControls = undefined;
     }
 
     if (backedBeforeTimeout != null) {

package/src/util/mapCollection.ts

@@ -17,6 +17,12 @@ export type MapCollectionInitializationError = {
   map: VcsMap;
 };
 
+export type DisableMapControlOptions = {
+  apiCalls: boolean;
+  pointerEvents: boolean;
+  keyEvents: boolean;
+};
+
 async function setCesiumToOLViewpoint(
   cesiumMap: CesiumMap,
   olMap: OpenlayersMap,
@@ -119,6 +125,10 @@ class MapCollection extends Collection<VcsMap> {
   // eslint-disable-next-line class-methods-use-this
   private _postRenderListener: () => void = () => {};
 
+  /** Callback function that is passed when calling requestExclusiveMapControls and called when exclusive map controls are forcefully removed. */
+  // eslint-disable-next-line class-methods-use-this
+  private _exclusiveMapControlsRemoved: () => void = () => {};
+
   constructor() {
     super();
 
@@ -342,6 +352,7 @@ class MapCollection extends Collection<VcsMap> {
       }
     }
 
+    const previousMap = this._activeMap;
     this._activeMap = map;
     await this._activeMap.activate();
     this._setActiveMapCSSClass();
@@ -350,6 +361,14 @@ class MapCollection extends Collection<VcsMap> {
       await this._activeMap.gotoViewpoint(viewpoint);
     }
 
+    const disableMapControlOptions: DisableMapControlOptions = {
+      apiCalls: !!previousMap?.movementApiCallsDisabled,
+      keyEvents: !!previousMap?.movementKeyEventsDisabled,
+      pointerEvents: !!previousMap?.movementPointerEventsDisabled,
+    };
+    map.disableMovement(disableMapControlOptions);
+    previousMap?.disableMovement(false);
+
     this.clippingObjectManager.mapActivated(map);
     this._postRenderListener();
     this._postRenderListener = this._activeMap.postRender.addEventListener(
@@ -368,6 +387,34 @@ class MapCollection extends Collection<VcsMap> {
     return this._array.filter((m) => m.className === type);
   }
 
+  /**
+   * Manages the disabling of map navigation controls. By calling this function the map navigation controls passed in the options are disabled. The remove function passed by the previous caller is executed.
+   * @param options - which of the movement controls should be disabled.
+   * @param removed - the callback for when the interaction is forcefully removed.
+   * @returns function to reset map controls.
+   */
+  requestExclusiveMapControls(
+    options: DisableMapControlOptions,
+    removed: () => void,
+  ): () => void {
+    this._exclusiveMapControlsRemoved();
+    if (this._activeMap) {
+      this._activeMap.disableMovement(options);
+    }
+
+    this._exclusiveMapControlsRemoved = removed;
+
+    return () => {
+      // only reset if this function is called by the current exclusiveMapControls owner.
+      if (removed === this._exclusiveMapControlsRemoved) {
+        this._exclusiveMapControlsRemoved = (): void => {};
+        if (this._activeMap) {
+          this._activeMap.disableMovement(false);
+        }
+      }
+    };
+  }
+
   destroy(): void {
     super.destroy();
     [...this._layerCollection].forEach((l) => {