leaflet-js 0.6.beta4

data/lib/leaflet.draw/src/ext/LatLngUtil.js

@@ -0,0 +1,18 @@
+/*
+ * L.LatLngUtil contains different utility functions for LatLngs.
+ */
+
+L.LatLngUtil = {
+	// Clones a LatLngs[], returns [][]
+	cloneLatLngs: function (latlngs) {
+		var clone = [];
+		for (var i = 0, l = latlngs.length; i < l; i++) {
+			clone.push(this.cloneLatLng(latlngs[i]));
+		}
+		return clone;
+	},
+
+	cloneLatLng: function (latlng) {
+		return L.latLng(latlng.lat, latlng.lng);
+	}
+};

data/lib/leaflet.draw/src/ext/LineUtil.Intersect.js

@@ -0,0 +1,15 @@
+L.Util.extend(L.LineUtil, {
+	// Checks to see if two line segments intersect. Does not handle degenerate cases.
+	// http://compgeom.cs.uiuc.edu/~jeffe/teaching/373/notes/x06-sweepline.pdf
+	segmentsIntersect: function (/*Point*/ p, /*Point*/ p1, /*Point*/ p2, /*Point*/ p3) {
+		return	this._checkCounterclockwise(p, p2, p3) !==
+				this._checkCounterclockwise(p1, p2, p3) &&
+				this._checkCounterclockwise(p, p1, p2) !==
+				this._checkCounterclockwise(p, p1, p3);
+	},
+
+	// check to see if points are in counterclockwise order
+	_checkCounterclockwise: function (/*Point*/ p, /*Point*/ p1, /*Point*/ p2) {
+		return (p2.y - p.y) * (p1.x - p.x) > (p1.y - p.y) * (p2.x - p.x);
+	}
+});

data/lib/leaflet.draw/src/ext/Polygon.Intersect.js

@@ -0,0 +1,27 @@
+L.Polygon.include({
+	// Checks a polygon for any intersecting line segments. Ignores holes.
+	intersects: function () {
+		var polylineIntersects,
+			points = this._originalPoints,
+			len, firstPoint, lastPoint, maxIndex;
+
+		if (this._tooFewPointsForIntersection()) {
+			return false;
+		}
+
+		polylineIntersects = L.Polyline.prototype.intersects.call(this);
+
+		// If already found an intersection don't need to check for any more.
+		if (polylineIntersects) {
+			return true;
+		}
+
+		len = points.length;
+		firstPoint = points[0];
+		lastPoint = points[len - 1];
+		maxIndex = len - 2;
+
+		// Check the line segment between last and first point. Don't need to check the first line segment (minIndex = 1)
+		return this._lineSegmentsIntersectsRange(lastPoint, firstPoint, maxIndex, 1);
+	}
+});

data/lib/leaflet.draw/src/ext/Polyline.Intersect.js

@@ -0,0 +1,85 @@
+L.Polyline.include({
+	// Check to see if this polyline has any linesegments that intersect.
+	// NOTE: does not support detecting intersection for degenerate cases.
+	intersects: function () {
+		var points = this._originalPoints,
+			len = points ? points.length : 0,
+			i, p, p1;
+
+		if (this._tooFewPointsForIntersection()) {
+			return false;
+		}
+
+		for (i = len - 1; i >= 3; i--) {
+			p = points[i - 1];
+			p1 = points[i];
+
+
+			if (this._lineSegmentsIntersectsRange(p, p1, i - 2)) {
+				return true;
+			}
+		}
+
+		return false;
+	},
+
+	// Check for intersection if new latlng was added to this polyline.
+	// NOTE: does not support detecting intersection for degenerate cases.
+	newLatLngIntersects: function (latlng, skipFirst) {
+		// Cannot check a polyline for intersecting lats/lngs when not added to the map
+		if (!this._map) {
+			return false;
+		}
+
+		return this.newPointIntersects(this._map.latLngToLayerPoint(latlng), skipFirst);
+	},
+
+	// Check for intersection if new point was added to this polyline.
+	// newPoint must be a layer point.
+	// NOTE: does not support detecting intersection for degenerate cases.
+	newPointIntersects: function (newPoint, skipFirst) {
+		var points = this._originalPoints,
+			len = points ? points.length : 0,
+			lastPoint = points ? points[len - 1] : null,
+			// The previous previous line segment. Previous line segement doesn't need testing.
+			maxIndex = len - 2;
+
+		if (this._tooFewPointsForIntersection(1)) {
+			return false;
+		}
+
+		return this._lineSegmentsIntersectsRange(lastPoint, newPoint, maxIndex, skipFirst ? 1 : 0);
+	},
+
+	// Polylines with 2 sides can only intersect in cases where points are collinear (we don't support detecting these).
+	// Cannot have intersection when < 3 line segments (< 4 points)
+	_tooFewPointsForIntersection: function (extraPoints) {
+		var points = this._originalPoints,
+			len = points ? points.length : 0;
+		// Increment length by extraPoints if present
+		len += extraPoints || 0;
+
+		return !this._originalPoints || len <= 3;
+	},
+
+	// Checks a line segment intersections with any line segements before its predecessor.
+	// Don't need to check the predecessor as will never intersect.
+	_lineSegmentsIntersectsRange: function (p, p1, maxIndex, minIndex) {
+		var points = this._originalPoints,
+			p2, p3;
+
+		minIndex = minIndex || 0;
+
+		// Check all previous line segments (beside the immediately previous) for intersections
+		for (var j = maxIndex; j > minIndex; j--) {
+			p2 = points[j - 1];
+			p3 = points[j];
+
+			if (L.LineUtil.segmentsIntersect(p, p1, p2, p3)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+});

data/lib/leaflet.label/CHANGELOG.md

@@ -0,0 +1,35 @@
+Leaflet.draw Changelog
+======================
+
+## master
+
+An in-progress version being developed on the master branch.
+
+### Plugin improvements
+
+ * Added method `L.Marker.setLabelNoHide()` to allow toggling of static marker labels. (inspired by [@kpwebb](https://github.com/kpwebb)). [#20](https://github.com/Leaflet/Leaflet.label/pull/20)
+ * Non-static labels will now hide when map container is tapped on touch devices. (by [@snkashis](https://github.com/snkashis)). [#26](https://github.com/Leaflet/Leaflet.label/pull/26)
+ * Added ability to set the opacity of the label along with the marker. (inspired by [@snkashis](https://github.com/snkashis)). [#20](https://github.com/Leaflet/Leaflet.label/pull/27)
+
+### Bug fixes
+
+ * Fixed labels not updating position after being dragged. (by [@snkashis](https://github.com/snkashis)). [#13](https://github.com/Leaflet/Leaflet.label/pull/13)
+ * Z-Index fixes aimed at static labels. This will ensure that label is shown at the same level as the marker.
+ * Correctly remove event listeners in Marker.Label and Path.Label.
+
+## 0.1.1 (December 10, 2012)
+
+### Plugin improvements
+
+ * FeatureGroup now supports label methods.
+
+### Bug fixes
+
+ * Fixed bug where label wouldn't hide when unbindLabel was called.
+ * Fixed Multi-Poly support.
+ * Fixed bug where a label's position wouldn't be updated when a marker moved.
+ * Fixed bug where label wouldn't be removed from map when a marker was. 
+
+## 0.1.0 (October 7, 2012)
+
+Initial version of Leaflet.label

data/lib/leaflet.label/Jakefile.js

@@ -0,0 +1,21 @@
+/*
+Leaflet.label building and linting scripts.
+
+To use, install Node, then run the following commands in the project root:
+
+    npm install -g jake
+    npm install uglify-js
+    npm install jshint
+
+To check the code and build Leaflet.label from source, run "jake"
+*/
+
+var build = require('./build/build.js');
+
+desc('Check Leaflet.label source for errors with JSHint');
+task('lint', build.lint);
+
+desc('Combine and compress Leaflet.label source files');
+task('build', ['lint'], build.build);
+
+task('default', ['build']);

data/lib/leaflet.label/MIT-LICENCE.txt

@@ -0,0 +1,20 @@
+Copyright 2012 Jacob Toye
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/leaflet.label/README.md

@@ -0,0 +1,86 @@
+Leaflet.label
+=============
+
+Leaflet.label is plugin for adding labels to markers & shapes on leaflet powered maps.
+
+Check out the [demo](http://leaflet.github.com/Leaflet.label/).
+
+##Usage examples
+
+If you want to just bind a label to marker that will show when the mouse is over it, it's really easy:
+
+````js
+L.marker([-37.7772, 175.2606]).bindLabel('Look revealing label!').addTo(map);
+````
+
+Path overlays works the same:
+
+````js
+L.polyline([
+	[-37.7612, 175.2756],
+	[-37.7702, 175.2796],
+	[-37.7802, 175.2750],
+]).bindLabel('Even polylines can have labels.').addTo(map)	
+````
+
+If you would prefer the label to be always visible set the ````noHide: true```` option and call ````showLabel()```` once added to the map:
+
+````js
+L.marker([-37.785, 175.263])
+	.bindLabel('A sweet static label!', { noHide: true })
+	.addTo(map)
+	.showLabel();
+````
+
+*N.B.* if you call `showLabel()` before it is added to the map the label will not show.
+
+##Options
+
+When you call ````bindLabel()```` you can pass in an options object. These options are:
+
+ - **noHide**: doesn't attach event handler for showing/hiding the label on mouseover/out.
+ - **className**: the css class to add to the label element
+
+##Positioning the label for custom icons
+
+The label is positioned relative to the L.Icon's ````iconAnchor```` option. To reposition the label set the ````labelAnchor```` option of your icon. By default ````labelAnchor```` is set so the label will show vertically centered for the default icon (````L.Icon.Default````).
+
+E.g. Vertically center an icon with ````iconAnchor```` set as the center of the icon:
+
+````js
+var myIcon = L.icon({
+	iconUrl: 'my-icon.png',
+	iconSize: [20, 20],
+	iconAnchor: [10, 10],
+	labelAnchor: [6, 0] // as I want the label to appear 2px past the icon (10 + 2 - 6)
+});
+L.marker([-37.7772, 175.2606], {
+	icon: myIcon
+}).bindLabel('Look revealing label!').addTo(map);
+````
+
+When positioning the label L.Label includes a 6px horizontal padding. you will need to take this into account when setting ````labelAnchor````.
+
+##Setting the opacity of a label
+
+You can set the opacity of a label by calling the `setOpacity` method on `L.Marker`. By default the opacity will either be **0** or **1**. 
+
+````js
+// Sets opacity of marker to 0.3 and opacity of label to 1
+markerLabel.setOpacity(0.3);
+
+// Sets opacity of marker to 0.3 and opacity of label to 0.3
+markerLabel.setOpacity(0.3, true);
+
+// Sets opacity of marker to 0 and opacity of label to 0
+markerLabel.setOpacity(0);
+markerLabel.setOpacity(0, true);
+
+// Sets opacity of marker to 1 and opacity of label to 1
+markerLabel.setOpacity(1);
+markerLabel.setOpacity(1, true);
+````
+
+##Alternative label plugin
+
+My previous label plugin is still available at https://github.com/jacobtoye/Leaflet.iconlabel. This plugin is a little harder to use, however if you want to have both the icon and label bound to the same event this plugin is for you.

data/lib/leaflet.label/build/build.js

@@ -0,0 +1,155 @@
+var fs = require('fs'),
+    jshint = require('jshint'),
+    UglifyJS = require('uglify-js'),
+
+    deps = require('./deps.js').deps,
+    hintrc = require('./hintrc.js').config;
+
+
+function lintFiles(files) {
+
+	var errorsFound = 0,
+	    i, j, len, len2, src, errors, e;
+
+	for (i = 0, len = files.length; i < len; i++) {
+
+		jshint.JSHINT(fs.readFileSync(files[i], 'utf8'), hintrc);
+		errors = jshint.JSHINT.errors;
+
+		for (j = 0, len2 = errors.length; j < len2; j++) {
+			e = errors[j];
+			console.log(files[i] + '\tline ' + e.line + '\tcol ' + e.character + '\t ' + e.reason);
+		}
+
+		errorsFound += len2;
+	}
+
+	return errorsFound;
+}
+
+function getFiles(compsBase32) {
+	var memo = {},
+	    comps;
+
+	if (compsBase32) {
+		comps = parseInt(compsBase32, 32).toString(2).split('');
+		console.log('Managing dependencies...');
+	}
+
+	function addFiles(srcs) {
+		for (var j = 0, len = srcs.length; j < len; j++) {
+			memo[srcs[j]] = true;
+		}
+	}
+
+	for (var i in deps) {
+		if (comps) {
+			if (parseInt(comps.pop(), 2) === 1) {
+				console.log('\t* ' + i);
+				addFiles(deps[i].src);
+			} else {
+				console.log('\t  ' + i);
+			}
+		} else {
+			addFiles(deps[i].src);
+		}
+	}
+
+	var files = [];
+
+	for (var src in memo) {
+		files.push('src/' + src);
+	}
+
+	return files;
+}
+
+exports.lint = function () {
+
+	var files = getFiles();
+
+	console.log('Checking for JS errors...');
+
+	var errorsFound = lintFiles(files);
+
+	if (errorsFound > 0) {
+		console.log(errorsFound + ' error(s) found.\n');
+		fail();
+	} else {
+		console.log('\tCheck passed');
+	}
+};
+
+
+function getSizeDelta(newContent, oldContent) {
+	if (!oldContent) {
+		return 'new';
+	}
+	var newLen = newContent.replace(/\r\n?/g, '\n').length,
+		oldLen = oldContent.replace(/\r\n?/g, '\n').length,
+		delta = newLen - oldLen;
+
+	return (delta >= 0 ? '+' : '') + delta;
+}
+
+function loadSilently(path) {
+	try {
+		return fs.readFileSync(path, 'utf8');
+	} catch (e) {
+		return null;
+	}
+}
+
+function combineFiles(files) {
+	var content = '';
+	for (var i = 0, len = files.length; i < len; i++) {
+		content += fs.readFileSync(files[i], 'utf8') + '\n\n';
+	}
+	return content;
+}
+
+exports.build = function (compsBase32, buildName) {
+
+	var files = getFiles(compsBase32);
+
+	console.log('Concatenating ' + files.length + ' files...');
+
+	var copy = fs.readFileSync('src/copyright.js', 'utf8'),
+	    intro = '(function (window, document, undefined) {\n',
+	    outro = '}(this, document));',
+	    newSrc = copy + intro + combineFiles(files) + outro,
+
+	    pathPart = 'dist/leaflet.label' + (buildName ? '-' + buildName : ''),
+	    srcPath = pathPart + '-src.js',
+
+	    oldSrc = loadSilently(srcPath),
+	    srcDelta = getSizeDelta(newSrc, oldSrc);
+
+	console.log('\tUncompressed size: ' + newSrc.length + ' bytes (' + srcDelta + ')');
+
+	if (newSrc === oldSrc) {
+		console.log('\tNo changes');
+	} else {
+		fs.writeFileSync(srcPath, newSrc);
+		console.log('\tSaved to ' + srcPath);
+	}
+
+	console.log('Compressing...');
+
+	var path = pathPart + '.js',
+	    oldCompressed = loadSilently(path),
+	    newCompressed = copy + UglifyJS.minify(newSrc, {
+	        warnings: true,
+	        fromString: true
+	    }).code,
+	    delta = getSizeDelta(newCompressed, oldCompressed);
+
+	console.log('\tCompressed size: ' + newCompressed.length + ' bytes (' + delta + ')');
+
+	if (newCompressed === oldCompressed) {
+		console.log('\tNo changes');
+	} else {
+		fs.writeFileSync(path, newCompressed);
+		console.log('\tSaved to ' + path);
+	}
+};