leaflet-ruby 0.3.beta1

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

@@ -0,0 +1,68 @@
+/*
+ * L.Circle is a circle overlay (with a certain radius in meters).
+ */
+
+L.Circle = L.Path.extend({
+	initialize: function (latlng, radius, options) {
+		L.Path.prototype.initialize.call(this, options);
+
+		this._latlng = latlng;
+		this._mRadius = radius;
+	},
+
+	options: {
+		fill: true
+	},
+
+	setLatLng: function (latlng) {
+		this._latlng = latlng;
+		this._redraw();
+		return this;
+	},
+
+	setRadius: function (radius) {
+		this._mRadius = radius;
+		this._redraw();
+		return this;
+	},
+
+	projectLatlngs: function () {
+		var equatorLength = 40075017,
+			hLength = equatorLength * Math.cos(L.LatLng.DEG_TO_RAD * this._latlng.lat);
+
+		var lngSpan = (this._mRadius / hLength) * 360,
+			latlng2 = new L.LatLng(this._latlng.lat, this._latlng.lng - lngSpan, true),
+			point2 = this._map.latLngToLayerPoint(latlng2);
+
+		this._point = this._map.latLngToLayerPoint(this._latlng);
+		this._radius = Math.round(this._point.x - point2.x);
+	},
+
+	getPathString: function () {
+		var p = this._point,
+			r = this._radius;
+
+		if (this._checkIfEmpty()) {
+			return '';
+		}
+
+		if (L.Browser.svg) {
+			return "M" + p.x + "," + (p.y - r) +
+					"A" + r + "," + r + ",0,1,1," +
+					(p.x - 0.1) + "," + (p.y - r) + " z";
+		} else {
+			p._round();
+			r = Math.round(r);
+			return "AL " + p.x + "," + p.y + " " + r + "," + r + " 0," + (65535 * 360);
+		}
+	},
+
+	_checkIfEmpty: function () {
+		var vp = this._map._pathViewport,
+			r = this._radius,
+			p = this._point;
+
+		return p.x - r > vp.max.x || p.y - r > vp.max.y ||
+			p.x + r < vp.min.x || p.y + r < vp.min.y;
+	}
+});

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

@@ -0,0 +1,25 @@
+/*
+ * L.CircleMarker is a circle overlay with a permanent pixel radius.
+ */
+
+L.CircleMarker = L.Circle.extend({
+	options: {
+		radius: 10,
+		weight: 2
+	},
+
+	initialize: function (latlng, options) {
+		L.Circle.prototype.initialize.call(this, latlng, null, options);
+		this._radius = this.options.radius;
+	},
+
+	projectLatlngs: function () {
+		this._point = this._map.latLngToLayerPoint(this._latlng);
+	},
+
+	setRadius: function (radius) {
+		this._radius = radius;
+		this._redraw();
+		return this;
+	}
+});

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

@@ -0,0 +1,34 @@
+/*
+ * Contains L.MultiPolyline and L.MultiPolygon layers.
+ */
+
+(function () {
+	function createMulti(Klass) {
+		return L.FeatureGroup.extend({
+			initialize: function (latlngs, options) {
+				this._layers = {};
+				this._options = options;
+				this.setLatLngs(latlngs);
+			},
+
+			setLatLngs: function (latlngs) {
+				var i = 0, len = latlngs.length;
+
+				this._iterateLayers(function (layer) {
+					if (i < len) {
+						layer.setLatLngs(latlngs[i++]);
+					} else {
+						this.removeLayer(layer);
+					}
+				}, this);
+
+				while (i < len) {
+					this.addLayer(new Klass(latlngs[i++], this._options));
+				}
+			}
+		});
+	}
+
+	L.MultiPolyline = createMulti(L.Polyline);
+	L.MultiPolygon = createMulti(L.Polygon);
+}());

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

@@ -0,0 +1,24 @@
+/*
+ * Popup extension to L.Path (polylines, polygons, circles), adding bindPopup method.
+ */
+
+L.Path.include({
+	bindPopup: function (content, options) {
+		if (!this._popup || this._popup.options !== options) {
+			this._popup = new L.Popup(options);
+		}
+		this._popup.setContent(content);
+
+		if (!this._openPopupAdded) {
+			this.on('click', this._openPopup, this);
+			this._openPopupAdded = true;
+		}
+
+		return this;
+	},
+
+	_openPopup: function (e) {
+		this._popup.setLatLng(e.latlng);
+		this._map.openPopup(this._popup);
+	}
+});

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

@@ -0,0 +1,138 @@
+L.Path.SVG_NS = 'http://www.w3.org/2000/svg';
+
+L.Browser.svg = !!(document.createElementNS && document.createElementNS(L.Path.SVG_NS, 'svg').createSVGRect);
+
+L.Path = L.Path.extend({
+	statics: {
+		SVG: L.Browser.svg,
+		_createElement: function (name) {
+			return document.createElementNS(L.Path.SVG_NS, name);
+		}
+	},
+
+	getPathString: function () {
+		// form path string here
+	},
+
+	_initElements: function () {
+		this._map._initPathRoot();
+		this._initPath();
+		this._initStyle();
+	},
+
+	_initPath: function () {
+		this._container = L.Path._createElement('g');
+
+		this._path = L.Path._createElement('path');
+		this._container.appendChild(this._path);
+
+		this._map._pathRoot.appendChild(this._container);
+	},
+
+	_initStyle: function () {
+		if (this.options.stroke) {
+			this._path.setAttribute('stroke-linejoin', 'round');
+			this._path.setAttribute('stroke-linecap', 'round');
+		}
+		if (this.options.fill) {
+			this._path.setAttribute('fill-rule', 'evenodd');
+		} else {
+			this._path.setAttribute('fill', 'none');
+		}
+		this._updateStyle();
+	},
+
+	_updateStyle: function () {
+		if (this.options.stroke) {
+			this._path.setAttribute('stroke', this.options.color);
+			this._path.setAttribute('stroke-opacity', this.options.opacity);
+			this._path.setAttribute('stroke-width', this.options.weight);
+		}
+		if (this.options.fill) {
+			this._path.setAttribute('fill', this.options.fillColor || this.options.color);
+			this._path.setAttribute('fill-opacity', this.options.fillOpacity);
+		}
+	},
+
+	_updatePath: function () {
+		var str = this.getPathString();
+		if (!str) {
+			// fix webkit empty string parsing bug
+			str = 'M0 0';
+		}
+		this._path.setAttribute('d', str);
+	},
+
+	// TODO remove duplication with L.Map
+	_initEvents: function () {
+		if (this.options.clickable) {
+			if (!L.Browser.vml) {
+				this._path.setAttribute('class', 'leaflet-clickable');
+			}
+
+			L.DomEvent.addListener(this._container, 'click', this._onMouseClick, this);
+
+			var events = ['dblclick', 'mousedown', 'mouseover', 'mouseout', 'mousemove'];
+			for (var i = 0; i < events.length; i++) {
+				L.DomEvent.addListener(this._container, events[i], this._fireMouseEvent, this);
+			}
+		}
+	},
+
+	_onMouseClick: function (e) {
+		if (this._map.dragging && this._map.dragging.moved()) {
+			return;
+		}
+		this._fireMouseEvent(e);
+	},
+
+	_fireMouseEvent: function (e) {
+		if (!this.hasEventListeners(e.type)) {
+			return;
+		}
+		this.fire(e.type, {
+			latlng: this._map.mouseEventToLatLng(e),
+			layerPoint: this._map.mouseEventToLayerPoint(e)
+		});
+		L.DomEvent.stopPropagation(e);
+	}
+});
+
+L.Map.include({
+	_initPathRoot: function () {
+		if (!this._pathRoot) {
+			this._pathRoot = L.Path._createElement('svg');
+			this._panes.overlayPane.appendChild(this._pathRoot);
+
+			this.on('moveend', this._updateSvgViewport);
+			this._updateSvgViewport();
+		}
+	},
+
+	_updateSvgViewport: function () {
+		this._updatePathViewport();
+
+		var vp = this._pathViewport,
+			min = vp.min,
+			max = vp.max,
+			width = max.x - min.x,
+			height = max.y - min.y,
+			root = this._pathRoot,
+			pane = this._panes.overlayPane;
+
+		// Hack to make flicker on drag end on mobile webkit less irritating
+		// Unfortunately I haven't found a good workaround for this yet
+		if (L.Browser.webkit) {
+			pane.removeChild(root);
+		}
+
+		L.DomUtil.setPosition(root, min);
+		root.setAttribute('width', width);
+		root.setAttribute('height', height);
+		root.setAttribute('viewBox', [min.x, min.y, width, height].join(' '));
+
+		if (L.Browser.webkit) {
+			pane.appendChild(root);
+		}
+	}
+});

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

@@ -0,0 +1,93 @@
+/*
+ * Vector rendering for IE6-8 through VML.
+ * Thanks to Dmitry Baranovsky and his Raphael library for inspiration!
+ */
+
+L.Browser.vml = (function () {
+	var d = document.createElement('div'), s;
+	d.innerHTML = '<v:shape adj="1"/>';
+	s = d.firstChild;
+	s.style.behavior = 'url(#default#VML)';
+
+	return (s && (typeof s.adj === 'object'));
+}());
+
+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 () {
+		this._container = L.Path._createElement('shape');
+		this._container.className += ' leaflet-vml-shape' +
+				(this.options.clickable ? ' leaflet-clickable' : '');
+		this._container.coordsize = '1 1';
+
+		this._path = L.Path._createElement('path');
+		this._container.appendChild(this._path);
+
+		this._map._pathRoot.appendChild(this._container);
+	},
+
+	_initStyle: function () {
+		if (this.options.stroke) {
+			this._stroke = L.Path._createElement('stroke');
+			this._stroke.endcap = 'round';
+			this._container.appendChild(this._stroke);
+		} else {
+			this._container.stroked = false;
+		}
+		if (this.options.fill) {
+			this._container.filled = true;
+			this._fill = L.Path._createElement('fill');
+			this._container.appendChild(this._fill);
+		} else {
+			this._container.filled = false;
+		}
+		this._updateStyle();
+	},
+
+	_updateStyle: function () {
+		if (this.options.stroke) {
+			this._stroke.weight = this.options.weight + 'px';
+			this._stroke.color = this.options.color;
+			this._stroke.opacity = this.options.opacity;
+		}
+		if (this.options.fill) {
+			this._fill.color = this.options.fillColor || this.options.color;
+			this._fill.opacity = this.options.fillOpacity;
+		}
+	},
+
+	_updatePath: function () {
+		this._container.style.display = 'none';
+		this._path.v = this.getPathString() + ' '; // the space fixes IE empty path string bug
+		this._container.style.display = '';
+	}
+});
+
+L.Map.include(L.Browser.svg || !L.Browser.vml ? {} : {
+	_initPathRoot: function () {
+		if (!this._pathRoot) {
+			this._pathRoot = document.createElement('div');
+			this._pathRoot.className = 'leaflet-vml-container';
+			this._panes.overlayPane.appendChild(this._pathRoot);
+
+			this.on('moveend', this._updatePathViewport);
+			this._updatePathViewport();
+		}
+	}
+});

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

@@ -0,0 +1,88 @@
+/*
+ * L.Path is a base class for rendering vector paths on a map. It's 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)
+		CLIP_PADDING: 0.5
+	},
+
+	options: {
+		stroke: true,
+		color: '#0033ff',
+		weight: 5,
+		opacity: 0.5,
+
+		fill: false,
+		fillColor: null, //same as color by default
+		fillOpacity: 0.2,
+
+		clickable: true,
+
+		// TODO remove this, as all paths now update on moveend
+		updateOnMoveEnd: true
+	},
+
+	initialize: function (options) {
+		L.Util.setOptions(this, options);
+	},
+
+	onAdd: function (map) {
+		this._map = map;
+
+		this._initElements();
+		this._initEvents();
+		this.projectLatlngs();
+		this._updatePath();
+
+		map.on('viewreset', this.projectLatlngs, this);
+
+		this._updateTrigger = this.options.updateOnMoveEnd ? 'moveend' : 'viewreset';
+		map.on(this._updateTrigger, this._updatePath, this);
+	},
+
+	onRemove: function (map) {
+		this._map = null;
+
+		map._pathRoot.removeChild(this._container);
+
+		map.off('viewreset', this.projectLatlngs, this);
+		map.off(this._updateTrigger, this._updatePath, this);
+	},
+
+	projectLatlngs: function () {
+		// do all projection stuff here
+	},
+
+	setStyle: function (style) {
+		L.Util.setOptions(this, style);
+		if (this._container) {
+			this._updateStyle();
+		}
+		return this;
+	},
+
+	_redraw: function () {
+		if (this._map) {
+			this.projectLatlngs();
+			this._updatePath();
+		}
+	}
+});
+
+L.Map.include({
+	_updatePathViewport: function () {
+		var p = L.Path.CLIP_PADDING,
+			size = this.getSize(),
+			//TODO this._map._getMapPanePos()
+			panePos = L.DomUtil.getPosition(this._mapPane),
+			min = panePos.multiplyBy(-1).subtract(size.multiplyBy(p)),
+			max = min.add(size.multiplyBy(1 + p * 2));
+
+		this._pathViewport = new L.Bounds(min, max);
+	}
+});