neutonsevero/SIGE-WEB-snapshot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3d498747c0ded0fade85479b5e188a7136989cc8
SIGE-WEB-snapshot/ambiente-de-test/wp-content/plugins/draw-attention/admin/assets/js/leaflet.draw.js

2946 lines
102 KiB
JavaScript
Raw Blame History

/*
Leaflet.draw 0.4.14, a plugin that adds drawing and editing tools to Leaflet powered maps.
(c) 2012-2017, Jacob Toye, Jon West, Smartrak, Leaflet
https://github.com/Leaflet/Leaflet.draw
http://leafletjs.com
*/
!(function (t, e, i) {
function o(t, e) {
for (; (t = t.parentElement) && !t.classList.contains(e); );
return t;
}
(L.drawVersion = "0.4.14"),
(L.Draw = {}),
(L.drawLocal = {
draw: {
toolbar: {
actions: { title: "Cancel drawing", text: "Cancel" },
finish: { title: "Finish drawing", text: "Finish" },
undo: { title: "Delete last point drawn", text: "Delete last point" },
buttons: {
polyline: "Draw a polyline",
polygon: "Draw a polygon",
rectangle: "Draw a rectangle",
circle: "Draw a circle",
marker: "Draw a marker",
circlemarker: "Draw a circlemarker",
},
},
handlers: {
circle: {
tooltip: { start: "Click and drag to draw circle." },
radius: "Radius",
},
circlemarker: {
tooltip: { start: "Click map to place circle marker." },
},
marker: { tooltip: { start: "Click map to place marker." } },
polygon: {
tooltip: {
start: "Click to start drawing shape.",
cont: "Click to continue drawing shape.",
end: "Click first point to close this shape.",
},
},
polyline: {
error: "<strong>Error:</strong> shape edges cannot cross!",
tooltip: {
start: "Click to start drawing line.",
cont: "Click to continue drawing line.",
end: "Click last point to finish line.",
},
},
rectangle: {
tooltip: { start: "Click and drag to draw rectangle." },
},
simpleshape: { tooltip: { end: "Release mouse to finish drawing." } },
},
},
edit: {
toolbar: {
actions: {
save: { title: "Save changes", text: "Save" },
cancel: {
title: "Cancel editing, discards all changes",
text: "Cancel",
},
clearAll: { title: "Clear all layers", text: "Clear All" },
},
buttons: {
edit: "Edit layers",
editDisabled: "No layers to edit",
remove: "Delete layers",
removeDisabled: "No layers to delete",
},
},
handlers: {
edit: {
tooltip: {
text: "Drag handles or markers to edit features.",
subtext: "Click cancel to undo changes.",
},
},
remove: { tooltip: { text: "Click on a feature to remove." } },
},
},
}),
(L.Draw.Event = {}),
(L.Draw.Event.CREATED = "draw:created"),
(L.Draw.Event.EDITED = "draw:edited"),
(L.Draw.Event.DELETED = "draw:deleted"),
(L.Draw.Event.DRAWSTART = "draw:drawstart"),
(L.Draw.Event.DRAWSTOP = "draw:drawstop"),
(L.Draw.Event.DRAWVERTEX = "draw:drawvertex"),
(L.Draw.Event.EDITSTART = "draw:editstart"),
(L.Draw.Event.EDITMOVE = "draw:editmove"),
(L.Draw.Event.EDITRESIZE = "draw:editresize"),
(L.Draw.Event.EDITVERTEX = "draw:editvertex"),
(L.Draw.Event.EDITSTOP = "draw:editstop"),
(L.Draw.Event.DELETESTART = "draw:deletestart"),
(L.Draw.Event.DELETESTOP = "draw:deletestop"),
(L.Draw.Event.TOOLBAROPENED = "draw:toolbaropened"),
(L.Draw.Event.TOOLBARCLOSED = "draw:toolbarclosed"),
(L.Draw.Event.MARKERCONTEXT = "draw:markercontext"),
(L.Draw = L.Draw || {}),
(L.Draw.Feature = L.Handler.extend({
initialize: function (t, e) {
(this._map = t),
(this._container = t._container),
(this._overlayPane = t._panes.overlayPane),
(this._popupPane = t._panes.popupPane),
e &&
e.shapeOptions &&
(e.shapeOptions = L.Util.extend(
{},
this.options.shapeOptions,
e.shapeOptions,
)),
L.setOptions(this, e);
var i = L.version.split(".");
1 === parseInt(i[0], 10) && parseInt(i[1], 10) >= 2
? L.Draw.Feature.include(L.Evented.prototype)
: L.Draw.Feature.include(L.Mixin.Events);
},
enable: function () {
this._enabled ||
(L.Handler.prototype.enable.call(this),
this.fire("enabled", { handler: this.type }),
this._map.fire(L.Draw.Event.DRAWSTART, { layerType: this.type }));
},
disable: function () {
this._enabled &&
(L.Handler.prototype.disable.call(this),
this._map.fire(L.Draw.Event.DRAWSTOP, { layerType: this.type }),
this.fire("disabled", { handler: this.type }));
},
addHooks: function () {
var t = this._map;
t &&
(L.DomUtil.disableTextSelection(),
t.getContainer().focus(),
(this._tooltip = new L.Draw.Tooltip(this._map)),
L.DomEvent.on(this._container, "keyup", this._cancelDrawing, this));
},
removeHooks: function () {
this._map &&
(L.DomUtil.enableTextSelection(),
this._tooltip.dispose(),
(this._tooltip = null),
L.DomEvent.off(this._container, "keyup", this._cancelDrawing, this));
},
setOptions: function (t) {
L.setOptions(this, t);
},
_fireCreatedEvent: function (t) {
this._map.fire(L.Draw.Event.CREATED, {
layer: t,
layerType: this.type,
});
},
_cancelDrawing: function (t) {
27 === t.keyCode &&
(this._map.fire("draw:canceled", { layerType: this.type }),
this.disable());
},
})),
(L.Draw.Polyline = L.Draw.Feature.extend({
statics: { TYPE: "polyline" },
Poly: L.Polyline,
options: {
allowIntersection: !0,
repeatMode: !1,
drawError: { color: "#b00b00", timeout: 2500 },
icon: new L.DivIcon({
iconSize: new L.Point(8, 8),
className: "leaflet-div-icon leaflet-editing-icon",
}),
touchIcon: new L.DivIcon({
iconSize: new L.Point(20, 20),
className: "leaflet-div-icon leaflet-editing-icon leaflet-touch-icon",
}),
guidelineDistance: 20,
maxGuideLineLength: 4e3,
shapeOptions: {
stroke: !0,
color: "#3388ff",
weight: 4,
opacity: 0.5,
fill: !1,
clickable: !0,
},
metric: !0,
feet: !0,
nautic: !1,
showLength: !0,
zIndexOffset: 2e3,
factor: 1,
maxPoints: 0,
},
initialize: function (t, e) {
L.Browser.touch && (this.options.icon = this.options.touchIcon),
(this.options.drawError.message =
L.drawLocal.draw.handlers.polyline.error),
e &&
e.drawError &&
(e.drawError = L.Util.extend(
{},
this.options.drawError,
e.drawError,
)),
(this.type = L.Draw.Polyline.TYPE),
L.Draw.Feature.prototype.initialize.call(this, t, e);
},
addHooks: function () {
L.Draw.Feature.prototype.addHooks.call(this),
this._map &&
((this._markers = []),
(this._markerGroup = new L.LayerGroup()),
this._map.addLayer(this._markerGroup),
(this._poly = new L.Polyline([], this.options.shapeOptions)),
this._tooltip.updateContent(this._getTooltipText()),
this._mouseMarker ||
(this._mouseMarker = L.marker(this._map.getCenter(), {
icon: L.divIcon({
className: "leaflet-mouse-marker",
iconAnchor: [20, 20],
iconSize: [40, 40],
}),
opacity: 0,
zIndexOffset: this.options.zIndexOffset,
})),
this._mouseMarker
.on("mouseout", this._onMouseOut, this)
.on("mousemove", this._onMouseMove, this)
.on("mousedown", this._onMouseDown, this)
.on("mouseup", this._onMouseUp, this)
.addTo(this._map),
this._map
.on("mouseup", this._onMouseUp, this)
.on("mousemove", this._onMouseMove, this)
.on("zoomlevelschange", this._onZoomEnd, this)
.on("touchstart", this._onTouch, this)
.on("zoomend", this._onZoomEnd, this));
},
removeHooks: function () {
L.Draw.Feature.prototype.removeHooks.call(this),
this._clearHideErrorTimeout(),
this._cleanUpShape(),
this._map.removeLayer(this._markerGroup),
delete this._markerGroup,
delete this._markers,
this._map.removeLayer(this._poly),
delete this._poly,
this._mouseMarker
.off("mousedown", this._onMouseDown, this)
.off("mouseout", this._onMouseOut, this)
.off("mouseup", this._onMouseUp, this)
.off("mousemove", this._onMouseMove, this),
this._map.removeLayer(this._mouseMarker),
delete this._mouseMarker,
this._clearGuides(),
this._map
.off("mouseup", this._onMouseUp, this)
.off("mousemove", this._onMouseMove, this)
.off("zoomlevelschange", this._onZoomEnd, this)
.off("zoomend", this._onZoomEnd, this)
.off("touchstart", this._onTouch, this)
.off("click", this._onTouch, this);
},
deleteLastVertex: function () {
if (!(this._markers.length <= 1)) {
var t = this._markers.pop(),
e = this._poly,
i = e.getLatLngs(),
o = i.splice(-1, 1)[0];
this._poly.setLatLngs(i),
this._markerGroup.removeLayer(t),
e.getLatLngs().length < 2 && this._map.removeLayer(e),
this._vertexChanged(o, !1);
}
},
addVertex: function (t) {
if (
this._markers.length >= 2 &&
!this.options.allowIntersection &&
this._poly.newLatLngIntersects(t)
)
return void this._showErrorTooltip();
this._errorShown && this._hideErrorTooltip(),
this._markers.push(this._createMarker(t)),
this._poly.addLatLng(t),
2 === this._poly.getLatLngs().length &&
this._map.addLayer(this._poly),
this._vertexChanged(t, !0);
},
completeShape: function () {
this._markers.length <= 1 ||
(this._fireCreatedEvent(),
this.disable(),
this.options.repeatMode && this.enable());
},
_finishShape: function () {
var t = this._poly._defaultShape
? this._poly._defaultShape()
: this._poly.getLatLngs(),
e = this._poly.newLatLngIntersects(t[t.length - 1]);
if ((!this.options.allowIntersection && e) || !this._shapeIsValid())
return void this._showErrorTooltip();
this._fireCreatedEvent(),
this.disable(),
this.options.repeatMode && this.enable();
},
_shapeIsValid: function () {
return !0;
},
_onZoomEnd: function () {
null !== this._markers && this._updateGuide();
},
_onMouseMove: function (t) {
var e = this._map.mouseEventToLayerPoint(t.originalEvent),
i = this._map.layerPointToLatLng(e);
(this._currentLatLng = i),
this._updateTooltip(i),
this._updateGuide(e),
this._mouseMarker.setLatLng(i),
L.DomEvent.preventDefault(t.originalEvent);
},
_vertexChanged: function (t, e) {
this._map.fire(L.Draw.Event.DRAWVERTEX, { layers: this._markerGroup }),
this._updateFinishHandler(),
this._updateRunningMeasure(t, e),
this._clearGuides(),
this._updateTooltip();
},
_onMouseDown: function (t) {
if (
!this._clickHandled &&
!this._touchHandled &&
!this._disableMarkers
) {
this._onMouseMove(t),
(this._clickHandled = !0),
this._disableNewMarkers();
var e = t.originalEvent,
i = e.clientX,
o = e.clientY;
this._startPoint.call(this, i, o);
}
},
_startPoint: function (t, e) {
this._mouseDownOrigin = L.point(t, e);
},
_onMouseUp: function (t) {
var e = t.originalEvent,
i = e.clientX,
o = e.clientY;
this._endPoint.call(this, i, o, t), (this._clickHandled = null);
},
_endPoint: function (e, i, o) {
if (this._mouseDownOrigin) {
var n = L.point(e, i).distanceTo(this._mouseDownOrigin),
a = this._calculateFinishDistance(o.latlng);
this.options.maxPoints > 1 &&
this.options.maxPoints == this._markers.length + 1
? (this.addVertex(o.latlng), this._finishShape())
: a < 10 && L.Browser.touch
? this._finishShape()
: Math.abs(n) < 9 * (t.devicePixelRatio || 1) &&
this.addVertex(o.latlng),
this._enableNewMarkers();
}
this._mouseDownOrigin = null;
},
_onTouch: function (t) {
var e,
i,
o = t.originalEvent;
!o.touches ||
!o.touches[0] ||
this._clickHandled ||
this._touchHandled ||
this._disableMarkers ||
((e = o.touches[0].clientX),
(i = o.touches[0].clientY),
this._disableNewMarkers(),
(this._touchHandled = !0),
this._startPoint.call(this, e, i),
this._endPoint.call(this, e, i, t),
(this._touchHandled = null)),
(this._clickHandled = null);
},
_onMouseOut: function () {
this._tooltip && this._tooltip._onMouseOut.call(this._tooltip);
},
_calculateFinishDistance: function (t) {
var e;
if (this._markers.length > 0) {
var i;
if (this.type === L.Draw.Polyline.TYPE)
i = this._markers[this._markers.length - 1];
else {
if (this.type !== L.Draw.Polygon.TYPE) return 1 / 0;
i = this._markers[0];
}
var o = this._map.latLngToContainerPoint(i.getLatLng()),
n = new L.Marker(t, {
icon: this.options.icon,
zIndexOffset: 2 * this.options.zIndexOffset,
}),
a = this._map.latLngToContainerPoint(n.getLatLng());
e = o.distanceTo(a);
} else e = 1 / 0;
return e;
},
_updateFinishHandler: function () {
var t = this._markers.length;
t > 1 && this._markers[t - 1].on("click", this._finishShape, this),
t > 2 && this._markers[t - 2].off("click", this._finishShape, this);
},
_createMarker: function (t) {
var e = new L.Marker(t, {
icon: this.options.icon,
zIndexOffset: 2 * this.options.zIndexOffset,
});
return this._markerGroup.addLayer(e), e;
},
_updateGuide: function (t) {
var e = this._markers ? this._markers.length : 0;
e > 0 &&
((t = t || this._map.latLngToLayerPoint(this._currentLatLng)),
this._clearGuides(),
this._drawGuide(
this._map.latLngToLayerPoint(this._markers[e - 1].getLatLng()),
t,
));
},
_updateTooltip: function (t) {
var e = this._getTooltipText();
t && this._tooltip.updatePosition(t),
this._errorShown || this._tooltip.updateContent(e);
},
_drawGuide: function (t, e) {
var i,
o,
n,
a = Math.floor(
Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2)),
),
s = this.options.guidelineDistance,
r = this.options.maxGuideLineLength,
l = a > r ? a - r : s;
for (
this._guidesContainer ||
(this._guidesContainer = L.DomUtil.create(
"div",
"leaflet-draw-guides",
this._overlayPane,
));
l < a;
l += this.options.guidelineDistance
)
(i = l / a),
(o = {
x: Math.floor(t.x * (1 - i) + i * e.x),
y: Math.floor(t.y * (1 - i) + i * e.y),
}),
(n = L.DomUtil.create(
"div",
"leaflet-draw-guide-dash",
this._guidesContainer,
)),
(n.style.backgroundColor = this._errorShown
? this.options.drawError.color
: this.options.shapeOptions.color),
L.DomUtil.setPosition(n, o);
},
_updateGuideColor: function (t) {
if (this._guidesContainer)
for (
var e = 0, i = this._guidesContainer.childNodes.length;
e < i;
e++
)
this._guidesContainer.childNodes[e].style.backgroundColor = t;
},
_clearGuides: function () {
if (this._guidesContainer)
for (; this._guidesContainer.firstChild; )
this._guidesContainer.removeChild(this._guidesContainer.firstChild);
},
_getTooltipText: function () {
var t,
e,
i = this.options.showLength;
return (
0 === this._markers.length
? (t = { text: L.drawLocal.draw.handlers.polyline.tooltip.start })
: ((e = i ? this._getMeasurementString() : ""),
(t =
1 === this._markers.length
? {
text: L.drawLocal.draw.handlers.polyline.tooltip.cont,
subtext: e,
}
: {
text: L.drawLocal.draw.handlers.polyline.tooltip.end,
subtext: e,
})),
t
);
},
_updateRunningMeasure: function (t, e) {
var i,
o,
n = this._markers.length;
1 === this._markers.length
? (this._measurementRunningTotal = 0)
: ((i = n - (e ? 2 : 1)),
(o = L.GeometryUtil.isVersion07x()
? t.distanceTo(this._markers[i].getLatLng()) *
(this.options.factor || 1)
: this._map.distance(t, this._markers[i].getLatLng()) *
(this.options.factor || 1)),
(this._measurementRunningTotal += o * (e ? 1 : -1)));
},
_getMeasurementString: function () {
var t,
e = this._currentLatLng,
i = this._markers[this._markers.length - 1].getLatLng();
return (
(t = L.GeometryUtil.isVersion07x()
? i && e && e.distanceTo
? this._measurementRunningTotal +
e.distanceTo(i) * (this.options.factor || 1)
: this._measurementRunningTotal || 0
: i && e
? this._measurementRunningTotal +
this._map.distance(e, i) * (this.options.factor || 1)
: this._measurementRunningTotal || 0),
L.GeometryUtil.readableDistance(
t,
this.options.metric,
this.options.feet,
this.options.nautic,
this.options.precision,
)
);
},
_showErrorTooltip: function () {
(this._errorShown = !0),
this._tooltip
.showAsError()
.updateContent({ text: this.options.drawError.message }),
this._updateGuideColor(this.options.drawError.color),
this._poly.setStyle({ color: this.options.drawError.color }),
this._clearHideErrorTimeout(),
(this._hideErrorTimeout = setTimeout(
L.Util.bind(this._hideErrorTooltip, this),
this.options.drawError.timeout,
));
},
_hideErrorTooltip: function () {
(this._errorShown = !1),
this._clearHideErrorTimeout(),
this._tooltip.removeError().updateContent(this._getTooltipText()),
this._updateGuideColor(this.options.shapeOptions.color),
this._poly.setStyle({ color: this.options.shapeOptions.color });
},
_clearHideErrorTimeout: function () {
this._hideErrorTimeout &&
(clearTimeout(this._hideErrorTimeout),
(this._hideErrorTimeout = null));
},
_disableNewMarkers: function () {
this._disableMarkers = !0;
},
_enableNewMarkers: function () {
setTimeout(
function () {
this._disableMarkers = !1;
}.bind(this),
50,
);
},
_cleanUpShape: function () {
this._markers.length > 1 &&
this._markers[this._markers.length - 1].off(
"click",
this._finishShape,
this,
);
},
_fireCreatedEvent: function () {
var t = new this.Poly(
this._poly.getLatLngs(),
this.options.shapeOptions,
);
L.Draw.Feature.prototype._fireCreatedEvent.call(this, t);
},
})),
(L.Draw.Polygon = L.Draw.Polyline.extend({
statics: { TYPE: "polygon" },
Poly: L.Polygon,
options: {
showArea: !1,
showLength: !1,
shapeOptions: {
stroke: !0,
color: "#3388ff",
weight: 4,
opacity: 0.5,
fill: !0,
fillColor: null,
fillOpacity: 0.2,
clickable: !0,
},
metric: !0,
feet: !0,
nautic: !1,
precision: {},
},
initialize: function (t, e) {
L.Draw.Polyline.prototype.initialize.call(this, t, e),
(this.type = L.Draw.Polygon.TYPE);
},
_updateFinishHandler: function () {
var t = this._markers.length;
1 === t && this._markers[0].on("click", this._finishShape, this),
t > 2 &&
(this._markers[t - 1].on("dblclick", this._finishShape, this),
t > 3 &&
this._markers[t - 2].off("dblclick", this._finishShape, this));
},
_getTooltipText: function () {
var t, e;
return (
0 === this._markers.length
? (t = L.drawLocal.draw.handlers.polygon.tooltip.start)
: this._markers.length < 3
? ((t = L.drawLocal.draw.handlers.polygon.tooltip.cont),
(e = this._getMeasurementString()))
: ((t = L.drawLocal.draw.handlers.polygon.tooltip.end),
(e = this._getMeasurementString())),
{ text: t, subtext: e }
);
},
_getMeasurementString: function () {
var t = this._area,
e = "";
return t || this.options.showLength
? (this.options.showLength &&
(e = L.Draw.Polyline.prototype._getMeasurementString.call(this)),
t &&
(e +=
"<br>" +
L.GeometryUtil.readableArea(
t,
this.options.metric,
this.options.precision,
)),
e)
: null;
},
_shapeIsValid: function () {
return this._markers.length >= 3;
},
_vertexChanged: function (t, e) {
var i;
!this.options.allowIntersection &&
this.options.showArea &&
((i = this._poly.getLatLngs()),
(this._area = L.GeometryUtil.geodesicArea(i))),
L.Draw.Polyline.prototype._vertexChanged.call(this, t, e);
},
_cleanUpShape: function () {
var t = this._markers.length;
t > 0 &&
(this._markers[0].off("click", this._finishShape, this),
t > 2 &&
this._markers[t - 1].off("dblclick", this._finishShape, this));
},
})),
(L.SimpleShape = {}),
(L.Draw.SimpleShape = L.Draw.Feature.extend({
options: { repeatMode: !1 },
initialize: function (t, e) {
(this._endLabelText =
L.drawLocal.draw.handlers.simpleshape.tooltip.end),
L.Draw.Feature.prototype.initialize.call(this, t, e);
},
addHooks: function () {
L.Draw.Feature.prototype.addHooks.call(this),
this._map &&
((this._mapDraggable = this._map.dragging.enabled()),
this._mapDraggable && this._map.dragging.disable(),
(this._container.style.cursor = "crosshair"),
this._tooltip.updateContent({ text: this._initialLabelText }),
this._map
.on("mousedown", this._onMouseDown, this)
.on("mousemove", this._onMouseMove, this)
.on("touchstart", this._onMouseDown, this)
.on("touchmove", this._onMouseMove, this),
e.addEventListener("touchstart", L.DomEvent.preventDefault, {
passive: !1,
}));
},
removeHooks: function () {
L.Draw.Feature.prototype.removeHooks.call(this),
this._map &&
(this._mapDraggable && this._map.dragging.enable(),
(this._container.style.cursor = ""),
this._map
.off("mousedown", this._onMouseDown, this)
.off("mousemove", this._onMouseMove, this)
.off("touchstart", this._onMouseDown, this)
.off("touchmove", this._onMouseMove, this),
L.DomEvent.off(e, "mouseup", this._onMouseUp, this),
L.DomEvent.off(e, "touchend", this._onMouseUp, this),
e.removeEventListener("touchstart", L.DomEvent.preventDefault),
this._shape &&
(this._map.removeLayer(this._shape), delete this._shape)),
(this._isDrawing = !1);
},
_getTooltipText: function () {
return { text: this._endLabelText };
},
_onMouseDown: function (t) {
(this._isDrawing = !0),
(this._startLatLng = t.latlng),
L.DomEvent.on(e, "mouseup", this._onMouseUp, this)
.on(e, "touchend", this._onMouseUp, this)
.preventDefault(t.originalEvent);
},
_onMouseMove: function (t) {
var e = t.latlng;
this._tooltip.updatePosition(e),
this._isDrawing &&
(this._tooltip.updateContent(this._getTooltipText()),
this._drawShape(e));
},
_onMouseUp: function () {
this._shape && this._fireCreatedEvent(),
this.disable(),
this.options.repeatMode && this.enable();
},
})),
(L.Draw.Rectangle = L.Draw.SimpleShape.extend({
statics: { TYPE: "rectangle" },
options: {
shapeOptions: {
stroke: !0,
color: "#3388ff",
weight: 4,
opacity: 0.5,
fill: !0,
fillColor: null,
fillOpacity: 0.2,
showArea: !0,
clickable: !0,
},
metric: !0,
},
initialize: function (t, e) {
(this.type = L.Draw.Rectangle.TYPE),
(this._initialLabelText =
L.drawLocal.draw.handlers.rectangle.tooltip.start),
L.Draw.SimpleShape.prototype.initialize.call(this, t, e);
},
disable: function () {
this._enabled &&
((this._isCurrentlyTwoClickDrawing = !1),
L.Draw.SimpleShape.prototype.disable.call(this));
},
_onMouseUp: function (t) {
if (!this._shape && !this._isCurrentlyTwoClickDrawing)
return void (this._isCurrentlyTwoClickDrawing = !0);
(this._isCurrentlyTwoClickDrawing && !o(t.target, "leaflet-pane")) ||
L.Draw.SimpleShape.prototype._onMouseUp.call(this);
},
_drawShape: function (t) {
this._shape
? this._shape.setBounds(new L.LatLngBounds(this._startLatLng, t))
: ((this._shape = new L.Rectangle(
new L.LatLngBounds(this._startLatLng, t),
this.options.shapeOptions,
)),
this._map.addLayer(this._shape));
},
_fireCreatedEvent: function () {
var t = new L.Rectangle(
this._shape.getBounds(),
this.options.shapeOptions,
);
L.Draw.SimpleShape.prototype._fireCreatedEvent.call(this, t);
},
_getTooltipText: function () {
var t,
e,
i,
o = L.Draw.SimpleShape.prototype._getTooltipText.call(this),
n = this._shape,
a = this.options.showArea;
return (
n &&
((t = this._shape._defaultShape
? this._shape._defaultShape()
: this._shape.getLatLngs()),
(e = L.GeometryUtil.geodesicArea(t)),
(i = a ? L.GeometryUtil.readableArea(e, this.options.metric) : "")),
{ text: o.text, subtext: i }
);
},
})),
(L.Draw.Marker = L.Draw.Feature.extend({
statics: { TYPE: "marker" },
options: {
icon: new L.Icon.Default(),
repeatMode: !1,
zIndexOffset: 2e3,
},
initialize: function (t, e) {
(this.type = L.Draw.Marker.TYPE),
(this._initialLabelText =
L.drawLocal.draw.handlers.marker.tooltip.start),
L.Draw.Feature.prototype.initialize.call(this, t, e);
},
addHooks: function () {
L.Draw.Feature.prototype.addHooks.call(this),
this._map &&
(this._tooltip.updateContent({ text: this._initialLabelText }),
this._mouseMarker ||
(this._mouseMarker = L.marker(this._map.getCenter(), {
icon: L.divIcon({
className: "leaflet-mouse-marker",
iconAnchor: [20, 20],
iconSize: [40, 40],
}),
opacity: 0,
zIndexOffset: this.options.zIndexOffset,
})),
this._mouseMarker.on("click", this._onClick, this).addTo(this._map),
this._map.on("mousemove", this._onMouseMove, this),
this._map.on("click", this._onTouch, this));
},
removeHooks: function () {
L.Draw.Feature.prototype.removeHooks.call(this),
this._map &&
(this._map
.off("click", this._onClick, this)
.off("click", this._onTouch, this),
this._marker &&
(this._marker.off("click", this._onClick, this),
this._map.removeLayer(this._marker),
delete this._marker),
this._mouseMarker.off("click", this._onClick, this),
this._map.removeLayer(this._mouseMarker),
delete this._mouseMarker,
this._map.off("mousemove", this._onMouseMove, this));
},
_onMouseMove: function (t) {
var e = t.latlng;
this._tooltip.updatePosition(e),
this._mouseMarker.setLatLng(e),
this._marker
? ((e = this._mouseMarker.getLatLng()), this._marker.setLatLng(e))
: ((this._marker = this._createMarker(e)),
this._marker.on("click", this._onClick, this),
this._map
.on("click", this._onClick, this)
.addLayer(this._marker));
},
_createMarker: function (t) {
return new L.Marker(t, {
icon: this.options.icon,
zIndexOffset: this.options.zIndexOffset,
});
},
_onClick: function () {
this._fireCreatedEvent(),
this.disable(),
this.options.repeatMode && this.enable();
},
_onTouch: function (t) {
this._onMouseMove(t), this._onClick();
},
_fireCreatedEvent: function () {
var t = new L.Marker.Touch(this._marker.getLatLng(), {
icon: this.options.icon,
});
L.Draw.Feature.prototype._fireCreatedEvent.call(this, t);
},
})),
(L.Draw.CircleMarker = L.Draw.Marker.extend({
statics: { TYPE: "circlemarker" },
options: {
stroke: !0,
color: "#3388ff",
weight: 4,
opacity: 0.5,
fill: !0,
fillColor: null,
fillOpacity: 0.2,
clickable: !0,
zIndexOffset: 2e3,
},
initialize: function (t, e) {
(this.type = L.Draw.CircleMarker.TYPE),
(this._initialLabelText =
L.drawLocal.draw.handlers.circlemarker.tooltip.start),
L.Draw.Feature.prototype.initialize.call(this, t, e);
},
_fireCreatedEvent: function () {
var t = new L.CircleMarker(this._marker.getLatLng(), this.options);
L.Draw.Feature.prototype._fireCreatedEvent.call(this, t);
},
_createMarker: function (t) {
return new L.CircleMarker(t, this.options);
},
})),
(L.Draw.Circle = L.Draw.SimpleShape.extend({
statics: { TYPE: "circle" },
options: {
shapeOptions: {
stroke: !0,
color: "#3388ff",
weight: 4,
opacity: 0.5,
fill: !0,
fillColor: null,
fillOpacity: 0.2,
clickable: !0,
},
showRadius: !0,
metric: !0,
feet: !0,
nautic: !1,
},
initialize: function (t, e) {
(this.type = L.Draw.Circle.TYPE),
(this._initialLabelText =
L.drawLocal.draw.handlers.circle.tooltip.start),
L.Draw.SimpleShape.prototype.initialize.call(this, t, e);
},
_drawShape: function (t) {
if (L.GeometryUtil.isVersion07x())
var e = this._startLatLng.distanceTo(t);
else var e = this._map.distance(this._startLatLng, t);
this._shape
? this._shape.setRadius(e)
: ((this._shape = new L.Circle(
this._startLatLng,
e,
this.options.shapeOptions,
)),
this._map.addLayer(this._shape));
},
_fireCreatedEvent: function () {
var t = new L.Circle(
this._startLatLng,
this._shape.getRadius(),
this.options.shapeOptions,
);
L.Draw.SimpleShape.prototype._fireCreatedEvent.call(this, t);
},
_onMouseMove: function (t) {
var e,
i = t.latlng,
o = this.options.showRadius,
n = this.options.metric;
if ((this._tooltip.updatePosition(i), this._isDrawing)) {
this._drawShape(i), (e = this._shape.getRadius().toFixed(1));
var a = "";
o &&
(a =
L.drawLocal.draw.handlers.circle.radius +
": " +
L.GeometryUtil.readableDistance(
e,
n,
this.options.feet,
this.options.nautic,
)),
this._tooltip.updateContent({
text: this._endLabelText,
subtext: a,
});
}
},
})),
(L.Edit = L.Edit || {}),
(L.Edit.Marker = L.Handler.extend({
initialize: function (t, e) {
(this._marker = t), L.setOptions(this, e);
},
addHooks: function () {
var t = this._marker;
t.dragging.enable(),
t.on("dragend", this._onDragEnd, t),
this._toggleMarkerHighlight();
},
removeHooks: function () {
var t = this._marker;
t.dragging.disable(),
t.off("dragend", this._onDragEnd, t),
this._toggleMarkerHighlight();
},
_onDragEnd: function (t) {
var e = t.target;
(e.edited = !0), this._map.fire(L.Draw.Event.EDITMOVE, { layer: e });
},
_toggleMarkerHighlight: function () {
var t = this._marker._icon;
t &&
((t.style.display = "none"),
L.DomUtil.hasClass(t, "leaflet-edit-marker-selected")
? (L.DomUtil.removeClass(t, "leaflet-edit-marker-selected"),
this._offsetMarker(t, -4))
: (L.DomUtil.addClass(t, "leaflet-edit-marker-selected"),
this._offsetMarker(t, 4)),
(t.style.display = ""));
},
_offsetMarker: function (t, e) {
var i = parseInt(t.style.marginTop, 10) - e,
o = parseInt(t.style.marginLeft, 10) - e;
(t.style.marginTop = i + "px"), (t.style.marginLeft = o + "px");
},
})),
L.Marker.addInitHook(function () {
L.Edit.Marker &&
((this.editing = new L.Edit.Marker(this)),
this.options.editable && this.editing.enable());
}),
(L.Edit = L.Edit || {}),
(L.Edit.Poly = L.Handler.extend({
initialize: function (t) {
(this.latlngs = [t._latlngs]),
t._holes && (this.latlngs = this.latlngs.concat(t._holes)),
(this._poly = t),
this._poly.on("revert-edited", this._updateLatLngs, this);
},
_defaultShape: function () {
return L.Polyline._flat
? L.Polyline._flat(this._poly._latlngs)
? this._poly._latlngs
: this._poly._latlngs[0]
: this._poly._latlngs;
},
_eachVertexHandler: function (t) {
for (var e = 0; e < this._verticesHandlers.length; e++)
t(this._verticesHandlers[e]);
},
addHooks: function () {
this._initHandlers(),
this._eachVertexHandler(function (t) {
t.addHooks();
});
},
removeHooks: function () {
this._eachVertexHandler(function (t) {
t.removeHooks();
});
},
updateMarkers: function () {
this._eachVertexHandler(function (t) {
t.updateMarkers();
});
},
_initHandlers: function () {
this._verticesHandlers = [];
for (var t = 0; t < this.latlngs.length; t++)
this._verticesHandlers.push(
new L.Edit.PolyVerticesEdit(
this._poly,
this.latlngs[t],
this._poly.options.poly,
),
);
},
_updateLatLngs: function (t) {
(this.latlngs = [t.layer._latlngs]),
t.layer._holes &&
(this.latlngs = this.latlngs.concat(t.layer._holes));
},
})),
(L.Edit.PolyVerticesEdit = L.Handler.extend({
options: {
icon: new L.DivIcon({
iconSize: new L.Point(8, 8),
className: "leaflet-div-icon leaflet-editing-icon",
}),
touchIcon: new L.DivIcon({
iconSize: new L.Point(20, 20),
className: "leaflet-div-icon leaflet-editing-icon leaflet-touch-icon",
}),
drawError: { color: "#b00b00", timeout: 1e3 },
},
initialize: function (t, e, i) {
L.Browser.touch && (this.options.icon = this.options.touchIcon),
(this._poly = t),
i &&
i.drawError &&
(i.drawError = L.Util.extend(
{},
this.options.drawError,
i.drawError,
)),
(this._latlngs = e),
L.setOptions(this, i);
},
_defaultShape: function () {
return L.Polyline._flat
? L.Polyline._flat(this._latlngs)
? this._latlngs
: this._latlngs[0]
: this._latlngs;
},
addHooks: function () {
var t = this._poly,
e = t._path;
t instanceof L.Polygon ||
((t.options.fill = !1),
t.options.editing && (t.options.editing.fill = !1)),
e &&
t.options.editing.className &&
(t.options.original.className &&
t.options.original.className.split(" ").forEach(function (t) {
L.DomUtil.removeClass(e, t);
}),
t.options.editing.className.split(" ").forEach(function (t) {
L.DomUtil.addClass(e, t);
})),
t.setStyle(t.options.editing),
this._poly._map &&
((this._map = this._poly._map),
this._markerGroup || this._initMarkers(),
this._poly._map.addLayer(this._markerGroup));
},
removeHooks: function () {
var t = this._poly,
e = t._path;
e &&
t.options.editing.className &&
(t.options.editing.className.split(" ").forEach(function (t) {
L.DomUtil.removeClass(e, t);
}),
t.options.original.className &&
t.options.original.className.split(" ").forEach(function (t) {
L.DomUtil.addClass(e, t);
})),
t.setStyle(t.options.original),
t._map &&
(t._map.removeLayer(this._markerGroup),
delete this._markerGroup,
delete this._markers);
},
updateMarkers: function () {
this._markerGroup.clearLayers(), this._initMarkers();
},
_initMarkers: function () {
this._markerGroup || (this._markerGroup = new L.LayerGroup()),
(this._markers = []);
var t,
e,
i,
o,
n = this._defaultShape();
for (t = 0, i = n.length; t < i; t++)
(o = this._createMarker(n[t], t)),
o.on("click", this._onMarkerClick, this),
o.on("contextmenu", this._onContextMenu, this),
this._markers.push(o);
var a, s;
for (t = 0, e = i - 1; t < i; e = t++)
(0 !== t || (L.Polygon && this._poly instanceof L.Polygon)) &&
((a = this._markers[e]),
(s = this._markers[t]),
this._createMiddleMarker(a, s),
this._updatePrevNext(a, s));
},
_createMarker: function (t, e) {
var i = new L.Marker.Touch(t, {
draggable: !0,
icon: this.options.icon,
});
return (
(i._origLatLng = t),
(i._index = e),
i
.on("dragstart", this._onMarkerDragStart, this)
.on("drag", this._onMarkerDrag, this)
.on("dragend", this._fireEdit, this)
.on("touchmove", this._onTouchMove, this)
.on("touchend", this._fireEdit, this)
.on("MSPointerMove", this._onTouchMove, this)
.on("MSPointerUp", this._fireEdit, this),
this._markerGroup.addLayer(i),
i
);
},
_onMarkerDragStart: function () {
this._poly.fire("editstart");
},
_spliceLatLngs: function () {
var t = this._defaultShape(),
e = [].splice.apply(t, arguments);
return this._poly._convertLatLngs(t, !0), this._poly.redraw(), e;
},
_removeMarker: function (t) {
var e = t._index;
this._markerGroup.removeLayer(t),
this._markers.splice(e, 1),
this._spliceLatLngs(e, 1),
this._updateIndexes(e, -1),
t
.off("dragstart", this._onMarkerDragStart, this)
.off("drag", this._onMarkerDrag, this)
.off("dragend", this._fireEdit, this)
.off("touchmove", this._onMarkerDrag, this)
.off("touchend", this._fireEdit, this)
.off("click", this._onMarkerClick, this)
.off("MSPointerMove", this._onTouchMove, this)
.off("MSPointerUp", this._fireEdit, this);
},
_fireEdit: function () {
(this._poly.edited = !0),
this._poly.fire("edit"),
this._poly._map.fire(L.Draw.Event.EDITVERTEX, {
layers: this._markerGroup,
poly: this._poly,
});
},
_onMarkerDrag: function (t) {
var e = t.target,
i = this._poly;
if (
(L.extend(e._origLatLng, e._latlng),
e._middleLeft &&
e._middleLeft.setLatLng(this._getMiddleLatLng(e._prev, e)),
e._middleRight &&
e._middleRight.setLatLng(this._getMiddleLatLng(e, e._next)),
i.options.poly)
) {
var o = i._map._editTooltip;
if (!i.options.poly.allowIntersection && i.intersects()) {
var n = i.options.color;
i.setStyle({ color: this.options.drawError.color }),
0 !== L.version.indexOf("0.7") && e.dragging._draggable._onUp(t),
this._onMarkerClick(t),
o &&
o.updateContent({
text: L.drawLocal.draw.handlers.polyline.error,
}),
setTimeout(function () {
i.setStyle({ color: n }),
o &&
o.updateContent({
text: L.drawLocal.edit.handlers.edit.tooltip.text,
subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext,
});
}, 1e3);
}
}
(this._poly._bounds._southWest = L.latLng(1 / 0, 1 / 0)),
(this._poly._bounds._northEast = L.latLng(-1 / 0, -1 / 0));
var a = this._poly.getLatLngs();
this._poly._convertLatLngs(a, !0),
this._poly.redraw(),
this._poly.fire("editdrag");
},
_onMarkerClick: function (t) {
var e = L.Polygon && this._poly instanceof L.Polygon ? 4 : 3,
i = t.target;
this._defaultShape().length < e ||
(this._removeMarker(i),
this._updatePrevNext(i._prev, i._next),
i._middleLeft && this._markerGroup.removeLayer(i._middleLeft),
i._middleRight && this._markerGroup.removeLayer(i._middleRight),
i._prev && i._next
? this._createMiddleMarker(i._prev, i._next)
: i._prev
? i._next || (i._prev._middleRight = null)
: (i._next._middleLeft = null),
this._fireEdit());
},
_onContextMenu: function (t) {
var e = t.target;
this._poly;
this._poly._map.fire(L.Draw.Event.MARKERCONTEXT, {
marker: e,
layers: this._markerGroup,
poly: this._poly,
}),
L.DomEvent.stopPropagation;
},
_onTouchMove: function (t) {
var e = this._map.mouseEventToLayerPoint(t.originalEvent.touches[0]),
i = this._map.layerPointToLatLng(e),
o = t.target;
L.extend(o._origLatLng, i),
o._middleLeft &&
o._middleLeft.setLatLng(this._getMiddleLatLng(o._prev, o)),
o._middleRight &&
o._middleRight.setLatLng(this._getMiddleLatLng(o, o._next)),
this._poly.redraw(),
this.updateMarkers();
},
_updateIndexes: function (t, e) {
this._markerGroup.eachLayer(function (i) {
i._index > t && (i._index += e);
});
},
_createMiddleMarker: function (t, e) {
var i,
o,
n,
a = this._getMiddleLatLng(t, e),
s = this._createMarker(a);
s.setOpacity(0.8),
(t._middleRight = e._middleLeft = s),
(o = function () {
s.off("touchmove", o, this);
var n = e._index;
(s._index = n),
s.off("click", i, this).on("click", this._onMarkerClick, this),
(a.lat = s.getLatLng().lat),
(a.lng = s.getLatLng().lng),
this._spliceLatLngs(n, 0, a),
this._markers.splice(n, 0, s),
s.setOpacity(1),
s._icon.classList.remove("leaflet-middle-icon"),
this._updateIndexes(n, 1),
e._index++,
this._updatePrevNext(t, s),
this._updatePrevNext(s, e),
this._poly.fire("editstart");
}),
(n = function () {
s.off("dragstart", o, this),
s.off("dragend", n, this),
s.off("touchmove", o, this),
this._createMiddleMarker(t, s),
this._createMiddleMarker(s, e);
}),
(i = function () {
o.call(this), n.call(this), this._fireEdit();
}),
s
.on("click", i, this)
.on("dragstart", o, this)
.on("dragend", n, this)
.on("touchmove", o, this),
this._markerGroup.addLayer(s);
setTimeout(() => {
s._icon.classList.add("leaflet-middle-icon");
}, 100);
},
_updatePrevNext: function (t, e) {
t && (t._next = e), e && (e._prev = t);
},
_getMiddleLatLng: function (t, e) {
var i = this._poly._map,
o = i.project(t.getLatLng()),
n = i.project(e.getLatLng());
return i.unproject(o._add(n)._divideBy(2));
},
})),
L.Polyline.addInitHook(function () {
this.editing ||
(L.Edit.Poly &&
((this.editing = new L.Edit.Poly(this)),
this.options.editable && this.editing.enable()),
this.on("add", function () {
this.editing && this.editing.enabled() && this.editing.addHooks();
}),
this.on("remove", function () {
this.editing && this.editing.enabled() && this.editing.removeHooks();
}));
}),
(L.Edit = L.Edit || {}),
(L.Edit.SimpleShape = L.Handler.extend({
options: {
moveIcon: new L.DivIcon({
iconSize: new L.Point(8, 8),
className: "leaflet-div-icon leaflet-editing-icon leaflet-edit-move",
}),
resizeIcon: new L.DivIcon({
iconSize: new L.Point(8, 8),
className:
"leaflet-div-icon leaflet-editing-icon leaflet-edit-resize",
}),
touchMoveIcon: new L.DivIcon({
iconSize: new L.Point(20, 20),
className:
"leaflet-div-icon leaflet-editing-icon leaflet-edit-move leaflet-touch-icon",
}),
touchResizeIcon: new L.DivIcon({
iconSize: new L.Point(20, 20),
className:
"leaflet-div-icon leaflet-editing-icon leaflet-edit-resize leaflet-touch-icon",
}),
},
initialize: function (t, e) {
L.Browser.touch &&
((this.options.moveIcon = this.options.touchMoveIcon),
(this.options.resizeIcon = this.options.touchResizeIcon)),
(this._shape = t),
L.Util.setOptions(this, e);
},
addHooks: function () {
var t = this._shape;
this._shape._map &&
((this._map = this._shape._map),
t.setStyle(t.options.editing),
t._map &&
((this._map = t._map),
this._markerGroup || this._initMarkers(),
this._map.addLayer(this._markerGroup)));
},
removeHooks: function () {
var t = this._shape;
if ((t.setStyle(t.options.original), t._map)) {
this._unbindMarker(this._moveMarker);
for (var e = 0, i = this._resizeMarkers.length; e < i; e++)
this._unbindMarker(this._resizeMarkers[e]);
(this._resizeMarkers = null),
this._map.removeLayer(this._markerGroup),
delete this._markerGroup;
}
this._map = null;
},
updateMarkers: function () {
this._markerGroup.clearLayers(), this._initMarkers();
},
_initMarkers: function () {
this._markerGroup || (this._markerGroup = new L.LayerGroup()),
this._createMoveMarker(),
this._createResizeMarker();
},
_createMoveMarker: function () {},
_createResizeMarker: function () {},
_createMarker: function (t, e) {
var i = new L.Marker.Touch(t, {
draggable: !0,
icon: e,
zIndexOffset: 10,
});
return this._bindMarker(i), this._markerGroup.addLayer(i), i;
},
_bindMarker: function (t) {
t.on("dragstart", this._onMarkerDragStart, this)
.on("drag", this._onMarkerDrag, this)
.on("dragend", this._onMarkerDragEnd, this)
.on("touchstart", this._onTouchStart, this)
.on("touchmove", this._onTouchMove, this)
.on("MSPointerMove", this._onTouchMove, this)
.on("touchend", this._onTouchEnd, this)
.on("MSPointerUp", this._onTouchEnd, this);
},
_unbindMarker: function (t) {
t.off("dragstart", this._onMarkerDragStart, this)
.off("drag", this._onMarkerDrag, this)
.off("dragend", this._onMarkerDragEnd, this)
.off("touchstart", this._onTouchStart, this)
.off("touchmove", this._onTouchMove, this)
.off("MSPointerMove", this._onTouchMove, this)
.off("touchend", this._onTouchEnd, this)
.off("MSPointerUp", this._onTouchEnd, this);
},
_onMarkerDragStart: function (t) {
t.target.setOpacity(0), this._shape.fire("editstart");
},
_fireEdit: function () {
(this._shape.edited = !0), this._shape.fire("edit");
},
_onMarkerDrag: function (t) {
var e = t.target,
i = e.getLatLng();
e === this._moveMarker ? this._move(i) : this._resize(i),
this._shape.redraw(),
this._shape.fire("editdrag");
},
_onMarkerDragEnd: function (t) {
t.target.setOpacity(1), this._fireEdit();
},
_onTouchStart: function (t) {
if (
(L.Edit.SimpleShape.prototype._onMarkerDragStart.call(this, t),
"function" == typeof this._getCorners)
) {
var e = this._getCorners(),
i = t.target,
o = i._cornerIndex;
i.setOpacity(0),
(this._oppositeCorner = e[(o + 2) % 4]),
this._toggleCornerMarkers(0, o);
}
this._shape.fire("editstart");
},
_onTouchMove: function (t) {
var e = this._map.mouseEventToLayerPoint(t.originalEvent.touches[0]),
i = this._map.layerPointToLatLng(e);
return (
t.target === this._moveMarker ? this._move(i) : this._resize(i),
this._shape.redraw(),
!1
);
},
_onTouchEnd: function (t) {
t.target.setOpacity(1), this.updateMarkers(), this._fireEdit();
},
_move: function () {},
_resize: function () {},
})),
(L.Edit = L.Edit || {}),
(L.Edit.Rectangle = L.Edit.SimpleShape.extend({
_createMoveMarker: function () {
var t = this._shape.getBounds(),
e = t.getCenter();
this._moveMarker = this._createMarker(e, this.options.moveIcon);
},
_createResizeMarker: function () {
var t = this._getCorners();
this._resizeMarkers = [];
for (var e = 0, i = t.length; e < i; e++)
this._resizeMarkers.push(
this._createMarker(t[e], this.options.resizeIcon),
),
(this._resizeMarkers[e]._cornerIndex = e);
},
_onMarkerDragStart: function (t) {
L.Edit.SimpleShape.prototype._onMarkerDragStart.call(this, t);
var e = this._getCorners(),
i = t.target,
o = i._cornerIndex;
(this._oppositeCorner = e[(o + 2) % 4]),
this._toggleCornerMarkers(0, o);
},
_onMarkerDragEnd: function (t) {
var e,
i,
o = t.target;
o === this._moveMarker &&
((e = this._shape.getBounds()), (i = e.getCenter()), o.setLatLng(i)),
this._toggleCornerMarkers(1),
this._repositionCornerMarkers(),
L.Edit.SimpleShape.prototype._onMarkerDragEnd.call(this, t);
},
_move: function (t) {
for (
var e,
i = this._shape._defaultShape
? this._shape._defaultShape()
: this._shape.getLatLngs(),
o = this._shape.getBounds(),
n = o.getCenter(),
a = [],
s = 0,
r = i.length;
s < r;
s++
)
(e = [i[s].lat - n.lat, i[s].lng - n.lng]),
a.push([t.lat + e[0], t.lng + e[1]]);
this._shape.setLatLngs(a),
this._repositionCornerMarkers(),
this._map.fire(L.Draw.Event.EDITMOVE, { layer: this._shape });
},
_resize: function (t) {
var e;
this._shape.setBounds(L.latLngBounds(t, this._oppositeCorner)),
(e = this._shape.getBounds()),
this._moveMarker.setLatLng(e.getCenter()),
this._map.fire(L.Draw.Event.EDITRESIZE, { layer: this._shape });
},
_getCorners: function () {
var t = this._shape.getBounds();
return [
t.getNorthWest(),
t.getNorthEast(),
t.getSouthEast(),
t.getSouthWest(),
];
},
_toggleCornerMarkers: function (t) {
for (var e = 0, i = this._resizeMarkers.length; e < i; e++)
this._resizeMarkers[e].setOpacity(t);
},
_repositionCornerMarkers: function () {
for (
var t = this._getCorners(), e = 0, i = this._resizeMarkers.length;
e < i;
e++
)
this._resizeMarkers[e].setLatLng(t[e]);
},
})),
L.Rectangle.addInitHook(function () {
L.Edit.Rectangle &&
((this.editing = new L.Edit.Rectangle(this)),
this.options.editable && this.editing.enable());
}),
(L.Edit = L.Edit || {}),
(L.Edit.CircleMarker = L.Edit.SimpleShape.extend({
_createMoveMarker: function () {
var t = this._shape.getLatLng();
this._moveMarker = this._createMarker(t, this.options.moveIcon);
},
_createResizeMarker: function () {
this._resizeMarkers = [];
},
_move: function (t) {
if (this._resizeMarkers.length) {
var e = this._getResizeMarkerPoint(t);
this._resizeMarkers[0].setLatLng(e);
}
this._shape.setLatLng(t),
this._map.fire(L.Draw.Event.EDITMOVE, { layer: this._shape });
},
})),
L.CircleMarker.addInitHook(function () {
L.Edit.CircleMarker &&
((this.editing = new L.Edit.CircleMarker(this)),
this.options.editable && this.editing.enable()),
this.on("add", function () {
this.editing && this.editing.enabled() && this.editing.addHooks();
}),
this.on("remove", function () {
this.editing && this.editing.enabled() && this.editing.removeHooks();
});
}),
(L.Edit = L.Edit || {}),
(L.Edit.Circle = L.Edit.CircleMarker.extend({
_createResizeMarker: function () {
var t = this._shape.getLatLng(),
e = this._getResizeMarkerPoint(t);
(this._resizeMarkers = []),
this._resizeMarkers.push(
this._createMarker(e, this.options.resizeIcon),
);
},
_getResizeMarkerPoint: function (t) {
var e = this._shape._radius * Math.cos(Math.PI / 4),
i = this._map.project(t);
return this._map.unproject([i.x + e, i.y - e]);
},
_resize: function (t) {
var e = this._moveMarker.getLatLng();
L.GeometryUtil.isVersion07x()
? (radius = e.distanceTo(t))
: (radius = this._map.distance(e, t)),
this._shape.setRadius(radius),
this._map._editTooltip.updateContent({
text:
L.drawLocal.edit.handlers.edit.tooltip.subtext +
"<br />" +
L.drawLocal.edit.handlers.edit.tooltip.text,
subtext:
L.drawLocal.draw.handlers.circle.radius +
": " +
L.GeometryUtil.readableDistance(
radius,
!0,
this.options.feet,
this.options.nautic,
),
}),
this._shape.setRadius(radius),
this._map.fire(L.Draw.Event.EDITRESIZE, { layer: this._shape });
},
})),
L.Circle.addInitHook(function () {
L.Edit.Circle &&
((this.editing = new L.Edit.Circle(this)),
this.options.editable && this.editing.enable()),
this.on("add", function () {
this.editing && this.editing.enabled() && this.editing.addHooks();
}),
this.on("remove", function () {
this.editing && this.editing.enabled() && this.editing.removeHooks();
});
}),
L.Map.mergeOptions({ touchExtend: !0 }),
(L.Map.TouchExtend = L.Handler.extend({
initialize: function (t) {
(this._map = t),
(this._container = t._container),
(this._pane = t._panes.overlayPane);
},
addHooks: function () {
L.DomEvent.on(this._container, "touchstart", this._onTouchStart, this),
L.DomEvent.on(this._container, "touchend", this._onTouchEnd, this),
L.DomEvent.on(this._container, "touchmove", this._onTouchMove, this),
this._detectIE()
? (L.DomEvent.on(
this._container,
"MSPointerDown",
this._onTouchStart,
this,
),
L.DomEvent.on(
this._container,
"MSPointerUp",
this._onTouchEnd,
this,
),
L.DomEvent.on(
this._container,
"MSPointerMove",
this._onTouchMove,
this,
),
L.DomEvent.on(
this._container,
"MSPointerCancel",
this._onTouchCancel,
this,
))
: (L.DomEvent.on(
this._container,
"touchcancel",
this._onTouchCancel,
this,
),
L.DomEvent.on(
this._container,
"touchleave",
this._onTouchLeave,
this,
));
},
removeHooks: function () {
L.DomEvent.off(this._container, "touchstart", this._onTouchStart),
L.DomEvent.off(this._container, "touchend", this._onTouchEnd),
L.DomEvent.off(this._container, "touchmove", this._onTouchMove),
this._detectIE()
? (L.DomEvent.off(
this._container,
"MSPointerDowm",
this._onTouchStart,
),
L.DomEvent.off(this._container, "MSPointerUp", this._onTouchEnd),
L.DomEvent.off(
this._container,
"MSPointerMove",
this._onTouchMove,
),
L.DomEvent.off(
this._container,
"MSPointerCancel",
this._onTouchCancel,
))
: (L.DomEvent.off(
this._container,
"touchcancel",
this._onTouchCancel,
),
L.DomEvent.off(
this._container,
"touchleave",
this._onTouchLeave,
));
},
_touchEvent: function (t, e) {
var i = {};
if (void 0 !== t.touches) {
if (!t.touches.length) return;
i = t.touches[0];
} else {
if ("touch" !== t.pointerType) return;
if (((i = t), !this._filterClick(t))) return;
}
var o = this._map.mouseEventToContainerPoint(i),
n = this._map.mouseEventToLayerPoint(i),
a = this._map.layerPointToLatLng(n);
this._map.fire(e, {
latlng: a,
layerPoint: n,
containerPoint: o,
pageX: i.pageX,
pageY: i.pageY,
originalEvent: t,
});
},
_filterClick: function (t) {
var e = t.timeStamp || t.originalEvent.timeStamp,
i = L.DomEvent._lastClick && e - L.DomEvent._lastClick;
return (i && i > 100 && i < 500) ||
(t.target._simulatedClick && !t._simulated)
? (L.DomEvent.stop(t), !1)
: ((L.DomEvent._lastClick = e), !0);
},
_onTouchStart: function (t) {
if (this._map._loaded) {
this._touchEvent(t, "touchstart");
}
},
_onTouchEnd: function (t) {
if (this._map._loaded) {
this._touchEvent(t, "touchend");
}
},
_onTouchCancel: function (t) {
if (this._map._loaded) {
var e = "touchcancel";
this._detectIE() && (e = "pointercancel"), this._touchEvent(t, e);
}
},
_onTouchLeave: function (t) {
if (this._map._loaded) {
this._touchEvent(t, "touchleave");
}
},
_onTouchMove: function (t) {
if (this._map._loaded) {
this._touchEvent(t, "touchmove");
}
},
_detectIE: function () {
var e = t.navigator.userAgent,
i = e.indexOf("MSIE ");
if (i > 0) return parseInt(e.substring(i + 5, e.indexOf(".", i)), 10);
if (e.indexOf("Trident/") > 0) {
var o = e.indexOf("rv:");
return parseInt(e.substring(o + 3, e.indexOf(".", o)), 10);
}
var n = e.indexOf("Edge/");
return n > 0 && parseInt(e.substring(n + 5, e.indexOf(".", n)), 10);
},
})),
L.Map.addInitHook("addHandler", "touchExtend", L.Map.TouchExtend),
(L.Marker.Touch = L.Marker.extend({
_initInteraction: function () {
return this.addInteractiveTarget
? L.Marker.prototype._initInteraction.apply(this)
: this._initInteractionLegacy();
},
_initInteractionLegacy: function () {
if (this.options.clickable) {
var t = this._icon,
e = [
"dblclick",
"mousedown",
"mouseover",
"mouseout",
"contextmenu",
"touchstart",
"touchend",
"touchmove",
];
this._detectIE
? e.concat([
"MSPointerDown",
"MSPointerUp",
"MSPointerMove",
"MSPointerCancel",
])
: e.concat(["touchcancel"]),
L.DomUtil.addClass(t, "leaflet-clickable"),
L.DomEvent.on(t, "click", this._onMouseClick, this),
L.DomEvent.on(t, "keypress", this._onKeyPress, this);
for (var i = 0; i < e.length; i++)
L.DomEvent.on(t, e[i], this._fireMouseEvent, this);
L.Handler.MarkerDrag &&
((this.dragging = new L.Handler.MarkerDrag(this)),
this.options.draggable && this.dragging.enable());
}
},
_detectIE: function () {
var e = t.navigator.userAgent,
i = e.indexOf("MSIE ");
if (i > 0) return parseInt(e.substring(i + 5, e.indexOf(".", i)), 10);
if (e.indexOf("Trident/") > 0) {
var o = e.indexOf("rv:");
return parseInt(e.substring(o + 3, e.indexOf(".", o)), 10);
}
var n = e.indexOf("Edge/");
return n > 0 && parseInt(e.substring(n + 5, e.indexOf(".", n)), 10);
},
})),
(L.LatLngUtil = {
cloneLatLngs: function (t) {
for (var e = [], i = 0, o = t.length; i < o; i++)
Array.isArray(t[i])
? e.push(L.LatLngUtil.cloneLatLngs(t[i]))
: e.push(this.cloneLatLng(t[i]));
return e;
},
cloneLatLng: function (t) {
return L.latLng(t.lat, t.lng);
},
}),
(function () {
var t = { km: 2, ha: 2, m: 0, mi: 2, ac: 2, yd: 0, ft: 0, nm: 2 };
L.GeometryUtil = L.extend(L.GeometryUtil || {}, {
geodesicArea: function (t) {
var e,
i,
o = t.length,
n = 0,
a = Math.PI / 180;
if (o > 2) {
for (var s = 0; s < o; s++)
(e = t[s]),
(i = t[(s + 1) % o]),
(n +=
(i.lng - e.lng) *
a *
(2 + Math.sin(e.lat * a) + Math.sin(i.lat * a)));
n = (6378137 * n * 6378137) / 2;
}
return Math.abs(n);
},
formattedNumber: function (t, e) {
var i = parseFloat(t).toFixed(e),
o = L.drawLocal.format && L.drawLocal.format.numeric,
n = o && o.delimiters,
a = n && n.thousands,
s = n && n.decimal;
if (a || s) {
var r = i.split(".");
(i = a ? r[0].replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1" + a) : r[0]),
(s = s || "."),
r.length > 1 && (i = i + s + r[1]);
}
return i;
},
readableArea: function (e, i, o) {
var n,
a,
o = L.Util.extend({}, t, o);
return (
i
? ((a = ["ha", "m"]),
(type = typeof i),
"string" === type ? (a = [i]) : "boolean" !== type && (a = i),
(n =
e >= 1e6 && -1 !== a.indexOf("km")
? L.GeometryUtil.formattedNumber(1e-6 * e, o.km) + " km²"
: e >= 1e4 && -1 !== a.indexOf("ha")
? L.GeometryUtil.formattedNumber(1e-4 * e, o.ha) + " ha"
: L.GeometryUtil.formattedNumber(e, o.m) + " m²"))
: ((e /= 0.836127),
(n =
e >= 3097600
? L.GeometryUtil.formattedNumber(e / 3097600, o.mi) + " mi²"
: e >= 4840
? L.GeometryUtil.formattedNumber(e / 4840, o.ac) +
" acres"
: L.GeometryUtil.formattedNumber(e, o.yd) + " yd²")),
n
);
},
readableDistance: function (e, i, o, n, a) {
var s,
a = L.Util.extend({}, t, a);
switch (
i
? "string" == typeof i
? i
: "metric"
: o
? "feet"
: n
? "nauticalMile"
: "yards"
) {
case "metric":
s =
e > 1e3
? L.GeometryUtil.formattedNumber(e / 1e3, a.km) + " km"
: L.GeometryUtil.formattedNumber(e, a.m) + " m";
break;
case "feet":
(e *= 3.28083),
(s = L.GeometryUtil.formattedNumber(e, a.ft) + " ft");
break;
case "nauticalMile":
(e *= 0.53996),
(s = L.GeometryUtil.formattedNumber(e / 1e3, a.nm) + " nm");
break;
case "yards":
default:
(e *= 1.09361),
(s =
e > 1760
? L.GeometryUtil.formattedNumber(e / 1760, a.mi) + " miles"
: L.GeometryUtil.formattedNumber(e, a.yd) + " yd");
}
return s;
},
isVersion07x: function () {
var t = L.version.split(".");
return 0 === parseInt(t[0], 10) && 7 === parseInt(t[1], 10);
},
});
})(),
L.Util.extend(L.LineUtil, {
segmentsIntersect: function (t, e, i, o) {
return (
this._checkCounterclockwise(t, i, o) !==
this._checkCounterclockwise(e, i, o) &&
this._checkCounterclockwise(t, e, i) !==
this._checkCounterclockwise(t, e, o)
);
},
_checkCounterclockwise: function (t, e, i) {
return (i.y - t.y) * (e.x - t.x) > (e.y - t.y) * (i.x - t.x);
},
}),
L.Polyline.include({
intersects: function () {
var t,
e,
i,
o = this._getProjectedPoints(),
n = o ? o.length : 0;
if (this._tooFewPointsForIntersection()) return !1;
for (t = n - 1; t >= 3; t--)
if (
((e = o[t - 1]),
(i = o[t]),
this._lineSegmentsIntersectsRange(e, i, t - 2))
)
return !0;
return !1;
},
newLatLngIntersects: function (t, e) {
return (
!!this._map &&
this.newPointIntersects(this._map.latLngToLayerPoint(t), e)
);
},
newPointIntersects: function (t, e) {
var i = this._getProjectedPoints(),
o = i ? i.length : 0,
n = i ? i[o - 1] : null,
a = o - 2;
return (
!this._tooFewPointsForIntersection(1) &&
this._lineSegmentsIntersectsRange(n, t, a, e ? 1 : 0)
);
},
_tooFewPointsForIntersection: function (t) {
var e = this._getProjectedPoints(),
i = e ? e.length : 0;
return (i += t || 0), !e || i <= 3;
},
_lineSegmentsIntersectsRange: function (t, e, i, o) {
var n,
a,
s = this._getProjectedPoints();
o = o || 0;
for (var r = i; r > o; r--)
if (
((n = s[r - 1]),
(a = s[r]),
L.LineUtil.segmentsIntersect(t, e, n, a))
)
return !0;
return !1;
},
_getProjectedPoints: function () {
if (!this._defaultShape) return this._originalPoints;
for (var t = [], e = this._defaultShape(), i = 0; i < e.length; i++)
t.push(this._map.latLngToLayerPoint(e[i]));
return t;
},
}),
L.Polygon.include({
intersects: function () {
var t,
e,
i,
o,
n = this._getProjectedPoints();
return (
!this._tooFewPointsForIntersection() &&
(!!L.Polyline.prototype.intersects.call(this) ||
((t = n.length),
(e = n[0]),
(i = n[t - 1]),
(o = t - 2),
this._lineSegmentsIntersectsRange(i, e, o, 1)))
);
},
}),
(L.Control.Draw = L.Control.extend({
options: { position: "topleft", draw: {}, edit: !1 },
initialize: function (t) {
if (L.version < "0.7")
throw new Error(
"Leaflet.draw 0.2.3+ requires Leaflet 0.7.0+. Download latest from https://github.com/Leaflet/Leaflet/",
);
L.Control.prototype.initialize.call(this, t);
var e;
(this._toolbars = {}),
L.DrawToolbar &&
this.options.draw &&
((e = new L.DrawToolbar(this.options.draw)),
(this._toolbars[L.DrawToolbar.TYPE] = e),
this._toolbars[L.DrawToolbar.TYPE].on(
"enable",
this._toolbarEnabled,
this,
)),
L.EditToolbar &&
this.options.edit &&
((e = new L.EditToolbar(this.options.edit)),
(this._toolbars[L.EditToolbar.TYPE] = e),
this._toolbars[L.EditToolbar.TYPE].on(
"enable",
this._toolbarEnabled,
this,
)),
(L.toolbar = this);
},
onAdd: function (t) {
var e,
i = L.DomUtil.create("div", "leaflet-draw"),
o = !1;
for (var n in this._toolbars)
this._toolbars.hasOwnProperty(n) &&
(e = this._toolbars[n].addToolbar(t)) &&
(o ||
(L.DomUtil.hasClass(e, "leaflet-draw-toolbar-top") ||
L.DomUtil.addClass(e.childNodes[0], "leaflet-draw-toolbar-top"),
(o = !0)),
i.appendChild(e));
return i;
},
onRemove: function () {
for (var t in this._toolbars)
this._toolbars.hasOwnProperty(t) && this._toolbars[t].removeToolbar();
},
setDrawingOptions: function (t) {
for (var e in this._toolbars)
this._toolbars[e] instanceof L.DrawToolbar &&
this._toolbars[e].setOptions(t);
},
_toolbarEnabled: function (t) {
var e = t.target;
for (var i in this._toolbars)
this._toolbars[i] !== e && this._toolbars[i].disable();
},
})),
L.Map.mergeOptions({ drawControlTooltips: !0, drawControl: !1 }),
L.Map.addInitHook(function () {
this.options.drawControl &&
((this.drawControl = new L.Control.Draw()),
this.addControl(this.drawControl));
}),
(L.Toolbar = L.Class.extend({
initialize: function (t) {
L.setOptions(this, t),
(this._modes = {}),
(this._actionButtons = []),
(this._activeMode = null);
var e = L.version.split(".");
1 === parseInt(e[0], 10) && parseInt(e[1], 10) >= 2
? L.Toolbar.include(L.Evented.prototype)
: L.Toolbar.include(L.Mixin.Events);
},
enabled: function () {
return null !== this._activeMode;
},
disable: function () {
this.enabled() && this._activeMode.handler.disable();
},
addToolbar: function (t) {
var e,
i = L.DomUtil.create("div", "leaflet-draw-section"),
o = 0,
n = this._toolbarClass || "",
a = this.getModeHandlers(t);
for (
this._toolbarContainer = L.DomUtil.create(
"div",
"leaflet-draw-toolbar leaflet-bar",
),
this._map = t,
e = 0;
e < a.length;
e++
)
a[e].enabled &&
this._initModeHandler(
a[e].handler,
this._toolbarContainer,
o++,
n,
a[e].title,
);
if (o)
return (
(this._lastButtonIndex = --o),
(this._actionsContainer = L.DomUtil.create(
"ul",
"leaflet-draw-actions",
)),
i.appendChild(this._toolbarContainer),
i.appendChild(this._actionsContainer),
i
);
},
removeToolbar: function () {
for (var t in this._modes)
this._modes.hasOwnProperty(t) &&
(this._disposeButton(
this._modes[t].button,
this._modes[t].handler.enable,
this._modes[t].handler,
),
this._modes[t].handler.disable(),
this._modes[t].handler
.off("enabled", this._handlerActivated, this)
.off("disabled", this._handlerDeactivated, this));
this._modes = {};
for (var e = 0, i = this._actionButtons.length; e < i; e++)
this._disposeButton(
this._actionButtons[e].button,
this._actionButtons[e].callback,
this,
);
(this._actionButtons = []), (this._actionsContainer = null);
},
_initModeHandler: function (t, e, i, o, n) {
var a = t.type;
(this._modes[a] = {}),
(this._modes[a].handler = t),
(this._modes[a].button = this._createButton({
type: a,
title: n,
className: o + "-" + a,
container: e,
callback: this._modes[a].handler.enable,
context: this._modes[a].handler,
})),
(this._modes[a].buttonIndex = i),
this._modes[a].handler
.on("enabled", this._handlerActivated, this)
.on("disabled", this._handlerDeactivated, this);
},
_detectIOS: function () {
return /iPad|iPhone|iPod/.test(navigator.userAgent) && !t.MSStream;
},
_createButton: function (t) {
var e = L.DomUtil.create("a", t.className || "", t.container),
i = L.DomUtil.create("span", "sr-only", t.container);
(e.href = "#"),
e.appendChild(i),
t.title && ((e.title = t.title), (i.innerHTML = t.title)),
t.text && ((e.innerHTML = t.text), (i.innerHTML = t.text));
var o = this._detectIOS() ? "touchstart" : "click";
return (
L.DomEvent.on(e, "click", L.DomEvent.stopPropagation)
.on(e, "mousedown", L.DomEvent.stopPropagation)
.on(e, "dblclick", L.DomEvent.stopPropagation)
.on(e, "touchstart", L.DomEvent.stopPropagation)
.on(e, "click", L.DomEvent.preventDefault)
.on(e, o, t.callback, t.context),
e
);
},
_disposeButton: function (t, e) {
var i = this._detectIOS() ? "touchstart" : "click";
L.DomEvent.off(t, "click", L.DomEvent.stopPropagation)
.off(t, "mousedown", L.DomEvent.stopPropagation)
.off(t, "dblclick", L.DomEvent.stopPropagation)
.off(t, "touchstart", L.DomEvent.stopPropagation)
.off(t, "click", L.DomEvent.preventDefault)
.off(t, i, e);
},
_handlerActivated: function (t) {
this.disable(),
(this._activeMode = this._modes[t.handler]),
L.DomUtil.addClass(
this._activeMode.button,
"leaflet-draw-toolbar-button-enabled",
),
this._showActionsToolbar(),
this.fire("enable");
},
_handlerDeactivated: function () {
this._hideActionsToolbar(),
L.DomUtil.removeClass(
this._activeMode.button,
"leaflet-draw-toolbar-button-enabled",
),
(this._activeMode = null),
this.fire("disable");
},
_createActions: function (t) {
var e,
i,
o,
n,
a = this._actionsContainer,
s = this.getActions(t),
r = s.length;
for (i = 0, o = this._actionButtons.length; i < o; i++)
this._disposeButton(
this._actionButtons[i].button,
this._actionButtons[i].callback,
);
for (this._actionButtons = []; a.firstChild; )
a.removeChild(a.firstChild);
for (var l = 0; l < r; l++)
("enabled" in s[l] && !s[l].enabled) ||
((e = L.DomUtil.create("li", "", a)),
(n = this._createButton({
title: s[l].title,
text: s[l].text,
container: e,
callback: s[l].callback,
context: s[l].context,
})),
this._actionButtons.push({ button: n, callback: s[l].callback }));
},
_showActionsToolbar: function () {
var t = this._activeMode.buttonIndex,
e = this._lastButtonIndex,
i = this._activeMode.button.offsetTop - 1;
this._createActions(this._activeMode.handler),
(this._actionsContainer.style.top = i + "px"),
0 === t &&
(L.DomUtil.addClass(
this._toolbarContainer,
"leaflet-draw-toolbar-notop",
),
L.DomUtil.addClass(
this._actionsContainer,
"leaflet-draw-actions-top",
)),
t === e &&
(L.DomUtil.addClass(
this._toolbarContainer,
"leaflet-draw-toolbar-nobottom",
),
L.DomUtil.addClass(
this._actionsContainer,
"leaflet-draw-actions-bottom",
)),
(this._actionsContainer.style.display = "block"),
this._map.fire(L.Draw.Event.TOOLBAROPENED);
},
_hideActionsToolbar: function () {
(this._actionsContainer.style.display = "none"),
L.DomUtil.removeClass(
this._toolbarContainer,
"leaflet-draw-toolbar-notop",
),
L.DomUtil.removeClass(
this._toolbarContainer,
"leaflet-draw-toolbar-nobottom",
),
L.DomUtil.removeClass(
this._actionsContainer,
"leaflet-draw-actions-top",
),
L.DomUtil.removeClass(
this._actionsContainer,
"leaflet-draw-actions-bottom",
),
this._map.fire(L.Draw.Event.TOOLBARCLOSED);
},
})),
(L.Draw = L.Draw || {}),
(L.Draw.Tooltip = L.Class.extend({
initialize: function (t) {
(this._map = t),
(this._popupPane = t._panes.popupPane),
(this._visible = !1),
(this._container = t.options.drawControlTooltips
? L.DomUtil.create("div", "leaflet-draw-tooltip", this._popupPane)
: null),
(this._singleLineLabel = !1),
this._map.on("mouseout", this._onMouseOut, this);
},
dispose: function () {
this._map.off("mouseout", this._onMouseOut, this),
this._container &&
(this._popupPane.removeChild(this._container),
(this._container = null));
},
updateContent: function (t) {
return this._container
? ((t.subtext = t.subtext || ""),
0 !== t.subtext.length || this._singleLineLabel
? t.subtext.length > 0 &&
this._singleLineLabel &&
(L.DomUtil.removeClass(
this._container,
"leaflet-draw-tooltip-single",
),
(this._singleLineLabel = !1))
: (L.DomUtil.addClass(
this._container,
"leaflet-draw-tooltip-single",
),
(this._singleLineLabel = !0)),
(this._container.innerHTML =
(t.subtext.length > 0
? '<span class="leaflet-draw-tooltip-subtext">' +
t.subtext +
"</span><br />"
: "") +
"<span>" +
t.text +
"</span>"),
t.text || t.subtext
? ((this._visible = !0),
(this._container.style.visibility = "inherit"))
: ((this._visible = !1),
(this._container.style.visibility = "hidden")),
this)
: this;
},
updatePosition: function (t) {
var e = this._map.latLngToLayerPoint(t),
i = this._container;
return (
this._container &&
(this._visible && (i.style.visibility = "inherit"),
L.DomUtil.setPosition(i, e)),
this
);
},
showAsError: function () {
return (
this._container &&
L.DomUtil.addClass(this._container, "leaflet-error-draw-tooltip"),
this
);
},
removeError: function () {
return (
this._container &&
L.DomUtil.removeClass(
this._container,
"leaflet-error-draw-tooltip",
),
this
);
},
_onMouseOut: function () {
this._container && (this._container.style.visibility = "hidden");
},
})),
(L.DrawToolbar = L.Toolbar.extend({
statics: { TYPE: "draw" },
options: {
polyline: {},
polygon: {},
rectangle: {},
circle: {},
marker: {},
circlemarker: {},
},
initialize: function (t) {
for (var e in this.options)
this.options.hasOwnProperty(e) &&
t[e] &&
(t[e] = L.extend({}, this.options[e], t[e]));
(this._toolbarClass = "leaflet-draw-draw"),
L.Toolbar.prototype.initialize.call(this, t);
},
getModeHandlers: function (t) {
return [
{
enabled: this.options.polyline,
handler: new L.Draw.Polyline(t, this.options.polyline),
title: L.drawLocal.draw.toolbar.buttons.polyline,
},
{
enabled: this.options.polygon,
handler: new L.Draw.Polygon(t, this.options.polygon),
title: L.drawLocal.draw.toolbar.buttons.polygon,
},
{
enabled: this.options.rectangle,
handler: new L.Draw.Rectangle(t, this.options.rectangle),
title: L.drawLocal.draw.toolbar.buttons.rectangle,
},
{
enabled: this.options.circle,
handler: new L.Draw.Circle(t, this.options.circle),
title: L.drawLocal.draw.toolbar.buttons.circle,
},
{
enabled: this.options.marker,
handler: new L.Draw.Marker(t, this.options.marker),
title: L.drawLocal.draw.toolbar.buttons.marker,
},
{
enabled: this.options.circlemarker,
handler: new L.Draw.CircleMarker(t, this.options.circlemarker),
title: L.drawLocal.draw.toolbar.buttons.circlemarker,
},
];
},
getActions: function (t) {
return [
{
enabled: t.completeShape,
title: L.drawLocal.draw.toolbar.finish.title,
text: L.drawLocal.draw.toolbar.finish.text,
callback: t.completeShape,
context: t,
},
{
enabled: t.deleteLastVertex,
title: L.drawLocal.draw.toolbar.undo.title,
text: L.drawLocal.draw.toolbar.undo.text,
callback: t.deleteLastVertex,
context: t,
},
{
title: L.drawLocal.draw.toolbar.actions.title,
text: L.drawLocal.draw.toolbar.actions.text,
callback: this.disable,
context: this,
},
];
},
setOptions: function (t) {
L.setOptions(this, t);
for (var e in this._modes)
this._modes.hasOwnProperty(e) &&
t.hasOwnProperty(e) &&
this._modes[e].handler.setOptions(t[e]);
},
})),
(L.EditToolbar = L.Toolbar.extend({
statics: { TYPE: "edit" },
options: {
edit: {
selectedPathOptions: {
dashArray: "10, 10",
fill: !0,
fillColor: "#fe57a1",
fillOpacity: 0.1,
maintainColor: !1,
},
},
remove: {},
poly: null,
featureGroup: null,
},
initialize: function (t) {
t.edit &&
(void 0 === t.edit.selectedPathOptions &&
(t.edit.selectedPathOptions =
this.options.edit.selectedPathOptions),
(t.edit.selectedPathOptions = L.extend(
{},
this.options.edit.selectedPathOptions,
t.edit.selectedPathOptions,
))),
t.remove && (t.remove = L.extend({}, this.options.remove, t.remove)),
t.poly && (t.poly = L.extend({}, this.options.poly, t.poly)),
(this._toolbarClass = "leaflet-draw-edit"),
L.Toolbar.prototype.initialize.call(this, t),
(this._selectedFeatureCount = 0);
},
getModeHandlers: function (t) {
var e = this.options.featureGroup;
return [
{
enabled: this.options.edit,
handler: new L.EditToolbar.Edit(t, {
featureGroup: e,
selectedPathOptions: this.options.edit.selectedPathOptions,
poly: this.options.poly,
}),
title: L.drawLocal.edit.toolbar.buttons.edit,
},
{
enabled: this.options.remove,
handler: new L.EditToolbar.Delete(t, { featureGroup: e }),
title: L.drawLocal.edit.toolbar.buttons.remove,
},
];
},
getActions: function (t) {
var e = [
{
title: L.drawLocal.edit.toolbar.actions.save.title,
text: L.drawLocal.edit.toolbar.actions.save.text,
callback: this._save,
context: this,
},
{
title: L.drawLocal.edit.toolbar.actions.cancel.title,
text: L.drawLocal.edit.toolbar.actions.cancel.text,
callback: this.disable,
context: this,
},
];
return (
t.removeAllLayers &&
e.push({
title: L.drawLocal.edit.toolbar.actions.clearAll.title,
text: L.drawLocal.edit.toolbar.actions.clearAll.text,
callback: this._clearAllLayers,
context: this,
}),
e
);
},
addToolbar: function (t) {
var e = L.Toolbar.prototype.addToolbar.call(this, t);
return (
this._checkDisabled(),
this.options.featureGroup.on(
"layeradd layerremove",
this._checkDisabled,
this,
),
e
);
},
removeToolbar: function () {
this.options.featureGroup.off(
"layeradd layerremove",
this._checkDisabled,
this,
),
L.Toolbar.prototype.removeToolbar.call(this);
},
disable: function () {
this.enabled() &&
(this._activeMode.handler.revertLayers(),
L.Toolbar.prototype.disable.call(this));
},
_save: function () {
this._activeMode.handler.save(),
this._activeMode && this._activeMode.handler.disable();
},
_clearAllLayers: function () {
this._activeMode.handler.removeAllLayers(),
this._activeMode && this._activeMode.handler.disable();
},
_checkDisabled: function () {
var t,
e = this.options.featureGroup,
i = 0 !== e.getLayers().length;
this.options.edit &&
((t = this._modes[L.EditToolbar.Edit.TYPE].button),
i
? L.DomUtil.removeClass(t, "leaflet-disabled")
: L.DomUtil.addClass(t, "leaflet-disabled"),
t.setAttribute(
"title",
i
? L.drawLocal.edit.toolbar.buttons.edit
: L.drawLocal.edit.toolbar.buttons.editDisabled,
)),
this.options.remove &&
((t = this._modes[L.EditToolbar.Delete.TYPE].button),
i
? L.DomUtil.removeClass(t, "leaflet-disabled")
: L.DomUtil.addClass(t, "leaflet-disabled"),
t.setAttribute(
"title",
i
? L.drawLocal.edit.toolbar.buttons.remove
: L.drawLocal.edit.toolbar.buttons.removeDisabled,
));
},
})),
(L.EditToolbar.Edit = L.Handler.extend({
statics: { TYPE: "edit" },
initialize: function (t, e) {
if (
(L.Handler.prototype.initialize.call(this, t),
L.setOptions(this, e),
(this._featureGroup = e.featureGroup),
!(this._featureGroup instanceof L.FeatureGroup))
)
throw new Error("options.featureGroup must be a L.FeatureGroup");
(this._uneditedLayerProps = {}), (this.type = L.EditToolbar.Edit.TYPE);
var i = L.version.split(".");
1 === parseInt(i[0], 10) && parseInt(i[1], 10) >= 2
? L.EditToolbar.Edit.include(L.Evented.prototype)
: L.EditToolbar.Edit.include(L.Mixin.Events);
},
enable: function () {
!this._enabled &&
this._hasAvailableLayers() &&
(this.fire("enabled", { handler: this.type }),
this._map.fire(L.Draw.Event.EDITSTART, { handler: this.type }),
L.Handler.prototype.enable.call(this),
this._featureGroup
.on("layeradd", this._enableLayerEdit, this)
.on("layerremove", this._disableLayerEdit, this));
},
disable: function () {
this._enabled &&
(this._featureGroup
.off("layeradd", this._enableLayerEdit, this)
.off("layerremove", this._disableLayerEdit, this),
L.Handler.prototype.disable.call(this),
this._map.fire(L.Draw.Event.EDITSTOP, { handler: this.type }),
this.fire("disabled", { handler: this.type }));
},
addHooks: function () {
var t = this._map;
t &&
(t.getContainer().focus(),
this._featureGroup.eachLayer(this._enableLayerEdit, this),
(this._tooltip = new L.Draw.Tooltip(this._map)),
this._tooltip.updateContent({
text: L.drawLocal.edit.handlers.edit.tooltip.text,
subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext,
}),
(t._editTooltip = this._tooltip),
this._updateTooltip(),
this._map
.on("mousemove", this._onMouseMove, this)
.on("touchmove", this._onMouseMove, this)
.on("MSPointerMove", this._onMouseMove, this)
.on(L.Draw.Event.EDITVERTEX, this._updateTooltip, this));
},
removeHooks: function () {
this._map &&
(this._featureGroup.eachLayer(this._disableLayerEdit, this),
(this._uneditedLayerProps = {}),
this._tooltip.dispose(),
(this._tooltip = null),
this._map
.off("mousemove", this._onMouseMove, this)
.off("touchmove", this._onMouseMove, this)
.off("MSPointerMove", this._onMouseMove, this)
.off(L.Draw.Event.EDITVERTEX, this._updateTooltip, this));
},
revertLayers: function () {
this._featureGroup.eachLayer(function (t) {
this._revertLayer(t);
}, this);
},
save: function () {
var t = new L.LayerGroup();
this._featureGroup.eachLayer(function (e) {
e.edited && (t.addLayer(e), (e.edited = !1));
}),
this._map.fire(L.Draw.Event.EDITED, { layers: t });
},
_backupLayer: function (t) {
var e = L.Util.stamp(t);
this._uneditedLayerProps[e] ||
(t instanceof L.Polyline ||
t instanceof L.Polygon ||
t instanceof L.Rectangle
? (this._uneditedLayerProps[e] = {
latlngs: L.LatLngUtil.cloneLatLngs(t.getLatLngs()),
})
: t instanceof L.Circle
? (this._uneditedLayerProps[e] = {
latlng: L.LatLngUtil.cloneLatLng(t.getLatLng()),
radius: t.getRadius(),
})
: (t instanceof L.Marker || t instanceof L.CircleMarker) &&
(this._uneditedLayerProps[e] = {
latlng: L.LatLngUtil.cloneLatLng(t.getLatLng()),
}));
},
_getTooltipText: function () {
return {
text: L.drawLocal.edit.handlers.edit.tooltip.text,
subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext,
};
},
_updateTooltip: function () {
this._tooltip.updateContent(this._getTooltipText());
},
_revertLayer: function (t) {
var e = L.Util.stamp(t);
(t.edited = !1),
this._uneditedLayerProps.hasOwnProperty(e) &&
(t instanceof L.Polyline ||
t instanceof L.Polygon ||
t instanceof L.Rectangle
? t.setLatLngs(this._uneditedLayerProps[e].latlngs)
: t instanceof L.Circle
? (t.setLatLng(this._uneditedLayerProps[e].latlng),
t.setRadius(this._uneditedLayerProps[e].radius))
: (t instanceof L.Marker || t instanceof L.CircleMarker) &&
t.setLatLng(this._uneditedLayerProps[e].latlng),
t.fire("revert-edited", { layer: t }));
},
_enableLayerEdit: function (t) {
var e,
i,
o = t.layer || t.target || t;
this._backupLayer(o),
this.options.poly &&
((i = L.Util.extend({}, this.options.poly)), (o.options.poly = i)),
this.options.selectedPathOptions &&
((e = L.Util.extend({}, this.options.selectedPathOptions)),
e.maintainColor &&
((e.color = o.options.color),
(e.fillColor = o.options.fillColor)),
(o.options.original = L.extend({}, o.options)),
(o.options.editing = e)),
o instanceof L.Marker
? (o.editing && o.editing.enable(),
o.dragging.enable(),
o
.on("dragend", this._onMarkerDragEnd)
.on("touchmove", this._onTouchMove, this)
.on("MSPointerMove", this._onTouchMove, this)
.on("touchend", this._onMarkerDragEnd, this)
.on("MSPointerUp", this._onMarkerDragEnd, this))
: o.editing.enable();
},
_disableLayerEdit: function (t) {
var e = t.layer || t.target || t;
(e.edited = !1),
e.editing && e.editing.disable(),
delete e.options.editing,
delete e.options.original,
this._selectedPathOptions &&
(e instanceof L.Marker
? this._toggleMarkerHighlight(e)
: (e.setStyle(e.options.previousOptions),
delete e.options.previousOptions)),
e instanceof L.Marker
? (e.dragging.disable(),
e
.off("dragend", this._onMarkerDragEnd, this)
.off("touchmove", this._onTouchMove, this)
.off("MSPointerMove", this._onTouchMove, this)
.off("touchend", this._onMarkerDragEnd, this)
.off("MSPointerUp", this._onMarkerDragEnd, this))
: e.editing.disable();
},
_onMouseMove: function (t) {
this._tooltip.updatePosition(t.latlng);
},
_onMarkerDragEnd: function (t) {
var e = t.target;
(e.edited = !0), this._map.fire(L.Draw.Event.EDITMOVE, { layer: e });
},
_onTouchMove: function (t) {
var e = t.originalEvent.changedTouches[0],
i = this._map.mouseEventToLayerPoint(e),
o = this._map.layerPointToLatLng(i);
t.target.setLatLng(o);
},
_hasAvailableLayers: function () {
return 0 !== this._featureGroup.getLayers().length;
},
})),
(L.EditToolbar.Delete = L.Handler.extend({
statics: { TYPE: "remove" },
initialize: function (t, e) {
if (
(L.Handler.prototype.initialize.call(this, t),
L.Util.setOptions(this, e),
(this._deletableLayers = this.options.featureGroup),
!(this._deletableLayers instanceof L.FeatureGroup))
)
throw new Error("options.featureGroup must be a L.FeatureGroup");
this.type = L.EditToolbar.Delete.TYPE;
var i = L.version.split(".");
1 === parseInt(i[0], 10) && parseInt(i[1], 10) >= 2
? L.EditToolbar.Delete.include(L.Evented.prototype)
: L.EditToolbar.Delete.include(L.Mixin.Events);
},
enable: function () {
!this._enabled &&
this._hasAvailableLayers() &&
(this.fire("enabled", { handler: this.type }),
this._map.fire(L.Draw.Event.DELETESTART, { handler: this.type }),
L.Handler.prototype.enable.call(this),
this._deletableLayers
.on("layeradd", this._enableLayerDelete, this)
.on("layerremove", this._disableLayerDelete, this));
},
disable: function () {
this._enabled &&
(this._deletableLayers
.off("layeradd", this._enableLayerDelete, this)
.off("layerremove", this._disableLayerDelete, this),
L.Handler.prototype.disable.call(this),
this._map.fire(L.Draw.Event.DELETESTOP, { handler: this.type }),
this.fire("disabled", { handler: this.type }));
},
addHooks: function () {
var t = this._map;
t &&
(t.getContainer().focus(),
this._deletableLayers.eachLayer(this._enableLayerDelete, this),
(this._deletedLayers = new L.LayerGroup()),
(this._tooltip = new L.Draw.Tooltip(this._map)),
this._tooltip.updateContent({
text: L.drawLocal.edit.handlers.remove.tooltip.text,
}),
this._map.on("mousemove", this._onMouseMove, this));
},
removeHooks: function () {
this._map &&
(this._deletableLayers.eachLayer(this._disableLayerDelete, this),
(this._deletedLayers = null),
this._tooltip.dispose(),
(this._tooltip = null),
this._map.off("mousemove", this._onMouseMove, this));
},
revertLayers: function () {
this._deletedLayers.eachLayer(function (t) {
this._deletableLayers.addLayer(t),
t.fire("revert-deleted", { layer: t });
}, this);
},
save: function () {
this._map.fire(L.Draw.Event.DELETED, { layers: this._deletedLayers });
},
removeAllLayers: function () {
this._deletableLayers.eachLayer(function (t) {
this._removeLayer({ layer: t });
}, this),
this.save();
},
_enableLayerDelete: function (t) {
(t.layer || t.target || t).on("click", this._removeLayer, this);
},
_disableLayerDelete: function (t) {
var e = t.layer || t.target || t;
e.off("click", this._removeLayer, this),
this._deletedLayers.removeLayer(e);
},
_removeLayer: function (t) {
var e = t.layer || t.target || t;
this._deletableLayers.removeLayer(e),
this._deletedLayers.addLayer(e),
e.fire("deleted");
},
_onMouseMove: function (t) {
this._tooltip.updatePosition(t.latlng);
},
_hasAvailableLayers: function () {
return 0 !== this._deletableLayers.getLayers().length;
},
}));
})(window, document);
Reference in New Issue View Git Blame Copy Permalink