leaflet-js 0.7.9 → 0.8.dev2

data/{vendor/assets/Leaflet → lib/leaflet}/src/layer/vector/Rectangle.js

@@ -1,27 +1,27 @@
-/*
- * L.Rectangle extends Polygon and creates a rectangle when passed a LatLngBounds object.
- */
-
-L.Rectangle = L.Polygon.extend({
-	initialize: function (latLngBounds, options) {
-		L.Polygon.prototype.initialize.call(this, this._boundsToLatLngs(latLngBounds), options);
-	},
-
-	setBounds: function (latLngBounds) {
-		this.setLatLngs(this._boundsToLatLngs(latLngBounds));
-	},
-
-	_boundsToLatLngs: function (latLngBounds) {
-		latLngBounds = L.latLngBounds(latLngBounds);
-		return [
-			latLngBounds.getSouthWest(),
-			latLngBounds.getNorthWest(),
-			latLngBounds.getNorthEast(),
-			latLngBounds.getSouthEast()
-		];
-	}
-});
-
-L.rectangle = function (latLngBounds, options) {
-	return new L.Rectangle(latLngBounds, options);
-};
+/*
+ * L.Rectangle extends Polygon and creates a rectangle when passed a LatLngBounds object.
+ */
+
+L.Rectangle = L.Polygon.extend({
+	initialize: function (latLngBounds, options) {
+		L.Polygon.prototype.initialize.call(this, this._boundsToLatLngs(latLngBounds), options);
+	},
+
+	setBounds: function (latLngBounds) {
+		this.setLatLngs(this._boundsToLatLngs(latLngBounds));
+	},
+
+	_boundsToLatLngs: function (latLngBounds) {
+		latLngBounds = L.latLngBounds(latLngBounds);
+		return [
+			latLngBounds.getSouthWest(),
+			latLngBounds.getNorthWest(),
+			latLngBounds.getNorthEast(),
+			latLngBounds.getSouthEast()
+		];
+	}
+});
+
+L.rectangle = function (latLngBounds, options) {
+	return new L.Rectangle(latLngBounds, options);
+};

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

@@ -0,0 +1,75 @@
+/*
+ * L.Renderer is a base class for renderer implementations (SVG, Canvas);
+ * handles renderer container, bounds and zoom animation.
+ */
+
+L.Renderer = L.Layer.extend({
+
+	options: {
+		// how much to extend the clip area around the map view (relative to its size)
+		// e.g. 0.1 would be 10% of map view in each direction; defaults to clip with the map view
+		padding: 0
+	},
+
+	initialize: function (options) {
+		L.setOptions(this, options);
+		L.stamp(this);
+	},
+
+	onAdd: function () {
+		if (!this._container) {
+			this._initContainer(); // defined by renderer implementations
+
+			if (this._zoomAnimated) {
+				L.DomUtil.addClass(this._container, 'leaflet-zoom-animated');
+			}
+		}
+
+		this.getPane().appendChild(this._container);
+		this._update();
+	},
+
+	onRemove: function () {
+		L.DomUtil.remove(this._container);
+	},
+
+	getEvents: function () {
+		var events = {
+			moveend: this._update
+		};
+		if (this._zoomAnimated) {
+			events.zoomanim = this._animateZoom;
+		}
+		return events;
+	},
+
+	_animateZoom: function (e) {
+		var origin = e.origin.subtract(this._map._getCenterLayerPoint()),
+		    offset = this._bounds.min.add(origin.multiplyBy(1 - e.scale));
+
+		L.DomUtil.setTransform(this._container, offset, e.scale);
+	},
+
+	_update: function () {
+		// update pixel bounds of renderer container (for positioning/sizing/clipping later)
+		var p = this.options.padding,
+		    size = this._map.getSize(),
+		    min = this._map.containerPointToLayerPoint(size.multiplyBy(-p)).round();
+
+		this._bounds = new L.Bounds(min, min.add(size.multiplyBy(1 + p * 2)).round());
+	}
+});
+
+
+L.Map.include({
+	// used by each vector layer to decide which renderer to use
+	getRenderer: function (layer) {
+		var renderer = layer.options.renderer || this.options.renderer ||
+				(L.SVG && L.SVG.instance) || (L.Canvas && L.Canvas.instance);
+
+		if (!this.hasLayer(renderer)) {
+			this.addLayer(renderer);
+		}
+		return renderer;
+	}
+});

data/lib/leaflet/src/layer/vector/SVG.VML.js

@@ -0,0 +1,134 @@
+/*
+ * Vector rendering for IE7-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;
+	}
+}());
+
+// redefine some SVG methods to handle VML syntax which is similar but with some differences
+L.SVG.include(!L.Browser.vml ? {} : {
+
+	_initContainer: function () {
+		this._container = L.DomUtil.create('div', 'leaflet-vml-container');
+	},
+
+	_update: function () {
+		if (this._map._animatingZoom) { return; }
+		L.Renderer.prototype._update.call(this);
+	},
+
+	_initPath: function (layer) {
+		var container = layer._container = L.SVG.create('shape');
+
+		L.DomUtil.addClass(container, 'leaflet-vml-shape ' + (this.options.className || ''));
+
+		container.coordsize = '1 1';
+
+		layer._path = L.SVG.create('path');
+		container.appendChild(layer._path);
+
+		if (layer.options.clickable) {
+			this._initEvents(layer, container);
+		}
+
+		this._updateStyle(layer);
+	},
+
+	_addPath: function (layer) {
+		this._container.appendChild(layer._container);
+	},
+
+	_removePath: function (layer) {
+		L.DomUtil.remove(layer._container);
+	},
+
+	_updateStyle: function (layer) {
+		var stroke = layer._stroke,
+		    fill = layer._fill,
+		    options = layer.options,
+		    container = layer._container;
+
+		container.stroked = !!options.stroke;
+		container.filled = !!options.fill;
+
+		if (options.stroke) {
+			if (!stroke) {
+				stroke = layer._stroke = L.SVG.create('stroke');
+				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 = '';
+			}
+			stroke.endcap = options.lineCap.replace('butt', 'flat');
+			stroke.joinstyle = options.lineJoin;
+
+		} else if (stroke) {
+			container.removeChild(stroke);
+			layer._stroke = null;
+		}
+
+		if (options.fill) {
+			if (!fill) {
+				fill = layer._fill = L.SVG.create('fill');
+				container.appendChild(fill);
+			}
+			fill.color = options.fillColor || options.color;
+			fill.opacity = options.fillOpacity;
+
+		} else if (fill) {
+			container.removeChild(fill);
+			layer._fill = null;
+		}
+	},
+
+	_updateCircle: function (layer) {
+		var p = layer._point,
+		    r = Math.round(layer._radius),
+		    r2 = Math.round(layer._radiusY || r);
+
+		this._setPath(layer, layer._empty() ? 'M0 0' :
+				'AL ' + p.x + ',' + p.y + ' ' + r + ',' + r2 + ' 0,' + (65535 * 360));
+	},
+
+	_setPath: function (layer, path) {
+		layer._path.v = path;
+	}
+});
+
+if (L.Browser.vml) {
+	L.SVG.create = (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">');
+			};
+		}
+	})();
+
+	L.SVG.instance = L.svg();
+}

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

@@ -0,0 +1,189 @@
+/*
+ * L.SVG renders vector layers with SVG. All SVG-specific code goes here.
+ */
+
+L.SVG = L.Renderer.extend({
+
+	_initContainer: function () {
+		this._container = L.SVG.create('svg');
+
+		this._paths = {};
+		this._initEvents();
+
+		// makes it possible to click through svg root; we'll reset it back in individual paths
+		this._container.setAttribute('pointer-events', 'none');
+	},
+
+	_update: function () {
+		if (this._map._animatingZoom) { return; }
+
+		L.Renderer.prototype._update.call(this);
+
+		var b = this._bounds,
+		    size = b.getSize(),
+		    container = this._container,
+		    pane = this.getPane();
+
+		// hack to make flicker on drag end on mobile webkit less irritating
+		if (L.Browser.mobileWebkit) {
+			pane.removeChild(container);
+		}
+
+		L.DomUtil.setPosition(container, b.min);
+
+		// update container viewBox so that we don't have to change coordinates of individual layers
+		container.setAttribute('width', size.x);
+		container.setAttribute('height', size.y);
+		container.setAttribute('viewBox', [b.min.x, b.min.y, size.x, size.y].join(' '));
+
+		if (L.Browser.mobileWebkit) {
+			pane.appendChild(container);
+		}
+	},
+
+	// methods below are called by vector layers implementations
+
+	_initPath: function (layer) {
+		var path = layer._path = L.SVG.create('path');
+
+		if (layer.options.className) {
+			L.DomUtil.addClass(path, layer.options.className);
+		}
+
+		if (layer.options.clickable) {
+			L.DomUtil.addClass(path, 'leaflet-clickable');
+		}
+
+		this._updateStyle(layer);
+	},
+
+	_addPath: function (layer) {
+		var path = layer._path;
+		this._container.appendChild(path);
+		this._paths[L.stamp(path)] = layer;
+	},
+
+	_removePath: function (layer) {
+		var path = layer._path;
+		L.DomUtil.remove(path);
+		delete this._paths[L.stamp(path)];
+	},
+
+	_updatePath: function (layer) {
+		layer._project();
+		layer._update();
+	},
+
+	_updateStyle: function (layer) {
+		var path = layer._path,
+			options = layer.options;
+
+		if (!path) { return; }
+
+		if (options.stroke) {
+			path.setAttribute('stroke', options.color);
+			path.setAttribute('stroke-opacity', options.opacity);
+			path.setAttribute('stroke-width', options.weight);
+			path.setAttribute('stroke-linecap', options.lineCap);
+			path.setAttribute('stroke-linejoin', options.lineJoin);
+
+			if (options.dashArray) {
+				path.setAttribute('stroke-dasharray', options.dashArray);
+			} else {
+				path.removeAttribute('stroke-dasharray');
+			}
+
+		} else {
+			path.setAttribute('stroke', 'none');
+		}
+
+		if (options.fill) {
+			path.setAttribute('fill', options.fillColor || options.color);
+			path.setAttribute('fill-opacity', options.fillOpacity);
+			path.setAttribute('fill-rule', 'evenodd');
+		} else {
+			path.setAttribute('fill', 'none');
+		}
+
+		path.setAttribute('pointer-events', options.pointerEvents || (options.clickable ? 'auto' : 'none'));
+	},
+
+	_updatePoly: function (layer, closed) {
+		this._setPath(layer, L.SVG.pointsToPath(layer._parts, closed));
+	},
+
+	_updateCircle: function (layer) {
+		var p = layer._point,
+		    r = layer._radius,
+		    r2 = layer._radiusY || r,
+		    arc = 'a' + r + ',' + r2 + ' 0 1,0 ';
+
+		// drawing a circle with two half-arcs
+		var d = layer._empty() ? 'M0 0' :
+				'M' + (p.x - r) + ',' + p.y +
+				arc +  (r * 2) + ',0 ' +
+				arc + (-r * 2) + ',0 ';
+
+		this._setPath(layer, d);
+	},
+
+	_setPath: function (layer, path) {
+		layer._path.setAttribute('d', path);
+	},
+
+	// SVG does not have the concept of zIndex so we resort to changing the DOM order of elements
+	_bringToFront: function (layer) {
+		L.DomUtil.toFront(layer._path);
+	},
+
+	_bringToBack: function (layer) {
+		L.DomUtil.toBack(layer._path);
+	},
+
+	// TODO remove duplication with L.Map
+	_initEvents: function () {
+		L.DomEvent.on(this._container, 'click dblclick mousedown mouseup mouseover mouseout mousemove contextmenu',
+				this._fireMouseEvent, this);
+	},
+
+	_fireMouseEvent: function (e) {
+		this._paths[L.stamp(e.target)]._fireMouseEvent(e);
+	}
+});
+
+
+L.extend(L.SVG, {
+	create: function (name) {
+		return document.createElementNS('http://www.w3.org/2000/svg', name);
+	},
+
+	// generates SVG path string for multiple rings, with each ring turning into "M..L..L.." instructions
+	pointsToPath: function (rings, closed) {
+		var str = '',
+			i, j, len, len2, points, p;
+
+		for (i = 0, len = rings.length; i < len; i++) {
+			points = rings[i];
+
+			for (j = 0, len2 = points.length; j < len2; j++) {
+				p = points[j];
+				str += (j ? 'L' : 'M') + p.x + ' ' + p.y;
+			}
+
+			// closes the ring for polygons; "x" is VML syntax
+			str += closed ? (L.Browser.svg ? 'z' : 'x') : '';
+		}
+
+		// SVG complains about empty path strings
+		return str || 'M0 0';
+	}
+});
+
+L.Browser.svg = !!(document.createElementNS && L.SVG.create('svg').createSVGRect);
+
+L.svg = function (options) {
+	return L.Browser.svg || L.Browser.vml ? new L.SVG(options) : null;
+};
+
+// default instance to use when adding vectors to the map
+L.SVG.instance = L.svg();