import { useContext, useEffect, useRef, useState } from "react"; import { ClickedFeature, ClickHandlerType, InternalContext, InternalContextType, } from "../context/LolOpenLayersMapContext"; import { compact, max, uniqBy } from "lodash-es"; import { Layer } from "ol/layer"; import { Source } from "ol/source"; import { IMapImplement } from "../map/MapImplement"; import log from "../utils/Log"; import { baseLayerName } from "../utils/LayerUtil"; import { LolOpenLayersVectorLayerDef } from "../layerDefinition/LolOpenLayersVectorLayerDef"; export type FeatureClickedHandler = ( clickedfeature: ClickedFeature | ClickedFeature[], coordinate: number[], internalContext: InternalContextType ) => boolean; export enum FeatureModeEnum { SINGLE, MULTIPLE, } type FeatureModeDef = { type: FeatureModeEnum; hitTolerancePixels?: number; }; export type FeatureMode = FeatureModeDef | (() => FeatureModeDef); interface FeatureClickedHandlerInstance { featureClicked: FeatureClickedHandler; featureMode: FeatureMode; } export const useLolOpenLayersFeatureClickEvent = ( featureClicked: FeatureClickedHandler, featureMode: FeatureMode = { type: FeatureModeEnum.SINGLE } ) => { const [setupHandler, setSetupHandler] = useState(true); const featureClickedHandlersRef = useRef< FeatureClickedHandlerInstance[] | undefined >(undefined); const internalContext = useContext(InternalContext); useEffect(() => { // When the handler or its bindings change, ensure we use the latest one // but only one of each function (by toString, e.g. lexical compare) // (the order in uniqBy and the stringing of the handler ensures this) featureClickedHandlersRef.current = uniqBy( [ { featureClicked, featureMode }, ...(featureClickedHandlersRef.current || []), ], (handler) => handler.featureClicked.toString() ); }, [featureClicked]); useEffect(() => { if (!setupHandler || undefined === internalContext.ref()) return; if (internalContext.ref()!!.clickHandlerType === ClickHandlerType.PIXEL) throw new Error( "Cannot do useLolOpenLayersPixelClickEvent and useLolOpenLayersFeatureClickEvent" ); internalContext.ref()!!.onClick = ( pixelCoordinate: number[], coordinateMetres: number[], mapImplement: IMapImplement ) => { log.debug(`onClick ${pixelCoordinate} ${coordinateMetres}`); const emptyFeatureModes = {} as Record; const wantedFeatureModes = featureClickedHandlersRef.current ?.map((handlerInstance) => handlerInstance.featureMode) ?.reduce((acc, handlerMode) => { const actualHandlerMode = ( handlerMode instanceof Function ? handlerMode() : handlerMode ) as FeatureModeDef; if (acc[actualHandlerMode.type]) { acc[actualHandlerMode.type].hitTolerancePixels = max([ acc[actualHandlerMode.type].hitTolerancePixels, actualHandlerMode.hitTolerancePixels, ]); return acc; } acc[actualHandlerMode.type] = { type: actualHandlerMode.type, hitTolerancePixels: actualHandlerMode.hitTolerancePixels, }; return acc; }, emptyFeatureModes) ?? emptyFeatureModes; if (wantedFeatureModes[FeatureModeEnum.SINGLE]) { // This tries the handlers in stack order (last added first) until one returns true // The fallback will have been added by the map component to handle selection clicks const clickedFeatures = mapImplement.getFeaturesAtPixel?.(pixelCoordinate); clickedFeatures?.some((clickedFeature) => { if (isUnwantedLabelFeatureClick(clickedFeature, mapImplement)) return true; return featureClickedHandlersRef.current?.some((handler) => handler.featureClicked( clickedFeature, coordinateMetres, internalContext ) ); }); } if (wantedFeatureModes[FeatureModeEnum.MULTIPLE]) { const clickedFeaturesByLayer = mapImplement.getFeaturesAtPixelOrderedByClosestToClick( pixelCoordinate, wantedFeatureModes[FeatureModeEnum.MULTIPLE].hitTolerancePixels! ) ?? []; const clickedFeatures = compact( Object.entries(clickedFeaturesByLayer).flatMap( ([layerName, featuresClicked]) => { if (isUnwantedLabelLayerClick(layerName, mapImplement)) return null; const olLayer = mapImplement.findMapLayerByName(layerName); if (!olLayer) return null; return featuresClicked.features.map((feature) => ({ layer: olLayer as Layer, feature, distance: 0, })); } ) ); if (clickedFeatures) { featureClickedHandlersRef.current ?.filter((handler) => { const actualHandlerMode = ( handler.featureMode instanceof Function ? handler.featureMode() : handler.featureMode ) as FeatureModeDef; return actualHandlerMode.type === FeatureModeEnum.MULTIPLE; }) ?.forEach((handler) => handler.featureClicked( clickedFeatures, coordinateMetres, internalContext ) ); } } }; setSetupHandler(false); }, [setupHandler]); // Ignore clicks on label layer when `selectableLabel` is false or default const isUnwantedLabelFeatureClick = ( clickedFeature: ClickedFeature, mapImplement: IMapImplement ) => { const layerDef = mapImplement.layerDefs()[ baseLayerName(clickedFeature.layer) ] as LolOpenLayersVectorLayerDef; const layerName = clickedFeature.layer.getClassName(); return isUnwantedLabelClick(layerDef, layerName); }; const isUnwantedLabelLayerClick = ( layerName: string, mapImplement: IMapImplement ) => { const layerDef = mapImplement.layerDefs()[ baseLayerName(layerName) ] as LolOpenLayersVectorLayerDef; return isUnwantedLabelClick(layerDef, layerName); }; const isUnwantedLabelClick = ( layerDef: LolOpenLayersVectorLayerDef, layerName: string ) => { if (!layerDef.selectableLabel && layerName.endsWith("_labels")) { log.info("Ignore click"); return true; } log.info("Click - find handler"); return false; }; };