leaflet-js 0.7.9 → 0.8.dev2

data/vendor/assets/Leaflet/src/layer/vector/Path.VML.js

@@ -1,135 +0,0 @@
-/*
- * Vector rendering for IE6-8 through VML.
- * Thanks to Dmitry Baranovsky and his Raphael library for inspiration!
- */
-
-L.Browser.vml = !L.Browser.svg && (function () {
-	try {
-		var div = document.createElement('div');
-		div.innerHTML = '<v:shape adj="1"/>';
-
-		var shape = div.firstChild;
-		shape.style.behavior = 'url(#default#VML)';
-
-		return shape && (typeof shape.adj === 'object');
-
-	} catch (e) {
-		return false;
-	}
-}());
-
-L.Path = L.Browser.svg || !L.Browser.vml ? L.Path : L.Path.extend({
-	statics: {
-		VML: true,
-		CLIP_PADDING: 0.02
-	},
-
-	_createElement: (function () {
-		try {
-			document.namespaces.add('lvml', 'urn:schemas-microsoft-com:vml');
-			return function (name) {
-				return document.createElement('<lvml:' + name + ' class="lvml">');
-			};
-		} catch (e) {
-			return function (name) {
-				return document.createElement(
-				        '<' + name + ' xmlns="urn:schemas-microsoft.com:vml" class="lvml">');
-			};
-		}
-	}()),
-
-	_initPath: function () {
-		var container = this._container = this._createElement('shape');
-
-		L.DomUtil.addClass(container, 'leaflet-vml-shape' +
-			(this.options.className ? ' ' + this.options.className : ''));
-
-		if (this.options.clickable) {
-			L.DomUtil.addClass(container, 'leaflet-clickable');
-		}
-
-		container.coordsize = '1 1';
-
-		this._path = this._createElement('path');
-		container.appendChild(this._path);
-
-		this._map._pathRoot.appendChild(container);
-	},
-
-	_initStyle: function () {
-		this._updateStyle();
-	},
-
-	_updateStyle: function () {
-		var stroke = this._stroke,
-		    fill = this._fill,
-		    options = this.options,
-		    container = this._container;
-
-		container.stroked = options.stroke;
-		container.filled = options.fill;
-
-		if (options.stroke) {
-			if (!stroke) {
-				stroke = this._stroke = this._createElement('stroke');
-				stroke.endcap = 'round';
-				container.appendChild(stroke);
-			}
-			stroke.weight = options.weight + 'px';
-			stroke.color = options.color;
-			stroke.opacity = options.opacity;
-
-			if (options.dashArray) {
-				stroke.dashStyle = L.Util.isArray(options.dashArray) ?
-				    options.dashArray.join(' ') :
-				    options.dashArray.replace(/( *, *)/g, ' ');
-			} else {
-				stroke.dashStyle = '';
-			}
-			if (options.lineCap) {
-				stroke.endcap = options.lineCap.replace('butt', 'flat');
-			}
-			if (options.lineJoin) {
-				stroke.joinstyle = options.lineJoin;
-			}
-
-		} else if (stroke) {
-			container.removeChild(stroke);
-			this._stroke = null;
-		}
-
-		if (options.fill) {
-			if (!fill) {
-				fill = this._fill = this._createElement('fill');
-				container.appendChild(fill);
-			}
-			fill.color = options.fillColor || options.color;
-			fill.opacity = options.fillOpacity;
-
-		} else if (fill) {
-			container.removeChild(fill);
-			this._fill = null;
-		}
-	},
-
-	_updatePath: function () {
-		var style = this._container.style;
-
-		style.display = 'none';
-		this._path.v = this.getPathString() + ' '; // the space fixes IE empty path string bug
-		style.display = '';
-	}
-});
-
-L.Map.include(L.Browser.svg || !L.Browser.vml ? {} : {
-	_initPathRoot: function () {
-		if (this._pathRoot) { return; }
-
-		var root = this._pathRoot = document.createElement('div');
-		root.className = 'leaflet-vml-container';
-		this._panes.overlayPane.appendChild(root);
-
-		this.on('moveend', this._updatePathViewport);
-		this._updatePathViewport();
-	}
-});

data/vendor/assets/Leaflet/src/layer/vector/Path.js

@@ -1,119 +0,0 @@
-/*
- * L.Path is a base class for rendering vector paths on a map. Inherited by Polyline, Circle, etc.
- */
-
-L.Path = L.Class.extend({
-	includes: [L.Mixin.Events],
-
-	statics: {
-		// how much to extend the clip area around the map view
-		// (relative to its size, e.g. 0.5 is half the screen in each direction)
-		// set it so that SVG element doesn't exceed 1280px (vectors flicker on dragend if it is)
-		CLIP_PADDING: (function () {
-			var max = L.Browser.mobile ? 1280 : 2000,
-			    target = (max / Math.max(window.outerWidth, window.outerHeight) - 1) / 2;
-			return Math.max(0, Math.min(0.5, target));
-		})()
-	},
-
-	options: {
-		stroke: true,
-		color: '#0033ff',
-		dashArray: null,
-		lineCap: null,
-		lineJoin: null,
-		weight: 5,
-		opacity: 0.5,
-
-		fill: false,
-		fillColor: null, //same as color by default
-		fillOpacity: 0.2,
-
-		clickable: true
-	},
-
-	initialize: function (options) {
-		L.setOptions(this, options);
-	},
-
-	onAdd: function (map) {
-		this._map = map;
-
-		if (!this._container) {
-			this._initElements();
-			this._initEvents();
-		}
-
-		this.projectLatlngs();
-		this._updatePath();
-
-		if (this._container) {
-			this._map._pathRoot.appendChild(this._container);
-		}
-
-		this.fire('add');
-
-		map.on({
-			'viewreset': this.projectLatlngs,
-			'moveend': this._updatePath
-		}, this);
-	},
-
-	addTo: function (map) {
-		map.addLayer(this);
-		return this;
-	},
-
-	onRemove: function (map) {
-		map._pathRoot.removeChild(this._container);
-
-		// Need to fire remove event before we set _map to null as the event hooks might need the object
-		this.fire('remove');
-		this._map = null;
-
-		if (L.Browser.vml) {
-			this._container = null;
-			this._stroke = null;
-			this._fill = null;
-		}
-
-		map.off({
-			'viewreset': this.projectLatlngs,
-			'moveend': this._updatePath
-		}, this);
-	},
-
-	projectLatlngs: function () {
-		// do all projection stuff here
-	},
-
-	setStyle: function (style) {
-		L.setOptions(this, style);
-
-		if (this._container) {
-			this._updateStyle();
-		}
-
-		return this;
-	},
-
-	redraw: function () {
-		if (this._map) {
-			this.projectLatlngs();
-			this._updatePath();
-		}
-		return this;
-	}
-});
-
-L.Map.include({
-	_updatePathViewport: function () {
-		var p = L.Path.CLIP_PADDING,
-		    size = this.getSize(),
-		    panePos = L.DomUtil.getPosition(this._mapPane),
-		    min = panePos.multiplyBy(-1)._subtract(size.multiplyBy(p)._round()),
-		    max = min.add(size.multiplyBy(1 + p * 2)._round());
-
-		this._pathViewport = new L.Bounds(min, max);
-	}
-});

data/vendor/assets/Leaflet/src/layer/vector/Polygon.js

@@ -1,92 +0,0 @@
-/*
- * L.Polygon is used to display polygons on a map.
- */
-
-L.Polygon = L.Polyline.extend({
-	options: {
-		fill: true
-	},
-
-	initialize: function (latlngs, options) {
-		L.Polyline.prototype.initialize.call(this, latlngs, options);
-		this._initWithHoles(latlngs);
-	},
-
-	_initWithHoles: function (latlngs) {
-		var i, len, hole;
-		if (latlngs && L.Util.isArray(latlngs[0]) && (typeof latlngs[0][0] !== 'number')) {
-			this._latlngs = this._convertLatLngs(latlngs[0]);
-			this._holes = latlngs.slice(1);
-
-			for (i = 0, len = this._holes.length; i < len; i++) {
-				hole = this._holes[i] = this._convertLatLngs(this._holes[i]);
-				if (hole[0].equals(hole[hole.length - 1])) {
-					hole.pop();
-				}
-			}
-		}
-
-		// filter out last point if its equal to the first one
-		latlngs = this._latlngs;
-
-		if (latlngs.length >= 2 && latlngs[0].equals(latlngs[latlngs.length - 1])) {
-			latlngs.pop();
-		}
-	},
-
-	projectLatlngs: function () {
-		L.Polyline.prototype.projectLatlngs.call(this);
-
-		// project polygon holes points
-		// TODO move this logic to Polyline to get rid of duplication
-		this._holePoints = [];
-
-		if (!this._holes) { return; }
-
-		var i, j, len, len2;
-
-		for (i = 0, len = this._holes.length; i < len; i++) {
-			this._holePoints[i] = [];
-
-			for (j = 0, len2 = this._holes[i].length; j < len2; j++) {
-				this._holePoints[i][j] = this._map.latLngToLayerPoint(this._holes[i][j]);
-			}
-		}
-	},
-
-	setLatLngs: function (latlngs) {
-		if (latlngs && L.Util.isArray(latlngs[0]) && (typeof latlngs[0][0] !== 'number')) {
-			this._initWithHoles(latlngs);
-			return this.redraw();
-		} else {
-			return L.Polyline.prototype.setLatLngs.call(this, latlngs);
-		}
-	},
-
-	_clipPoints: function () {
-		var points = this._originalPoints,
-		    newParts = [];
-
-		this._parts = [points].concat(this._holePoints);
-
-		if (this.options.noClip) { return; }
-
-		for (var i = 0, len = this._parts.length; i < len; i++) {
-			var clipped = L.PolyUtil.clipPolygon(this._parts[i], this._map._pathViewport);
-			if (clipped.length) {
-				newParts.push(clipped);
-			}
-		}
-
-		this._parts = newParts;
-	},
-
-	_getPathPartStr: function (points) {
-		var str = L.Polyline.prototype._getPathPartStr.call(this, points);
-		return str + (L.Browser.svg ? 'z' : 'x');
-	}
-});
-
-L.polygon = function (latlngs, options) {
-	return new L.Polygon(latlngs, options);
-};

data/vendor/assets/Leaflet/src/layer/vector/Polyline.js

@@ -1,164 +0,0 @@
-/*
- * L.Polyline is used to display polylines on a map.
- */
-
-L.Polyline = L.Path.extend({
-	initialize: function (latlngs, options) {
-		L.Path.prototype.initialize.call(this, options);
-
-		this._latlngs = this._convertLatLngs(latlngs);
-	},
-
-	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
-	},
-
-	projectLatlngs: function () {
-		this._originalPoints = [];
-
-		for (var i = 0, len = this._latlngs.length; i < len; i++) {
-			this._originalPoints[i] = this._map.latLngToLayerPoint(this._latlngs[i]);
-		}
-	},
-
-	getPathString: function () {
-		for (var i = 0, len = this._parts.length, str = ''; i < len; i++) {
-			str += this._getPathPartStr(this._parts[i]);
-		}
-		return str;
-	},
-
-	getLatLngs: function () {
-		return this._latlngs;
-	},
-
-	setLatLngs: function (latlngs) {
-		this._latlngs = this._convertLatLngs(latlngs);
-		return this.redraw();
-	},
-
-	addLatLng: function (latlng) {
-		this._latlngs.push(L.latLng(latlng));
-		return this.redraw();
-	},
-
-	spliceLatLngs: function () { // (Number index, Number howMany)
-		var removed = [].splice.apply(this._latlngs, arguments);
-		this._convertLatLngs(this._latlngs, true);
-		this.redraw();
-		return removed;
-	},
-
-	closestLayerPoint: function (p) {
-		var minDistance = Infinity, parts = this._parts, p1, p2, minPoint = null;
-
-		for (var j = 0, jLen = parts.length; j < jLen; j++) {
-			var points = parts[j];
-			for (var i = 1, len = points.length; i < len; i++) {
-				p1 = points[i - 1];
-				p2 = points[i];
-				var sqDist = L.LineUtil._sqClosestPointOnSegment(p, p1, p2, true);
-				if (sqDist < minDistance) {
-					minDistance = sqDist;
-					minPoint = L.LineUtil._sqClosestPointOnSegment(p, p1, p2);
-				}
-			}
-		}
-		if (minPoint) {
-			minPoint.distance = Math.sqrt(minDistance);
-		}
-		return minPoint;
-	},
-
-	getBounds: function () {
-		return new L.LatLngBounds(this.getLatLngs());
-	},
-
-	_convertLatLngs: function (latlngs, overwrite) {
-		var i, len, target = overwrite ? latlngs : [];
-
-		for (i = 0, len = latlngs.length; i < len; i++) {
-			if (L.Util.isArray(latlngs[i]) && typeof latlngs[i][0] !== 'number') {
-				return;
-			}
-			target[i] = L.latLng(latlngs[i]);
-		}
-		return target;
-	},
-
-	_initEvents: function () {
-		L.Path.prototype._initEvents.call(this);
-	},
-
-	_getPathPartStr: function (points) {
-		var round = L.Path.VML;
-
-		for (var j = 0, len2 = points.length, str = '', p; j < len2; j++) {
-			p = points[j];
-			if (round) {
-				p._round();
-			}
-			str += (j ? 'L' : 'M') + p.x + ' ' + p.y;
-		}
-		return str;
-	},
-
-	_clipPoints: function () {
-		var points = this._originalPoints,
-		    len = points.length,
-		    i, k, segment;
-
-		if (this.options.noClip) {
-			this._parts = [points];
-			return;
-		}
-
-		this._parts = [];
-
-		var parts = this._parts,
-		    vp = this._map._pathViewport,
-		    lu = L.LineUtil;
-
-		for (i = 0, k = 0; i < len - 1; i++) {
-			segment = lu.clipSegment(points[i], points[i + 1], vp, i);
-			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[i + 1]) || (i === len - 2)) {
-				parts[k].push(segment[1]);
-				k++;
-			}
-		}
-	},
-
-	// simplify each clipped part of the polyline
-	_simplifyPoints: function () {
-		var parts = this._parts,
-		    lu = L.LineUtil;
-
-		for (var i = 0, len = parts.length; i < len; i++) {
-			parts[i] = lu.simplify(parts[i], this.options.smoothFactor);
-		}
-	},
-
-	_updatePath: function () {
-		if (!this._map) { return; }
-
-		this._clipPoints();
-		this._simplifyPoints();
-
-		L.Path.prototype._updatePath.call(this);
-	}
-});
-
-L.polyline = function (latlngs, options) {
-	return new L.Polyline(latlngs, options);
-};