import { createContext, MutableRefObject, ReactElement, ReactNode, useEffect, useRef, useState, } from "react"; import { IFeatureSource } from "../sourceDefinition/LolOpenLayersSourceDef"; import { emptyLayerStatus, ILayerStatus } from "../model/layerstatus"; import { cloneDeep, flatten } from "lodash-es"; import Map from "ol/Map"; import { Geometry, LineString, Point } from "ol/geom"; import { Source } from "ol/source"; import { FeatureLike } from "ol/Feature"; import { MapSelectHandler } from "../events/LolOpenLayersMapSelectEvent"; import { Layer } from "ol/layer"; import { ClickedFeaturesByLayer, IMapImplement } from "../map/MapImplement"; import { featureId } from "../utils/FeatureUtil"; import { AnchorPosition } from "../component/MapContextMenu"; import { Feature, Overlay } from "ol"; import { Pixel } from "ol/pixel"; import { PlacementParams } from "../map/placement/PlacementParams"; import GeoImage from "ol-ext/source/GeoImage"; import log from "../utils/Log"; /** A feature and its corresponding layer */ export interface ClickedFeature { layer: Layer; feature: FeatureLike; distance: number; } export enum ClickHandlerType { NONE, PIXEL, FEATURE, } /** * Keep the state of event handlers implemented as custom hooks. * When the custom hook is used (currently this must be a singleton) the onXXX * field is set to the handler, which is marshalled through the hook. * Applications don't see this and will always use the hook interface. */ export type InternalContextRefType = { inContext: () => boolean; setMap: (map: Map) => void; setMapImplement: (v: IMapImplement) => void; setLoading: (isLoading: boolean) => void; setMapResolution: (res: number) => void; setOverlay: (overlay: Overlay) => void; setZoomed: () => void; zoomed: () => boolean; onMove?: (extent: number[][], size: number[]) => void; onClick?: ( pixelCoordinate: number[], coordinateMetres: number[], mapImplement: IMapImplement ) => void; clickHandlerType: ClickHandlerType; onSelect?: MapSelectHandler; onContextMenu?: ( clickedFeatures: ClickedFeature[], coordinate: number[], anchorPoint: AnchorPosition ) => void; onDrawStart?: () => void; onDrawEnd?: (drawFeatures: Feature) => void; // set line string for now onModifyStart?: (features: Feature[]) => void; onModifyEnd?: (features: Feature[]) => void; onRemoveInteraction?: () => void; onPlacement?: (placement: PlacementParams) => void; placementInProgress: () => boolean; setPlacementInProgress: (state: boolean) => void; enableAutoPlacement: () => boolean; setEnableAutoPlacement: (state: boolean) => void; showOnlyPlacedLabels: () => boolean; setShowOnlyPlacedLabels: (state: boolean) => void; autoLabelPlacementType: () => AutoLabelPlacementType | undefined; setAutoLabelPlacementType: (type: AutoLabelPlacementType | undefined) => void; ctrlKeyDown: () => boolean; setCtrlKeyDown(ctrlKeyState: boolean): void; enableClipFeatureLayers: () => Set; setEnableClipFeatureLayers: (layers: Set) => void; }; export enum AutoLabelPlacementType { ABSOLUTE, OFFSET, } export type InternalContextType = { ref: () => InternalContextRefType | undefined; }; export const InternalContext = createContext({ ref: () => undefined, }); export type FeaturePlacements = Record< string, { callout: boolean; hide: boolean; /** * Offset the label in pixels, positive values are down and to the right */ offsetPixels: number[] | null; rotateRads: number | null; labelCenterPoint?: Point; } >; export type Placements = Record; export type StyleContext = { highlightIds?: number[]; missingLabelIds?: string[]; placements?: FeaturePlacements; }; export type LolOpenLayersMapContextType = { /** The status (visibility, etc) of each layer */ layerStatus: (layerName: string) => ILayerStatus; setLayerStatus: (layerName: string, layerStatus: ILayerStatus) => void; /** The features dispalyed on a vector layer */ featureData: ( layerName: string ) => IFeatureSource[] | string | GeoImage | undefined; setFeatureData: ( layerName: string, features: IFeatureSource[] | string | GeoImage ) => void; /** Features that are selected, can be changed using set or interactively in the map * We can specify either an array of features or of feature ids here **/ setFeatureSelect: ( layerName: string, selectFeatures: (FeatureLike | number)[] ) => void; featureSelect: (layerName: string) => (FeatureLike | number)[]; /** Zoom to fit features on identified layers (with `inInitialZoom` true) */ zoomToFit: () => void; /** Zoom by a delta amount */ zoomByDelta: (delta: number) => void; /** The resolution (e.g. scale) of the map */ readonly mapResolution: number; /** provide access to layers as a map */ layersStatusMap: () => Record; map: Map | undefined; readonly loading: boolean; readonly errorMessages: string[]; /** put context into here that gets passed into style functions */ getStyleContext: (layerName: string) => StyleContext | undefined; changeStyleContext: ( layerNames: string | string[], f: (c: StyleContext) => StyleContext ) => void; updateStyleContext: ( layerNames: string, highlightIds?: number[], missingLabelIds?: string[], placements?: FeaturePlacements ) => void; /** get features that are at the passed pixel click point and within `hitTolerance` pixels */ getFeaturesAtPixel?: ( pixel: Pixel, hitTolerancePixels?: number ) => ClickedFeature[]; /** * Gets a map of the closest feature (features if multiple equidistant features) to clicked pixel for each layer. * Result is in a map of layerName to featureIds. * * @param pixelCoordinates Pixel to search from. * @param hitTolerancePixels Maximum pixel radius to search. * @param includeLayerNames If present, only include listed layers * * @return Map of layerName to sorted featureIds. */ getFeaturesAtPixelOrderedByClosestToClick?: ( pixelCoordinates: Pixel, hitTolerancePixels: number, includeLayerNames?: string[] ) => ClickedFeaturesByLayer; /** * When the map has `withOverlay=true` this access a reference to the overlay */ getOverlayRef: () => MutableRefObject | undefined; /** * Set the automatic label placements * * @param placements Placement adjustments for labels */ setPlacements(placements: Placements): void; /* * Get the current placement params, based on the maps scroll position and zoom */ getPlacementParams: () => PlacementParams | undefined; }; export const LolOpenLayersMapContext = createContext({ layerStatus: () => emptyLayerStatus, setLayerStatus: () => {}, featureData: () => [], setFeatureData: () => {}, setFeatureSelect: () => {}, featureSelect: () => [], zoomToFit: () => {}, zoomByDelta: () => {}, mapResolution: 0, layersStatusMap: (): Record => ({}), map: undefined, loading: false, errorMessages: [], getStyleContext: () => undefined, changeStyleContext: () => {}, updateStyleContext: () => {}, getFeaturesAtPixel: () => [], getFeaturesAtPixelOrderedByClosestToClick: () => ({}), getOverlayRef: () => undefined, setPlacements: () => {}, getPlacementParams: () => undefined, }); interface ProviderProps { children: ReactNode; } export interface LayerState { layerHasChanged: boolean; featureSelect: (FeatureLike | number)[]; featuresChanged: boolean; features: IFeatureSource[] | string | GeoImage | undefined; status: ILayerStatus; } export interface MapState { layers: Record; } export const LolOpenLayersMapContextProvider = ( props: ProviderProps ): ReactElement | null => { const [mapState, setMapState] = useState({ layers: {}, } as MapState); const [loading, setLoading] = useState(true); const [mapResolution, setMapResolution] = useState(0); const [errorMessages] = useState([]); const [map, setMap] = useState(); const [mapImplement, setMapImplement] = useState(); const overlayRef = useRef(undefined); const zoomedRef = useRef(false); const enableAutoPlacementRef = useRef(false); const showOnlyPlacedLabelsRef = useRef(false); const autoLabelPlacementTypeRef = useRef( undefined ); const placementInProgressRef = useRef(false); const ctrlKeyDownRef = useRef(false); const enableClipFeatureLayersRef = useRef>(new Set()); // We need to implement internalEventContext as a ref, so it can be hit by // event handlers without a React context const internalContext = useRef({ ctrlKeyDown: () => ctrlKeyDownRef.current, setCtrlKeyDown: (state) => { ctrlKeyDownRef.current = state; }, inContext: () => true, setMap, setMapImplement, setMapResolution, setOverlay: (overlay) => { overlayRef.current = overlay; }, setLoading, setZoomed: () => (zoomedRef.current = true), zoomed: () => zoomedRef.current, clickHandlerType: ClickHandlerType.NONE, placementInProgress: () => placementInProgressRef.current, setPlacementInProgress: (state: boolean) => { log.debug(`setPlacementIsInProgress ${state}`); placementInProgressRef.current = state; }, enableAutoPlacement: () => enableAutoPlacementRef.current, setEnableAutoPlacement: (state: boolean) => { log.debug(`setEnableAutoPlacement ${state}`); enableAutoPlacementRef.current = state; }, showOnlyPlacedLabels: () => showOnlyPlacedLabelsRef.current, setShowOnlyPlacedLabels: (state: boolean) => { showOnlyPlacedLabelsRef.current = state; }, autoLabelPlacementType: () => autoLabelPlacementTypeRef.current, setAutoLabelPlacementType: (type: AutoLabelPlacementType | undefined) => { autoLabelPlacementTypeRef.current = type; }, enableClipFeatureLayers: () => enableClipFeatureLayersRef.current, setEnableClipFeatureLayers: (layers: Set) => { enableClipFeatureLayersRef.current = layers; }, }); const styleContextContainer = useRef>({}); const layerStatus = (layerName: string) => mapState.layers[layerName]?.status; const layersStatusMap = (): Record => { return Object.fromEntries( Object.entries(mapState.layers).map((layerEntry) => [ layerEntry[0], layerEntry[1].status, ]) ); }; const setLayerStatus = (layerName: string, status: ILayerStatus) => { if (mapState.layers[layerName]?.status === status) return; setMapState((mapState) => { const newMapState = cloneDeep(mapState); if (!newMapState.layers[layerName]) newMapState.layers[layerName] = { status: emptyLayerStatus, featuresChanged: true, layerHasChanged: false, features: undefined, featureSelect: [], }; newMapState.layers[layerName].status = cloneDeep(status); return newMapState; }); }; useEffect(() => { mapImplement?.updateLayerVisibility( undefined, internalContext.current, mapState.layers ); }, [mapImplement, mapState]); const getFeatureData = (layerName: string) => { return mapState.layers[layerName]?.features; }; const featureSelect = (layerName: string): (number | FeatureLike)[] => { return mapState.layers[layerName]?.featureSelect ?? []; }; const layerHasChanged = (layerName: string) => { return mapState.layers[layerName]?.layerHasChanged; }; const setFeatureData = ( layerName: string, features: IFeatureSource[] | string | GeoImage ) => { if (mapState.layers[layerName]?.features === features) return; log.debug(`setFeatureData ${layerName} to ${JSON.stringify(features)}`); setMapState((mapState) => { const newMapState = { ...mapState }; if (newMapState.layers[layerName]) { newMapState.layers[layerName].features = features; newMapState.layers[layerName].featuresChanged = true; } else { newMapState.layers[layerName] = { status: emptyLayerStatus, featuresChanged: true, layerHasChanged: false, features: features, featureSelect: [], }; } return newMapState; }); }; const setFeatureSelect = ( layerName: string, selectFeatures: (FeatureLike | number)[] ) => { setMapState((mapState) => { const newMapState = { ...mapState }; if (newMapState.layers[layerName]) { newMapState.layers[layerName].featureSelect = [...selectFeatures]; newMapState.layers[layerName].layerHasChanged = true; } else { newMapState.layers[layerName] = { status: emptyLayerStatus, featuresChanged: false, layerHasChanged: true, features: undefined, featureSelect: [...selectFeatures], }; } return newMapState; }); // We also want the highlight in style context updateStyleContext( layerName, selectFeatures.map((f) => featureId(f)) ); }; const changeLayerHasChanged = (layerName: string, changedState: boolean) => { setMapState((mapState) => { const newMapState = { ...mapState }; if (newMapState.layers[layerName]) { newMapState.layers[layerName].layerHasChanged = changedState; } return newMapState; }); }; const clearLayerHasChanged = (layerName: string) => { if (!mapState.layers[layerName]?.layerHasChanged) return; changeLayerHasChanged(layerName, false); }; const getStyleContext = (layerName: string) => { const styleContext = styleContextContainer.current; if (!styleContext[layerName]) styleContext[layerName] = {}; return styleContext[layerName]; }; const changeStyleContext = ( layerNames: string | string[], f: (c: StyleContext) => StyleContext ) => { flatten([layerNames]).forEach((layerName) => { const styleContext = getStyleContext(layerName); const newValues = f(styleContext); // We need to clear any optional values out as assign won't overwrite them for (const key in styleContext) { delete (styleContext as Record)[key]; } Object.assign(styleContext, newValues); changeLayerHasChanged(layerName, true); }); }; /** * Updates style context replacing defined fields and marks layer as changed */ const updateStyleContext = ( layerName: string, highlightIds: number[] | undefined = undefined, missingLabelIds: string[] | undefined = undefined, placements: FeaturePlacements | undefined = undefined ) => { const styleContext = styleContextContainer.current; const style = styleContext[layerName] ?? {}; style.highlightIds = highlightIds || style.highlightIds; style.missingLabelIds = missingLabelIds || style.missingLabelIds; style.placements = placements || style.placements; styleContextContainer.current = { ...styleContext, [layerName]: style }; changeLayerHasChanged(layerName, true); }; const zoomToFit = () => mapImplement!.zoomToFit(this, internalContext.current, mapState.layers); const zoomByDelta = (delta: number) => mapImplement!.zoomMapByDelta(delta); const setPlacements = (placements: Placements) => { Object.entries(placements).forEach(([layerName, layerPlacement]) => { updateStyleContext( layerName, undefined, Object.keys(layerPlacement).filter((key) => layerPlacement[key].hide), layerPlacement ); }); internalContext.current.setPlacementInProgress(false); }; useEffect(() => { mapImplement?.layerNames?.()?.forEach((layerName: string) => { const featureData = getFeatureData(layerName); if (featureData) { const layerDef = mapImplement?.layerDefs()[layerName]; mapImplement?.loadChangedFeaturesFrom(layerName, layerDef, featureData); } if (layerHasChanged(layerName)) { mapImplement?.layerChanged(layerName); clearLayerHasChanged(layerName); } }); }, [mapState]); return ( mapImplement?.getFeaturesAtPixel(pixel, hitTolerancePixels) ?? [], getFeaturesAtPixelOrderedByClosestToClick: mapImplement?.getFeaturesAtPixelOrderedByClosestToClick, getOverlayRef: () => overlayRef.current ? (overlayRef as MutableRefObject) : undefined, setPlacements, getPlacementParams: mapImplement?.getPlacementParams ?? (() => undefined), }} > internalContext.current }}> {props.children} ); };