leaflet-js 0.7.9 → 0.8.dev2

data/lib/leaflet/src/layer/vector/Circle.js

@@ -0,0 +1,67 @@
+/*
+ * L.Circle is a circle overlay (with a certain radius in meters).
+ * It's an approximation and starts to diverge from a real circle closer to poles (due to projection distortion)
+ */
+
+L.Circle = L.CircleMarker.extend({
+
+	initialize: function (latlng, radius, options) {
+		L.setOptions(this, options);
+		this._latlng = L.latLng(latlng);
+		this._mRadius = radius;
+	},
+
+	setRadius: function (radius) {
+		this._mRadius = radius;
+		return this.redraw();
+	},
+
+	getRadius: function () {
+		return this._mRadius;
+	},
+
+	getBounds: function () {
+		var half = [this._radius, this._radiusY];
+
+		return new L.LatLngBounds(
+			this._map.layerPointToLatLng(this._point.subtract(half)),
+			this._map.layerPointToLatLng(this._point.add(half)));
+	},
+
+	setStyle: L.Path.prototype.setStyle,
+
+	_project: function () {
+
+		var lng = this._latlng.lng,
+		    lat = this._latlng.lat,
+		    map = this._map,
+		    crs = map.options.crs;
+
+		if (crs.distance === L.CRS.Earth.distance) {
+			var d = Math.PI / 180,
+			    latR = (this._mRadius / L.CRS.Earth.R) / d,
+			    top = map.project([lat + latR, lng]),
+			    bottom = map.project([lat - latR, lng]),
+			    p = top.add(bottom).divideBy(2),
+			    lat2 = map.unproject(p).lat,
+			    lngR = Math.acos((Math.cos(latR * d) - Math.sin(lat * d) * Math.sin(lat2 * d)) /
+			            (Math.cos(lat * d) * Math.cos(lat2 * d))) / d;
+
+			this._point = p.subtract(map.getPixelOrigin());
+			this._radius = isNaN(lngR) ? 0 : Math.max(Math.round(p.x - map.project([lat2, lng - lngR]).x), 1);
+			this._radiusY = Math.max(Math.round(p.y - top.y), 1);
+
+		} else {
+			var latlng2 = crs.unproject(crs.project(this._latlng).subtract([this._mRadius, 0]));
+
+			this._point = map.latLngToLayerPoint(this._latlng);
+			this._radius = this._point.x - map.latLngToLayerPoint(latlng2).x;
+		}
+
+		this._updateBounds();
+	}
+});
+
+L.circle = function (latlng, radius, options) {
+	return new L.Circle(latlng, radius, options);
+};

data/lib/leaflet/src/layer/vector/CircleMarker.js

@@ -0,0 +1,72 @@
+/*
+ * L.CircleMarker is a circle overlay with a permanent pixel radius.
+ */
+
+L.CircleMarker = L.Path.extend({
+
+	options: {
+		fill: true,
+		radius: 10
+	},
+
+	initialize: function (latlng, options) {
+		L.setOptions(this, options);
+		this._latlng = L.latLng(latlng);
+		this._radius = this.options.radius;
+	},
+
+	setLatLng: function (latlng) {
+		this._latlng = L.latLng(latlng);
+		this.redraw();
+		return this.fire('move', {latlng: this._latlng});
+	},
+
+	getLatLng: function () {
+		return this._latlng;
+	},
+
+	setRadius: function (radius) {
+		this.options.radius = this._radius = radius;
+		return this.redraw();
+	},
+
+	getRadius: function () {
+		return this._radius;
+	},
+
+	setStyle : function (options) {
+		this._radius = options && options.radius || this._radius;
+		L.Path.prototype.setStyle.call(this, options);
+	},
+
+	_project: function () {
+		this._point = this._map.latLngToLayerPoint(this._latlng);
+		this._updateBounds();
+	},
+
+	_updateBounds: function () {
+		var r = this._radius,
+		    r2 = this._radiusY || r,
+		    w = this._clickTolerance(),
+		    p = [r + w, r2 + w];
+		this._pxBounds = new L.Bounds(this._point.subtract(p), this._point.add(p));
+	},
+
+	_update: function () {
+		if (this._map) {
+			this._updatePath();
+		}
+	},
+
+	_updatePath: function () {
+		this._renderer._updateCircle(this);
+	},
+
+	_empty: function () {
+		return this._radius && !this._renderer._bounds.intersects(this._pxBounds);
+	}
+});
+
+L.circleMarker = function (latlng, options) {
+	return new L.CircleMarker(latlng, options);
+};

data/lib/leaflet/src/layer/vector/Path.js

@@ -0,0 +1,79 @@
+/*
+ * L.Path is the base class for all Leaflet vector layers like polygons and circles.
+ */
+
+L.Path = L.Layer.extend({
+
+	options: {
+		stroke: true,
+		color: '#3388ff',
+		weight: 3,
+		opacity: 1,
+		lineCap: 'round',
+		lineJoin: 'round',
+		// dashArray: null
+
+		// fill: false
+		// fillColor: same as color by default
+		fillOpacity: 0.2,
+
+		// className: ''
+		clickable: true
+	},
+
+	onAdd: function () {
+		this._renderer = this._map.getRenderer(this);
+		this._renderer._initPath(this);
+
+		// defined in children classes
+		this._project();
+		this._update();
+
+		this._renderer._addPath(this);
+	},
+
+	onRemove: function () {
+		this._renderer._removePath(this);
+	},
+
+	getEvents: function () {
+		return {
+			viewreset: this._project,
+			moveend: this._update
+		};
+	},
+
+	redraw: function () {
+		if (this._map) {
+			this._renderer._updatePath(this);
+		}
+		return this;
+	},
+
+	setStyle: function (style) {
+		L.setOptions(this, style);
+		if (this._renderer) {
+			this._renderer._updateStyle(this);
+		}
+		return this;
+	},
+
+	bringToFront: function () {
+		this._renderer._bringToFront(this);
+		return this;
+	},
+
+	bringToBack: function () {
+		this._renderer._bringToBack(this);
+		return this;
+	},
+
+	_fireMouseEvent: function (e, type) {
+		this._map._fireMouseEvent(this, e, type, true);
+	},
+
+	_clickTolerance: function () {
+		// used when doing hit detection for Canvas layers
+		return (this.options.stroke ? this.options.weight / 2 : 0) + (L.Browser.touch ? 10 : 0);
+	}
+});

data/lib/leaflet/src/layer/vector/Polygon.js

@@ -0,0 +1,75 @@
+/*
+ * L.Polygon implements polygon vector layer (closed polyline with a fill inside).
+ */
+
+L.Polygon = L.Polyline.extend({
+
+	options: {
+		fill: true
+	},
+
+	getCenter: function () {
+		var i, j, len, p1, p2, f, area, x, y,
+		    points = this._rings[0];
+
+		// polygon centroid algorithm; only uses the first ring if there are multiple
+
+		area = x = y = 0;
+
+		for (i = 0, len = points.length, j = len - 1; i < len; j = i++) {
+			p1 = points[i];
+			p2 = points[j];
+
+			f = p1.y * p2.x - p2.y * p1.x;
+			x += (p1.x + p2.x) * f;
+			y += (p1.y + p2.y) * f;
+			area += f * 3;
+		}
+
+		return this._map.layerPointToLatLng([x / area, y / area]);
+	},
+
+	_convertLatLngs: function (latlngs) {
+		var result = L.Polyline.prototype._convertLatLngs.call(this, latlngs),
+		    len = result.length;
+
+		// remove last point if it equals first one
+		if (len >= 2 && result[0] instanceof L.LatLng && result[0].equals(result[len - 1])) {
+			result.pop();
+		}
+		return result;
+	},
+
+	_clipPoints: function () {
+		if (this.options.noClip) {
+			this._parts = this._rings;
+			return;
+		}
+
+		// polygons need a different clipping algorithm so we redefine that
+
+		var bounds = this._renderer._bounds,
+		    w = this.options.weight,
+		    p = new L.Point(w, w);
+
+		// increase clip padding by stroke width to avoid stroke on clip edges
+		bounds = new L.Bounds(bounds.min.subtract(p), bounds.max.add(p));
+
+		this._parts = [];
+
+		for (var i = 0, len = this._rings.length, clipped; i < len; i++) {
+			clipped = L.PolyUtil.clipPolygon(this._rings[i], bounds);
+			if (clipped.length) {
+				this._parts.push(clipped);
+			}
+		}
+	},
+
+	_updatePath: function () {
+		this._renderer._updatePoly(this, true);
+	}
+});
+
+L.polygon = function (latlngs, options) {
+	return new L.Polygon(latlngs, options);
+};

data/lib/leaflet/src/layer/vector/Polyline.js

@@ -0,0 +1,223 @@
+/*
+ * L.Polyline implements polyline vector layer (a set of points connected with lines)
+ */
+
+L.Polyline = L.Path.extend({
+
+	options: {
+		// how much to simplify the polyline on each zoom level
+		// more = better performance and smoother look, less = more accurate
+		smoothFactor: 1.0
+		// noClip: false
+	},
+
+	initialize: function (latlngs, options) {
+		L.setOptions(this, options);
+		this._setLatLngs(latlngs);
+	},
+
+	getLatLngs: function () {
+		// TODO rings
+		return this._latlngs;
+	},
+
+	setLatLngs: function (latlngs) {
+		this._setLatLngs(latlngs);
+		return this.redraw();
+	},
+
+	addLatLng: function (latlng) {
+		// TODO rings
+		latlng = L.latLng(latlng);
+		this._latlngs.push(latlng);
+		this._bounds.extend(latlng);
+		return this.redraw();
+	},
+
+	spliceLatLngs: function () {
+		// TODO rings
+		var removed = [].splice.apply(this._latlngs, arguments);
+		this._setLatLngs(this._latlngs);
+		this.redraw();
+		return removed;
+	},
+
+	closestLayerPoint: function (p) {
+		var minDistance = Infinity,
+		    minPoint = null,
+		    closest = L.LineUtil._sqClosestPointOnSegment,
+		    p1, p2;
+
+		for (var j = 0, jLen = this._parts.length; j < jLen; j++) {
+			var points = this._parts[j];
+
+			for (var i = 1, len = points.length; i < len; i++) {
+				p1 = points[i - 1];
+				p2 = points[i];
+
+				var sqDist = closest(p, p1, p2, true);
+
+				if (sqDist < minDistance) {
+					minDistance = sqDist;
+					minPoint = closest(p, p1, p2);
+				}
+			}
+		}
+		if (minPoint) {
+			minPoint.distance = Math.sqrt(minDistance);
+		}
+		return minPoint;
+	},
+
+	getCenter: function () {
+		var i, halfDist, segDist, dist, p1, p2, ratio,
+		    points = this._rings[0],
+		    len = points.length;
+
+		// polyline centroid algorithm; only uses the first ring if there are multiple
+
+		for (i = 0, halfDist = 0; i < len - 1; i++) {
+			halfDist += points[i].distanceTo(points[i + 1]) / 2;
+		}
+
+		for (i = 0, dist = 0; i < len - 1; i++) {
+			p1 = points[i];
+			p2 = points[i + 1];
+			segDist = p1.distanceTo(p2);
+			dist += segDist;
+
+			if (dist > halfDist) {
+				ratio = (dist - halfDist) / segDist;
+				return this._map.layerPointToLatLng([
+					p2.x - ratio * (p2.x - p1.x),
+					p2.y - ratio * (p2.y - p1.y)
+				]);
+			}
+		}
+	},
+
+	getBounds: function () {
+		return this._bounds;
+	},
+
+	_setLatLngs: function (latlngs) {
+		this._bounds = new L.LatLngBounds();
+		this._latlngs = this._convertLatLngs(latlngs);
+	},
+
+	// recursively convert latlngs input into actual LatLng instances; calculate bounds along the way
+	_convertLatLngs: function (latlngs) {
+		var result = [],
+		    flat = this._flat(latlngs);
+
+		for (var i = 0, len = latlngs.length; i < len; i++) {
+			if (flat) {
+				result[i] = L.latLng(latlngs[i]);
+				this._bounds.extend(result[i]);
+			} else {
+				result[i] = this._convertLatLngs(latlngs[i]);
+			}
+		}
+
+		return result;
+	},
+
+	_flat: function (latlngs) {
+		// true if it's a flat array of latlngs; false if nested
+		return !L.Util.isArray(latlngs[0]) || typeof latlngs[0][0] !== 'object';
+	},
+
+	_project: function () {
+		this._rings = [];
+		this._projectLatlngs(this._latlngs, this._rings);
+
+		// project bounds as well to use later for Canvas hit detection/etc.
+		var w = this._clickTolerance(),
+			p = new L.Point(w, -w);
+
+		if (this._latlngs.length) {
+			this._pxBounds = new L.Bounds(
+				this._map.latLngToLayerPoint(this._bounds.getSouthWest())._subtract(p),
+				this._map.latLngToLayerPoint(this._bounds.getNorthEast())._add(p));
+		}
+	},
+
+	// recursively turns latlngs into a set of rings with projected coordinates
+	_projectLatlngs: function (latlngs, result) {
+
+		var flat = latlngs[0] instanceof L.LatLng,
+		    len = latlngs.length,
+		    i, ring;
+
+		if (flat) {
+			ring = [];
+			for (i = 0; i < len; i++) {
+				ring[i] = this._map.latLngToLayerPoint(latlngs[i]);
+			}
+			result.push(ring);
+		} else {
+			for (i = 0; i < len; i++) {
+				this._projectLatlngs(latlngs[i], result);
+			}
+		}
+	},
+
+	// clip polyline by renderer bounds so that we have less to render for performance
+	_clipPoints: function () {
+		if (this.options.noClip) {
+			this._parts = this._rings;
+			return;
+		}
+
+		this._parts = [];
+
+		var parts = this._parts,
+		    bounds = this._renderer._bounds,
+		    i, j, k, len, len2, segment, points;
+
+		for (i = 0, k = 0, len = this._rings.length; i < len; i++) {
+			points = this._rings[i];
+
+			for (j = 0, len2 = points.length; j < len2 - 1; j++) {
+				segment = L.LineUtil.clipSegment(points[j], points[j + 1], bounds, j);
+
+				if (!segment) { continue; }
+
+				parts[k] = parts[k] || [];
+				parts[k].push(segment[0]);
+
+				// if segment goes out of screen, or it's the last one, it's the end of the line part
+				if ((segment[1] !== points[j + 1]) || (j === len2 - 2)) {
+					parts[k].push(segment[1]);
+					k++;
+				}
+			}
+		}
+	},
+
+	// simplify each clipped part of the polyline for performance
+	_simplifyPoints: function () {
+		var parts = this._parts,
+			tolerance = this.options.smoothFactor;
+
+		for (var i = 0, len = parts.length; i < len; i++) {
+			parts[i] = L.LineUtil.simplify(parts[i], tolerance);
+		}
+	},
+
+	_update: function () {
+		if (!this._map) { return; }
+
+		this._clipPoints();
+		this._simplifyPoints();
+		this._updatePath();
+	},
+
+	_updatePath: function () {
+		this._renderer._updatePoly(this);
+	}
+});
+
+L.polyline = function (latlngs, options) {
+	return new L.Polyline(latlngs, options);
+};