f7f338e265
git-svn-id: http://svn.openlayers.org/branches/openlayers/2.7@8012 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
288 lines
11 KiB
JavaScript
288 lines
11 KiB
JavaScript
/* Copyright (c) 2006-2008 MetaCarta, Inc., 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/GML/Base.js
|
|
*/
|
|
|
|
/**
|
|
* Class: OpenLayers.Format.GML.v3
|
|
* Parses GML version 3.
|
|
*
|
|
* Inherits from:
|
|
* - <OpenLayers.Format.GML.Base>
|
|
*/
|
|
OpenLayers.Format.GML.v3 = OpenLayers.Class(OpenLayers.Format.GML.Base, {
|
|
|
|
/**
|
|
* Property: schemaLocation
|
|
* {String} Schema location for a particular minor version. The writers
|
|
* conform with the Simple Features Profile for GML.
|
|
*/
|
|
schemaLocation: "http://www.opengis.net/gml http://schemas.opengis.net/gml/3.1.1/profiles/gmlsfProfile/1.0.0/gmlsf.xsd",
|
|
|
|
/**
|
|
* Constructor: OpenLayers.Format.GML.v3
|
|
* Create a parser for GML v3.
|
|
*
|
|
* Parameters:
|
|
* options - {Object} An optional object whose properties will be set on
|
|
* this instance.
|
|
*
|
|
* Valid options properties:
|
|
* featureType - {String} Local (without prefix) feature typeName (required).
|
|
* featureNS - {String} Feature namespace (required).
|
|
* geometryName - {String} Geometry element name.
|
|
*/
|
|
initialize: function(options) {
|
|
OpenLayers.Format.GML.Base.prototype.initialize.apply(this, [options]);
|
|
},
|
|
|
|
/**
|
|
* 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: {
|
|
"gml": OpenLayers.Util.applyDefaults({
|
|
"featureMembers": function(node, obj) {
|
|
this.readChildNodes(node, obj);
|
|
},
|
|
"pos": function(node, obj) {
|
|
var str = this.getChildValue(node).replace(
|
|
this.regExes.trimSpace, ""
|
|
);
|
|
var coords = str.split(this.regExes.splitSpace);
|
|
var point;
|
|
if(this.xy) {
|
|
point = new OpenLayers.Geometry.Point(
|
|
coords[0], coords[1], coords[2]
|
|
);
|
|
} else {
|
|
point = new OpenLayers.Geometry.Point(
|
|
coords[1], coords[0], coords[2]
|
|
);
|
|
}
|
|
obj.points = [point];
|
|
},
|
|
"posList": function(node, obj) {
|
|
var str = this.concatChildValues(node).replace(
|
|
this.regExes.trimSpace, ""
|
|
);
|
|
var coords = str.split(this.regExes.splitSpace);
|
|
var dim = parseInt(node.getAttribute("dimension")) || 2;
|
|
var j, x, y, z;
|
|
var numPoints = coords.length / dim;
|
|
var points = new Array(numPoints);
|
|
for(var i=0, len=coords.length; i<len; i += dim) {
|
|
x = coords[i];
|
|
y = coords[i+1];
|
|
z = (dim == 2) ? undefined : coords[i+2];
|
|
if (this.xy) {
|
|
points[i/dim] = new OpenLayers.Geometry.Point(x, y, z);
|
|
} else {
|
|
points[i/dim] = new OpenLayers.Geometry.Point(y, x, z);
|
|
}
|
|
}
|
|
obj.points = points;
|
|
},
|
|
"exterior": function(node, container) {
|
|
var obj = {};
|
|
this.readChildNodes(node, obj);
|
|
container.outer = obj.components[0];
|
|
},
|
|
"interior": function(node, container) {
|
|
var obj = {};
|
|
this.readChildNodes(node, obj);
|
|
container.inner.push(obj.components[0]);
|
|
},
|
|
"MultiSurface": function(node, container) {
|
|
var obj = {components: []};
|
|
this.readChildNodes(node, obj);
|
|
if(obj.components.length > 0) {
|
|
container.components = [
|
|
new OpenLayers.Geometry.MultiPolygon(obj.components)
|
|
];
|
|
}
|
|
},
|
|
"surfaceMember": function(node, obj) {
|
|
this.readChildNodes(node, obj);
|
|
},
|
|
"surfaceMembers": function(node, obj) {
|
|
this.readChildNodes(node, obj);
|
|
},
|
|
"pointMembers": function(node, obj) {
|
|
this.readChildNodes(node, obj);
|
|
},
|
|
"lineStringMembers": function(node, obj) {
|
|
this.readChildNodes(node, obj);
|
|
},
|
|
"polygonMembers": function(node, obj) {
|
|
this.readChildNodes(node, obj);
|
|
},
|
|
"geometryMembers": function(node, obj) {
|
|
this.readChildNodes(node, obj);
|
|
},
|
|
"Envelope": function(node, container) {
|
|
var obj = {points: new Array(2)};
|
|
this.readChildNodes(node, obj);
|
|
if(!container.components) {
|
|
container.components = [];
|
|
}
|
|
var min = obj.points[0];
|
|
var max = obj.points[1];
|
|
container.components.push(
|
|
new OpenLayers.Bounds(min.x, min.y, max.x, max.y)
|
|
);
|
|
},
|
|
"lowerCorner": function(node, container) {
|
|
var obj = {};
|
|
this.readChildNodes(node, obj)
|
|
container.points[0] = obj.points[0];
|
|
},
|
|
"upperCorner": function(node, container) {
|
|
var obj = {};
|
|
this.readChildNodes(node, obj)
|
|
container.points[1] = obj.points[0];
|
|
}
|
|
}, OpenLayers.Format.GML.Base.prototype.readers["gml"]),
|
|
"feature": OpenLayers.Format.GML.Base.prototype.readers["feature"],
|
|
"wfs": OpenLayers.Format.GML.Base.prototype.readers["wfs"]
|
|
},
|
|
|
|
/**
|
|
* Method: write
|
|
*
|
|
* Parameters:
|
|
* features - {Array(<OpenLayers.Feature.Vector>) | OpenLayers.Feature.Vector}
|
|
* An array of features or a single feature.
|
|
*
|
|
* Returns:
|
|
* {String} Given an array of features, a doc with a gml:featureMembers
|
|
* element will be returned. Given a single feature, a doc with a
|
|
* gml:featureMember element will be returned.
|
|
*/
|
|
write: function(features) {
|
|
var name;
|
|
if(features instanceof Array) {
|
|
name = "featureMembers";
|
|
} else {
|
|
name = "featureMember";
|
|
}
|
|
var root = this.writeNode("gml:" + name, features);
|
|
this.setAttributeNS(
|
|
root, this.namespaces["xsi"],
|
|
"xsi:schemaLocation", this.schemaLocation
|
|
);
|
|
|
|
return OpenLayers.Format.XML.prototype.write.apply(this, [root]);
|
|
},
|
|
|
|
/**
|
|
* Property: writers
|
|
* As a compliment to the readers property, this structure contains public
|
|
* writing functions grouped by namespace alias and named like the
|
|
* node names they produce.
|
|
*/
|
|
writers: {
|
|
"gml": OpenLayers.Util.applyDefaults({
|
|
"featureMembers": function(features) {
|
|
var node = this.createElementNSPlus("gml:featureMembers");
|
|
for(var i=0, len=features.length; i<len; ++i) {
|
|
this.writeNode("feature:_typeName", features[i], node);
|
|
}
|
|
return node;
|
|
},
|
|
"Point": function(geometry) {
|
|
var node = this.createElementNSPlus("gml:Point");
|
|
this.writeNode("pos", geometry, node);
|
|
return node;
|
|
},
|
|
"pos": function(point) {
|
|
// only 2d for simple features profile
|
|
var pos = (this.xy) ?
|
|
(point.x + " " + point.y) : (point.y + " " + point.x);
|
|
return this.createElementNSPlus("gml:pos", {
|
|
value: pos
|
|
});
|
|
},
|
|
"LineString": function(geometry) {
|
|
var node = this.createElementNSPlus("gml:LineString");
|
|
this.writeNode("posList", geometry.components, node);
|
|
return node;
|
|
},
|
|
"posList": function(points) {
|
|
// only 2d for simple features profile
|
|
var len = points.length;
|
|
var parts = new Array(len);
|
|
var point;
|
|
for(var i=0; i<len; ++i) {
|
|
point = points[i];
|
|
if(this.xy) {
|
|
parts[i] = point.x + " " + point.y;
|
|
} else {
|
|
parts[i] = point.y + " " + point.x;
|
|
}
|
|
}
|
|
return this.createElementNSPlus("gml:posList", {
|
|
value: parts.join(" ")
|
|
});
|
|
},
|
|
"Polygon": function(geometry) {
|
|
var node = this.createElementNSPlus("gml:Polygon");
|
|
this.writeNode("exterior", geometry.components[0], node);
|
|
for(var i=1, len=geometry.components.length; i<len; ++i) {
|
|
this.writeNode(
|
|
"interior", geometry.components[i], node
|
|
);
|
|
}
|
|
return node;
|
|
},
|
|
"exterior": function(ring) {
|
|
var node = this.createElementNSPlus("gml:exterior");
|
|
this.writeNode("LinearRing", ring, node);
|
|
return node;
|
|
},
|
|
"interior": function(ring) {
|
|
var node = this.createElementNSPlus("gml:interior");
|
|
this.writeNode("LinearRing", ring, node);
|
|
return node;
|
|
},
|
|
"LinearRing": function(ring) {
|
|
var node = this.createElementNSPlus("gml:LinearRing");
|
|
this.writeNode("posList", ring.components, node);
|
|
return node;
|
|
},
|
|
"Envelope": function(bounds) {
|
|
var node = this.createElementNSPlus("gml:Envelope");
|
|
this.writeNode("lowerCorner", bounds, node);
|
|
this.writeNode("upperCorner", bounds, node);
|
|
// srsName attribute is required for gml:Envelope
|
|
if(this.srsName) {
|
|
node.setAttribute("srsName", this.srsName);
|
|
}
|
|
return node;
|
|
},
|
|
"lowerCorner": function(bounds) {
|
|
var node = this.createElementNSPlus("gml:lowerCorner");
|
|
this.writeNode("pos", {x: bounds.left, y: bounds.bottom}, node);
|
|
return node;
|
|
},
|
|
"upperCorner": function(bounds) {
|
|
var node = this.createElementNSPlus("gml:upperCorner");
|
|
this.writeNode("pos", {x: bounds.right, y: bounds.top}, node);
|
|
return node;
|
|
}
|
|
}, OpenLayers.Format.GML.Base.prototype.writers["gml"]),
|
|
"feature": OpenLayers.Format.GML.Base.prototype.writers["feature"],
|
|
"wfs": OpenLayers.Format.GML.Base.prototype.writers["wfs"]
|
|
},
|
|
|
|
CLASS_NAME: "OpenLayers.Format.GML.v3"
|
|
|
|
});
|