import { LolOpenLayersMap } from "../../map/LolOpenLayersMap"; import { StoryFn, Meta } from "@storybook/react"; import { AppComponent } from "../StoryUtil"; import { ClickedFeature, InternalContext, LolOpenLayersMapContext, LolOpenLayersMapContextProvider, } from "../../context/LolOpenLayersMapContext"; import { basemap, basinReserveView, drawInteractionTestLayer, labelledMarksLayer, oamaruView, vectorFeatureSource, vectorHighlightStyleTestLine, } from "./Common"; import React, { useContext, useEffect, useState } from "react"; import { FeatureModeEnum, useLolOpenLayersFeatureClickEvent, } from "../../events/LolOpenLayersFeatureClickEvent"; import { Fill, Style } from "ol/style"; import CircleStyle from "ol/style/Circle"; import Stroke from "ol/style/Stroke"; import { LolOpenLayersVectorTileLayerDef } from "../../layerDefinition/LolOpenLayersVectorTileLayerDef"; import { MapLayerSelection, useLolOpenLayersMapSelectEvent, } from "../../events/LolOpenLayersMapSelectEvent"; import { useLolOpenLayersMapMoveEvent } from "../../events/LolOpenLayersMapMoveEvent"; import { AnchorPosition, MapContextMenu } from "../../component/MapContextMenu"; import proj4 from "proj4"; import { Feature } from "ol"; import { FeatureLike } from "ol/Feature"; import { GeoJSON } from "ol/format"; import { LuiButton } from "@linzjs/lui"; import { MenuDivider, MenuHeader, MenuItem } from "@szhsin/react-menu"; import { useLolOpenLayersMapRightClickEvent } from "../../events/LolOpenLayersMapRightClickEvent"; import { useLolOpenLayersMapDrawInteraction } from "../../interactions/LolOpenLayersMapDrawInteraction"; import { flatten } from "lodash-es"; import { InteractionType } from "../../interactionDefinition/LolOpenLayersInteractionDef"; import { useLolOpenLayersMapSnapInteraction } from "../../interactions/LolOpenLayersMapSnapInteraction"; import { useLolOpenLayersPixelClickEvent } from "../../events/LolOpenLayersPixelClickEvent"; import { useLolOpenLayersMapModifyInteraction } from "../../interactions/LolOpenLayersMapModifyInteraction"; import { Geometry } from "ol/geom"; import Text from "ol/style/Text"; const PixelClickableMapInner = () => { const [pixelCoordinate, setPixelCoordinate] = useState([]); const [coordinateMetres, setCoordinateMetres] = useState([]); const [featuresAtPixel, setFeaturesAtPixel] = useState(); const [layerFeaturesAtPixel, setLayerFeaturesAtPixel] = useState( [] ); const mapContext = useContext(LolOpenLayersMapContext); useLolOpenLayersPixelClickEvent((pc: number[], cm: number[]) => { setPixelCoordinate(pc); setCoordinateMetres(cm); setFeaturesAtPixel( mapContext.getFeaturesAtPixel!(pc, 5) .map((f) => f.feature.get("name")) .join(",") ); setLayerFeaturesAtPixel( Object.entries( mapContext.getFeaturesAtPixelOrderedByClosestToClick!(pc, 15) ).map( ([layerName, clickedFeature]) => `${layerName}: ${clickedFeature.ids .map((i) => i.toString()) .join(", ")}` ) ); }); return ( <>

Map with clickable pixel event

Last clicked: {JSON.stringify(pixelCoordinate)} =={" "} {JSON.stringify(coordinateMetres)}

Features at pixel: {featuresAtPixel}

Layer features at pixel: {layerFeaturesAtPixel}

); }; const ClickablePixelEventStory: StoryFn = () => { return (
); }; // eslint-disable-next-line no-unused-vars export const ClickablePixelEvent = ClickablePixelEventStory.bind({}); export interface ContextMenuMark { type: "mark"; id: number; name: string; markType: string; } export type ContextMenuFeature = ContextMenuMark; export default { title: "Openlayers Map Wrapper/LolOpenLayersMap/Interaction", component: LolOpenLayersMap, docs: { inlineStories: false }, } as Meta; const ClickableMapInner = ({ multiple }: { multiple: boolean }) => { const [lastClickedLabel, setLastClickedLabel] = useState(); const [isContextMenuOpen, setContextMenuOpen] = useState(false); const [contextMenuAnchorPoint, setContextMenuAnchorPoint] = useState({ x: 0, y: 0, }); const [contextMenuCoordinate, setContextMenuCoordinate] = useState( [] ); const [selectedFeatures, setSelectedFeatures] = useState([]); // This sets a React-safe callback for when the user clicks on any feature useLolOpenLayersFeatureClickEvent( (clickedFeature: ClickedFeature | ClickedFeature[], coordinate) => { setLastClickedLabel( `${flatten([clickedFeature]) .map((f) => f.feature.get("name")) .join(", ")} @ ${JSON.stringify(coordinate)}` ); return true; }, multiple ? { type: FeatureModeEnum.MULTIPLE, hitTolerancePixels: 50 } : { type: FeatureModeEnum.SINGLE } ); useLolOpenLayersMapRightClickEvent( ( clickedFeatures: ClickedFeature[], coordinate: number[], anchorPoint?: AnchorPosition ) => { setContextMenuOpen(true); const markContextMenuFeatures = clickedFeatures.map( (f) => ({ type: "mark", id: f.feature.get("mark_id"), name: f.feature.get("name"), markType: f.feature.get("mark_type"), }) as ContextMenuMark ); setContextMenuAnchorPoint(anchorPoint!!); setContextMenuCoordinate(coordinate); setSelectedFeatures(markContextMenuFeatures); return true; } ); return ( <>

Last clicked: {lastClickedLabel}

{selectedFeatures.map((item, i) => ( {item.type} {item.id} {item.name} ))} ); }; const ClickableFeatureEventStory: StoryFn = () => { return (

Map with clickable feature event

); }; // eslint-disable-next-line no-unused-vars export const ClickableFeatureEvent = ClickableFeatureEventStory.bind({}); const ClickableFeatureEventMultipleStory: StoryFn< typeof LolOpenLayersMap > = () => { return (

Map with clickable feature event (multiple feature mode)

); }; // eslint-disable-next-line no-unused-vars export const ClickableFeatureEventMultiple = ClickableFeatureEventMultipleStory.bind({}); const selectableMarksLayer = { ...labelledMarksLayer, togglable: true, highlightStyle: (_, f) => new Style({ image: new CircleStyle({ radius: 4, fill: new Fill({ color: "#00FF00" }), stroke: new Stroke({ color: "#ff0000", width: 4, }), }), // Because this layer has no labelStyle and hence puts labels in the main layer // we need a label style when highlights are on text: new Text({ text: f.get("name"), }), }), } as LolOpenLayersVectorTileLayerDef; const SelectableMapInner = () => { const [allSelectedFeatures, setAllSelectedFeatures] = useState< MapLayerSelection[] >([]); const mapContext = useContext(LolOpenLayersMapContext); useLolOpenLayersMapSelectEvent((selected) => { setAllSelectedFeatures(selected); }); return ( <>

Selected features (read): {mapContext .featureSelect("underlying_marks") ?.map((f) => (f as FeatureLike).get("name")) ?.join(", ")}

Selected ids (updated): {allSelectedFeatures ?.map((f) => f.ids.map((n) => n.toString())) .join(",")}

Selected names (updated): {allSelectedFeatures ?.map((f) => f.features.map((f) => f.name)) .join(",")}

); }; const SelectableFeatureStory: StoryFn = () => { return (

Map with selectable features

); }; // eslint-disable-next-line no-unused-vars export const SelectableFeature = SelectableFeatureStory.bind({}); const MovableMapInner = () => { const [centreLat, setCentreLat] = useState(); const [centreLong, setCentreLong] = useState(); const [scale, setScale] = useState(); useLolOpenLayersMapMoveEvent((extent, size) => { const latLongSW = proj4("EPSG:3857", "EPSG:4326", extent[0]); const latLongNE = proj4("EPSG:3857", "EPSG:4326", extent[1]); setCentreLat(((latLongSW[0] + latLongNE[0]) / 2).toFixed(5)); setCentreLong((-(latLongSW[1] + latLongNE[1]) / 2).toFixed(5)); setScale(((extent[1][1] - extent[0][1]) / size[1]).toFixed(2)); }); return ( <>

Events on map move

Centre: E{centreLat} S{centreLong}

Scale: {scale}

); }; const MapMoveStory: StoryFn = () => { return (
); }; // eslint-disable-next-line no-unused-vars export const MapMove = MapMoveStory.bind({}); // Map draw const DrawMapInner = () => { const [drawLineLabel, setDrawLineLabel] = useState(); const [modifyLineLabel, setModifyLineLabel] = useState(); const internalContext = useContext(InternalContext); useLolOpenLayersMapDrawInteraction((drawFeature) => { let irregularLineShape = createLineFeature(drawFeature); setDrawLineLabel(`${irregularLineShape}`); return true; }); useLolOpenLayersMapSnapInteraction(() => { return true; }); /** Modify line interaction */ useLolOpenLayersMapModifyInteraction((modifyFeature) => { let modifiedLineShape = createLineFeature(modifyFeature[0]); setModifyLineLabel(modifiedLineShape); return true; }); if (internalContext.ref()?.onDrawEnd) { /** After drawing, remove interactions */ internalContext.ref()!!.onRemoveInteraction = () => { return true; }; } const createLineFeature = ( irregularBoundaryFeatures: Feature ): string => { return new GeoJSON().writeFeature(irregularBoundaryFeatures, { dataProjection: "EPSG:1", featureProjection: "EPSG:3857", }); }; return ( <>

Draw line shape: {drawLineLabel}

Modify line shape: {modifyLineLabel}

Events on map draw

{ return true; }, finishCondition: () => { return true; }, }} modifyInteraction={{ type: InteractionType.MODIFY, layerName: "draw_test", source: undefined, style: [], condition: () => { return true; }, }} snapInteraction={{ type: InteractionType.SNAP, layerName: "test_line", pixelTolerance: 15, }} useLoadingIndicator={true} /> ); }; const MapDrawStory: StoryFn = () => { return (
); }; export const MapDraw = MapDrawStory.bind({}); const BothwaySelectableMapInner = () => { const [selectedMarks, setSelectedMarks] = useState(); const mapContext = useContext(LolOpenLayersMapContext); useLolOpenLayersMapSelectEvent((selected) => { const newSelectedMarks = selected.find( (ms) => ms.layerName === "underlying_marks" ); if (newSelectedMarks) setSelectedMarks(newSelectedMarks); }); useEffect(() => { if (selectedMarks) mapContext.setFeatureSelect( "underlying_marks", selectedMarks.features.map((v) => new Feature(v)) ); }, [selectedMarks]); return ( <>

Select marks:

{selectedMarks?.ids.map((buttonId, index) => ( { const newSelectedMarks = { ...selectedMarks }; newSelectedMarks.ids = newSelectedMarks.ids.filter( (id) => buttonId !== id ); newSelectedMarks.features = newSelectedMarks.features.filter( (f) => buttonId !== f.id ); setSelectedMarks(newSelectedMarks); }} > {buttonId} ))}

); }; const BothWaySelectableFeatureStory: StoryFn = () => { return (

Map with features selectable from map or text

); }; // eslint-disable-next-line no-unused-vars export const BothWaySelectableFeature = BothWaySelectableFeatureStory.bind({}); const BothwayVectorMapInner = () => { const [selectedVectorIds, setSelectedVectorIds] = useState([]); const mapContext = useContext(LolOpenLayersMapContext); useLolOpenLayersMapSelectEvent((selected) => { const newSelectedVectors = selected.find( (ms) => ms.layerName === "test_line" ); if (newSelectedVectors) setSelectedVectorIds(newSelectedVectors.ids); }); useEffect(() => { mapContext.setFeatureSelect("test_line", selectedVectorIds); }, [selectedVectorIds]); return ( <>

Select vectors:

{vectorFeatureSource.map((vectorFeature, index) => { const vectorId = vectorFeature.id; const isSelected = selectedVectorIds.includes(vectorId); return ( { const newSelectedVectorIds = isSelected ? selectedVectorIds.filter((id) => vectorId !== id) : [...selectedVectorIds, vectorId]; setSelectedVectorIds(newSelectedVectorIds); }} > {vectorId} ); })}

); }; const BothWayVectorStory: StoryFn = () => { return (

Map with vector highlight features selectable from map or text

(Using ids only)

); }; export const BothWayVector = BothWayVectorStory.bind({});