leaflet-js 0.7.9 → 0.8.dev2

data/{vendor/assets/Leaflet → lib/leaflet}/src/map/anim/Map.ZoomAnimation.js

@@ -7,12 +7,13 @@ L.Map.mergeOptions({
 	zoomAnimationThreshold: 4
 });
 
-if (L.DomUtil.TRANSITION) {
+var zoomAnimated = L.DomUtil.TRANSITION && L.Browser.any3d && !L.Browser.mobileOpera;
+
+if (zoomAnimated) {
 
 	L.Map.addInitHook(function () {
 		// don't animate on browsers without hardware-accelerated transitions or old Android/Opera
-		this._zoomAnimated = this.options.zoomAnimation && L.DomUtil.TRANSITION &&
-				L.Browser.any3d && !L.Browser.android23 && !L.Browser.mobileOpera;
+		this._zoomAnimated = this.options.zoomAnimation;
 
 		// zoom transitions run with the same duration for all layers, so if one of transitionend events
 		// happens after starting zoom animation (propagating to the map pane), we know that it ended globally
@@ -22,7 +23,7 @@ if (L.DomUtil.TRANSITION) {
 	});
 }
 
-L.Map.include(!L.DomUtil.TRANSITION ? {} : {
+L.Map.include(!zoomAnimated ? {} : {
 
 	_catchTransitionEnd: function (e) {
 		if (this._animatingZoom && e.propertyName.indexOf('transform') >= 0) {
@@ -46,8 +47,7 @@ L.Map.include(!L.DomUtil.TRANSITION ? {} : {
 
 		// offset is the pixel coords of the zoom origin relative to the current center
 		var scale = this.getZoomScale(zoom),
-		    offset = this._getCenterOffset(center)._divideBy(1 - 1 / scale),
-			origin = this._getCenterLayerPoint()._add(offset);
+		    offset = this._getCenterOffset(center)._divideBy(1 - 1 / scale);
 
 		// don't animate if the zoom origin isn't within one screen from the current center, unless forced
 		if (options.animate !== true && !this.getSize().contains(offset)) { return false; }
@@ -56,56 +56,48 @@ L.Map.include(!L.DomUtil.TRANSITION ? {} : {
 		    .fire('movestart')
 		    .fire('zoomstart');
 
-		this._animateZoom(center, zoom, origin, scale, null, true);
+		this._animateZoom(center, zoom, true);
 
 		return true;
 	},
 
-	_animateZoom: function (center, zoom, origin, scale, delta, backwards, forTouchZoom) {
-
-		if (!forTouchZoom) {
+	_animateZoom: function (center, zoom, startAnim) {
+		if (startAnim) {
 			this._animatingZoom = true;
-		}
 
-		// put transform transition on all layers with leaflet-zoom-animated class
-		L.DomUtil.addClass(this._mapPane, 'leaflet-zoom-anim');
+			// remember what center/zoom to set after animation
+			this._animateToCenter = center;
+			this._animateToZoom = zoom;
 
-		// remember what center/zoom to set after animation
-		this._animateToCenter = center;
-		this._animateToZoom = zoom;
+			// disable any dragging during animation
+			if (L.Draggable) {
+				L.Draggable._disabled = true;
+			}
 
-		// disable any dragging during animation
-		if (L.Draggable) {
-			L.Draggable._disabled = true;
+			L.DomUtil.addClass(this._mapPane, 'leaflet-zoom-anim');
 		}
 
-		L.Util.requestAnimFrame(function () {
-			this.fire('zoomanim', {
-				center: center,
-				zoom: zoom,
-				origin: origin,
-				scale: scale,
-				delta: delta,
-				backwards: backwards
-			});
-			// horrible hack to work around a Chrome bug https://github.com/Leaflet/Leaflet/issues/3689
-			setTimeout(L.bind(this._onZoomTransitionEnd, this), 250);
-		}, this);
+		var scale = this.getZoomScale(zoom),
+			origin = this._getCenterLayerPoint().add(this._getCenterOffset(center)._divideBy(1 - 1 / scale));
+
+		this.fire('zoomanim', {
+			center: center,
+			zoom: zoom,
+			origin: origin,
+			scale: scale
+		});
 	},
 
 	_onZoomTransitionEnd: function () {
-		if (!this._animatingZoom) { return; }
 
 		this._animatingZoom = false;
 
 		L.DomUtil.removeClass(this._mapPane, 'leaflet-zoom-anim');
 
-		L.Util.requestAnimFrame(function () {
-			this._resetView(this._animateToCenter, this._animateToZoom, true, true);
+		this._resetView(this._animateToCenter, this._animateToZoom, true, true);
 
-			if (L.Draggable) {
-				L.Draggable._disabled = false;
-			}
-		}, this);
+		if (L.Draggable) {
+			L.Draggable._disabled = false;
+		}
 	}
 });

data/{vendor/assets/Leaflet → lib/leaflet}/src/map/ext/Map.Geolocation.js

@@ -4,12 +4,12 @@
 
 L.Map.include({
 	_defaultLocateOptions: {
-		watch: false,
-		setView: false,
-		maxZoom: Infinity,
 		timeout: 10000,
-		maximumAge: 0,
-		enableHighAccuracy: false
+		watch: false
+		// setView: false
+		// maxZoom: <Number>
+		// maximumAge: 0
+		// enableHighAccuracy: false
 	},
 
 	locate: function (/*Object*/ options) {
@@ -68,7 +68,7 @@ L.Map.include({
 		    latlng = new L.LatLng(lat, lng),
 
 		    latAccuracy = 180 * pos.coords.accuracy / 40075017,
-		    lngAccuracy = latAccuracy / Math.cos(L.LatLng.DEG_TO_RAD * lat),
+		    lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * lat),
 
 		    bounds = L.latLngBounds(
 		            [lat - latAccuracy, lng - lngAccuracy],
@@ -77,8 +77,8 @@ L.Map.include({
 		    options = this._locateOptions;
 
 		if (options.setView) {
-			var zoom = Math.min(this.getBoundsZoom(bounds), options.maxZoom);
-			this.setView(latlng, zoom);
+			var zoom = this.getBoundsZoom(bounds);
+			this.setView(latlng, options.maxZoom ? Math.min(zoom, options.maxZoom) : zoom);
 		}
 
 		var data = {

data/lib/leaflet/src/map/handler/Map.BoxZoom.js

@@ -0,0 +1,105 @@
+/*
+ * L.Handler.ShiftDragZoom is used to add shift-drag zoom interaction to the map
+  * (zoom to a selected bounding box), enabled by default.
+ */
+
+L.Map.mergeOptions({
+	boxZoom: true
+});
+
+L.Map.BoxZoom = L.Handler.extend({
+	initialize: function (map) {
+		this._map = map;
+		this._container = map._container;
+		this._pane = map._panes.overlayPane;
+	},
+
+	addHooks: function () {
+		L.DomEvent.on(this._container, 'mousedown', this._onMouseDown, this);
+	},
+
+	removeHooks: function () {
+		L.DomEvent.off(this._container, 'mousedown', this._onMouseDown, this);
+	},
+
+	moved: function () {
+		return this._moved;
+	},
+
+	_onMouseDown: function (e) {
+		this._moved = false;
+
+		if (!e.shiftKey || ((e.which !== 1) && (e.button !== 1))) { return false; }
+
+		L.DomUtil.disableTextSelection();
+		L.DomUtil.disableImageDrag();
+
+		this._startPoint = this._map.mouseEventToContainerPoint(e);
+
+		L.DomEvent.on(document, {
+			mousemove: this._onMouseMove,
+		    mouseup: this._onMouseUp,
+		    keydown: this._onKeyDown
+		}, this);
+	},
+
+	_onMouseMove: function (e) {
+		if (!this._moved) {
+			this._moved = true;
+
+			this._box = L.DomUtil.create('div', 'leaflet-zoom-box', this._container);
+			L.DomUtil.addClass(this._container, 'leaflet-crosshair');
+
+			this._map.fire('boxzoomstart');
+		}
+
+		this._point = this._map.mouseEventToContainerPoint(e);
+
+		var bounds = new L.Bounds(this._point, this._startPoint),
+		    size = bounds.getSize();
+
+		L.DomUtil.setPosition(this._box, bounds.min);
+
+		this._box.style.width  = size.x + 'px';
+		this._box.style.height = size.y + 'px';
+	},
+
+	_finish: function () {
+		if (this._moved) {
+			L.DomUtil.remove(this._box);
+			L.DomUtil.removeClass(this._container, 'leaflet-crosshair');
+		}
+
+		L.DomUtil.enableTextSelection();
+		L.DomUtil.enableImageDrag();
+
+		L.DomEvent.off(document, {
+			mousemove: this._onMouseMove,
+		    mouseup: this._onMouseUp,
+		    keydown: this._onKeyDown
+		}, this);
+	},
+
+	_onMouseUp: function () {
+
+		this._finish();
+
+		if (!this._moved) { return; }
+
+		var bounds = new L.LatLngBounds(
+		        this._map.containerPointToLatLng(this._startPoint),
+		        this._map.containerPointToLatLng(this._point));
+
+		this._map
+			.fitBounds(bounds)
+			.fire('boxzoomend', {boxZoomBounds: bounds});
+	},
+
+	_onKeyDown: function (e) {
+		if (e.keyCode === 27) {
+			this._finish();
+		}
+	}
+});
+
+L.Map.addInitHook('addHandler', 'boxZoom', L.Map.BoxZoom);

data/{vendor/assets/Leaflet → lib/leaflet}/src/map/handler/Map.Drag.js

@@ -23,9 +23,10 @@ L.Map.Drag = L.Handler.extend({
 			this._draggable = new L.Draggable(map._mapPane, map._container);
 
 			this._draggable.on({
-				'dragstart': this._onDragStart,
-				'drag': this._onDrag,
-				'dragend': this._onDragEnd
+				down: this._onDown,
+				dragstart: this._onDragStart,
+				drag: this._onDrag,
+				dragend: this._onDragEnd
 			}, this);
 
 			if (map.options.worldCopyJump) {
@@ -46,13 +47,15 @@ L.Map.Drag = L.Handler.extend({
 		return this._draggable && this._draggable._moved;
 	},
 
+	_onDown: function () {
+		if (this._map._panAnim) {
+			this._map._panAnim.stop();
+		}
+	},
+
 	_onDragStart: function () {
 		var map = this._map;
 
-		if (map._panAnim) {
-			map._panAnim.stop();
-		}
-
 		map
 		    .fire('movestart')
 		    .fire('dragstart');
@@ -83,12 +86,11 @@ L.Map.Drag = L.Handler.extend({
 	},
 
 	_onViewReset: function () {
-		// TODO fix hardcoded Earth values
-		var pxCenter = this._map.getSize()._divideBy(2),
+		var pxCenter = this._map.getSize().divideBy(2),
 		    pxWorldCenter = this._map.latLngToLayerPoint([0, 0]);
 
 		this._initialWorldOffset = pxWorldCenter.subtract(pxCenter).x;
-		this._worldWidth = this._map.project([0, 180]).x;
+		this._worldWidth = this._map.getPixelWorldBounds().getSize().x;
 	},
 
 	_onPreDrag: function () {

data/{vendor/assets/Leaflet → lib/leaflet}/src/map/handler/Map.Keyboard.js

@@ -34,29 +34,31 @@ L.Map.Keyboard = L.Handler.extend({
 			container.tabIndex = '0';
 		}
 
-		L.DomEvent
-		    .on(container, 'focus', this._onFocus, this)
-		    .on(container, 'blur', this._onBlur, this)
-		    .on(container, 'mousedown', this._onMouseDown, this);
-
-		this._map
-		    .on('focus', this._addHooks, this)
-		    .on('blur', this._removeHooks, this);
+		L.DomEvent.on(container, {
+		    focus: this._onFocus,
+		    blur: this._onBlur,
+		    mousedown: this._onMouseDown
+		}, this);
+
+		this._map.on({
+			focus: this._addHooks,
+		    blur: this._removeHooks
+		}, this);
 	},
 
 	removeHooks: function () {
 		this._removeHooks();
 
-		var container = this._map._container;
-
-		L.DomEvent
-		    .off(container, 'focus', this._onFocus, this)
-		    .off(container, 'blur', this._onBlur, this)
-		    .off(container, 'mousedown', this._onMouseDown, this);
+		L.DomEvent.off(this._map._container, {
+		    focus: this._onFocus,
+		    blur: this._onBlur,
+		    mousedown: this._onMouseDown
+		}, this);
 
-		this._map
-		    .off('focus', this._addHooks, this)
-		    .off('blur', this._removeHooks, this);
+		this._map.off({
+			focus: this._addHooks,
+		    blur: this._removeHooks
+		}, this);
 	},
 
 	_onMouseDown: function () {

data/{vendor/assets/Leaflet → lib/leaflet}/src/map/handler/Map.ScrollWheelZoom.js

@@ -8,14 +8,19 @@ L.Map.mergeOptions({
 
 L.Map.ScrollWheelZoom = L.Handler.extend({
 	addHooks: function () {
-		L.DomEvent.on(this._map._container, 'mousewheel', this._onWheelScroll, this);
-		L.DomEvent.on(this._map._container, 'MozMousePixelScroll', L.DomEvent.preventDefault);
+		L.DomEvent.on(this._map._container, {
+			mousewheel: this._onWheelScroll,
+			MozMousePixelScroll: L.DomEvent.preventDefault
+		}, this);
+
 		this._delta = 0;
 	},
 
 	removeHooks: function () {
-		L.DomEvent.off(this._map._container, 'mousewheel', this._onWheelScroll);
-		L.DomEvent.off(this._map._container, 'MozMousePixelScroll', L.DomEvent.preventDefault);
+		L.DomEvent.off(this._map._container, {
+			mousewheel: this._onWheelScroll,
+			MozMousePixelScroll: L.DomEvent.preventDefault
+		}, this);
 	},
 
 	_onWheelScroll: function (e) {
@@ -33,8 +38,7 @@ L.Map.ScrollWheelZoom = L.Handler.extend({
 		clearTimeout(this._timer);
 		this._timer = setTimeout(L.bind(this._performZoom, this), left);
 
-		L.DomEvent.preventDefault(e);
-		L.DomEvent.stopPropagation(e);
+		L.DomEvent.stop(e);
 	},
 
 	_performZoom: function () {

data/{vendor/assets/Leaflet → lib/leaflet}/src/map/handler/Map.Tap.js

@@ -49,17 +49,19 @@ L.Map.Tap = L.Handler.extend({
 			}
 		}, this), 1000);
 
-		L.DomEvent
-			.on(document, 'touchmove', this._onMove, this)
-			.on(document, 'touchend', this._onUp, this);
+		L.DomEvent.on(document, {
+			touchmove: this._onMove,
+			touchend: this._onUp
+		}, this);
 	},
 
 	_onUp: function (e) {
 		clearTimeout(this._holdTimeout);
 
-		L.DomEvent
-			.off(document, 'touchmove', this._onMove, this)
-			.off(document, 'touchend', this._onUp, this);
+		L.DomEvent.off(document, {
+			touchmove: this._onMove,
+			touchend: this._onUp
+		}, this);
 
 		if (this._fireClick && e && e.changedTouches) {
 

data/{vendor/assets/Leaflet → lib/leaflet}/src/map/handler/Map.TouchZoom.js

@@ -45,26 +45,20 @@ L.Map.TouchZoom = L.Handler.extend({
 	},
 
 	_onTouchMove: function (e) {
-		var map = this._map;
-
 		if (!e.touches || e.touches.length !== 2 || !this._zooming) { return; }
 
-		var p1 = map.mouseEventToLayerPoint(e.touches[0]),
+		var map = this._map,
+		    p1 = map.mouseEventToLayerPoint(e.touches[0]),
 		    p2 = map.mouseEventToLayerPoint(e.touches[1]);
 
 		this._scale = p1.distanceTo(p2) / this._startDist;
 		this._delta = p1._add(p2)._divideBy(2)._subtract(this._startCenter);
 
-		if (this._scale === 1) { return; }
-
-		if (!map.options.bounceAtZoomLimits) {
-			if ((map.getZoom() === map.getMinZoom() && this._scale < 1) ||
-			    (map.getZoom() === map.getMaxZoom() && this._scale > 1)) { return; }
-		}
+		if (!map.options.bounceAtZoomLimits &&
+		    ((map.getZoom() === map.getMinZoom() && this._scale < 1) ||
+		     (map.getZoom() === map.getMaxZoom() && this._scale > 1))) { return; }
 
 		if (!this._moved) {
-			L.DomUtil.addClass(map._mapPane, 'leaflet-touching');
-
 			map
 			    .fire('movestart')
 			    .fire('zoomstart');
@@ -73,19 +67,18 @@ L.Map.TouchZoom = L.Handler.extend({
 		}
 
 		L.Util.cancelAnimFrame(this._animRequest);
-		this._animRequest = L.Util.requestAnimFrame(
-		        this._updateOnMove, this, true, this._map._container);
+		this._animRequest = L.Util.requestAnimFrame(this._updateOnMove, this, true, this._map._container);
 
 		L.DomEvent.preventDefault(e);
 	},
 
 	_updateOnMove: function () {
-		var map = this._map,
-		    origin = this._getScaleOrigin(),
-		    center = map.layerPointToLatLng(origin),
-		    zoom = map.getScaleZoom(this._scale);
+		var map = this._map;
+
+		this._center = map.layerPointToLatLng(this._getTargetCenter());
+		this._zoom = map.getScaleZoom(this._scale);
 
-		map._animateZoom(center, zoom, this._startCenter, this._scale, this._delta, false, true);
+		map._animateZoom(this._center, this._zoom);
 	},
 
 	_onTouchEnd: function () {
@@ -94,31 +87,22 @@ L.Map.TouchZoom = L.Handler.extend({
 			return;
 		}
 
-		var map = this._map;
-
 		this._zooming = false;
-		L.DomUtil.removeClass(map._mapPane, 'leaflet-touching');
 		L.Util.cancelAnimFrame(this._animRequest);
 
 		L.DomEvent
 		    .off(document, 'touchmove', this._onTouchMove)
 		    .off(document, 'touchend', this._onTouchEnd);
 
-		var origin = this._getScaleOrigin(),
-		    center = map.layerPointToLatLng(origin),
-
+		var map = this._map,
 		    oldZoom = map.getZoom(),
-		    floatZoomDelta = map.getScaleZoom(this._scale) - oldZoom,
-		    roundZoomDelta = (floatZoomDelta > 0 ?
-		            Math.ceil(floatZoomDelta) : Math.floor(floatZoomDelta)),
-
-		    zoom = map._limitZoom(oldZoom + roundZoomDelta),
-		    scale = map.getZoomScale(zoom) / this._scale;
+		    zoomDelta = this._zoom - oldZoom,
+		    finalZoom = map._limitZoom(oldZoom + (zoomDelta > 0 ? Math.ceil(zoomDelta) : Math.floor(zoomDelta)));
 
-		map._animateZoom(center, zoom, origin, scale);
+		map._animateZoom(this._center, finalZoom, true);
 	},
 
-	_getScaleOrigin: function () {
+	_getTargetCenter: function () {
 		var centerOffset = this._centerOffset.subtract(this._delta).divideBy(this._scale);
 		return this._startCenter.add(centerOffset);
 	}