leaflet-ruby 0.3.beta1

data/lib/leaflet/src/geometry/Transformation.js

@@ -0,0 +1,31 @@
+/*
+ * L.Transformation is an utility class to perform simple point transformations through a 2d-matrix.
+ */
+
+L.Transformation = L.Class.extend({
+	initialize: function (/*Number*/ a, /*Number*/ b, /*Number*/ c, /*Number*/ d) {
+		this._a = a;
+		this._b = b;
+		this._c = c;
+		this._d = d;
+	},
+
+	transform: function (point, scale) {
+		return this._transform(point.clone(), scale);
+	},
+
+	// destructive transform (faster)
+	_transform: function (/*Point*/ point, /*Number*/ scale) /*-> Point*/ {
+		scale = scale || 1;
+		point.x = scale * (this._a * point.x + this._b);
+		point.y = scale * (this._c * point.y + this._d);
+		return point;
+	},
+
+	untransform: function (/*Point*/ point, /*Number*/ scale) /*-> Point*/ {
+		scale = scale || 1;
+		return new L.Point(
+			(point.x / scale - this._b) / this._a,
+			(point.y / scale - this._d) / this._c);
+	}
+});

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

@@ -0,0 +1,40 @@
+/*
+ * L.FeatureGroup extends L.LayerGroup by introducing mouse events and bindPopup method shared between a group of layers.
+ */
+
+L.FeatureGroup = L.LayerGroup.extend({
+	includes: L.Mixin.Events,
+
+	addLayer: function (layer) {
+		this._initEvents(layer);
+		L.LayerGroup.prototype.addLayer.call(this, layer);
+
+		if (this._popupContent && layer.bindPopup) {
+			layer.bindPopup(this._popupContent);
+		}
+	},
+
+	bindPopup: function (content) {
+		this._popupContent = content;
+
+		return this.invoke('bindPopup', content);
+	},
+
+	setStyle: function (style) {
+		return this.invoke('setStyle', style);
+	},
+
+	_events: ['click', 'dblclick', 'mouseover', 'mouseout'],
+
+	_initEvents: function (layer) {
+		for (var i = 0, len = this._events.length; i < len; i++) {
+			layer.on(this._events[i], this._propagateEvent, this);
+		}
+	},
+
+	_propagateEvent: function (e) {
+		e.layer = e.target;
+		e.target = this;
+		this.fire(e.type, e);
+	}
+});

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

@@ -0,0 +1,104 @@
+
+L.GeoJSON = L.FeatureGroup.extend({
+	initialize: function (geojson, options) {
+		L.Util.setOptions(this, options);
+		this._geojson = geojson;
+		this._layers = {};
+
+		if (geojson) {
+			this.addGeoJSON(geojson);
+		}
+	},
+
+	addGeoJSON: function (geojson) {
+		if (geojson.features) {
+			for (var i = 0, len = geojson.features.length; i < len; i++) {
+				this.addGeoJSON(geojson.features[i]);
+			}
+			return;
+		}
+
+		var isFeature = (geojson.type === 'Feature'),
+			geometry = (isFeature ? geojson.geometry : geojson),
+			layer = L.GeoJSON.geometryToLayer(geometry, this.options.pointToLayer);
+
+		this.fire('featureparse', {
+			layer: layer,
+			properties: geojson.properties,
+			geometryType: geometry.type,
+			bbox: geojson.bbox,
+			id: geojson.id
+		});
+
+		this.addLayer(layer);
+	}
+});
+
+L.Util.extend(L.GeoJSON, {
+	geometryToLayer: function (geometry, pointToLayer) {
+		var coords = geometry.coordinates,
+			latlng, latlngs,
+			i, len,
+			layer,
+			layers = [];
+
+		switch (geometry.type) {
+		case 'Point':
+			latlng = this.coordsToLatLng(coords);
+			return pointToLayer ? pointToLayer(latlng) : new L.Marker(latlng);
+
+		case 'MultiPoint':
+			for (i = 0, len = coords.length; i < len; i++) {
+				latlng = this.coordsToLatLng(coords[i]);
+				layer = pointToLayer ? pointToLayer(latlng) : new L.Marker(latlng);
+				layers.push(layer);
+			}
+			return new L.FeatureGroup(layers);
+
+		case 'LineString':
+			latlngs = this.coordsToLatLngs(coords);
+			return new L.Polyline(latlngs);
+
+		case 'Polygon':
+			latlngs = this.coordsToLatLngs(coords, 1);
+			return new L.Polygon(latlngs);
+
+		case 'MultiLineString':
+			latlngs = this.coordsToLatLngs(coords, 1);
+			return new L.MultiPolyline(latlngs);
+
+		case "MultiPolygon":
+			latlngs = this.coordsToLatLngs(coords, 2);
+			return new L.MultiPolygon(latlngs);
+
+		case "GeometryCollection":
+			for (i = 0, len = geometry.geometries.length; i < len; i++) {
+				layer = this.geometryToLayer(geometry.geometries[i], pointToLayer);
+				layers.push(layer);
+			}
+			return new L.FeatureGroup(layers);
+
+		default:
+			throw new Error('Invalid GeoJSON object.');
+		}
+	},
+
+	coordsToLatLng: function (/*Array*/ coords, /*Boolean*/ reverse)/*: LatLng*/ {
+		var lat = parseFloat(coords[reverse ? 0 : 1]),
+			lng = parseFloat(coords[reverse ? 1 : 0]);
+		return new L.LatLng(lat, lng, true);
+	},
+
+	coordsToLatLngs: function (/*Array*/ coords, /*Number*/ levelsDeep, /*Boolean*/ reverse)/*: Array*/ {
+		var latlng, latlngs = [],
+			i, len = coords.length;
+
+		for (i = 0; i < len; i++) {
+			latlng = levelsDeep ?
+					this.coordsToLatLngs(coords[i], levelsDeep - 1, reverse) :
+					this.coordsToLatLng(coords[i], reverse);
+			latlngs.push(latlng);
+		}
+		return latlngs;
+	}
+});

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

@@ -0,0 +1,58 @@
+L.ImageOverlay = L.Class.extend({
+	includes: L.Mixin.Events,
+
+	initialize: function (/*String*/ url, /*LatLngBounds*/ bounds) {
+		this._url = url;
+		this._bounds = bounds;
+	},
+
+	onAdd: function (map) {
+		this._map = map;
+
+		if (!this._image) {
+			this._initImage();
+		}
+
+		map.getPanes().overlayPane.appendChild(this._image);
+
+		map.on('viewreset', this._reset, this);
+		this._reset();
+	},
+
+	onRemove: function (map) {
+		map.getPanes().overlayPane.removeChild(this._image);
+		map.off('viewreset', this._reset, this);
+	},
+
+	_initImage: function () {
+		this._image = L.DomUtil.create('img', 'leaflet-image-layer');
+
+		this._image.style.visibility = 'hidden';
+		//TODO opacity option
+
+		//TODO createImage util method to remove duplication
+		L.Util.extend(this._image, {
+			galleryimg: 'no',
+			onselectstart: L.Util.falseFn,
+			onmousemove: L.Util.falseFn,
+			onload: L.Util.bind(this._onImageLoad, this),
+			src: this._url
+		});
+	},
+
+	_reset: function () {
+		var topLeft = this._map.latLngToLayerPoint(this._bounds.getNorthWest()),
+			bottomRight = this._map.latLngToLayerPoint(this._bounds.getSouthEast()),
+			size = bottomRight.subtract(topLeft);
+
+		L.DomUtil.setPosition(this._image, topLeft);
+
+		this._image.style.width = size.x + 'px';
+		this._image.style.height = size.y + 'px';
+	},
+
+	_onImageLoad: function () {
+		this._image.style.visibility = '';
+		this.fire('load');
+	}
+});

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

@@ -0,0 +1,74 @@
+/*
+ * L.LayerGroup is a class to combine several layers so you can manipulate the group (e.g. add/remove it) as one layer.
+ */
+
+L.LayerGroup = L.Class.extend({
+	initialize: function (layers) {
+		this._layers = {};
+
+		if (layers) {
+			for (var i = 0, len = layers.length; i < len; i++) {
+				this.addLayer(layers[i]);
+			}
+		}
+	},
+
+	addLayer: function (layer) {
+		var id = L.Util.stamp(layer);
+		this._layers[id] = layer;
+
+		if (this._map) {
+			this._map.addLayer(layer);
+		}
+		return this;
+	},
+
+	removeLayer: function (layer) {
+		var id = L.Util.stamp(layer);
+		delete this._layers[id];
+
+		if (this._map) {
+			this._map.removeLayer(layer);
+		}
+		return this;
+	},
+
+	clearLayers: function () {
+		this._iterateLayers(this.removeLayer, this);
+		return this;
+	},
+
+	invoke: function (methodName) {
+		var args = Array.prototype.slice.call(arguments, 1),
+			i, layer;
+
+		for (i in this._layers) {
+			if (this._layers.hasOwnProperty(i)) {
+				layer = this._layers[i];
+
+				if (layer[methodName]) {
+					layer[methodName].apply(layer, args);
+				}
+			}
+		}
+		return this;
+	},
+
+	onAdd: function (map) {
+		this._map = map;
+		this._iterateLayers(map.addLayer, map);
+	},
+
+	onRemove: function (map) {
+		this._iterateLayers(map.removeLayer, map);
+		delete this._map;
+	},
+
+	_iterateLayers: function (method, context) {
+		for (var i in this._layers) {
+			if (this._layers.hasOwnProperty(i)) {
+				method.call(context, this._layers[i]);
+			}
+		}
+	}
+});

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

@@ -0,0 +1,179 @@
+
+L.Popup = L.Class.extend({
+	includes: L.Mixin.Events,
+
+	options: {
+		minWidth: 50,
+		maxWidth: 300,
+		autoPan: true,
+		closeButton: true,
+		offset: new L.Point(0, 2),
+		autoPanPadding: new L.Point(5, 5),
+		className: ''
+	},
+
+	initialize: function (options, source) {
+		L.Util.setOptions(this, options);
+
+		this._source = source;
+	},
+
+	onAdd: function (map) {
+		this._map = map;
+		if (!this._container) {
+			this._initLayout();
+		}
+		this._updateContent();
+
+		this._container.style.opacity = '0';
+
+		this._map._panes.popupPane.appendChild(this._container);
+		this._map.on('viewreset', this._updatePosition, this);
+
+		if (this._map.options.closePopupOnClick) {
+			this._map.on('preclick', this._close, this);
+		}
+
+		this._update();
+
+		this._container.style.opacity = '1'; //TODO fix ugly opacity hack
+
+		this._opened = true;
+	},
+
+	onRemove: function (map) {
+		map._panes.popupPane.removeChild(this._container);
+		L.Util.falseFn(this._container.offsetWidth);
+
+		map.off('viewreset', this._updatePosition, this);
+		map.off('click', this._close, this);
+
+		this._container.style.opacity = '0';
+
+		this._opened = false;
+	},
+
+	setLatLng: function (latlng) {
+		this._latlng = latlng;
+		if (this._opened) {
+			this._update();
+		}
+		return this;
+	},
+
+	setContent: function (content) {
+		this._content = content;
+		if (this._opened) {
+			this._update();
+		}
+		return this;
+	},
+
+	_close: function () {
+		if (this._opened) {
+			this._map.closePopup();
+		}
+	},
+
+	_initLayout: function () {
+		this._container = L.DomUtil.create('div', 'leaflet-popup ' + this.options.className);
+
+		if (this.options.closeButton) {
+			this._closeButton = L.DomUtil.create('a', 'leaflet-popup-close-button', this._container);
+			this._closeButton.href = '#close';
+			L.DomEvent.addListener(this._closeButton, 'click', this._onCloseButtonClick, this);
+		}
+
+		this._wrapper = L.DomUtil.create('div', 'leaflet-popup-content-wrapper', this._container);
+		L.DomEvent.disableClickPropagation(this._wrapper);
+		this._contentNode = L.DomUtil.create('div', 'leaflet-popup-content', this._wrapper);
+
+		this._tipContainer = L.DomUtil.create('div', 'leaflet-popup-tip-container', this._container);
+		this._tip = L.DomUtil.create('div', 'leaflet-popup-tip', this._tipContainer);
+	},
+
+	_update: function () {
+		this._container.style.visibility = 'hidden';
+
+		this._updateContent();
+		this._updateLayout();
+		this._updatePosition();
+
+		this._container.style.visibility = '';
+
+		this._adjustPan();
+	},
+
+	_updateContent: function () {
+		if (!this._content) {
+			return;
+		}
+
+		if (typeof this._content === 'string') {
+			this._contentNode.innerHTML = this._content;
+		} else {
+			this._contentNode.innerHTML = '';
+			this._contentNode.appendChild(this._content);
+		}
+	},
+
+	_updateLayout: function () {
+		this._container.style.width = '';
+		this._container.style.whiteSpace = 'nowrap';
+
+		var width = this._container.offsetWidth;
+
+		this._container.style.width = (width > this.options.maxWidth ?
+				this.options.maxWidth : (width < this.options.minWidth ? this.options.minWidth : width)) + 'px';
+		this._container.style.whiteSpace = '';
+
+		this._containerWidth = this._container.offsetWidth;
+	},
+
+	_updatePosition: function () {
+		var pos = this._map.latLngToLayerPoint(this._latlng);
+
+		this._containerBottom = -pos.y - this.options.offset.y;
+		this._containerLeft = pos.x - Math.round(this._containerWidth / 2) + this.options.offset.x;
+
+		this._container.style.bottom = this._containerBottom + 'px';
+		this._container.style.left = this._containerLeft + 'px';
+	},
+
+	_adjustPan: function () {
+		if (!this.options.autoPan) {
+			return;
+		}
+
+		var containerHeight = this._container.offsetHeight,
+			layerPos = new L.Point(
+				this._containerLeft,
+				-containerHeight - this._containerBottom),
+			containerPos = this._map.layerPointToContainerPoint(layerPos),
+			adjustOffset = new L.Point(0, 0),
+			padding = this.options.autoPanPadding,
+			size = this._map.getSize();
+
+		if (containerPos.x < 0) {
+			adjustOffset.x = containerPos.x - padding.x;
+		}
+		if (containerPos.x + this._containerWidth > size.x) {
+			adjustOffset.x = containerPos.x + this._containerWidth - size.x + padding.x;
+		}
+		if (containerPos.y < 0) {
+			adjustOffset.y = containerPos.y - padding.y;
+		}
+		if (containerPos.y + containerHeight > size.y) {
+			adjustOffset.y = containerPos.y + containerHeight - size.y + padding.y;
+		}
+
+		if (adjustOffset.x || adjustOffset.y) {
+			this._map.panBy(adjustOffset);
+		}
+	},
+
+	_onCloseButtonClick: function (e) {
+		this._close();
+		L.DomEvent.stop(e);
+	}
+});