leaflet-ruby 0.3.beta1

data/lib/leaflet/src/map/anim/Map.PanAnimation.js

@@ -0,0 +1,70 @@
+L.Map.include(!(L.Transition && L.Transition.implemented()) ? {} : {
+	setView: function (center, zoom, forceReset) {
+		zoom = this._limitZoom(zoom);
+		var zoomChanged = (this._zoom !== zoom);
+
+		if (this._loaded && !forceReset && this._layers) {
+			// difference between the new and current centers in pixels
+			var offset = this._getNewTopLeftPoint(center).subtract(this._getTopLeftPoint());
+
+			center = new L.LatLng(center.lat, center.lng);
+
+			var done = (zoomChanged ?
+						!!this._zoomToIfCenterInView && this._zoomToIfCenterInView(center, zoom, offset) :
+						this._panByIfClose(offset));
+
+			// exit if animated pan or zoom started
+			if (done) {
+				return this;
+			}
+		}
+
+		// reset the map view
+		this._resetView(center, zoom);
+
+		return this;
+	},
+
+	panBy: function (offset) {
+		if (!(offset.x || offset.y)) {
+			return this;
+		}
+
+		if (!this._panTransition) {
+			this._panTransition = new L.Transition(this._mapPane, {duration: 0.3});
+
+			this._panTransition.on('step', this._onPanTransitionStep, this);
+			this._panTransition.on('end', this._onPanTransitionEnd, this);
+		}
+		this.fire('movestart');
+
+		this._panTransition.run({
+			position: L.DomUtil.getPosition(this._mapPane).subtract(offset)
+		});
+
+		return this;
+	},
+
+	_onPanTransitionStep: function () {
+		this.fire('move');
+	},
+
+	_onPanTransitionEnd: function () {
+		this.fire('moveend');
+	},
+
+	_panByIfClose: function (offset) {
+		if (this._offsetIsWithinView(offset)) {
+			this.panBy(offset);
+			return true;
+		}
+		return false;
+	},
+
+	_offsetIsWithinView: function (offset, multiplyFactor) {
+		var m = multiplyFactor || 1,
+			size = this.getSize();
+		return (Math.abs(offset.x) <= size.x * m) &&
+				(Math.abs(offset.y) <= size.y * m);
+	}
+});

data/lib/leaflet/src/map/anim/Map.ZoomAnimation.js

@@ -0,0 +1,133 @@
+L.Map.include(!L.DomUtil.TRANSITION ? {} : {
+	_zoomToIfCenterInView: function (center, zoom, centerOffset) {
+
+		if (this._animatingZoom) {
+			return true;
+		}
+		if (!this.options.zoomAnimation) {
+			return false;
+		}
+
+		var zoomDelta = zoom - this._zoom,
+			scale = Math.pow(2, zoomDelta),
+			offset = centerOffset.divideBy(1 - 1 / scale);
+
+		//if offset does not exceed half of the view
+		if (!this._offsetIsWithinView(offset, 1)) {
+			return false;
+		}
+
+		this._mapPane.className += ' leaflet-zoom-anim';
+
+        this
+			.fire('movestart')
+			.fire('zoomstart');
+
+		var centerPoint = this.containerPointToLayerPoint(this.getSize().divideBy(2)),
+			origin = centerPoint.add(offset);
+
+		this._prepareTileBg();
+
+		this._runAnimation(center, zoom, scale, origin);
+
+		return true;
+	},
+
+
+	_runAnimation: function (center, zoom, scale, origin) {
+		this._animatingZoom = true;
+
+		this._animateToCenter = center;
+		this._animateToZoom = zoom;
+
+		var transform = L.DomUtil.TRANSFORM;
+
+		//dumb FireFox hack, I have no idea why this magic zero translate fixes the scale transition problem
+		if (L.Browser.gecko || window.opera) {
+			this._tileBg.style[transform] += ' translate(0,0)';
+		}
+
+		var scaleStr;
+
+		// Android doesn't like translate/scale chains, transformOrigin + scale works better but
+		// it breaks touch zoom which Anroid doesn't support anyway, so that's a really ugly hack
+		// TODO work around this prettier
+		if (L.Browser.android) {
+			this._tileBg.style[transform + 'Origin'] = origin.x + 'px ' + origin.y + 'px';
+			scaleStr = 'scale(' + scale + ')';
+		} else {
+			scaleStr = L.DomUtil.getScaleString(scale, origin);
+		}
+
+		L.Util.falseFn(this._tileBg.offsetWidth); //hack to make sure transform is updated before running animation
+
+		var options = {};
+		options[transform] = this._tileBg.style[transform] + ' ' + scaleStr;
+		this._tileBg.transition.run(options);
+	},
+
+	_prepareTileBg: function () {
+		if (!this._tileBg) {
+			this._tileBg = this._createPane('leaflet-tile-pane', this._mapPane);
+			this._tileBg.style.zIndex = 1;
+		}
+
+		var tilePane = this._tilePane,
+			tileBg = this._tileBg;
+
+		// prepare the background pane to become the main tile pane
+		//tileBg.innerHTML = '';
+		tileBg.style[L.DomUtil.TRANSFORM] = '';
+		tileBg.style.visibility = 'hidden';
+
+		// tells tile layers to reinitialize their containers
+		tileBg.empty = true;
+		tilePane.empty = false;
+
+		this._tilePane = this._panes.tilePane = tileBg;
+		this._tileBg = tilePane;
+
+		if (!this._tileBg.transition) {
+			this._tileBg.transition = new L.Transition(this._tileBg, {duration: 0.3, easing: 'cubic-bezier(0.25,0.1,0.25,0.75)'});
+			this._tileBg.transition.on('end', this._onZoomTransitionEnd, this);
+		}
+
+		this._stopLoadingBgTiles();
+	},
+
+	// stops loading all tiles in the background layer
+	_stopLoadingBgTiles: function () {
+		var tiles = [].slice.call(this._tileBg.getElementsByTagName('img'));
+
+		for (var i = 0, len = tiles.length; i < len; i++) {
+			if (!tiles[i].complete) {
+				// tiles[i].src = '' - evil, doesn't cancel the request!
+				tiles[i].parentNode.removeChild(tiles[i]);
+				tiles[i] = null;
+			}
+		}
+	},
+
+	_onZoomTransitionEnd: function () {
+		this._restoreTileFront();
+
+		L.Util.falseFn(this._tileBg.offsetWidth);
+		this._resetView(this._animateToCenter, this._animateToZoom, true, true);
+
+		this._mapPane.className = this._mapPane.className.replace(' leaflet-zoom-anim', ''); //TODO toggleClass util
+		this._animatingZoom = false;
+	},
+
+	_restoreTileFront: function () {
+		this._tilePane.innerHTML = '';
+		this._tilePane.style.visibility = '';
+		this._tilePane.style.zIndex = 2;
+		this._tileBg.style.zIndex = 1;
+	},
+
+	_clearTileBg: function () {
+		if (!this._animatingZoom && !this.touchZoom._zooming) {
+			this._tileBg.innerHTML = '';
+		}
+	}
+});

data/lib/leaflet/src/map/ext/Map.Control.js

@@ -0,0 +1,50 @@
+L.Map.include({
+	addControl: function (control) {
+		control.onAdd(this);
+
+		var pos = control.getPosition(),
+			corner = this._controlCorners[pos],
+			container = control.getContainer();
+
+		L.DomUtil.addClass(container, 'leaflet-control');
+
+		if (pos.indexOf('bottom') !== -1) {
+			corner.insertBefore(container, corner.firstChild);
+		} else {
+			corner.appendChild(container);
+		}
+		return this;
+	},
+
+	removeControl: function (control) {
+		var pos = control.getPosition(),
+			corner = this._controlCorners[pos],
+			container = control.getContainer();
+
+		corner.removeChild(container);
+
+		if (control.onRemove) {
+			control.onRemove(this);
+		}
+		return this;
+	},
+
+	_initControlPos: function () {
+		var corners = this._controlCorners = {},
+			classPart = 'leaflet-',
+			top = classPart + 'top',
+			bottom = classPart + 'bottom',
+			left = classPart + 'left',
+			right = classPart + 'right',
+			controlContainer = L.DomUtil.create('div', classPart + 'control-container', this._container);
+
+		if (L.Browser.touch) {
+			controlContainer.className += ' ' + classPart + 'big-buttons';
+		}
+
+		corners.topLeft = L.DomUtil.create('div', top + ' ' + left, controlContainer);
+		corners.topRight = L.DomUtil.create('div', top + ' ' + right, controlContainer);
+		corners.bottomLeft = L.DomUtil.create('div', bottom + ' ' + left, controlContainer);
+		corners.bottomRight = L.DomUtil.create('div', bottom + ' ' + right, controlContainer);
+	}
+});

data/lib/leaflet/src/map/ext/Map.Geolocation.js

@@ -0,0 +1,86 @@
+/*
+ * Provides L.Map with convenient shortcuts for W3C geolocation.
+ */
+
+L.Map.include({
+	locate: function (/*Object*/ options) {
+
+		this._locationOptions = options = L.Util.extend({
+			watch: false,
+			setView: false,
+			maxZoom: Infinity,
+			timeout: 10000,
+			maximumAge: 0,
+			enableHighAccuracy: false
+		}, options);
+
+		if (!navigator.geolocation) {
+			return this.fire('locationerror', {
+				code: 0,
+				message: "Geolocation not supported."
+			});
+		}
+
+		var onResponse = L.Util.bind(this._handleGeolocationResponse, this),
+			onError = L.Util.bind(this._handleGeolocationError, this);
+
+		if (options.watch) {
+			this._locationWatchId = navigator.geolocation.watchPosition(onResponse, onError, options);
+		} else {
+			navigator.geolocation.getCurrentPosition(onResponse, onError, options);
+		}
+		return this;
+	},
+
+	stopLocate: function () {
+		if (navigator.geolocation) {
+			navigator.geolocation.clearWatch(this._locationWatchId);
+		}
+	},
+
+	locateAndSetView: function (maxZoom, options) {
+		options = L.Util.extend({
+			maxZoom: maxZoom || Infinity,
+			setView: true
+		}, options);
+		return this.locate(options);
+	},
+
+	_handleGeolocationError: function (error) {
+		var c = error.code,
+			message = (c === 1 ? "permission denied" :
+				(c === 2 ? "position unavailable" : "timeout"));
+
+		if (this._locationOptions.setView && !this._loaded) {
+			this.fitWorld();
+		}
+
+		this.fire('locationerror', {
+			code: c,
+			message: "Geolocation error: " + message + "."
+		});
+	},
+
+	_handleGeolocationResponse: function (pos) {
+		var latAccuracy = 180 * pos.coords.accuracy / 4e7,
+			lngAccuracy = latAccuracy * 2,
+			lat = pos.coords.latitude,
+			lng = pos.coords.longitude,
+			latlng = new L.LatLng(lat, lng);
+
+		var sw = new L.LatLng(lat - latAccuracy, lng - lngAccuracy),
+			ne = new L.LatLng(lat + latAccuracy, lng + lngAccuracy),
+			bounds = new L.LatLngBounds(sw, ne);
+
+		if (this._locationOptions.setView) {
+			var zoom = Math.min(this.getBoundsZoom(bounds), this._locationOptions.maxZoom);
+			this.setView(latlng, zoom);
+		}
+
+		this.fire('locationfound', {
+			latlng: latlng,
+			bounds: bounds,
+			accuracy: pos.coords.accuracy
+		});
+	}
+});

data/lib/leaflet/src/map/ext/Map.Popup.js

@@ -0,0 +1,20 @@
+
+L.Map.include({
+	openPopup: function (popup) {
+		this.closePopup();
+		this._popup = popup;
+		this.addLayer(popup);
+		this.fire('popupopen', { popup: this._popup });
+	
+		return this;
+	},
+
+	closePopup: function () {
+		if (this._popup) {
+			this.removeLayer(this._popup);
+			this.fire('popupclose', { popup: this._popup });
+			this._popup = null;
+		}
+		return this;
+	}
+});

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

@@ -0,0 +1,73 @@
+/*
+ * L.Handler.ShiftDragZoom is used internally by L.Map to add shift-drag zoom (zoom to a selected bounding box).
+ */
+
+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.addListener(this._container, 'mousedown', this._onMouseDown, this);
+	},
+
+	removeHooks: function () {
+		L.DomEvent.removeListener(this._container, 'mousedown', this._onMouseDown);
+	},
+
+	_onMouseDown: function (e) {
+		if (!e.shiftKey || ((e.which !== 1) && (e.button !== 1))) {
+			return false;
+		}
+
+		L.DomUtil.disableTextSelection();
+
+		this._startLayerPoint = this._map.mouseEventToLayerPoint(e);
+
+		this._box = L.DomUtil.create('div', 'leaflet-zoom-box', this._pane);
+		L.DomUtil.setPosition(this._box, this._startLayerPoint);
+
+		//TODO move cursor to styles
+		this._container.style.cursor = 'crosshair';
+
+		L.DomEvent.addListener(document, 'mousemove', this._onMouseMove, this);
+		L.DomEvent.addListener(document, 'mouseup', this._onMouseUp, this);
+
+		L.DomEvent.preventDefault(e);
+	},
+
+	_onMouseMove: function (e) {
+		var layerPoint = this._map.mouseEventToLayerPoint(e),
+			dx = layerPoint.x - this._startLayerPoint.x,
+			dy = layerPoint.y - this._startLayerPoint.y;
+
+		var newX = Math.min(layerPoint.x, this._startLayerPoint.x),
+			newY = Math.min(layerPoint.y, this._startLayerPoint.y),
+			newPos = new L.Point(newX, newY);
+
+		L.DomUtil.setPosition(this._box, newPos);
+
+		this._box.style.width = (Math.abs(dx) - 4) + 'px';
+		this._box.style.height = (Math.abs(dy) - 4) + 'px';
+	},
+
+	_onMouseUp: function (e) {
+		this._pane.removeChild(this._box);
+		this._container.style.cursor = '';
+
+		L.DomUtil.enableTextSelection();
+
+		L.DomEvent.removeListener(document, 'mousemove', this._onMouseMove);
+		L.DomEvent.removeListener(document, 'mouseup', this._onMouseUp);
+
+		var layerPoint = this._map.mouseEventToLayerPoint(e);
+
+		var bounds = new L.LatLngBounds(
+				this._map.layerPointToLatLng(this._startLayerPoint),
+				this._map.layerPointToLatLng(layerPoint));
+
+		this._map.fitBounds(bounds);
+	}
+});

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

@@ -0,0 +1,18 @@
+/*
+ * L.Handler.DoubleClickZoom is used internally by L.Map to add double-click zooming.
+ */
+
+L.Map.DoubleClickZoom = L.Handler.extend({
+	addHooks: function () {
+		this._map.on('dblclick', this._onDoubleClick);
+		// TODO remove 3d argument?
+	},
+
+	removeHooks: function () {
+		this._map.off('dblclick', this._onDoubleClick);
+	},
+
+	_onDoubleClick: function (e) {
+		this.setView(e.latlng, this._zoom + 1);
+	}
+});