leaflet-js 0.7.9 → 0.8.dev2

data/lib/leaflet/src/layer/Layer.Popup.js

@@ -0,0 +1,87 @@
+/*
+ * Adds popup-related methods to all layers.
+ */
+
+L.Layer.include({
+
+	bindPopup: function (content, options) {
+
+		if (content instanceof L.Popup) {
+			this._popup = content;
+			content._source = this;
+		} else {
+			if (!this._popup || options) {
+				this._popup = new L.Popup(options, this);
+			}
+			this._popup.setContent(content);
+		}
+
+		if (!this._popupHandlersAdded) {
+			this.on({
+				click: this._openPopup,
+				remove: this.closePopup,
+				move: this._movePopup
+			});
+			this._popupHandlersAdded = true;
+		}
+
+		return this;
+	},
+
+	unbindPopup: function () {
+		if (this._popup) {
+			this.on({
+			    click: this._openPopup,
+			    remove: this.closePopup,
+			    move: this._movePopup
+			});
+			this._popupHandlersAdded = false;
+			this._popup = null;
+		}
+		return this;
+	},
+
+	openPopup: function (latlng) {
+		if (this._popup && this._map) {
+			this._map.openPopup(this._popup, latlng || this._latlng || this.getCenter());
+		}
+		return this;
+	},
+
+	closePopup: function () {
+		if (this._popup) {
+			this._popup._close();
+		}
+		return this;
+	},
+
+	togglePopup: function () {
+		if (this._popup) {
+			if (this._popup._map) {
+				this.closePopup();
+			} else {
+				this.openPopup();
+			}
+		}
+		return this;
+	},
+
+	setPopupContent: function (content) {
+		if (this._popup) {
+			this._popup.setContent(content);
+		}
+		return this;
+	},
+
+	getPopup: function () {
+		return this._popup;
+	},
+
+	_openPopup: function (e) {
+		this._map.openPopup(this._popup, e.latlng);
+	},
+
+	_movePopup: function (e) {
+		this._popup.setLatLng(e.latlng);
+	}
+});

data/lib/leaflet/src/layer/Layer.js

@@ -0,0 +1,150 @@
+
+L.Layer = L.Evented.extend({
+
+	options: {
+		pane: 'overlayPane'
+	},
+
+	addTo: function (map) {
+		var id = L.stamp(this);
+		if (map._layers[id]) { return this; }
+		map._layers[id] = this;
+
+		this._zoomAnimated = map._zoomAnimated;
+
+		if (this.beforeAdd) {
+			this.beforeAdd(map);
+		}
+
+		this._mapToAdd = map;
+		map.whenReady(this._layerAdd, this);
+
+		return this;
+	},
+
+	_layerAdd: function () {
+		var map = this._mapToAdd;
+
+		// check in case layer gets added and then removed before the map is ready
+		if (!map) { return; }
+
+		this._map = map;
+		this._mapToAdd = null;
+
+		this.onAdd(map);
+
+		if (this.getAttribution && this._map.attributionControl) {
+			this._map.attributionControl.addAttribution(this.getAttribution());
+		}
+
+		if (this.getEvents) {
+			map.on(this.getEvents(), this);
+		}
+
+		this.fire('add');
+		map.fire('layeradd', {layer: this});
+	},
+
+	remove: function () {
+
+		var id = L.stamp(this),
+		    map = this._map || this._mapToAdd;
+
+		if (!map || !map._layers[id]) { return this; }
+
+		if (map._loaded) {
+			this.onRemove(map);
+		}
+
+		if (this.getAttribution && this._map.attributionControl) {
+			this._map.attributionControl.removeAttribution(this.getAttribution());
+		}
+
+		if (this.getEvents) {
+			map.off(this.getEvents(), this);
+		}
+
+		delete map._layers[id];
+
+		if (map._loaded) {
+			map.fire('layerremove', {layer: this});
+			this.fire('remove');
+		}
+
+		this._map = this._mapToAdd = null;
+
+		return this;
+	},
+
+	getPane: function (name) {
+		return this._map.getPane(name ? (this.options[name] || name) : this.options.pane);
+	}
+});
+
+
+L.Map.include({
+	addLayer: function (layer) {
+		layer.addTo(this);
+		return this;
+	},
+
+	removeLayer: function (layer) {
+		layer.remove();
+		return this;
+	},
+
+	hasLayer: function (layer) {
+		return !!layer && (L.stamp(layer) in this._layers);
+	},
+
+	eachLayer: function (method, context) {
+		for (var i in this._layers) {
+			method.call(context, this._layers[i]);
+		}
+		return this;
+	},
+
+	_addLayers: function (layers) {
+		layers = layers ? (L.Util.isArray(layers) ? layers : [layers]) : [];
+
+		for (var i = 0, len = layers.length; i < len; i++) {
+			this.addLayer(layers[i]);
+		}
+	},
+
+	_addZoomLimit: function (layer) {
+		if (isNaN(layer.options.maxZoom) || !isNaN(layer.options.minZoom)) {
+			this._zoomBoundLayers[L.stamp(layer)] = layer;
+			this._updateZoomLevels();
+		}
+	},
+
+	_removeZoomLimit: function (layer) {
+		var id = L.stamp(layer);
+
+		if (this._zoomBoundLayers[id]) {
+			delete this._zoomBoundLayers[id];
+			this._updateZoomLevels();
+		}
+	},
+
+	_updateZoomLevels: function () {
+		var minZoom = Infinity,
+			maxZoom = -Infinity,
+			oldZoomSpan = this._getZoomSpan();
+
+		for (var i in this._zoomBoundLayers) {
+			var options = this._zoomBoundLayers[i].options;
+
+			minZoom = options.minZoom === undefined ? minZoom : Math.min(minZoom, options.minZoom);
+			maxZoom = options.maxZoom === undefined ? maxZoom : Math.max(maxZoom, options.maxZoom);
+		}
+
+		this._layersMaxZoom = maxZoom === -Infinity ? undefined : maxZoom;
+		this._layersMinZoom = minZoom === Infinity ? undefined : minZoom;
+
+		if (oldZoomSpan !== this._getZoomSpan()) {
+			this.fire('zoomlevelschange');
+		}
+	}
+});

data/{vendor/assets/Leaflet → lib/leaflet}/src/layer/LayerGroup.js

@@ -3,7 +3,8 @@
  * you can manipulate the group (e.g. add/remove it) as one layer.
  */
 
-L.LayerGroup = L.Class.extend({
+L.LayerGroup = L.Layer.extend({
+
 	initialize: function (layers) {
 		this._layers = {};
 
@@ -41,13 +42,13 @@ L.LayerGroup = L.Class.extend({
 	},
 
 	hasLayer: function (layer) {
-		if (!layer) { return false; }
-
-		return (layer in this._layers || this.getLayerId(layer) in this._layers);
+		return !!layer && (layer in this._layers || this.getLayerId(layer) in this._layers);
 	},
 
 	clearLayers: function () {
-		this.eachLayer(this.removeLayer, this);
+		for (var i in this._layers) {
+			this.removeLayer(this._layers[i]);
+		}
 		return this;
 	},
 
@@ -67,18 +68,15 @@ L.LayerGroup = L.Class.extend({
 	},
 
 	onAdd: function (map) {
-		this._map = map;
-		this.eachLayer(map.addLayer, map);
+		for (var i in this._layers) {
+			map.addLayer(this._layers[i]);
+		}
 	},
 
 	onRemove: function (map) {
-		this.eachLayer(map.removeLayer, map);
-		this._map = null;
-	},
-
-	addTo: function (map) {
-		map.addLayer(this);
-		return this;
+		for (var i in this._layers) {
+			map.removeLayer(this._layers[i]);
+		}
 	},
 
 	eachLayer: function (method, context) {

data/{vendor/assets/Leaflet → lib/leaflet}/src/layer/Popup.js

@@ -6,21 +6,24 @@ L.Map.mergeOptions({
 	closePopupOnClick: true
 });
 
-L.Popup = L.Class.extend({
-	includes: L.Mixin.Events,
+L.Popup = L.Layer.extend({
 
 	options: {
+		pane: 'popupPane',
+
 		minWidth: 50,
 		maxWidth: 300,
-		// maxHeight: null,
-		autoPan: true,
-		closeButton: true,
+		// maxHeight: <Number>,
 		offset: [0, 7],
+
+		autoPan: true,
 		autoPanPadding: [5, 5],
-		// autoPanPaddingTopLeft: null,
-		// autoPanPaddingBottomRight: null,
-		keepInView: false,
-		className: '',
+		// autoPanPaddingTopLeft: <Point>,
+		// autoPanPaddingBottomRight: <Point>,
+
+		closeButton: true,
+		// keepInView: false,
+		// className: '',
 		zoomAnimation: true
 	},
 
@@ -28,70 +31,51 @@ L.Popup = L.Class.extend({
 		L.setOptions(this, options);
 
 		this._source = source;
-		this._animated = L.Browser.any3d && this.options.zoomAnimation;
-		this._isOpen = false;
 	},
 
 	onAdd: function (map) {
-		this._map = map;
+		this._zoomAnimated = this._zoomAnimated && this.options.zoomAnimation;
 
 		if (!this._container) {
 			this._initLayout();
 		}
 
-		var animFade = map.options.fadeAnimation;
-
-		if (animFade) {
+		if (map._fadeAnimated) {
 			L.DomUtil.setOpacity(this._container, 0);
 		}
-		map._panes.popupPane.appendChild(this._container);
-
-		map.on(this._getEvents(), this);
 
+		clearTimeout(this._removeTimeout);
+		this.getPane().appendChild(this._container);
 		this.update();
 
-		if (animFade) {
+		if (map._fadeAnimated) {
 			L.DomUtil.setOpacity(this._container, 1);
 		}
 
-		this.fire('open');
-
 		map.fire('popupopen', {popup: this});
 
 		if (this._source) {
-			this._source.fire('popupopen', {popup: this});
+			this._source.fire('popupopen', {popup: this}, true);
 		}
 	},
 
-	addTo: function (map) {
-		map.addLayer(this);
-		return this;
-	},
-
 	openOn: function (map) {
 		map.openPopup(this);
 		return this;
 	},
 
 	onRemove: function (map) {
-		map._panes.popupPane.removeChild(this._container);
-
-		L.Util.falseFn(this._container.offsetWidth); // force reflow
-
-		map.off(this._getEvents(), this);
-
-		if (map.options.fadeAnimation) {
+		if (map._fadeAnimated) {
 			L.DomUtil.setOpacity(this._container, 0);
+			this._removeTimeout = setTimeout(L.bind(L.DomUtil.remove, L.DomUtil, this._container), 200);
+		} else {
+			L.DomUtil.remove(this._container);
 		}
 
-		this._map = null;
-
-		this.fire('close');
-
 		map.fire('popupclose', {popup: this});
 
 		if (this._source) {
-			this._source.fire('popupclose', {popup: this});
+			this._source.fire('popupclose', {popup: this}, true);
 		}
 	},
 
@@ -132,21 +116,19 @@ L.Popup = L.Class.extend({
 		this._adjustPan();
 	},
 
-	_getEvents: function () {
-		var events = {
-			viewreset: this._updatePosition
-		};
+	getEvents: function () {
+		var events = {viewreset: this._updatePosition},
+		    options = this.options;
 
-		if (this._animated) {
-			events.zoomanim = this._zoomAnimation;
+		if (this._zoomAnimated) {
+			events.zoomanim = this._animateZoom;
 		}
-		if ('closeOnClick' in this.options ? this.options.closeOnClick : this._map.options.closePopupOnClick) {
+		if ('closeOnClick' in options ? options.closeOnClick : this._map.options.closePopupOnClick) {
 			events.preclick = this._close;
 		}
-		if (this.options.keepInView) {
+		if (options.keepInView) {
 			events.moveend = this._adjustPan;
 		}
-
 		return events;
 	},
 
@@ -158,29 +140,25 @@ L.Popup = L.Class.extend({
 
 	_initLayout: function () {
 		var prefix = 'leaflet-popup',
-			containerClass = prefix + ' ' + this.options.className + ' leaflet-zoom-' +
-			        (this._animated ? 'animated' : 'hide'),
-			container = this._container = L.DomUtil.create('div', containerClass),
-			closeButton;
+		    container = this._container = L.DomUtil.create('div',
+			prefix + ' ' + (this.options.className || '') +
+			' leaflet-zoom-' + (this._zoomAnimated ? 'animated' : 'hide'));
 
 		if (this.options.closeButton) {
-			closeButton = this._closeButton =
-			        L.DomUtil.create('a', prefix + '-close-button', container);
+			var closeButton = this._closeButton = L.DomUtil.create('a', prefix + '-close-button', container);
 			closeButton.href = '#close';
 			closeButton.innerHTML = '&#215;';
-			L.DomEvent.disableClickPropagation(closeButton);
 
 			L.DomEvent.on(closeButton, 'click', this._onCloseButtonClick, this);
 		}
 
-		var wrapper = this._wrapper =
-		        L.DomUtil.create('div', prefix + '-content-wrapper', container);
-		L.DomEvent.disableClickPropagation(wrapper);
-
+		var wrapper = this._wrapper = L.DomUtil.create('div', prefix + '-content-wrapper', container);
 		this._contentNode = L.DomUtil.create('div', prefix + '-content', wrapper);
 
-		L.DomEvent.disableScrollPropagation(this._contentNode);
-		L.DomEvent.on(wrapper, 'contextmenu', L.DomEvent.stopPropagation);
+		L.DomEvent
+			.disableClickPropagation(wrapper)
+			.disableScrollPropagation(this._contentNode)
+			.on(wrapper, 'contextmenu', L.DomEvent.stopPropagation);
 
 		this._tipContainer = L.DomUtil.create('div', prefix + '-tip-container', container);
 		this._tip = L.DomUtil.create('div', prefix + '-tip', this._tipContainer);
@@ -189,13 +167,15 @@ L.Popup = L.Class.extend({
 	_updateContent: function () {
 		if (!this._content) { return; }
 
+		var node = this._contentNode;
+
 		if (typeof this._content === 'string') {
-			this._contentNode.innerHTML = this._content;
+			node.innerHTML = this._content;
 		} else {
-			while (this._contentNode.hasChildNodes()) {
-				this._contentNode.removeChild(this._contentNode.firstChild);
+			while (node.hasChildNodes()) {
+				node.removeChild(node.firstChild);
 			}
-			this._contentNode.appendChild(this._content);
+			node.appendChild(this._content);
 		}
 		this.fire('contentupdate');
 	},
@@ -234,24 +214,24 @@ L.Popup = L.Class.extend({
 		if (!this._map) { return; }
 
 		var pos = this._map.latLngToLayerPoint(this._latlng),
-		    animated = this._animated,
 		    offset = L.point(this.options.offset);
 
-		if (animated) {
+		if (this._zoomAnimated) {
 			L.DomUtil.setPosition(this._container, pos);
+		} else {
+			offset = offset.add(pos);
 		}
 
-		this._containerBottom = -offset.y - (animated ? 0 : pos.y);
-		this._containerLeft = -Math.round(this._containerWidth / 2) + offset.x + (animated ? 0 : pos.x);
+		var bottom = this._containerBottom = -offset.y,
+		    left = this._containerLeft = -Math.round(this._containerWidth / 2) + offset.x;
 
 		// bottom position the popup in case the height of the popup changes (images loading etc)
-		this._container.style.bottom = this._containerBottom + 'px';
-		this._container.style.left = this._containerLeft + 'px';
+		this._container.style.bottom = bottom + 'px';
+		this._container.style.left = left + 'px';
 	},
 
-	_zoomAnimation: function (opt) {
-		var pos = this._map._latLngToNewLayerPoint(this._latlng, opt.zoom, opt.center);
-
+	_animateZoom: function (e) {
+		var pos = this._map._latLngToNewLayerPoint(this._latlng, e.zoom, e.center);
 		L.DomUtil.setPosition(this._container, pos);
 	},
 
@@ -261,10 +241,9 @@ L.Popup = L.Class.extend({
 		var map = this._map,
 		    containerHeight = this._container.offsetHeight,
 		    containerWidth = this._containerWidth,
-
 		    layerPos = new L.Point(this._containerLeft, -containerHeight - this._containerBottom);
 
-		if (this._animated) {
+		if (this._zoomAnimated) {
 			layerPos._add(L.DomUtil.getPosition(this._container));
 		}
 
@@ -309,17 +288,21 @@ L.popup = function (options, source) {
 
 L.Map.include({
 	openPopup: function (popup, latlng, options) { // (Popup) or (String || HTMLElement, LatLng[, Object])
-		this.closePopup();
-
 		if (!(popup instanceof L.Popup)) {
 			var content = popup;
 
-			popup = new L.Popup(options)
-			    .setLatLng(latlng)
-			    .setContent(content);
+			popup = new L.Popup(options).setContent(content);
+		}
+
+		if (latlng) {
+			popup.setLatLng(latlng);
+		}
+
+		if (this.hasLayer(popup)) {
+			return this;
 		}
-		popup._isOpen = true;
 
+		this.closePopup();
 		this._popup = popup;
 		return this.addLayer(popup);
 	},
@@ -331,7 +314,6 @@ L.Map.include({
 		}
 		if (popup) {
 			this.removeLayer(popup);
-			popup._isOpen = false;
 		}
 		return this;
 	}