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}
))}
>
);
};
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({});