ebf3554754
* added static map field * leaflet draw plugin added to map control * Editable layer working no icons * Save and load data in form field * images and icons working * Locate plugin added, and loads on geolocation * organized map control code * loads layer as per form * new form clears editableLayers * update: leaflet 1.2.0 and leaflet-draw 0.4.2 * changed to ERPNext colors * Multiple map fields and fixes * fixes codacy suggestions * loaded geojson data editable * Map layers editable * add only one layer on draw:create * code organized with helper functions * Replaced Leaflet Draw with Leaflet Editable * read values from database * layers saved in db * Using Patched Leaflet Draw (mobile-friendly) * Working Map field with multiple forms open * Leaflet Draw css image path fix * Leaflet Draw Fixes Leaflet draw css image paths Fixes Circle marker and Circle * locate to geolocation or set featurecollection as center * [fix] leaflet fitBounds padding 50,50 * [Fix] Leaflet (auto) locate * Map field basic test * added refresh button on map * Mute map geojson in print format * renamed Map field to Geolocation * Suggested changes and fixes * eslint disable * csslint allow important
1702 lines
77 KiB
JavaScript
1702 lines
77 KiB
JavaScript
/*
|
|
Leaflet.draw 0.4.12, 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.12", 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 = 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 version = L.version.split(".");
|
|
if(parseInt(version[0],10) === 1 && parseInt(version[1],10) >= 2 ) {
|
|
L.Draw.Feature.include(L.Evented.prototype);
|
|
} else {
|
|
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: .5,
|
|
fill: !1,
|
|
clickable: !0
|
|
},
|
|
metric: !0,
|
|
feet: !0,
|
|
nautic: !1,
|
|
showLength: !0,
|
|
zIndexOffset: 2e3,
|
|
factor: 1
|
|
},
|
|
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);
|
|
this._calculateFinishDistance(o.latlng) < 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 L.Browser.touch && (i = !1), 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 = 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 = 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: .5,
|
|
fill: !0,
|
|
fillColor: null,
|
|
fillOpacity: .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))
|
|
},
|
|
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), 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: .5,
|
|
fill: !0,
|
|
fillColor: null,
|
|
fillOpacity: .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._marker && (this._marker.off("click", this._onClick, this), this._map.off("click", this._onClick, this).off("click", this._onTouch, this).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: .5,
|
|
fill: !0,
|
|
fillColor: null,
|
|
fillOpacity: .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: .5,
|
|
fill: !0,
|
|
fillColor: null,
|
|
fillOpacity: .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) {
|
|
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({
|
|
options: {},
|
|
initialize: function(t, e) {
|
|
this.latlngs = [t._latlngs], t._holes && (this.latlngs = this.latlngs.concat(t._holes)), this._poly = t, L.setOptions(this, e), 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.options))
|
|
},
|
|
_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;
|
|
t instanceof L.Polygon || (t.options.fill = !1, t.options.editing && (t.options.editing.fill = !1)), 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;
|
|
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), 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.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())
|
|
},
|
|
_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(.6), 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), 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)
|
|
},
|
|
_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.poly), 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(),
|
|
i = this._map.distance(e, t);
|
|
this._shape.setRadius(i), 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 /= .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 *= .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
|
|
}
|
|
})
|
|
}(), 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 version = L.version.split(".");
|
|
if (parseInt(version[0],10) === 1 && parseInt(version[1],10) >= 2 ) {
|
|
L.Toolbar.include(L.Evented.prototype);
|
|
} else {
|
|
L.Toolbar.include(L.Mixin.Events);
|
|
}
|
|
},
|
|
enabled: function() {
|
|
return this._activeMode !== null;
|
|
},
|
|
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"
|
|
},
|
|
_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")
|
|
}
|
|
}), 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: .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 version = L.version.split(".");
|
|
if(parseInt(version[0],10) === 1 && parseInt(version[1],10) >= 2 ) {
|
|
L.EditToolbar.Edit.include(L.Evented.prototype);
|
|
} else {
|
|
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 version = L.version.split(".");
|
|
if(parseInt(version[0],10) === 1 && parseInt(version[1],10) >= 2 ) {
|
|
L.EditToolbar.Delete.include(L.Evented.prototype);
|
|
} else {
|
|
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);
|