Software: Apache. PHP/5.5.15 uname -a: Windows NT SVR-DMZ 6.1 build 7600 (Windows Server 2008 R2 Enterprise Edition) i586 SYSTEM Safe-mode: OFF (not secure) E:\nuevo\phpMyAdmin\js\openlayers\src\openlayers\lib\OpenLayers\Format\ drwxrwxrwx | |
| Viewing file: Select action/file-type: /* Copyright (c) 2006-2010 by OpenLayers Contributors (see authors.txt for
* full list of contributors). Published under the Clear BSD license.
* See http://svn.openlayers.org/trunk/openlayers/license.txt for the
* full text of the license. */
/**
* @requires OpenLayers/Format/XML.js
* @requires OpenLayers/Feature/Vector.js
* @requires OpenLayers/Geometry/Point.js
* @requires OpenLayers/Geometry/LineString.js
* @requires OpenLayers/Geometry/Polygon.js
* @requires OpenLayers/Geometry/Collection.js
* @requires OpenLayers/Request/XMLHttpRequest.js
* @requires OpenLayers/Console.js
* @requires OpenLayers/Projection.js
*/
/**
* Class: OpenLayers.Format.KML
* Read/Write KML. Create a new instance with the <OpenLayers.Format.KML>
* constructor.
*
* Inherits from:
* - <OpenLayers.Format.XML>
*/
OpenLayers.Format.KML = OpenLayers.Class(OpenLayers.Format.XML, {
/**
* Property: namespaces
* {Object} Mapping of namespace aliases to namespace URIs.
*/
namespaces: {
kml: "http://www.opengis.net/kml/2.2",
gx: "http://www.google.com/kml/ext/2.2"
},
/**
* APIProperty: kmlns
* {String} KML Namespace to use. Defaults to 2.0 namespace.
*/
kmlns: "http://earth.google.com/kml/2.0",
/**
* APIProperty: placemarksDesc
* {String} Name of the placemarks. Default is "No description available".
*/
placemarksDesc: "No description available",
/**
* APIProperty: foldersName
* {String} Name of the folders. Default is "OpenLayers export".
* If set to null, no name element will be created.
*/
foldersName: "OpenLayers export",
/**
* APIProperty: foldersDesc
* {String} Description of the folders. Default is "Exported on [date]."
* If set to null, no description element will be created.
*/
foldersDesc: "Exported on " + new Date(),
/**
* APIProperty: extractAttributes
* {Boolean} Extract attributes from KML. Default is true.
* Extracting styleUrls requires this to be set to true
*/
extractAttributes: true,
/**
* Property: extractStyles
* {Boolean} Extract styles from KML. Default is false.
* Extracting styleUrls also requires extractAttributes to be
* set to true
*/
extractStyles: false,
/**
* APIProperty: extractTracks
* {Boolean} Extract gx:Track elements from Placemark elements. Default
* is false. If true, features will be generated for all points in
* all gx:Track elements. Features will have a when (Date) attribute
* based on when elements in the track. If tracks include angle
* elements, features will have heading, tilt, and roll attributes.
* If track point coordinates have three values, features will have
* an altitude attribute with the third coordinate value.
*/
extractTracks: false,
/**
* APIProperty: trackAttributes
* {Array} If <extractTracks> is true, points within gx:Track elements will
* be parsed as features with when, heading, tilt, and roll attributes.
* Any additional attribute names can be provided in <trackAttributes>.
*/
trackAttributes: null,
/**
* Property: internalns
* {String} KML Namespace to use -- defaults to the namespace of the
* Placemark node being parsed, but falls back to kmlns.
*/
internalns: null,
/**
* Property: features
* {Array} Array of features
*
*/
features: null,
/**
* Property: styles
* {Object} Storage of style objects
*
*/
styles: null,
/**
* Property: styleBaseUrl
* {String}
*/
styleBaseUrl: "",
/**
* Property: fetched
* {Object} Storage of KML URLs that have been fetched before
* in order to prevent reloading them.
*/
fetched: null,
/**
* APIProperty: maxDepth
* {Integer} Maximum depth for recursive loading external KML URLs
* Defaults to 0: do no external fetching
*/
maxDepth: 0,
/**
* Constructor: OpenLayers.Format.KML
* Create a new parser for KML.
*
* Parameters:
* options - {Object} An optional object whose properties will be set on
* this instance.
*/
initialize: function(options) {
// compile regular expressions once instead of every time they are used
this.regExes = {
trimSpace: (/^\s*|\s*$/g),
removeSpace: (/\s*/g),
splitSpace: (/\s+/),
trimComma: (/\s*,\s*/g),
kmlColor: (/(\w{2})(\w{2})(\w{2})(\w{2})/),
kmlIconPalette: (/root:\/\/icons\/palette-(\d+)(\.\w+)/),
straightBracket: (/\$\[(.*?)\]/g)
};
// KML coordinates are always in longlat WGS84
this.externalProjection = new OpenLayers.Projection("EPSG:4326");
OpenLayers.Format.XML.prototype.initialize.apply(this, [options]);
},
/**
* APIMethod: read
* Read data from a string, and return a list of features.
*
* Parameters:
* data - {String} or {DOMElement} data to read/parse.
*
* Returns:
* {Array(<OpenLayers.Feature.Vector>)} List of features.
*/
read: function(data) {
this.features = [];
this.styles = {};
this.fetched = {};
// Set default options
var options = {
depth: 0,
styleBaseUrl: this.styleBaseUrl
};
return this.parseData(data, options);
},
/**
* Method: parseData
* Read data from a string, and return a list of features.
*
* Parameters:
* data - {String} or {DOMElement} data to read/parse.
* options - {Object} Hash of options
*
* Returns:
* {Array(<OpenLayers.Feature.Vector>)} List of features.
*/
parseData: function(data, options) {
if(typeof data == "string") {
data = OpenLayers.Format.XML.prototype.read.apply(this, [data]);
}
// Loop throught the following node types in this order and
// process the nodes found
var types = ["Link", "NetworkLink", "Style", "StyleMap", "Placemark"];
for(var i=0, len=types.length; i<len; ++i) {
var type = types[i];
var nodes = this.getElementsByTagNameNS(data, "*", type);
// skip to next type if no nodes are found
if(nodes.length == 0) {
continue;
}
switch (type.toLowerCase()) {
// Fetch external links
case "link":
case "networklink":
this.parseLinks(nodes, options);
break;
// parse style information
case "style":
if (this.extractStyles) {
this.parseStyles(nodes, options);
}
break;
case "stylemap":
if (this.extractStyles) {
this.parseStyleMaps(nodes, options);
}
break;
// parse features
case "placemark":
this.parseFeatures(nodes, options);
break;
}
}
return this.features;
},
/**
* Method: parseLinks
* Finds URLs of linked KML documents and fetches them
*
* Parameters:
* nodes - {Array} of {DOMElement} data to read/parse.
* options - {Object} Hash of options
*
*/
parseLinks: function(nodes, options) {
// Fetch external links <NetworkLink> and <Link>
// Don't do anything if we have reached our maximum depth for recursion
if (options.depth >= this.maxDepth) {
return false;
}
// increase depth
var newOptions = OpenLayers.Util.extend({}, options);
newOptions.depth++;
for(var i=0, len=nodes.length; i<len; i++) {
var href = this.parseProperty(nodes[i], "*", "href");
if(href && !this.fetched[href]) {
this.fetched[href] = true; // prevent reloading the same urls
var data = this.fetchLink(href);
if (data) {
this.parseData(data, newOptions);
}
}
}
},
/**
* Method: fetchLink
* Fetches a URL and returns the result
*
* Parameters:
* href - {String} url to be fetched
*
*/
fetchLink: function(href) {
var request = OpenLayers.Request.GET({url: href, async: false});
if (request) {
return request.responseText;
}
},
/**
* Method: parseStyles
* Looks for <Style> nodes in the data and parses them
* Also parses <StyleMap> nodes, but only uses the 'normal' key
*
* Parameters:
* nodes - {Array} of {DOMElement} data to read/parse.
* options - {Object} Hash of options
*
*/
parseStyles: function(nodes, options) {
for(var i=0, len=nodes.length; i<len; i++) {
var style = this.parseStyle(nodes[i]);
if(style) {
var styleName = (options.styleBaseUrl || "") + "#" + style.id;
this.styles[styleName] = style;
}
}
},
/**
* Method: parseKmlColor
* Parses a kml color (in 'aabbggrr' format) and returns the corresponding
* color and opacity or null if the color is invalid.
*
* Parameters:
* kmlColor - {String} a kml formated color
*
* Returns:
* {Object}
*/
parseKmlColor: function(kmlColor) {
var color = null;
if (kmlColor) {
var matches = kmlColor.match(this.regExes.kmlColor);
if (matches) {
color = {
color: '#' + matches[4] + matches[3] + matches[2],
opacity: parseInt(matches[1], 16) / 255
};
}
}
return color;
},
/**
* Method: parseStyle
* Parses the children of a <Style> node and builds the style hash
* accordingly
*
* Parameters:
* node - {DOMElement} <Style> node
*
*/
parseStyle: function(node) {
var style = {};
var types = ["LineStyle", "PolyStyle", "IconStyle", "BalloonStyle",
"LabelStyle"];
var type, nodeList, geometry, parser;
for(var i=0, len=types.length; i<len; ++i) {
type = types[i];
styleTypeNode = this.getElementsByTagNameNS(node,
"*", type)[0];
if(!styleTypeNode) {
continue;
}
// only deal with first geometry of this type
switch (type.toLowerCase()) {
case "linestyle":
var kmlColor = this.parseProperty(styleTypeNode, "*", "color");
var color = this.parseKmlColor(kmlColor);
if (color) {
style["strokeColor"] = color.color;
style["strokeOpacity"] = color.opacity;
}
var width = this.parseProperty(styleTypeNode, "*", "width");
if (width) {
style["strokeWidth"] = width;
}
break;
case "polystyle":
var kmlColor = this.parseProperty(styleTypeNode, "*", "color");
var color = this.parseKmlColor(kmlColor);
if (color) {
style["fillOpacity"] = color.opacity;
style["fillColor"] = color.color;
}
// Check if fill is disabled
var fill = this.parseProperty(styleTypeNode, "*", "fill");
if (fill == "0") {
style["fillColor"] = "none";
}
// Check if outline is disabled
var outline = this.parseProperty(styleTypeNode, "*", "outline");
if (outline == "0") {
style["strokeWidth"] = "0";
}
break;
case "iconstyle":
// set scale
var scale = parseFloat(this.parseProperty(styleTypeNode,
"*", "scale") || 1);
// set default width and height of icon
var width = 32 * scale;
var height = 32 * scale;
var iconNode = this.getElementsByTagNameNS(styleTypeNode,
"*",
"Icon")[0];
if (iconNode) {
var href = this.parseProperty(iconNode, "*", "href");
if (href) {
var w = this.parseProperty(iconNode, "*", "w");
var h = this.parseProperty(iconNode, "*", "h");
// Settings for Google specific icons that are 64x64
// We set the width and height to 64 and halve the
// scale to prevent icons from being too big
var google = "http://maps.google.com/mapfiles/kml";
if (OpenLayers.String.startsWith(
href, google) && !w && !h) {
w = 64;
h = 64;
scale = scale / 2;
}
// if only dimension is defined, make sure the
// other one has the same value
w = w || h;
h = h || w;
if (w) {
width = parseInt(w) * scale;
}
if (h) {
height = parseInt(h) * scale;
}
// support for internal icons
// (/root://icons/palette-x.png)
// x and y tell the position on the palette:
// - in pixels
// - starting from the left bottom
// We translate that to a position in the list
// and request the appropriate icon from the
// google maps website
var matches = href.match(this.regExes.kmlIconPalette);
if (matches) {
var palette = matches[1];
var file_extension = matches[2];
var x = this.parseProperty(iconNode, "*", "x");
var y = this.parseProperty(iconNode, "*", "y");
var posX = x ? x/32 : 0;
var posY = y ? (7 - y/32) : 7;
var pos = posY * 8 + posX;
href = "http://maps.google.com/mapfiles/kml/pal"
+ palette + "/icon" + pos + file_extension;
}
style["graphicOpacity"] = 1; // fully opaque
style["externalGraphic"] = href;
}
}
// hotSpots define the offset for an Icon
var hotSpotNode = this.getElementsByTagNameNS(styleTypeNode,
"*",
"hotSpot")[0];
if (hotSpotNode) {
var x = parseFloat(hotSpotNode.getAttribute("x"));
var y = parseFloat(hotSpotNode.getAttribute("y"));
var xUnits = hotSpotNode.getAttribute("xunits");
if (xUnits == "pixels") {
style["graphicXOffset"] = -x * scale;
}
else if (xUnits == "insetPixels") {
style["graphicXOffset"] = -width + (x * scale);
}
else if (xUnits == "fraction") {
style["graphicXOffset"] = -width * x;
}
var yUnits = hotSpotNode.getAttribute("yunits");
if (yUnits == "pixels") {
style["graphicYOffset"] = -height + (y * scale) + 1;
}
else if (yUnits == "insetPixels") {
style["graphicYOffset"] = -(y * scale) + 1;
}
else if (yUnits == "fraction") {
style["graphicYOffset"] = -height * (1 - y) + 1;
}
}
style["graphicWidth"] = width;
style["graphicHeight"] = height;
break;
case "balloonstyle":
var balloonStyle = OpenLayers.Util.getXmlNodeValue(
styleTypeNode);
if (balloonStyle) {
style["balloonStyle"] = balloonStyle.replace(
this.regExes.straightBracket, "${$1}");
}
break;
case "labelstyle":
var kmlColor = this.parseProperty(styleTypeNode, "*", "color");
var color = this.parseKmlColor(kmlColor);
if (color) {
style["fontColor"] = color.color;
style["fontOpacity"] = color.opacity;
}
break;
default:
}
}
// Some polygons have no line color, so we use the fillColor for that
if (!style["strokeColor"] && style["fillColor"]) {
style["strokeColor"] = style["fillColor"];
}
var id = node.getAttribute("id");
if (id && style) {
style.id = id;
}
return style;
},
/**
* Method: parseStyleMaps
* Looks for <Style> nodes in the data and parses them
* Also parses <StyleMap> nodes, but only uses the 'normal' key
*
* Parameters:
* nodes - {Array} of {DOMElement} data to read/parse.
* options - {Object} Hash of options
*
*/
parseStyleMaps: function(nodes, options) {
// Only the default or "normal" part of the StyleMap is processed now
// To do the select or "highlight" bit, we'd need to change lots more
for(var i=0, len=nodes.length; i<len; i++) {
var node = nodes[i];
var pairs = this.getElementsByTagNameNS(node, "*",
"Pair");
var id = node.getAttribute("id");
for (var j=0, jlen=pairs.length; j<jlen; j++) {
var pair = pairs[j];
// Use the shortcut in the SLD format to quickly retrieve the
// value of a node. Maybe it's good to have a method in
// Format.XML to do this
var key = this.parseProperty(pair, "*", "key");
var styleUrl = this.parseProperty(pair, "*", "styleUrl");
if (styleUrl && key == "normal") {
this.styles[(options.styleBaseUrl || "") + "#" + id] =
this.styles[(options.styleBaseUrl || "") + styleUrl];
}
if (styleUrl && key == "highlight") {
// TODO: implement the "select" part
}
}
}
},
/**
* Method: parseFeatures
* Loop through all Placemark nodes and parse them.
* Will create a list of features
*
* Parameters:
* nodes - {Array} of {DOMElement} data to read/parse.
* options - {Object} Hash of options
*
*/
parseFeatures: function(nodes, options) {
var features = [];
for(var i=0, len=nodes.length; i<len; i++) {
var featureNode = nodes[i];
var feature = this.parseFeature.apply(this,[featureNode]) ;
if(feature) {
// Create reference to styleUrl
if (this.extractStyles && feature.attributes &&
feature.attributes.styleUrl) {
feature.style = this.getStyle(feature.attributes.styleUrl, options);
}
if (this.extractStyles) {
// Make sure that <Style> nodes within a placemark are
// processed as well
var inlineStyleNode = this.getElementsByTagNameNS(featureNode,
"*",
"Style")[0];
if (inlineStyleNode) {
var inlineStyle= this.parseStyle(inlineStyleNode);
if (inlineStyle) {
feature.style = OpenLayers.Util.extend(
feature.style, inlineStyle
);
}
}
}
// check if gx:Track elements should be parsed
if (this.extractTracks) {
var tracks = this.getElementsByTagNameNS(
featureNode, this.namespaces.gx, "Track"
);
if (tracks && tracks.length > 0) {
var track = tracks[0];
var container = {
features: [],
feature: feature
};
this.readNode(track, container);
if (container.features.length > 0) {
features.push.apply(features, container.features);
}
}
} else {
// add feature to list of features
features.push(feature);
}
} else {
throw "Bad Placemark: " + i;
}
}
// add new features to existing feature list
this.features = this.features.concat(features);
},
/**
* Property: readers
* Contains public functions, grouped by namespace prefix, that will
* be applied when a namespaced node is found matching the function
* name. The function will be applied in the scope of this parser
* with two arguments: the node being read and a context object passed
* from the parent.
*/
readers: {
"kml": {
"when": function(node, container) {
container.whens.push(OpenLayers.Date.parse(
this.getChildValue(node)
));
},
"_trackPointAttribute": function(node, container) {
var name = node.nodeName.split(":").pop();
container.attributes[name].push(this.getChildValue(node));
}
},
"gx": {
"Track": function(node, container) {
var obj = {
whens: [],
points: [],
angles: []
};
if (this.trackAttributes) {
var name;
obj.attributes = {};
for (var i=0, ii=this.trackAttributes.length; i<ii; ++i) {
name = this.trackAttributes[i];
obj.attributes[name] = [];
if (!(name in this.readers.kml)) {
this.readers.kml[name] = this.readers.kml._trackPointAttribute;
}
}
}
this.readChildNodes(node, obj);
if (obj.whens.length !== obj.points.length) {
throw new Error("gx:Track with unequal number of when (" + obj.whens.length + ") and gx:coord (" + obj.points.length + ") elements.");
}
var hasAngles = obj.angles.length > 0;
if (hasAngles && obj.whens.length !== obj.angles.length) {
throw new Error("gx:Track with unequal number of when (" + obj.whens.length + ") and gx:angles (" + obj.angles.length + ") elements.");
}
var feature, point, angles;
for (var i=0, ii=obj.whens.length; i<ii; ++i) {
feature = container.feature.clone();
feature.fid = container.feature.fid || container.feature.id;
point = obj.points[i];
feature.geometry = point;
if ("z" in point) {
feature.attributes.altitude = point.z;
}
if (this.internalProjection && this.externalProjection) {
feature.geometry.transform(
this.externalProjection, this.internalProjection
);
}
if (this.trackAttributes) {
for (var j=0, jj=this.trackAttributes.length; j<jj; ++j) {
feature.attributes[name] = obj.attributes[this.trackAttributes[j]][i];
}
}
feature.attributes.when = obj.whens[i];
feature.attributes.trackId = container.feature.id;
if (hasAngles) {
angles = obj.angles[i];
feature.attributes.heading = parseFloat(angles[0]);
feature.attributes.tilt = parseFloat(angles[1]);
feature.attributes.roll = parseFloat(angles[2]);
}
container.features.push(feature);
}
},
"coord": function(node, container) {
var str = this.getChildValue(node);
var coords = str.replace(this.regExes.trimSpace, "").split(/\s+/);
var point = new OpenLayers.Geometry.Point(coords[0], coords[1]);
if (coords.length > 2) {
point.z = parseFloat(coords[2]);
}
container.points.push(point);
},
"angles": function(node, container) {
var str = this.getChildValue(node);
var parts = str.replace(this.regExes.trimSpace, "").split(/\s+/);
container.angles.push(parts);
}
}
},
/**
* Method: parseFeature
* This function is the core of the KML parsing code in OpenLayers.
* It creates the geometries that are then attached to the returned
* feature, and calls parseAttributes() to get attribute data out.
*
* Parameters:
* node - {DOMElement}
*
* Returns:
* {<OpenLayers.Feature.Vector>} A vector feature.
*/
parseFeature: function(node) {
// only accept one geometry per feature - look for highest "order"
var order = ["MultiGeometry", "Polygon", "LineString", "Point"];
var type, nodeList, geometry, parser;
for(var i=0, len=order.length; i<len; ++i) {
type = order[i];
this.internalns = node.namespaceURI ?
node.namespaceURI : this.kmlns;
nodeList = this.getElementsByTagNameNS(node,
this.internalns, type);
if(nodeList.length > 0) {
// only deal with first geometry of this type
var parser = this.parseGeometry[type.toLowerCase()];
if(parser) {
geometry = parser.apply(this, [nodeList[0]]);
if (this.internalProjection && this.externalProjection) {
geometry.transform(this.externalProjection,
this.internalProjection);
}
} else {
OpenLayers.Console.error(OpenLayers.i18n(
"unsupportedGeometryType", {'geomType':type}));
}
// stop looking for different geometry types
break;
}
}
// construct feature (optionally with attributes)
var attributes;
if(this.extractAttributes) {
attributes = this.parseAttributes(node);
}
var feature = new OpenLayers.Feature.Vector(geometry, attributes);
var fid = node.getAttribute("id") || node.getAttribute("name");
if(fid != null) {
feature.fid = fid;
}
return feature;
},
/**
* Method: getStyle
* Retrieves a style from a style hash using styleUrl as the key
* If the styleUrl doesn't exist yet, we try to fetch it
* Internet
*
* Parameters:
* styleUrl - {String} URL of style
* options - {Object} Hash of options
*
* Returns:
* {Object} - (reference to) Style hash
*/
getStyle: function(styleUrl, options) {
var styleBaseUrl = OpenLayers.Util.removeTail(styleUrl);
var newOptions = OpenLayers.Util.extend({}, options);
newOptions.depth++;
newOptions.styleBaseUrl = styleBaseUrl;
// Fetch remote Style URLs (if not fetched before)
if (!this.styles[styleUrl]
&& !OpenLayers.String.startsWith(styleUrl, "#")
&& newOptions.depth <= this.maxDepth
&& !this.fetched[styleBaseUrl] ) {
var data = this.fetchLink(styleBaseUrl);
if (data) {
this.parseData(data, newOptions);
}
}
// return requested style
var style = OpenLayers.Util.extend({}, this.styles[styleUrl]);
return style;
},
/**
* Property: parseGeometry
* Properties of this object are the functions that parse geometries based
* on their type.
*/
parseGeometry: {
/**
* Method: parseGeometry.point
* Given a KML node representing a point geometry, create an OpenLayers
* point geometry.
*
* Parameters:
* node - {DOMElement} A KML Point node.
*
* Returns:
* {<OpenLayers.Geometry.Point>} A point geometry.
*/
point: function(node) {
var nodeList = this.getElementsByTagNameNS(node, this.internalns,
"coordinates");
var coords = [];
if(nodeList.length > 0) {
var coordString = nodeList[0].firstChild.nodeValue;
coordString = coordString.replace(this.regExes.removeSpace, "");
coords = coordString.split(",");
}
var point = null;
if(coords.length > 1) {
// preserve third dimension
if(coords.length == 2) {
coords[2] = null;
}
point = new OpenLayers.Geometry.Point(coords[0], coords[1],
coords[2]);
} else {
throw "Bad coordinate string: " + coordString;
}
return point;
},
/**
* Method: parseGeometry.linestring
* Given a KML node representing a linestring geometry, create an
* OpenLayers linestring geometry.
*
* Parameters:
* node - {DOMElement} A KML LineString node.
*
* Returns:
* {<OpenLayers.Geometry.LineString>} A linestring geometry.
*/
linestring: function(node, ring) {
var nodeList = this.getElementsByTagNameNS(node, this.internalns,
"coordinates");
var line = null;
if(nodeList.length > 0) {
var coordString = this.getChildValue(nodeList[0]);
coordString = coordString.replace(this.regExes.trimSpace,
"");
coordString = coordString.replace(this.regExes.trimComma,
",");
var pointList = coordString.split(this.regExes.splitSpace);
var numPoints = pointList.length;
var points = new Array(numPoints);
var coords, numCoords;
for(var i=0; i<numPoints; ++i) {
coords = pointList[i].split(",");
numCoords = coords.length;
if(numCoords > 1) {
if(coords.length == 2) {
coords[2] = null;
}
points[i] = new OpenLayers.Geometry.Point(coords[0],
coords[1],
coords[2]);
} else {
throw "Bad LineString point coordinates: " +
pointList[i];
}
}
if(numPoints) {
if(ring) {
line = new OpenLayers.Geometry.LinearRing(points);
} else {
line = new OpenLayers.Geometry.LineString(points);
}
} else {
throw "Bad LineString coordinates: " + coordString;
}
}
return line;
},
/**
* Method: parseGeometry.polygon
* Given a KML node representing a polygon geometry, create an
* OpenLayers polygon geometry.
*
* Parameters:
* node - {DOMElement} A KML Polygon node.
*
* Returns:
* {<OpenLayers.Geometry.Polygon>} A polygon geometry.
*/
polygon: function(node) {
var nodeList = this.getElementsByTagNameNS(node, this.internalns,
"LinearRing");
var numRings = nodeList.length;
var components = new Array(numRings);
if(numRings > 0) {
// this assumes exterior ring first, inner rings after
var ring;
for(var i=0, len=nodeList.length; i<len; ++i) {
ring = this.parseGeometry.linestring.apply(this,
[nodeList[i], true]);
if(ring) {
components[i] = ring;
} else {
throw "Bad LinearRing geometry: " + i;
}
}
}
return new OpenLayers.Geometry.Polygon(components);
},
/**
* Method: parseGeometry.multigeometry
* Given a KML node representing a multigeometry, create an
* OpenLayers geometry collection.
*
* Parameters:
* node - {DOMElement} A KML MultiGeometry node.
*
* Returns:
* {<OpenLayers.Geometry.Collection>} A geometry collection.
*/
multigeometry: function(node) {
var child, parser;
var parts = [];
var children = node.childNodes;
for(var i=0, len=children.length; i<len; ++i ) {
child = children[i];
if(child.nodeType == 1) {
var type = (child.prefix) ?
child.nodeName.split(":")[1] :
child.nodeName;
var parser = this.parseGeometry[type.toLowerCase()];
if(parser) {
parts.push(parser.apply(this, [child]));
}
}
}
return new OpenLayers.Geometry.Collection(parts);
}
},
/**
* Method: parseAttributes
*
* Parameters:
* node - {DOMElement}
*
* Returns:
* {Object} An attributes object.
*/
parseAttributes: function(node) {
var attributes = {};
// Extended Data is parsed first.
var edNodes = node.getElementsByTagName("ExtendedData");
if (edNodes.length) {
attributes = this.parseExtendedData(edNodes[0]);
}
// assume attribute nodes are type 1 children with a type 3 or 4 child
var child, grandchildren, grandchild;
var children = node.childNodes;
for(var i=0, len=children.length; i<len; ++i) {
child = children[i];
if(child.nodeType == 1) {
grandchildren = child.childNodes;
if(grandchildren.length >= 1 && grandchildren.length <= 3) {
var grandchild;
switch (grandchildren.length) {
case 1:
grandchild = grandchildren[0];
break;
case 2:
var c1 = grandchildren[0];
var c2 = grandchildren[1];
grandchild = (c1.nodeType == 3 || c1.nodeType == 4) ?
c1 : c2;
break;
case 3:
default:
grandchild = grandchildren[1];
break;
}
if(grandchild.nodeType == 3 || grandchild.nodeType == 4) {
var name = (child.prefix) ?
child.nodeName.split(":")[1] :
child.nodeName;
var value = OpenLayers.Util.getXmlNodeValue(grandchild);
if (value) {
value = value.replace(this.regExes.trimSpace, "");
attributes[name] = value;
}
}
}
}
}
return attributes;
},
/**
* Method: parseExtendedData
* Parse ExtendedData from KML. Limited support for schemas/datatypes.
* See http://code.google.com/apis/kml/documentation/kmlreference.html#extendeddata
* for more information on extendeddata.
*/
parseExtendedData: function(node) {
var attributes = {};
var i, len, data, key;
var dataNodes = node.getElementsByTagName("Data");
for (i = 0, len = dataNodes.length; i < len; i++) {
data = dataNodes[i];
key = data.getAttribute("name");
var ed = {};
var valueNode = data.getElementsByTagName("value");
if (valueNode.length) {
ed['value'] = this.getChildValue(valueNode[0]);
}
var nameNode = data.getElementsByTagName("displayName");
if (nameNode.length) {
ed['displayName'] = this.getChildValue(nameNode[0]);
}
attributes[key] = ed;
}
var simpleDataNodes = node.getElementsByTagName("SimpleData");
for (i = 0, len = simpleDataNodes.length; i < len; i++) {
var ed = {};
data = simpleDataNodes[i];
key = data.getAttribute("name");
ed['value'] = this.getChildValue(data);
ed['displayName'] = key;
attributes[key] = ed;
}
return attributes;
},
/**
* Method: parseProperty
* Convenience method to find a node and return its value
*
* Parameters:
* xmlNode - {<DOMElement>}
* namespace - {String} namespace of the node to find
* tagName - {String} name of the property to parse
*
* Returns:
* {String} The value for the requested property (defaults to null)
*/
parseProperty: function(xmlNode, namespace, tagName) {
var value;
var nodeList = this.getElementsByTagNameNS(xmlNode, namespace, tagName);
try {
value = OpenLayers.Util.getXmlNodeValue(nodeList[0]);
} catch(e) {
value = null;
}
return value;
},
/**
* APIMethod: write
* Accept Feature Collection, and return a string.
*
* Parameters:
* features - {Array(<OpenLayers.Feature.Vector>} An array of features.
*
* Returns:
* {String} A KML string.
*/
write: function(features) {
if(!(features instanceof Array)) {
features = [features];
}
var kml = this.createElementNS(this.kmlns, "kml");
var folder = this.createFolderXML();
for(var i=0, len=features.length; i<len; ++i) {
folder.appendChild(this.createPlacemarkXML(features[i]));
}
kml.appendChild(folder);
return OpenLayers.Format.XML.prototype.write.apply(this, [kml]);
},
/**
* Method: createFolderXML
* Creates and returns a KML folder node
*
* Returns:
* {DOMElement}
*/
createFolderXML: function() {
// Folder
var folder = this.createElementNS(this.kmlns, "Folder");
// Folder name
if (this.foldersName) {
var folderName = this.createElementNS(this.kmlns, "name");
var folderNameText = this.createTextNode(this.foldersName);
folderName.appendChild(folderNameText);
folder.appendChild(folderName);
}
// Folder description
if (this.foldersDesc) {
var folderDesc = this.createElementNS(this.kmlns, "description");
var folderDescText = this.createTextNode(this.foldersDesc);
folderDesc.appendChild(folderDescText);
folder.appendChild(folderDesc);
}
return folder;
},
/**
* Method: createPlacemarkXML
* Creates and returns a KML placemark node representing the given feature.
*
* Parameters:
* feature - {<OpenLayers.Feature.Vector>}
*
* Returns:
* {DOMElement}
*/
createPlacemarkXML: function(feature) {
// Placemark name
var placemarkName = this.createElementNS(this.kmlns, "name");
var name = feature.style && feature.style.label ? feature.style.label :
feature.attributes.name || feature.id;
placemarkName.appendChild(this.createTextNode(name));
// Placemark description
var placemarkDesc = this.createElementNS(this.kmlns, "description");
var desc = feature.attributes.description || this.placemarksDesc;
placemarkDesc.appendChild(this.createTextNode(desc));
// Placemark
var placemarkNode = this.createElementNS(this.kmlns, "Placemark");
if(feature.fid != null) {
placemarkNode.setAttribute("id", feature.fid);
}
placemarkNode.appendChild(placemarkName);
placemarkNode.appendChild(placemarkDesc);
// Geometry node (Point, LineString, etc. nodes)
var geometryNode = this.buildGeometryNode(feature.geometry);
placemarkNode.appendChild(geometryNode);
// TBD - deal with remaining (non name/description) attributes.
return placemarkNode;
},
/**
* Method: buildGeometryNode
* Builds and returns a KML geometry node with the given geometry.
*
* Parameters:
* geometry - {<OpenLayers.Geometry>}
*
* Returns:
* {DOMElement}
*/
buildGeometryNode: function(geometry) {
if (this.internalProjection && this.externalProjection) {
geometry = geometry.clone();
geometry.transform(this.internalProjection,
this.externalProjection);
}
var className = geometry.CLASS_NAME;
var type = className.substring(className.lastIndexOf(".") + 1);
var builder = this.buildGeometry[type.toLowerCase()];
var node = null;
if(builder) {
node = builder.apply(this, [geometry]);
}
return node;
},
/**
* Property: buildGeometry
* Object containing methods to do the actual geometry node building
* based on geometry type.
*/
buildGeometry: {
// TBD: Anybody care about namespace aliases here (these nodes have
// no prefixes)?
/**
* Method: buildGeometry.point
* Given an OpenLayers point geometry, create a KML point.
*
* Parameters:
* geometry - {<OpenLayers.Geometry.Point>} A point geometry.
*
* Returns:
* {DOMElement} A KML point node.
*/
point: function(geometry) {
var kml = this.createElementNS(this.kmlns, "Point");
kml.appendChild(this.buildCoordinatesNode(geometry));
return kml;
},
/**
* Method: buildGeometry.multipoint
* Given an OpenLayers multipoint geometry, create a KML
* GeometryCollection.
*
* Parameters:
* geometry - {<OpenLayers.Geometry.Point>} A multipoint geometry.
*
* Returns:
* {DOMElement} A KML GeometryCollection node.
*/
multipoint: function(geometry) {
return this.buildGeometry.collection.apply(this, [geometry]);
},
/**
* Method: buildGeometry.linestring
* Given an OpenLayers linestring geometry, create a KML linestring.
*
* Parameters:
* geometry - {<OpenLayers.Geometry.LineString>} A linestring geometry.
*
* Returns:
* {DOMElement} A KML linestring node.
*/
linestring: function(geometry) {
var kml = this.createElementNS(this.kmlns, "LineString");
kml.appendChild(this.buildCoordinatesNode(geometry));
return kml;
},
/**
* Method: buildGeometry.multilinestring
* Given an OpenLayers multilinestring geometry, create a KML
* GeometryCollection.
*
* Parameters:
* geometry - {<OpenLayers.Geometry.Point>} A multilinestring geometry.
*
* Returns:
* {DOMElement} A KML GeometryCollection node.
*/
multilinestring: function(geometry) {
return this.buildGeometry.collection.apply(this, [geometry]);
},
/**
* Method: buildGeometry.linearring
* Given an OpenLayers linearring geometry, create a KML linearring.
*
* Parameters:
* geometry - {<OpenLayers.Geometry.LinearRing>} A linearring geometry.
*
* Returns:
* {DOMElement} A KML linearring node.
*/
linearring: function(geometry) {
var kml = this.createElementNS(this.kmlns, "LinearRing");
kml.appendChild(this.buildCoordinatesNode(geometry));
return kml;
},
/**
* Method: buildGeometry.polygon
* Given an OpenLayers polygon geometry, create a KML polygon.
*
* Parameters:
* geometry - {<OpenLayers.Geometry.Polygon>} A polygon geometry.
*
* Returns:
* {DOMElement} A KML polygon node.
*/
polygon: function(geometry) {
var kml = this.createElementNS(this.kmlns, "Polygon");
var rings = geometry.components;
var ringMember, ringGeom, type;
for(var i=0, len=rings.length; i<len; ++i) {
type = (i==0) ? "outerBoundaryIs" : "innerBoundaryIs";
ringMember = this.createElementNS(this.kmlns, type);
ringGeom = this.buildGeometry.linearring.apply(this,
[rings[i]]);
ringMember.appendChild(ringGeom);
kml.appendChild(ringMember);
}
return kml;
},
/**
* Method: buildGeometry.multipolygon
* Given an OpenLayers multipolygon geometry, create a KML
* GeometryCollection.
*
* Parameters:
* geometry - {<OpenLayers.Geometry.Point>} A multipolygon geometry.
*
* Returns:
* {DOMElement} A KML GeometryCollection node.
*/
multipolygon: function(geometry) {
return this.buildGeometry.collection.apply(this, [geometry]);
},
/**
* Method: buildGeometry.collection
* Given an OpenLayers geometry collection, create a KML MultiGeometry.
*
* Parameters:
* geometry - {<OpenLayers.Geometry.Collection>} A geometry collection.
*
* Returns:
* {DOMElement} A KML MultiGeometry node.
*/
collection: function(geometry) {
var kml = this.createElementNS(this.kmlns, "MultiGeometry");
var child;
for(var i=0, len=geometry.components.length; i<len; ++i) {
child = this.buildGeometryNode.apply(this,
[geometry.components[i]]);
if(child) {
kml.appendChild(child);
}
}
return kml;
}
},
/**
* Method: buildCoordinatesNode
* Builds and returns the KML coordinates node with the given geometry
* <coordinates>...</coordinates>
*
* Parameters:
* geometry - {<OpenLayers.Geometry>}
*
* Return:
* {DOMElement}
*/
buildCoordinatesNode: function(geometry) {
var coordinatesNode = this.createElementNS(this.kmlns, "coordinates");
var path;
var points = geometry.components;
if(points) {
// LineString or LinearRing
var point;
var numPoints = points.length;
var parts = new Array(numPoints);
for(var i=0; i<numPoints; ++i) {
point = points[i];
parts[i] = point.x + "," + point.y;
}
path = parts.join(" ");
} else {
// Point
path = geometry.x + "," + geometry.y;
}
var txtNode = this.createTextNode(path);
coordinatesNode.appendChild(txtNode);
return coordinatesNode;
},
CLASS_NAME: "OpenLayers.Format.KML"
});
|
:: Command execute :: | |
--[ c99shell v. 1.0 pre-release build #13 powered by Captain Crunch Security Team | http://ccteam.ru | Generation time: 0.0468 ]-- |