Non puoi selezionare più di 25 argomenti
Gli argomenti devono iniziare con una lettera o un numero, possono includere trattini ('-') e possono essere lunghi fino a 35 caratteri.
1768 righe
102 KiB
1768 righe
102 KiB
/* |
|
Leaflet.draw 1.0.4, 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 = "1.0.4"), |
|
(L.Draw = {}), |
|
(L.drawLocal = { |
|
draw: { |
|
toolbar: { |
|
actions: { title: "Cancel disegno", text: "Cancella" }, |
|
finish: { title: "Finisci disegno", text: "Finisci" }, |
|
undo: { title: "Cancella ultimo punto disegnato", text: "Cancella ultimo punto" }, |
|
buttons: { polyline: "Disegna una polilinea", polygon: "Disegna un poligono", rectangle: "Disegna un rettangolo", circle: "Disegna un un cerchio", marker: "Disegna un marker", circlemarker: "Disegna un circlemarker" }, |
|
}, |
|
handlers: { |
|
circle: { tooltip: { start: "Click and drag to draw circle." }, radius: "Radius" }, |
|
circlemarker: { tooltip: { start: "Click sulla mappa e posizione il marker." } }, |
|
marker: { tooltip: { start: "Click sulla mappa e posizione il marker." } }, |
|
polygon: { tooltip: { start: "Click per iniziare a disegnare.", cont: "Click per continuare a disegnare.", end: "Click sul primo punto per chiudere il disegno." } }, |
|
polyline: { error: "<strong>Error:</strong> shape edges cannot cross!", tooltip: { start: "Click per iniziare a disegnare una linea.", cont: "Click per continuare a disegnare una linea.", end: "Click ultimo punto per finire linea." } }, |
|
rectangle: { tooltip: { start: "Click and muovi per disegnare un rettangolo." } }, |
|
simpleshape: { tooltip: { end: "Rilascia il mouse per finire il disegno." } }, |
|
}, |
|
}, |
|
edit: { |
|
toolbar: { |
|
actions: { save: { title: "Salva modifiche", text: "Salva" }, cancel: { title: "Cancella modifiche, discards all changes", text: "Cancel" }, clearAll: { title: "Cancella tutti i layers", text: "Cancella tutto" } }, |
|
buttons: { edit: "Modifica layers", editDisabled: "Nessun layer da modificare", remove: "Cancella layer", removeDisabled: "Nessun layer da cancellare" }, |
|
}, |
|
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._shapeIsValid() || (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 a = L.point(e, i).distanceTo(this._mouseDownOrigin), |
|
n = this._calculateFinishDistance(o.latlng); |
|
this.options.maxPoints > 1 && this.options.maxPoints == this._markers.length + 1 |
|
? (this.addVertex(o.latlng), this._finishShape()) |
|
: n < 10 && L.Browser.touch |
|
? this._finishShape() |
|
: Math.abs(a) < 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()), |
|
a = new L.Marker(t, { icon: this.options.icon, zIndexOffset: 2 * this.options.zIndexOffset }), |
|
n = this._map.latLngToContainerPoint(a.getLatLng()); |
|
e = o.distanceTo(n); |
|
} 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, |
|
a, |
|
n = 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 = n > r ? n - r : s; |
|
for (this._guidesContainer || (this._guidesContainer = L.DomUtil.create("div", "leaflet-draw-guides", this._overlayPane)); l < n; l += this.options.guidelineDistance) |
|
(i = l / n), |
|
(o = { x: Math.floor(t.x * (1 - i) + i * e.x), y: Math.floor(t.y * (1 - i) + i * e.y) }), |
|
(a = L.DomUtil.create("div", "leaflet-draw-guide-dash", this._guidesContainer)), |
|
(a.style.backgroundColor = this._errorShown ? this.options.drawError.color : this.options.shapeOptions.color), |
|
L.DomUtil.setPosition(a, 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, |
|
a = this._markers.length; |
|
1 === this._markers.length |
|
? (this._measurementRunningTotal = 0) |
|
: ((i = a - (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, clickable: !0 }, showArea: !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), |
|
a = this._shape, |
|
n = this.options.showArea; |
|
return ( |
|
a && ((t = this._shape._defaultShape ? this._shape._defaultShape() : this._shape.getLatLngs()), (e = L.GeometryUtil.geodesicArea(t)), (i = n ? 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, |
|
a = this.options.metric; |
|
if ((this._tooltip.updatePosition(i), this._isDrawing)) { |
|
this._drawShape(i), (e = this._shape.getRadius().toFixed(1)); |
|
var n = ""; |
|
o && (n = L.drawLocal.draw.handlers.circle.radius + ": " + L.GeometryUtil.readableDistance(e, a, this.options.feet, this.options.nautic)), this._tooltip.updateContent({ text: this._endLabelText, subtext: n }); |
|
} |
|
}, |
|
})), |
|
(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 && |
|
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 && |
|
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, |
|
a = this._defaultShape(); |
|
for (t = 0, i = a.length; t < i; t++) (o = this._createMarker(a[t], t)), o.on("click", this._onMarkerClick, this), o.on("contextmenu", this._onContextMenu, this), this._markers.push(o); |
|
var n, s; |
|
for (t = 0, e = i - 1; t < i; e = t++) (0 !== t || (L.Polygon && this._poly instanceof L.Polygon)) && ((n = this._markers[e]), (s = this._markers[t]), this._createMiddleMarker(n, s), this._updatePrevNext(n, 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, |
|
o = L.LatLngUtil.cloneLatLng(e._origLatLng); |
|
if ((L.extend(e._origLatLng, e._latlng), i.options.poly)) { |
|
var a = i._map._editTooltip; |
|
if (!i.options.poly.allowIntersection && i.intersects()) { |
|
L.extend(e._origLatLng, o), e.setLatLng(o); |
|
var n = i.options.color; |
|
i.setStyle({ color: this.options.drawError.color }), |
|
a && a.updateContent({ text: L.drawLocal.draw.handlers.polyline.error }), |
|
setTimeout(function () { |
|
i.setStyle({ color: n }), a && a.updateContent({ text: L.drawLocal.edit.handlers.edit.tooltip.text, subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext }); |
|
}, 1e3); |
|
} |
|
} |
|
e._middleLeft && e._middleLeft.setLatLng(this._getMiddleLatLng(e._prev, e)), |
|
e._middleRight && e._middleRight.setLatLng(this._getMiddleLatLng(e, e._next)), |
|
(this._poly._bounds._southWest = L.latLng(1 / 0, 1 / 0)), |
|
(this._poly._bounds._northEast = L.latLng(-1 / 0, -1 / 0)); |
|
var s = this._poly.getLatLngs(); |
|
this._poly._convertLatLngs(s, !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, |
|
a, |
|
n = this._getMiddleLatLng(t, e), |
|
s = this._createMarker(n); |
|
s.setOpacity(0.6), |
|
(t._middleRight = e._middleLeft = s), |
|
(o = function () { |
|
s.off("touchmove", o, this); |
|
var a = e._index; |
|
(s._index = a), |
|
s.off("click", i, this).on("click", this._onMarkerClick, this), |
|
(n.lat = s.getLatLng().lat), |
|
(n.lng = s.getLatLng().lng), |
|
this._spliceLatLngs(a, 0, n), |
|
this._markers.splice(a, 0, s), |
|
s.setOpacity(1), |
|
this._updateIndexes(a, 1), |
|
e._index++, |
|
this._updatePrevNext(t, s), |
|
this._updatePrevNext(s, e), |
|
this._poly.fire("editstart"); |
|
}), |
|
(a = function () { |
|
s.off("dragstart", o, this), s.off("dragend", a, this), s.off("touchmove", o, this), this._createMiddleMarker(t, s), this._createMiddleMarker(s, e); |
|
}), |
|
(i = function () { |
|
o.call(this), a.call(this), this._fireEdit(); |
|
}), |
|
s.on("click", i, this).on("dragstart", o, this).on("dragend", a, this).on("touchmove", o, this), |
|
this._markerGroup.addLayer(s); |
|
}, |
|
_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()), |
|
a = i.project(e.getLatLng()); |
|
return i.unproject(o._add(a)._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(), a = o.getCenter(), n = [], s = 0, r = i.length; s < r; s++) |
|
(e = [i[s].lat - a.lat, i[s].lng - a.lng]), n.push([t.lat + e[0], t.lng + e[1]]); |
|
this._shape.setLatLngs(n), 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 && |
|
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()); |
|
}), |
|
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, this), |
|
L.DomEvent.off(this._container, "touchend", this._onTouchEnd, this), |
|
L.DomEvent.off(this._container, "touchmove", this._onTouchMove, this), |
|
this._detectIE() |
|
? (L.DomEvent.off(this._container, "MSPointerDown", this._onTouchStart, this), |
|
L.DomEvent.off(this._container, "MSPointerUp", this._onTouchEnd, this), |
|
L.DomEvent.off(this._container, "MSPointerMove", this._onTouchMove, this), |
|
L.DomEvent.off(this._container, "MSPointerCancel", this._onTouchCancel, this)) |
|
: (L.DomEvent.off(this._container, "touchcancel", this._onTouchCancel, this), L.DomEvent.off(this._container, "touchleave", this._onTouchLeave, this)); |
|
}, |
|
_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), |
|
a = this._map.mouseEventToLayerPoint(i), |
|
n = this._map.layerPointToLatLng(a); |
|
this._map.fire(e, { latlng: n, layerPoint: a, 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 a = e.indexOf("Edge/"); |
|
return a > 0 && parseInt(e.substring(a + 5, e.indexOf(".", a)), 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 a = e.indexOf("Edge/"); |
|
return a > 0 && parseInt(e.substring(a + 5, e.indexOf(".", a)), 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, |
|
a = 0, |
|
n = Math.PI / 180; |
|
if (o > 2) { |
|
for (var s = 0; s < o; s++) (e = t[s]), (i = t[(s + 1) % o]), (a += (i.lng - e.lng) * n * (2 + Math.sin(e.lat * n) + Math.sin(i.lat * n))); |
|
a = (6378137 * a * 6378137) / 2; |
|
} |
|
return Math.abs(a); |
|
}, |
|
formattedNumber: function (t, e) { |
|
var i = parseFloat(t).toFixed(e), |
|
o = L.drawLocal.format && L.drawLocal.format.numeric, |
|
a = o && o.delimiters, |
|
n = a && a.thousands, |
|
s = a && a.decimal; |
|
if (n || s) { |
|
var r = i.split("."); |
|
(i = n ? r[0].replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1" + n) : r[0]), (s = s || "."), r.length > 1 && (i = i + s + r[1]); |
|
} |
|
return i; |
|
}, |
|
readableArea: function (e, i, o) { |
|
var a, |
|
n, |
|
o = L.Util.extend({}, t, o); |
|
return ( |
|
i |
|
? ((n = ["ha", "m"]), |
|
(type = typeof i), |
|
"string" === type ? (n = [i]) : "boolean" !== type && (n = i), |
|
(a = |
|
e >= 1e6 && -1 !== n.indexOf("km") |
|
? L.GeometryUtil.formattedNumber(1e-6 * e, o.km) + " km²" |
|
: e >= 1e4 && -1 !== n.indexOf("ha") |
|
? L.GeometryUtil.formattedNumber(1e-4 * e, o.ha) + " ha" |
|
: L.GeometryUtil.formattedNumber(e, o.m) + " m²")) |
|
: ((e /= 0.836127), |
|
(a = 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²")), |
|
a |
|
); |
|
}, |
|
readableDistance: function (e, i, o, a, n) { |
|
var s, |
|
n = L.Util.extend({}, t, n); |
|
switch (i ? ("string" == typeof i ? i : "metric") : o ? "feet" : a ? "nauticalMile" : "yards") { |
|
case "metric": |
|
s = e > 1e3 ? L.GeometryUtil.formattedNumber(e / 1e3, n.km) + " km" : L.GeometryUtil.formattedNumber(e, n.m) + " m"; |
|
break; |
|
case "feet": |
|
(e *= 3.28083), (s = L.GeometryUtil.formattedNumber(e, n.ft) + " ft"); |
|
break; |
|
case "nauticalMile": |
|
(e *= 0.53996), (s = L.GeometryUtil.formattedNumber(e / 1e3, n.nm) + " nm"); |
|
break; |
|
case "yards": |
|
default: |
|
(e *= 1.09361), (s = e > 1760 ? L.GeometryUtil.formattedNumber(e / 1760, n.mi) + " miles" : L.GeometryUtil.formattedNumber(e, n.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(), |
|
a = o ? o.length : 0; |
|
if (this._tooFewPointsForIntersection()) return !1; |
|
for (t = a - 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, |
|
a = i ? i[o - 1] : null, |
|
n = o - 2; |
|
return !this._tooFewPointsForIntersection(1) && this._lineSegmentsIntersectsRange(a, t, n, 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 a, |
|
n, |
|
s = this._getProjectedPoints(); |
|
o = o || 0; |
|
for (var r = i; r > o; r--) if (((a = s[r - 1]), (n = s[r]), L.LineUtil.segmentsIntersect(t, e, a, n))) 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, |
|
a = this._getProjectedPoints(); |
|
return !this._tooFewPointsForIntersection() && (!!L.Polyline.prototype.intersects.call(this) || ((t = a.length), (e = a[0]), (i = a[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 a in this._toolbars) |
|
this._toolbars.hasOwnProperty(a) && |
|
(e = this._toolbars[a].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, |
|
a = this._toolbarClass || "", |
|
n = this.getModeHandlers(t); |
|
for (this._toolbarContainer = L.DomUtil.create("div", "leaflet-draw-toolbar leaflet-bar"), this._map = t, e = 0; e < n.length; e++) |
|
n[e].enabled && this._initModeHandler(n[e].handler, this._toolbarContainer, o++, a, n[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, a) { |
|
var n = t.type; |
|
(this._modes[n] = {}), |
|
(this._modes[n].handler = t), |
|
(this._modes[n].button = this._createButton({ type: n, title: a, className: o + "-" + n, container: e, callback: this._modes[n].handler.enable, context: this._modes[n].handler })), |
|
(this._modes[n].buttonIndex = i), |
|
this._modes[n].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, |
|
a, |
|
n = 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 = []; n.firstChild; ) n.removeChild(n.firstChild); |
|
for (var l = 0; l < r; l++) |
|
("enabled" in s[l] && !s[l].enabled) || |
|
((e = L.DomUtil.create("li", "", n)), |
|
(a = this._createButton({ title: s[l].title, text: s[l].text, container: e, callback: s[l].callback, context: s[l].context })), |
|
this._actionButtons.push({ button: a, 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);
|
|
|