leaflet-js 0.7.9 → 0.8.dev2

data/lib/leaflet/spec/suites/map/handler/Map.DragSpec.js

@@ -0,0 +1,38 @@
+describe("Map.Drag", function () {
+	describe("#addHook", function () {
+		it("calls the map with dragging enabled", function () {
+			var container = document.createElement('div'),
+				map = new L.Map(container, {
+					dragging: true
+				});
+
+			expect(map.dragging.enabled()).to.be(true);
+			map.setView([0, 0], 0);
+			expect(map.dragging.enabled()).to.be(true);
+		});
+		it("calls the map with dragging and worldCopyJump enabled", function () {
+			var container = document.createElement('div'),
+				map = new L.Map(container, {
+					dragging: true,
+					worldCopyJump: true
+				});
+
+			expect(map.dragging.enabled()).to.be(true);
+			map.setView([0, 0], 0);
+			expect(map.dragging.enabled()).to.be(true);
+		});
+		it("calls the map with dragging disabled and worldCopyJump enabled; " +
+				"enables dragging after setting center and zoom", function () {
+			var container = document.createElement('div'),
+				map = new L.Map(container, {
+					dragging: false,
+					worldCopyJump: true
+				});
+
+			expect(map.dragging.enabled()).to.be(false);
+			map.setView([0, 0], 0);
+			map.dragging.enable();
+			expect(map.dragging.enabled()).to.be(true);
+		});
+	});
+});

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

@@ -1,8 +1,18 @@
 
-var oldL = window.L,
-    L = {};
+var L = {
+	version: '0.8-dev'
+};
+
+function expose() {
+	var oldL = window.L;
 
-L.version = '0.7.7';
+	L.noConflict = function () {
+		window.L = oldL;
+		return this;
+	};
+
+	window.L = L;
+}
 
 // define Leaflet for Node module pattern loaders, including Browserify
 if (typeof module === 'object' && typeof module.exports === 'object') {
@@ -11,13 +21,8 @@ if (typeof module === 'object' && typeof module.exports === 'object') {
 // define Leaflet as an AMD module
 } else if (typeof define === 'function' && define.amd) {
 	define(L);
-}
 
 // define Leaflet as a global L variable, saving the original L to restore later if needed
-
-L.noConflict = function () {
-	window.L = oldL;
-	return this;
-};
-
-window.L = L;
+} else {
+	expose();
+}

data/{vendor/assets/Leaflet → lib/leaflet}/src/control/Control.Attribution.js

@@ -18,28 +18,18 @@ L.Control.Attribution = L.Control.extend({
 		this._container = L.DomUtil.create('div', 'leaflet-control-attribution');
 		L.DomEvent.disableClickPropagation(this._container);
 
+		// TODO ugly, refactor
 		for (var i in map._layers) {
 			if (map._layers[i].getAttribution) {
 				this.addAttribution(map._layers[i].getAttribution());
 			}
 		}
-		
-		map
-		    .on('layeradd', this._onLayerAdd, this)
-		    .on('layerremove', this._onLayerRemove, this);
 
 		this._update();
 
 		return this._container;
 	},
 
-	onRemove: function (map) {
-		map
-		    .off('layeradd', this._onLayerAdd)
-		    .off('layerremove', this._onLayerRemove);
-
-	},
-
 	setPrefix: function (prefix) {
 		this.options.prefix = prefix;
 		this._update();
@@ -91,18 +81,6 @@ L.Control.Attribution = L.Control.extend({
 		}
 
 		this._container.innerHTML = prefixAndAttribs.join(' | ');
-	},
-
-	_onLayerAdd: function (e) {
-		if (e.layer.getAttribution) {
-			this.addAttribution(e.layer.getAttribution());
-		}
-	},
-
-	_onLayerRemove: function (e) {
-		if (e.layer.getAttribution) {
-			this.removeAttribution(e.layer.getAttribution());
-		}
 	}
 });
 

data/{vendor/assets/Leaflet → lib/leaflet}/src/control/Control.Layers.js

@@ -25,47 +25,35 @@ L.Control.Layers = L.Control.extend({
 		}
 	},
 
-	onAdd: function (map) {
+	onAdd: function () {
 		this._initLayout();
 		this._update();
 
-		map
-		    .on('layeradd', this._onLayerChange, this)
-		    .on('layerremove', this._onLayerChange, this);
-
 		return this._container;
 	},
 
-	onRemove: function (map) {
-		map
-		    .off('layeradd', this._onLayerChange, this)
-		    .off('layerremove', this._onLayerChange, this);
-	},
-
 	addBaseLayer: function (layer, name) {
 		this._addLayer(layer, name);
-		this._update();
-		return this;
+		return this._update();
 	},
 
 	addOverlay: function (layer, name) {
 		this._addLayer(layer, name, true);
-		this._update();
-		return this;
+		return this._update();
 	},
 
 	removeLayer: function (layer) {
-		var id = L.stamp(layer);
-		delete this._layers[id];
-		this._update();
-		return this;
+		layer.off('add remove', this._onLayerChange, this);
+
+		delete this._layers[L.stamp(layer)];
+		return this._update();
 	},
 
 	_initLayout: function () {
 		var className = 'leaflet-control-layers',
 		    container = this._container = L.DomUtil.create('div', className);
 
-		//Makes this work on IE10 Touch devices by stopping it from firing a mouseout event when the touch is released
+		// makes this work on IE touch devices by stopping it from firing a mouseout event when the touch is released
 		container.setAttribute('aria-haspopup', true);
 
 		if (!L.Browser.touch) {
@@ -80,10 +68,12 @@ L.Control.Layers = L.Control.extend({
 
 		if (this.options.collapsed) {
 			if (!L.Browser.android) {
-				L.DomEvent
-				    .on(container, 'mouseover', this._expand, this)
-				    .on(container, 'mouseout', this._collapse, this);
+				L.DomEvent.on(container, {
+					mouseover: this._expand,
+				    mouseout: this._collapse
+				}, this);
 			}
+
 			var link = this._layersLink = L.DomUtil.create('a', className + '-toggle', container);
 			link.href = '#';
 			link.title = 'Layers';
@@ -92,11 +82,11 @@ L.Control.Layers = L.Control.extend({
 				L.DomEvent
 				    .on(link, 'click', L.DomEvent.stop)
 				    .on(link, 'click', this._expand, this);
-			}
-			else {
+			} else {
 				L.DomEvent.on(link, 'focus', this._expand, this);
 			}
-			//Work around for Firefox android issue https://github.com/Leaflet/Leaflet/issues/2033
+
+			// work around for Firefox Android issue https://github.com/Leaflet/Leaflet/issues/2033
 			L.DomEvent.on(form, 'click', function () {
 				setTimeout(L.bind(this._onInputClick, this), 0);
 			}, this);
@@ -115,6 +105,8 @@ L.Control.Layers = L.Control.extend({
 	},
 
 	_addLayer: function (layer, name, overlay) {
+		layer.on('add remove', this._onLayerChange, this);
+
 		var id = L.stamp(layer);
 
 		this._layers[id] = {
@@ -130,16 +122,12 @@ L.Control.Layers = L.Control.extend({
 	},
 
 	_update: function () {
-		if (!this._container) {
-			return;
-		}
+		if (!this._container) { return; }
 
 		this._baseLayersList.innerHTML = '';
 		this._overlaysList.innerHTML = '';
 
-		var baseLayersPresent = false,
-		    overlaysPresent = false,
-		    i, obj;
+		var baseLayersPresent, overlaysPresent, i, obj;
 
 		for (i in this._layers) {
 			obj = this._layers[i];
@@ -149,34 +137,31 @@ L.Control.Layers = L.Control.extend({
 		}
 
 		this._separator.style.display = overlaysPresent && baseLayersPresent ? '' : 'none';
+
+		return this;
 	},
 
 	_onLayerChange: function (e) {
-		var obj = this._layers[L.stamp(e.layer)];
-
-		if (!obj) { return; }
-
 		if (!this._handlingClick) {
 			this._update();
 		}
 
-		var type = obj.overlay ?
-			(e.type === 'layeradd' ? 'overlayadd' : 'overlayremove') :
-			(e.type === 'layeradd' ? 'baselayerchange' : null);
+		var overlay = this._layers[L.stamp(e.target)].overlay;
+
+		var type = overlay ?
+			(e.type === 'add' ? 'overlayadd' : 'overlayremove') :
+			(e.type === 'add' ? 'baselayerchange' : null);
 
 		if (type) {
-			this._map.fire(type, obj);
+			this._map.fire(type, e.target);
 		}
 	},
 
 	// IE7 bugs out if you create a radio dynamically, so you have to do it this hacky way (see http://bit.ly/PqYLBe)
 	_createRadioElement: function (name, checked) {
 
-		var radioHtml = '<input type="radio" class="leaflet-control-layers-selector" name="' + name + '"';
-		if (checked) {
-			radioHtml += ' checked="checked"';
-		}
-		radioHtml += '/>';
+		var radioHtml = '<input type="radio" class="leaflet-control-layers-selector" name="' +
+				name + '"' + (checked ? ' checked="checked"' : '') + '/>';
 
 		var radioFragment = document.createElement('div');
 		radioFragment.innerHTML = radioHtml;
@@ -186,8 +171,8 @@ L.Control.Layers = L.Control.extend({
 
 	_addItem: function (obj) {
 		var label = document.createElement('label'),
-		    input,
-		    checked = this._map.hasLayer(obj.layer);
+		    checked = this._map.hasLayer(obj.layer),
+		    input;
 
 		if (obj.overlay) {
 			input = document.createElement('input');
@@ -215,21 +200,21 @@ L.Control.Layers = L.Control.extend({
 	},
 
 	_onInputClick: function () {
-		var i, input, obj,
-		    inputs = this._form.getElementsByTagName('input'),
-		    inputsLen = inputs.length;
+		var inputs = this._form.getElementsByTagName('input'),
+		    input, layer, hasLayer;
 
 		this._handlingClick = true;
 
-		for (i = 0; i < inputsLen; i++) {
+		for (var i = 0, len = inputs.length; i < len; i++) {
 			input = inputs[i];
-			obj = this._layers[input.layerId];
+			layer = this._layers[input.layerId].layer;
+			hasLayer = this._map.hasLayer(layer);
 
-			if (input.checked && !this._map.hasLayer(obj.layer)) {
-				this._map.addLayer(obj.layer);
+			if (input.checked && !hasLayer) {
+				this._map.addLayer(layer);
 
-			} else if (!input.checked && this._map.hasLayer(obj.layer)) {
-				this._map.removeLayer(obj.layer);
+			} else if (!input.checked && hasLayer) {
+				this._map.removeLayer(layer);
 			}
 		}
 
@@ -243,7 +228,7 @@ L.Control.Layers = L.Control.extend({
 	},
 
 	_collapse: function () {
-		this._container.className = this._container.className.replace(' leaflet-control-layers-expanded', '');
+		L.DomUtil.removeClass(this._container, 'leaflet-control-layers-expanded');
 	}
 });
 

data/lib/leaflet/src/control/Control.Scale.js

@@ -0,0 +1,102 @@
+/*
+ * L.Control.Scale is used for displaying metric/imperial scale on the map.
+ */
+
+L.Control.Scale = L.Control.extend({
+	options: {
+		position: 'bottomleft',
+		maxWidth: 100,
+		metric: true,
+		imperial: true
+		// updateWhenIdle: false
+	},
+
+	onAdd: function (map) {
+		var className = 'leaflet-control-scale',
+		    container = L.DomUtil.create('div', className),
+		    options = this.options;
+
+		this._addScales(options, className + '-line', container);
+
+		map.on(options.updateWhenIdle ? 'moveend' : 'move', this._update, this);
+		map.whenReady(this._update, this);
+
+		return container;
+	},
+
+	onRemove: function (map) {
+		map.off(this.options.updateWhenIdle ? 'moveend' : 'move', this._update, this);
+	},
+
+	_addScales: function (options, className, container) {
+		if (options.metric) {
+			this._mScale = L.DomUtil.create('div', className, container);
+		}
+		if (options.imperial) {
+			this._iScale = L.DomUtil.create('div', className, container);
+		}
+	},
+
+	_update: function () {
+		var map = this._map,
+		    y = map.getSize().y / 2;
+
+		var maxMeters = L.CRS.Earth.distance(
+				map.containerPointToLatLng([0, y]),
+				map.containerPointToLatLng([this.options.maxWidth, y]));
+
+		this._updateScales(maxMeters);
+	},
+
+	_updateScales: function (maxMeters) {
+		if (this.options.metric && maxMeters) {
+			this._updateMetric(maxMeters);
+		}
+		if (this.options.imperial && maxMeters) {
+			this._updateImperial(maxMeters);
+		}
+	},
+
+	_updateMetric: function (maxMeters) {
+		var meters = this._getRoundNum(maxMeters),
+		    label = meters < 1000 ? meters + ' m' : (meters / 1000) + ' km';
+
+		this._updateScale(this._mScale, label, meters / maxMeters);
+	},
+
+	_updateImperial: function (maxMeters) {
+		var maxFeet = maxMeters * 3.2808399,
+		    maxMiles, miles, feet;
+
+		if (maxFeet > 5280) {
+			maxMiles = maxFeet / 5280;
+			miles = this._getRoundNum(maxMiles);
+			this._updateScale(this._iScale, miles + ' mi', miles / maxMiles);
+
+		} else {
+			feet = this._getRoundNum(maxFeet);
+			this._updateScale(this._iScale, feet + ' ft', feet / maxFeet);
+		}
+	},
+
+	_updateScale: function (scale, text, ratio) {
+		scale.style.width = (Math.round(this.options.maxWidth * ratio) - 10) + 'px';
+		scale.innerHTML = text;
+	},
+
+	_getRoundNum: function (num) {
+		var pow10 = Math.pow(10, (Math.floor(num) + '').length - 1),
+		    d = num / pow10;
+
+		d = d >= 10 ? 10 :
+		    d >= 5 ? 5 :
+		    d >= 3 ? 3 :
+		    d >= 2 ? 2 : 1;
+
+		return pow10 * d;
+	}
+});
+
+L.control.scale = function (options) {
+	return new L.Control.Scale(options);
+};

data/{vendor/assets/Leaflet → lib/leaflet}/src/control/Control.Zoom.js

@@ -13,16 +13,13 @@ L.Control.Zoom = L.Control.extend({
 
 	onAdd: function (map) {
 		var zoomName = 'leaflet-control-zoom',
-		    container = L.DomUtil.create('div', zoomName + ' leaflet-bar');
+		    container = L.DomUtil.create('div', zoomName + ' leaflet-bar'),
+		    options = this.options;
 
-		this._map = map;
-
-		this._zoomInButton  = this._createButton(
-		        this.options.zoomInText, this.options.zoomInTitle,
-		        zoomName + '-in',  container, this._zoomIn,  this);
-		this._zoomOutButton = this._createButton(
-		        this.options.zoomOutText, this.options.zoomOutTitle,
-		        zoomName + '-out', container, this._zoomOut, this);
+		this._zoomInButton  = this._createButton(options.zoomInText, options.zoomInTitle,
+		        zoomName + '-in',  container, this._zoomIn);
+		this._zoomOutButton = this._createButton(options.zoomOutText, options.zoomOutTitle,
+		        zoomName + '-out', container, this._zoomOut);
 
 		this._updateDisabled();
 		map.on('zoomend zoomlevelschange', this._updateDisabled, this);
@@ -42,21 +39,17 @@ L.Control.Zoom = L.Control.extend({
 		this._map.zoomOut(e.shiftKey ? 3 : 1);
 	},
 
-	_createButton: function (html, title, className, container, fn, context) {
+	_createButton: function (html, title, className, container, fn) {
 		var link = L.DomUtil.create('a', className, container);
 		link.innerHTML = html;
 		link.href = '#';
 		link.title = title;
 
-		var stop = L.DomEvent.stopPropagation;
-
 		L.DomEvent
-		    .on(link, 'click', stop)
-		    .on(link, 'mousedown', stop)
-		    .on(link, 'dblclick', stop)
-		    .on(link, 'click', L.DomEvent.preventDefault)
-		    .on(link, 'click', fn, context)
-		    .on(link, 'click', this._refocusOnMap, context);
+		    .on(link, 'mousedown dblclick', L.DomEvent.stopPropagation)
+		    .on(link, 'click', L.DomEvent.stop)
+		    .on(link, 'click', fn, this)
+		    .on(link, 'click', this._refocusOnMap, this);
 
 		return link;
 	},