Subversion Repositories eFlore/Applications.moissonnage

/*

 *

 * Copyright (c) 2011-2012, Pavel Shramov

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without modification, are

 * permitted provided that the following conditions are met:

 *

 *    1. Redistributions of source code must retain the above copyright notice, this list of

 *       conditions and the following disclaimer.

 *

 *    2. Redistributions in binary form must reproduce the above copyright notice, this list

 *       of conditions and the following disclaimer in the documentation and/or other materials

 *       provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR

 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 */

// Adaptation Alexandre GALIBERT :

//   - Define fill opacity for polygons at 0 for transparent rendering

//   - Disable creation of icons for KML elements

//   - Specific beahaviour to add an array of files by their urls. A variable will define

//     the status of the processing (BUSY or READY) and managed with a counter for the number

//     of files remaining to parse. Once all files parsed, the map zooms on KML spatial elements

const KML_READY = 0;

const KML_BUSY = 1;

L.KML = L.FeatureGroup.extend({

	options: {

		async: true

	},

	initialize: function(kml, options) {

		L.Util.setOptions(this, options);

		this._kml = kml;

		this._status = KML_READY;

		this._onWaiting = 0;

		this._layers = {};

		if (kml) {

			this.addKML(kml, options, this.options.async);

		}

	},

	loadXML: function(url, cb, options, async) {

		if (async == undefined) async = this.options.async;

		if (options == undefined) options = this.options;

		var req = new window.XMLHttpRequest();

		req.open('GET', url, async);

		try {

			req.overrideMimeType('text/xml'); // unsupported by IE

		} catch(e) {}

		req.onreadystatechange = function() {

			if (req.readyState != 4) return;

			if(req.status == 200) cb(req.responseXML, options);

		};

		req.send(null);

	},

	addKMLFiles: function(urlList, options, async) {

		this._status = KML_BUSY;

		this._onWaiting = urlList.length;

		for (var index = 0; index < urlList.length; index ++) {

			this.addKML(urlList[index], options, async);

		}

	},

	addKML: function(url, options, async) {

		var _this = this;

		var cb = function(gpx, options) { _this._addKML(gpx, options) };

		this.loadXML(url, cb, options, async);

	},

	_addKML: function(xml, options) {

		var layers = L.KML.parseKML(xml);

		if (!layers || !layers.length) return;

		for (var i = 0; i < layers.length; i++)

		{

			this.fire('addlayer', {

				layer: layers[i]

			});

			this.addLayer(layers[i]);

		}

		this.latLngs = L.KML.getLatLngs(xml);

		this.fire("loaded");

		this._onWaiting --;

		if (this._onWaiting == 0) {

			this._status = KML_READY;

			this._map.fitBounds(this.getBounds());

		}

	},

	getStatus: function() {

		return this._status;

	},

	latLngs: []

});

L.Util.extend(L.KML, {

	parseKML: function (xml) {

		var style = this.parseStyle(xml);

		var el = xml.getElementsByTagName("Folder");

		var layers = [], l;

		for (var i = 0; i < el.length; i++) {

			if (!this._check_folder(el[i])) { continue; }

			l = this.parseFolder(el[i], style);

			if (l) { layers.push(l); }

		}

		el = xml.getElementsByTagName('Placemark');

		for (var j = 0; j < el.length; j++) {

			if (!this._check_folder(el[j])) { continue; }

			l = this.parsePlacemark(el[j], xml, style);

			if (l) { layers.push(l); }

		}

		return layers;

	},

	// Return false if e's first parent Folder is not [folder]

	// - returns true if no parent Folders

	_check_folder: function (e, folder) {

		e = e.parentElement;

		while (e && e.tagName !== "Folder")

		{

			e = e.parentElement;

		}

		return !e || e === folder;

	},

	parseStyle: function (xml) {

		var style = {};

		var sl = xml.getElementsByTagName("Style");

		//for (var i = 0; i < sl.length; i++) {

		var attributes = {color: true, width: true, Icon: true, href: true,

						  hotSpot: true};

		function _parse(xml) {

			var options = {};

			for (var i = 0; i < xml.childNodes.length; i++) {

				var e = xml.childNodes[i];

				var key = e.tagName;

				if (!attributes[key]) { continue; }

				if (key === 'hotSpot')

				{

					for (var j = 0; j < e.attributes.length; j++) {

						options[e.attributes[j].name] = e.attributes[j].nodeValue;

					}

				} else {

					var value = e.childNodes[0].nodeValue;

					if (key === 'color') {

						options.opacity = parseInt(value.substring(0, 2), 16) / 255.0;

						options.color = "#" + value.substring(2, 8);

					} else if (key === 'width') {

						options.weight = value;

					} else if (key === 'Icon') {

						ioptions = _parse(e);

						if (ioptions.href) { options.href = ioptions.href; }

					} else if (key === 'href') {

						options.href = value;

					}

				}

			}

			options.fillOpacity = 0;

			return options;

		}

		for (var i = 0; i < sl.length; i++) {

			var e = sl[i], el;

			var options = {}, poptions = {}, ioptions = {};

			el = e.getElementsByTagName("LineStyle");

			if (el && el[0]) { options = _parse(el[0]); }

			el = e.getElementsByTagName("PolyStyle");

			if (el && el[0]) { poptions = _parse(el[0]); }

			if (poptions.color) { options.fillColor = poptions.color; }

			if (poptions.opacity) { options.fillOpacity = poptions.opacity; }

			el = e.getElementsByTagName("IconStyle");

			if (el && el[0]) { ioptions = _parse(el[0]); }

			if (ioptions.href) {

				// save anchor info until the image is loaded

				options.icon = new L.KMLIcon({

					iconUrl: ioptions.href,

					shadowUrl: null,

					iconAnchorRef: {x: ioptions.x, y: ioptions.y},

					iconAnchorType:	{x: ioptions.xunits, y: ioptions.yunits}

				});

			}

			style['#' + e.getAttribute('id')] = options;

		}

		return style;

	},

	parseFolder: function (xml, style) {

		var el, layers = [], l;

		el = xml.getElementsByTagName('Folder');

		for (var i = 0; i < el.length; i++) {

			if (!this._check_folder(el[i], xml)) { continue; }

			l = this.parseFolder(el[i], style);

			if (l) { layers.push(l); }

		}

		el = xml.getElementsByTagName('Placemark');

		for (var j = 0; j < el.length; j++) {

			if (!this._check_folder(el[j], xml)) { continue; }

			l = this.parsePlacemark(el[j], xml, style);

			if (l) { layers.push(l); }

		}

		if (!layers.length) { return; }

		if (layers.length === 1) { return layers[0]; }

		return new L.FeatureGroup(layers);

	},

	parsePlacemark: function (place, xml, style) {

		var i, j, el, options = {};

		el = place.getElementsByTagName('styleUrl');

		for (i = 0; i < el.length; i++) {

			var url = el[i].childNodes[0].nodeValue;

			for (var a in style[url])

			{

				// for jshint

				if (true)

				{

					options[a] = style[url][a];

				}

			}

		}

		var layers = [];

		var parse = ['LineString', 'Polygon', 'Point'];

		for (j in parse) {

			// for jshint

			if (true)

			{

				var tag = parse[j];

				el = place.getElementsByTagName(tag);

				for (i = 0; i < el.length; i++) {

					var l = this["parse" + tag](el[i], xml, options);

					if (l) { layers.push(l); }

				}

			}

		}

		if (!layers.length) {

			return;

		}

		var layer = layers[0];

		if (layers.length > 1) {

			layer = new L.FeatureGroup(layers);

		}

		var name, descr = "";

		el = place.getElementsByTagName('name');

		if (el.length) {

			name = el[0].childNodes[0].nodeValue;

		}

		el = place.getElementsByTagName('description');

		for (i = 0; i < el.length; i++) {

			for (j = 0; j < el[i].childNodes.length; j++) {

				descr = descr + el[i].childNodes[j].nodeValue;

			}

		}

		/*if (name) {

			layer.bindPopup("<h2>" + name + "</h2>" + descr);

		}*/

		return layer;

	},

	parseCoords: function (xml) {

		var el = xml.getElementsByTagName('coordinates');

		return this._read_coords(el[0]);

	},

	parseLineString: function (line, xml, options) {

		var coords = this.parseCoords(line);

		if (!coords.length) { return; }

		return new L.Polyline(coords, options);

	},

	parsePoint: function (line, xml, options) {

		var el = line.getElementsByTagName('coordinates');

		if (!el.length) {

			return;

		}

		var ll = el[0].childNodes[0].nodeValue.split(',');

		return new L.KMLMarker(new L.LatLng(ll[1], ll[0]), options);

	},

	parsePolygon: function (line, xml, options) {

		var el, polys = [], inner = [], i, coords;

		el = line.getElementsByTagName('outerBoundaryIs');

		for (i = 0; i < el.length; i++) {

			coords = this.parseCoords(el[i]);

			if (coords) {

				polys.push(coords);

			}

		}

		el = line.getElementsByTagName('innerBoundaryIs');

		for (i = 0; i < el.length; i++) {

			coords = this.parseCoords(el[i]);

			if (coords) {

				inner.push(coords);

			}

		}

		if (!polys.length) {

			return;

		}

		if (options.fillColor) {

			options.fill = true;

		}

		if (polys.length === 1) {

			return new L.Polygon(polys.concat(inner), options);

		}

		return new L.MultiPolygon(polys, options);

	},

	getLatLngs: function (xml) {

		var el = xml.getElementsByTagName('coordinates');

		var coords = [];

		for (var j = 0; j < el.length; j++) {

			// text might span many childnodes

			coords = coords.concat(this._read_coords(el[j]));

		}

		return coords;

	},

	_read_coords: function (el) {

		var text = "", coords = [], i;

		for (i = 0; i < el.childNodes.length; i++) {

			text = text + el.childNodes[i].nodeValue;

		}

		text = text.split(/[\s\n]+/);

		for (i = 0; i < text.length; i++) {

			var ll = text[i].split(',');

			if (ll.length < 2) {

				continue;

			}

			coords.push(new L.LatLng(ll[1], ll[0]));

		}

		return coords;

	}

});

L.KMLIcon = L.Icon.extend({

	createIcon: function () {

		var img = this._createIcon('icon');

		img.onload = function () {

			var i = new Image();

			i.src = this.src;

			this.style.width = i.width + 'px';

			this.style.height = i.height + 'px';

			if (this.anchorType.x === 'UNITS_FRACTION' || this.anchorType.x === 'fraction') {

				img.style.marginLeft = (-this.anchor.x * i.width) + 'px';

			}

			if (this.anchorType.y === 'UNITS_FRACTION' || this.anchorType.x === 'fraction') {

				img.style.marginTop  = (-(1 - this.anchor.y) * i.height) + 'px';

			}

			this.style.display = "";

		};

		return img;

	},

	_setIconStyles: function (img, name) {

		L.Icon.prototype._setIconStyles.apply(this, [img, name])

		// save anchor information to the image

		img.anchor = this.options.iconAnchorRef;

		img.anchorType = this.options.iconAnchorType;

	}

});

L.KMLMarker = L.Marker.extend({

	options: {

		icon: new L.KMLIcon.Default()

	}

});