summaryrefslogtreecommitdiff
path: root/misc/openlayers/lib/OpenLayers/Format/ArcXML.js
diff options
context:
space:
mode:
Diffstat (limited to 'misc/openlayers/lib/OpenLayers/Format/ArcXML.js')
-rw-r--r--misc/openlayers/lib/OpenLayers/Format/ArcXML.js1028
1 files changed, 1028 insertions, 0 deletions
diff --git a/misc/openlayers/lib/OpenLayers/Format/ArcXML.js b/misc/openlayers/lib/OpenLayers/Format/ArcXML.js
new file mode 100644
index 0000000..9d523d1
--- /dev/null
+++ b/misc/openlayers/lib/OpenLayers/Format/ArcXML.js
@@ -0,0 +1,1028 @@
+/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for
+ * full list of contributors). Published under the 2-clause BSD license.
+ * See license.txt in the OpenLayers distribution or repository for the
+ * full text of the license. */
+
+/**
+ * @requires OpenLayers/Format/XML.js
+ * @requires OpenLayers/Geometry/Polygon.js
+ * @requires OpenLayers/Geometry/Point.js
+ * @requires OpenLayers/Geometry/MultiPolygon.js
+ * @requires OpenLayers/Geometry/LinearRing.js
+ */
+
+/**
+ * Class: OpenLayers.Format.ArcXML
+ * Read/Write ArcXML. Create a new instance with the <OpenLayers.Format.ArcXML>
+ * constructor.
+ *
+ * Inherits from:
+ * - <OpenLayers.Format.XML>
+ */
+OpenLayers.Format.ArcXML = OpenLayers.Class(OpenLayers.Format.XML, {
+
+ /**
+ * Property: fontStyleKeys
+ * {Array} List of keys used in font styling.
+ */
+ fontStyleKeys: [
+ 'antialiasing', 'blockout', 'font', 'fontcolor','fontsize', 'fontstyle',
+ 'glowing', 'interval', 'outline', 'printmode', 'shadow', 'transparency'
+ ],
+
+ /**
+ * Property: request
+ * A get_image request destined for an ArcIMS server.
+ */
+ request: null,
+
+ /**
+ * Property: response
+ * A parsed response from an ArcIMS server.
+ */
+ response: null,
+
+ /**
+ * Constructor: OpenLayers.Format.ArcXML
+ * Create a new parser/writer for ArcXML. Create an instance of this class
+ * to begin authoring a request to an ArcIMS service. This is used
+ * primarily by the ArcIMS layer, but could be used to do other wild
+ * stuff, like geocoding.
+ *
+ * Parameters:
+ * options - {Object} An optional object whose properties will be set on
+ * this instance.
+ */
+ initialize: function(options) {
+ this.request = new OpenLayers.Format.ArcXML.Request();
+ this.response = new OpenLayers.Format.ArcXML.Response();
+
+ if (options) {
+ if (options.requesttype == "feature") {
+ this.request.get_image = null;
+
+ var qry = this.request.get_feature.query;
+ this.addCoordSys(qry.featurecoordsys, options.featureCoordSys);
+ this.addCoordSys(qry.filtercoordsys, options.filterCoordSys);
+
+ if (options.polygon) {
+ qry.isspatial = true;
+ qry.spatialfilter.polygon = options.polygon;
+ } else if (options.envelope) {
+ qry.isspatial = true;
+ qry.spatialfilter.envelope = {minx:0, miny:0, maxx:0, maxy:0};
+ this.parseEnvelope(qry.spatialfilter.envelope, options.envelope);
+ }
+ } else if (options.requesttype == "image") {
+ this.request.get_feature = null;
+
+ var props = this.request.get_image.properties;
+ this.parseEnvelope(props.envelope, options.envelope);
+
+ this.addLayers(props.layerlist, options.layers);
+ this.addImageSize(props.imagesize, options.tileSize);
+ this.addCoordSys(props.featurecoordsys, options.featureCoordSys);
+ this.addCoordSys(props.filtercoordsys, options.filterCoordSys);
+ } else {
+ // if an arcxml object is being created with no request type, it is
+ // probably going to consume a response, so do not throw an error if
+ // the requesttype is not defined
+ this.request = null;
+ }
+ }
+
+ OpenLayers.Format.XML.prototype.initialize.apply(this, [options]);
+ },
+
+ /**
+ * Method: parseEnvelope
+ * Parse an array of coordinates into an ArcXML envelope structure.
+ *
+ * Parameters:
+ * env - {Object} An envelope object that will contain the parsed coordinates.
+ * arr - {Array(double)} An array of coordinates in the order: [ minx, miny, maxx, maxy ]
+ */
+ parseEnvelope: function(env, arr) {
+ if (arr && arr.length == 4) {
+ env.minx = arr[0];
+ env.miny = arr[1];
+ env.maxx = arr[2];
+ env.maxy = arr[3];
+ }
+ },
+
+ /**
+ * Method: addLayers
+ * Add a collection of layers to another collection of layers. Each layer in the list is tuple of
+ * { id, visible }. These layer collections represent the
+ * /ARCXML/REQUEST/get_image/PROPERTIES/LAYERLIST/LAYERDEF items in ArcXML
+ *
+ * TODO: Add support for dynamic layer rendering.
+ *
+ * Parameters:
+ * ll - {Array({id,visible})} A list of layer definitions.
+ * lyrs - {Array({id,visible})} A list of layer definitions.
+ */
+ addLayers: function(ll, lyrs) {
+ for(var lind = 0, len=lyrs.length; lind < len; lind++) {
+ ll.push(lyrs[lind]);
+ }
+ },
+
+ /**
+ * Method: addImageSize
+ * Set the size of the requested image.
+ *
+ * Parameters:
+ * imsize - {Object} An ArcXML imagesize object.
+ * olsize - {<OpenLayers.Size>} The image size to set.
+ */
+ addImageSize: function(imsize, olsize) {
+ if (olsize !== null) {
+ imsize.width = olsize.w;
+ imsize.height = olsize.h;
+ imsize.printwidth = olsize.w;
+ imsize.printheight = olsize.h;
+ }
+ },
+
+ /**
+ * Method: addCoordSys
+ * Add the coordinate system information to an object. The object may be
+ *
+ * Parameters:
+ * featOrFilt - {Object} A featurecoordsys or filtercoordsys ArcXML structure.
+ * fsys - {String} or {<OpenLayers.Projection>} or {filtercoordsys} or
+ * {featurecoordsys} A projection representation. If it's a {String},
+ * the value is assumed to be the SRID. If it's a {OpenLayers.Projection}
+ * AND Proj4js is available, the projection number and name are extracted
+ * from there. If it's a filter or feature ArcXML structure, it is copied.
+ */
+ addCoordSys: function(featOrFilt, fsys) {
+ if (typeof fsys == "string") {
+ featOrFilt.id = parseInt(fsys);
+ featOrFilt.string = fsys;
+ }
+ // is this a proj4js instance?
+ else if (typeof fsys == "object" && fsys.proj !== null){
+ featOrFilt.id = fsys.proj.srsProjNumber;
+ featOrFilt.string = fsys.proj.srsCode;
+ } else {
+ featOrFilt = fsys;
+ }
+ },
+
+ /**
+ * APIMethod: iserror
+ * Check to see if the response from the server was an error.
+ *
+ * Parameters:
+ * data - {String} or {DOMElement} data to read/parse. If nothing is supplied,
+ * the current response is examined.
+ *
+ * Returns:
+ * {Boolean} true if the response was an error.
+ */
+ iserror: function(data) {
+ var ret = null;
+
+ if (!data) {
+ ret = (this.response.error !== '');
+ } else {
+ data = OpenLayers.Format.XML.prototype.read.apply(this, [data]);
+ var errorNodes = data.documentElement.getElementsByTagName("ERROR");
+ ret = (errorNodes !== null && errorNodes.length > 0);
+ }
+
+ return ret;
+ },
+
+ /**
+ * APIMethod: read
+ * Read data from a string, and return an response.
+ *
+ * Parameters:
+ * data - {String} or {DOMElement} data to read/parse.
+ *
+ * Returns:
+ * {<OpenLayers.Format.ArcXML.Response>} An ArcXML response. Note that this response
+ * data may change in the future.
+ */
+ read: function(data) {
+ if(typeof data == "string") {
+ data = OpenLayers.Format.XML.prototype.read.apply(this, [data]);
+ }
+
+ var arcNode = null;
+ if (data && data.documentElement) {
+ if(data.documentElement.nodeName == "ARCXML") {
+ arcNode = data.documentElement;
+ } else {
+ arcNode = data.documentElement.getElementsByTagName("ARCXML")[0];
+ }
+ }
+
+ // in Safari, arcNode will be there but will have a child named
+ // parsererror
+ if (!arcNode || arcNode.firstChild.nodeName === 'parsererror') {
+ var error, source;
+ try {
+ error = data.firstChild.nodeValue;
+ source = data.firstChild.childNodes[1].firstChild.nodeValue;
+ } catch (err) {
+ // pass
+ }
+ throw {
+ message: "Error parsing the ArcXML request",
+ error: error,
+ source: source
+ };
+ }
+
+ var response = this.parseResponse(arcNode);
+ return response;
+ },
+
+ /**
+ * APIMethod: write
+ * Generate an ArcXml document string for sending to an ArcIMS server.
+ *
+ * Returns:
+ * {String} A string representing the ArcXML document request.
+ */
+ write: function(request) {
+ if (!request) {
+ request = this.request;
+ }
+ var root = this.createElementNS("", "ARCXML");
+ root.setAttribute("version","1.1");
+
+ var reqElem = this.createElementNS("", "REQUEST");
+
+ if (request.get_image != null) {
+ var getElem = this.createElementNS("", "GET_IMAGE");
+ reqElem.appendChild(getElem);
+
+ var propElem = this.createElementNS("", "PROPERTIES");
+ getElem.appendChild(propElem);
+
+ var props = request.get_image.properties;
+ if (props.featurecoordsys != null) {
+ var feat = this.createElementNS("", "FEATURECOORDSYS");
+ propElem.appendChild(feat);
+
+ if (props.featurecoordsys.id === 0) {
+ feat.setAttribute("string", props.featurecoordsys['string']);
+ }
+ else {
+ feat.setAttribute("id", props.featurecoordsys.id);
+ }
+ }
+
+ if (props.filtercoordsys != null) {
+ var filt = this.createElementNS("", "FILTERCOORDSYS");
+ propElem.appendChild(filt);
+
+ if (props.filtercoordsys.id === 0) {
+ filt.setAttribute("string", props.filtercoordsys.string);
+ }
+ else {
+ filt.setAttribute("id", props.filtercoordsys.id);
+ }
+ }
+
+ if (props.envelope != null) {
+ var env = this.createElementNS("", "ENVELOPE");
+ propElem.appendChild(env);
+
+ env.setAttribute("minx", props.envelope.minx);
+ env.setAttribute("miny", props.envelope.miny);
+ env.setAttribute("maxx", props.envelope.maxx);
+ env.setAttribute("maxy", props.envelope.maxy);
+ }
+
+ var imagesz = this.createElementNS("", "IMAGESIZE");
+ propElem.appendChild(imagesz);
+
+ imagesz.setAttribute("height", props.imagesize.height);
+ imagesz.setAttribute("width", props.imagesize.width);
+
+ if (props.imagesize.height != props.imagesize.printheight ||
+ props.imagesize.width != props.imagesize.printwidth) {
+ imagesz.setAttribute("printheight", props.imagesize.printheight);
+ imagesz.setArrtibute("printwidth", props.imagesize.printwidth);
+ }
+
+ if (props.background != null) {
+ var backgrnd = this.createElementNS("", "BACKGROUND");
+ propElem.appendChild(backgrnd);
+
+ backgrnd.setAttribute("color",
+ props.background.color.r + "," +
+ props.background.color.g + "," +
+ props.background.color.b);
+
+ if (props.background.transcolor !== null) {
+ backgrnd.setAttribute("transcolor",
+ props.background.transcolor.r + "," +
+ props.background.transcolor.g + "," +
+ props.background.transcolor.b);
+ }
+ }
+
+ if (props.layerlist != null && props.layerlist.length > 0) {
+ var layerlst = this.createElementNS("", "LAYERLIST");
+ propElem.appendChild(layerlst);
+
+ for (var ld = 0; ld < props.layerlist.length; ld++) {
+ var ldef = this.createElementNS("", "LAYERDEF");
+ layerlst.appendChild(ldef);
+
+ ldef.setAttribute("id", props.layerlist[ld].id);
+ ldef.setAttribute("visible", props.layerlist[ld].visible);
+
+ if (typeof props.layerlist[ld].query == "object") {
+ var query = props.layerlist[ld].query;
+
+ if (query.where.length < 0) {
+ continue;
+ }
+
+ var queryElem = null;
+ if (typeof query.spatialfilter == "boolean" && query.spatialfilter) {
+ // handle spatial filter madness
+ queryElem = this.createElementNS("", "SPATIALQUERY");
+ }
+ else {
+ queryElem = this.createElementNS("", "QUERY");
+ }
+
+ queryElem.setAttribute("where", query.where);
+
+ if (typeof query.accuracy == "number" && query.accuracy > 0) {
+ queryElem.setAttribute("accuracy", query.accuracy);
+ }
+ if (typeof query.featurelimit == "number" && query.featurelimit < 2000) {
+ queryElem.setAttribute("featurelimit", query.featurelimit);
+ }
+ if (typeof query.subfields == "string" && query.subfields != "#ALL#") {
+ queryElem.setAttribute("subfields", query.subfields);
+ }
+ if (typeof query.joinexpression == "string" && query.joinexpression.length > 0) {
+ queryElem.setAttribute("joinexpression", query.joinexpression);
+ }
+ if (typeof query.jointables == "string" && query.jointables.length > 0) {
+ queryElem.setAttribute("jointables", query.jointables);
+ }
+
+ ldef.appendChild(queryElem);
+ }
+
+ if (typeof props.layerlist[ld].renderer == "object") {
+ this.addRenderer(ldef, props.layerlist[ld].renderer);
+ }
+ }
+ }
+ } else if (request.get_feature != null) {
+ var getElem = this.createElementNS("", "GET_FEATURES");
+ getElem.setAttribute("outputmode", "newxml");
+ getElem.setAttribute("checkesc", "true");
+
+ if (request.get_feature.geometry) {
+ getElem.setAttribute("geometry", request.get_feature.geometry);
+ }
+ else {
+ getElem.setAttribute("geometry", "false");
+ }
+
+ if (request.get_feature.compact) {
+ getElem.setAttribute("compact", request.get_feature.compact);
+ }
+
+ if (request.get_feature.featurelimit == "number") {
+ getElem.setAttribute("featurelimit", request.get_feature.featurelimit);
+ }
+
+ getElem.setAttribute("globalenvelope", "true");
+ reqElem.appendChild(getElem);
+
+ if (request.get_feature.layer != null && request.get_feature.layer.length > 0) {
+ var lyrElem = this.createElementNS("", "LAYER");
+ lyrElem.setAttribute("id", request.get_feature.layer);
+ getElem.appendChild(lyrElem);
+ }
+
+ var fquery = request.get_feature.query;
+ if (fquery != null) {
+ var qElem = null;
+ if (fquery.isspatial) {
+ qElem = this.createElementNS("", "SPATIALQUERY");
+ } else {
+ qElem = this.createElementNS("", "QUERY");
+ }
+ getElem.appendChild(qElem);
+
+ if (typeof fquery.accuracy == "number") {
+ qElem.setAttribute("accuracy", fquery.accuracy);
+ }
+ //qElem.setAttribute("featurelimit", "5");
+
+ if (fquery.featurecoordsys != null) {
+ var fcsElem1 = this.createElementNS("", "FEATURECOORDSYS");
+
+ if (fquery.featurecoordsys.id == 0) {
+ fcsElem1.setAttribute("string", fquery.featurecoordsys.string);
+ } else {
+ fcsElem1.setAttribute("id", fquery.featurecoordsys.id);
+ }
+ qElem.appendChild(fcsElem1);
+ }
+
+ if (fquery.filtercoordsys != null) {
+ var fcsElem2 = this.createElementNS("", "FILTERCOORDSYS");
+
+ if (fquery.filtercoordsys.id === 0) {
+ fcsElem2.setAttribute("string", fquery.filtercoordsys.string);
+ } else {
+ fcsElem2.setAttribute("id", fquery.filtercoordsys.id);
+ }
+ qElem.appendChild(fcsElem2);
+ }
+
+ if (fquery.buffer > 0) {
+ var bufElem = this.createElementNS("", "BUFFER");
+ bufElem.setAttribute("distance", fquery.buffer);
+ qElem.appendChild(bufElem);
+ }
+
+ if (fquery.isspatial) {
+ var spfElem = this.createElementNS("", "SPATIALFILTER");
+ spfElem.setAttribute("relation", fquery.spatialfilter.relation);
+ qElem.appendChild(spfElem);
+
+ if (fquery.spatialfilter.envelope) {
+ var envElem = this.createElementNS("", "ENVELOPE");
+ envElem.setAttribute("minx", fquery.spatialfilter.envelope.minx);
+ envElem.setAttribute("miny", fquery.spatialfilter.envelope.miny);
+ envElem.setAttribute("maxx", fquery.spatialfilter.envelope.maxx);
+ envElem.setAttribute("maxy", fquery.spatialfilter.envelope.maxy);
+ spfElem.appendChild(envElem);
+ } else if(typeof fquery.spatialfilter.polygon == "object") {
+ spfElem.appendChild(this.writePolygonGeometry(fquery.spatialfilter.polygon));
+ }
+ }
+
+ if (fquery.where != null && fquery.where.length > 0) {
+ qElem.setAttribute("where", fquery.where);
+ }
+ }
+ }
+
+ root.appendChild(reqElem);
+
+ return OpenLayers.Format.XML.prototype.write.apply(this, [root]);
+ },
+
+
+ addGroupRenderer: function(ldef, toprenderer) {
+ var topRelem = this.createElementNS("", "GROUPRENDERER");
+ ldef.appendChild(topRelem);
+
+ for (var rind = 0; rind < toprenderer.length; rind++) {
+ var renderer = toprenderer[rind];
+ this.addRenderer(topRelem, renderer);
+ }
+ },
+
+
+ addRenderer: function(topRelem, renderer) {
+ if (OpenLayers.Util.isArray(renderer)) {
+ this.addGroupRenderer(topRelem, renderer);
+ } else {
+ var renderElem = this.createElementNS("", renderer.type.toUpperCase() + "RENDERER");
+ topRelem.appendChild(renderElem);
+
+ if (renderElem.tagName == "VALUEMAPRENDERER") {
+ this.addValueMapRenderer(renderElem, renderer);
+ } else if (renderElem.tagName == "VALUEMAPLABELRENDERER") {
+ this.addValueMapLabelRenderer(renderElem, renderer);
+ } else if (renderElem.tagName == "SIMPLELABELRENDERER") {
+ this.addSimpleLabelRenderer(renderElem, renderer);
+ } else if (renderElem.tagName == "SCALEDEPENDENTRENDERER") {
+ this.addScaleDependentRenderer(renderElem, renderer);
+ }
+ }
+ },
+
+
+ addScaleDependentRenderer: function(renderElem, renderer) {
+ if (typeof renderer.lower == "string" || typeof renderer.lower == "number") {
+ renderElem.setAttribute("lower", renderer.lower);
+ }
+ if (typeof renderer.upper == "string" || typeof renderer.upper == "number") {
+ renderElem.setAttribute("upper", renderer.upper);
+ }
+
+ this.addRenderer(renderElem, renderer.renderer);
+ },
+
+
+ addValueMapLabelRenderer: function(renderElem, renderer) {
+ renderElem.setAttribute("lookupfield", renderer.lookupfield);
+ renderElem.setAttribute("labelfield", renderer.labelfield);
+
+ if (typeof renderer.exacts == "object") {
+ for (var ext=0, extlen=renderer.exacts.length; ext<extlen; ext++) {
+ var exact = renderer.exacts[ext];
+
+ var eelem = this.createElementNS("", "EXACT");
+
+ if (typeof exact.value == "string") {
+ eelem.setAttribute("value", exact.value);
+ }
+ if (typeof exact.label == "string") {
+ eelem.setAttribute("label", exact.label);
+ }
+ if (typeof exact.method == "string") {
+ eelem.setAttribute("method", exact.method);
+ }
+
+ renderElem.appendChild(eelem);
+
+ if (typeof exact.symbol == "object") {
+ var selem = null;
+
+ if (exact.symbol.type == "text") {
+ selem = this.createElementNS("", "TEXTSYMBOL");
+ }
+
+ if (selem != null) {
+ var keys = this.fontStyleKeys;
+ for (var i = 0, len = keys.length; i < len; i++) {
+ var key = keys[i];
+ if (exact.symbol[key]) {
+ selem.setAttribute(key, exact.symbol[key]);
+ }
+ }
+ eelem.appendChild(selem);
+ }
+ }
+ } // for each exact
+ }
+ },
+
+ addValueMapRenderer: function(renderElem, renderer) {
+ renderElem.setAttribute("lookupfield", renderer.lookupfield);
+
+ if (typeof renderer.ranges == "object") {
+ for(var rng=0, rnglen=renderer.ranges.length; rng<rnglen; rng++) {
+ var range = renderer.ranges[rng];
+
+ var relem = this.createElementNS("", "RANGE");
+ relem.setAttribute("lower", range.lower);
+ relem.setAttribute("upper", range.upper);
+
+ renderElem.appendChild(relem);
+
+ if (typeof range.symbol == "object") {
+ var selem = null;
+
+ if (range.symbol.type == "simplepolygon") {
+ selem = this.createElementNS("", "SIMPLEPOLYGONSYMBOL");
+ }
+
+ if (selem != null) {
+ if (typeof range.symbol.boundarycolor == "string") {
+ selem.setAttribute("boundarycolor", range.symbol.boundarycolor);
+ }
+ if (typeof range.symbol.fillcolor == "string") {
+ selem.setAttribute("fillcolor", range.symbol.fillcolor);
+ }
+ if (typeof range.symbol.filltransparency == "number") {
+ selem.setAttribute("filltransparency", range.symbol.filltransparency);
+ }
+ relem.appendChild(selem);
+ }
+ }
+ } // for each range
+ } else if (typeof renderer.exacts == "object") {
+ for (var ext=0, extlen=renderer.exacts.length; ext<extlen; ext++) {
+ var exact = renderer.exacts[ext];
+
+ var eelem = this.createElementNS("", "EXACT");
+ if (typeof exact.value == "string") {
+ eelem.setAttribute("value", exact.value);
+ }
+ if (typeof exact.label == "string") {
+ eelem.setAttribute("label", exact.label);
+ }
+ if (typeof exact.method == "string") {
+ eelem.setAttribute("method", exact.method);
+ }
+
+ renderElem.appendChild(eelem);
+
+ if (typeof exact.symbol == "object") {
+ var selem = null;
+
+ if (exact.symbol.type == "simplemarker") {
+ selem = this.createElementNS("", "SIMPLEMARKERSYMBOL");
+ }
+
+ if (selem != null) {
+ if (typeof exact.symbol.antialiasing == "string") {
+ selem.setAttribute("antialiasing", exact.symbol.antialiasing);
+ }
+ if (typeof exact.symbol.color == "string") {
+ selem.setAttribute("color", exact.symbol.color);
+ }
+ if (typeof exact.symbol.outline == "string") {
+ selem.setAttribute("outline", exact.symbol.outline);
+ }
+ if (typeof exact.symbol.overlap == "string") {
+ selem.setAttribute("overlap", exact.symbol.overlap);
+ }
+ if (typeof exact.symbol.shadow == "string") {
+ selem.setAttribute("shadow", exact.symbol.shadow);
+ }
+ if (typeof exact.symbol.transparency == "number") {
+ selem.setAttribute("transparency", exact.symbol.transparency);
+ }
+ //if (typeof exact.symbol.type == "string")
+ // selem.setAttribute("type", exact.symbol.type);
+ if (typeof exact.symbol.usecentroid == "string") {
+ selem.setAttribute("usecentroid", exact.symbol.usecentroid);
+ }
+ if (typeof exact.symbol.width == "number") {
+ selem.setAttribute("width", exact.symbol.width);
+ }
+
+ eelem.appendChild(selem);
+ }
+ }
+ } // for each exact
+ }
+ },
+
+
+ addSimpleLabelRenderer: function(renderElem, renderer) {
+ renderElem.setAttribute("field", renderer.field);
+ var keys = ['featureweight', 'howmanylabels', 'labelbufferratio',
+ 'labelpriorities', 'labelweight', 'linelabelposition',
+ 'rotationalangles'];
+ for (var i=0, len=keys.length; i<len; i++) {
+ var key = keys[i];
+ if (renderer[key]) {
+ renderElem.setAttribute(key, renderer[key]);
+ }
+ }
+
+ if (renderer.symbol.type == "text") {
+ var symbol = renderer.symbol;
+ var selem = this.createElementNS("", "TEXTSYMBOL");
+ renderElem.appendChild(selem);
+
+ var keys = this.fontStyleKeys;
+ for (var i=0, len=keys.length; i<len; i++) {
+ var key = keys[i];
+ if (symbol[key]) {
+ selem.setAttribute(key, renderer[key]);
+ }
+ }
+ }
+ },
+
+ writePolygonGeometry: function(polygon) {
+ if (!(polygon instanceof OpenLayers.Geometry.Polygon)) {
+ throw {
+ message:'Cannot write polygon geometry to ArcXML with an ' +
+ polygon.CLASS_NAME + ' object.',
+ geometry: polygon
+ };
+ }
+
+ var polyElem = this.createElementNS("", "POLYGON");
+
+ for (var ln=0, lnlen=polygon.components.length; ln<lnlen; ln++) {
+ var ring = polygon.components[ln];
+ var ringElem = this.createElementNS("", "RING");
+
+ for (var rn=0, rnlen=ring.components.length; rn<rnlen; rn++) {
+ var point = ring.components[rn];
+ var pointElem = this.createElementNS("", "POINT");
+
+ pointElem.setAttribute("x", point.x);
+ pointElem.setAttribute("y", point.y);
+
+ ringElem.appendChild(pointElem);
+ }
+
+ polyElem.appendChild(ringElem);
+ }
+
+ return polyElem;
+ },
+
+ /**
+ * Method: parseResponse
+ * Take an ArcXML response, and parse in into this object's internal properties.
+ *
+ * Parameters:
+ * data - {String} or {DOMElement} The ArcXML response, as either a string or the
+ * top level DOMElement of the response.
+ */
+ parseResponse: function(data) {
+ if(typeof data == "string") {
+ var newData = new OpenLayers.Format.XML();
+ data = newData.read(data);
+ }
+ var response = new OpenLayers.Format.ArcXML.Response();
+
+ var errorNode = data.getElementsByTagName("ERROR");
+
+ if (errorNode != null && errorNode.length > 0) {
+ response.error = this.getChildValue(errorNode, "Unknown error.");
+ } else {
+ var responseNode = data.getElementsByTagName("RESPONSE");
+
+ if (responseNode == null || responseNode.length == 0) {
+ response.error = "No RESPONSE tag found in ArcXML response.";
+ return response;
+ }
+
+ var rtype = responseNode[0].firstChild.nodeName;
+ if (rtype == "#text") {
+ rtype = responseNode[0].firstChild.nextSibling.nodeName;
+ }
+
+ if (rtype == "IMAGE") {
+ var envelopeNode = data.getElementsByTagName("ENVELOPE");
+ var outputNode = data.getElementsByTagName("OUTPUT");
+
+ if (envelopeNode == null || envelopeNode.length == 0) {
+ response.error = "No ENVELOPE tag found in ArcXML response.";
+ } else if (outputNode == null || outputNode.length == 0) {
+ response.error = "No OUTPUT tag found in ArcXML response.";
+ } else {
+ var envAttr = this.parseAttributes(envelopeNode[0]);
+ var outputAttr = this.parseAttributes(outputNode[0]);
+
+ if (typeof outputAttr.type == "string") {
+ response.image = {
+ envelope: envAttr,
+ output: {
+ type: outputAttr.type,
+ data: this.getChildValue(outputNode[0])
+ }
+ };
+ } else {
+ response.image = { envelope: envAttr, output: outputAttr };
+ }
+ }
+ } else if (rtype == "FEATURES") {
+ var features = responseNode[0].getElementsByTagName("FEATURES");
+
+ // get the feature count
+ var featureCount = features[0].getElementsByTagName("FEATURECOUNT");
+ response.features.featurecount = featureCount[0].getAttribute("count");
+
+ if (response.features.featurecount > 0) {
+ // get the feature envelope
+ var envelope = features[0].getElementsByTagName("ENVELOPE");
+ response.features.envelope = this.parseAttributes(envelope[0], typeof(0));
+
+ // get the field values per feature
+ var featureList = features[0].getElementsByTagName("FEATURE");
+ for (var fn = 0; fn < featureList.length; fn++) {
+ var feature = new OpenLayers.Feature.Vector();
+ var fields = featureList[fn].getElementsByTagName("FIELD");
+
+ for (var fdn = 0; fdn < fields.length; fdn++) {
+ var fieldName = fields[fdn].getAttribute("name");
+ var fieldValue = fields[fdn].getAttribute("value");
+ feature.attributes[ fieldName ] = fieldValue;
+ }
+
+ var geom = featureList[fn].getElementsByTagName("POLYGON");
+
+ if (geom.length > 0) {
+ // if there is a polygon, create an openlayers polygon, and assign
+ // it to the .geometry property of the feature
+ var ring = geom[0].getElementsByTagName("RING");
+
+ var polys = [];
+ for (var rn = 0; rn < ring.length; rn++) {
+ var linearRings = [];
+ linearRings.push(this.parsePointGeometry(ring[rn]));
+
+ var holes = ring[rn].getElementsByTagName("HOLE");
+ for (var hn = 0; hn < holes.length; hn++) {
+ linearRings.push(this.parsePointGeometry(holes[hn]));
+ }
+ holes = null;
+ polys.push(new OpenLayers.Geometry.Polygon(linearRings));
+ linearRings = null;
+ }
+ ring = null;
+
+ if (polys.length == 1) {
+ feature.geometry = polys[0];
+ } else
+ {
+ feature.geometry = new OpenLayers.Geometry.MultiPolygon(polys);
+ }
+ }
+
+ response.features.feature.push(feature);
+ }
+ }
+ } else {
+ response.error = "Unidentified response type.";
+ }
+ }
+ return response;
+ },
+
+
+ /**
+ * Method: parseAttributes
+ *
+ * Parameters:
+ * node - {<DOMElement>} An element to parse attributes from.
+ *
+ * Returns:
+ * {Object} An attributes object, with properties set to attribute values.
+ */
+ parseAttributes: function(node,type) {
+ var attributes = {};
+ for(var attr = 0; attr < node.attributes.length; attr++) {
+ if (type == "number") {
+ attributes[node.attributes[attr].nodeName] = parseFloat(node.attributes[attr].nodeValue);
+ } else {
+ attributes[node.attributes[attr].nodeName] = node.attributes[attr].nodeValue;
+ }
+ }
+ return attributes;
+ },
+
+
+ /**
+ * Method: parsePointGeometry
+ *
+ * Parameters:
+ * node - {<DOMElement>} An element to parse <COORDS> or <POINT> arcxml data from.
+ *
+ * Returns:
+ * {<OpenLayers.Geometry.LinearRing>} A linear ring represented by the node's points.
+ */
+ parsePointGeometry: function(node) {
+ var ringPoints = [];
+ var coords = node.getElementsByTagName("COORDS");
+
+ if (coords.length > 0) {
+ // if coords is present, it's the only coords item
+ var coordArr = this.getChildValue(coords[0]);
+ coordArr = coordArr.split(/;/);
+ for (var cn = 0; cn < coordArr.length; cn++) {
+ var coordItems = coordArr[cn].split(/ /);
+ ringPoints.push(new OpenLayers.Geometry.Point(coordItems[0], coordItems[1]));
+ }
+ coords = null;
+ } else {
+ var point = node.getElementsByTagName("POINT");
+ if (point.length > 0) {
+ for (var pn = 0; pn < point.length; pn++) {
+ ringPoints.push(
+ new OpenLayers.Geometry.Point(
+ parseFloat(point[pn].getAttribute("x")),
+ parseFloat(point[pn].getAttribute("y"))
+ )
+ );
+ }
+ }
+ point = null;
+ }
+
+ return new OpenLayers.Geometry.LinearRing(ringPoints);
+ },
+
+ CLASS_NAME: "OpenLayers.Format.ArcXML"
+});
+
+OpenLayers.Format.ArcXML.Request = OpenLayers.Class({
+ initialize: function(params) {
+ var defaults = {
+ get_image: {
+ properties: {
+ background: null,
+ /*{
+ color: { r:255, g:255, b:255 },
+ transcolor: null
+ },*/
+ draw: true,
+ envelope: {
+ minx: 0,
+ miny: 0,
+ maxx: 0,
+ maxy: 0
+ },
+ featurecoordsys: {
+ id:0,
+ string:"",
+ datumtransformid:0,
+ datumtransformstring:""
+ },
+ filtercoordsys:{
+ id:0,
+ string:"",
+ datumtransformid:0,
+ datumtransformstring:""
+ },
+ imagesize:{
+ height:0,
+ width:0,
+ dpi:96,
+ printheight:0,
+ printwidth:0,
+ scalesymbols:false
+ },
+ layerlist:[],
+ /* no support for legends */
+ output:{
+ baseurl:"",
+ legendbaseurl:"",
+ legendname:"",
+ legendpath:"",
+ legendurl:"",
+ name:"",
+ path:"",
+ type:"jpg",
+ url:""
+ }
+ }
+ },
+
+ get_feature: {
+ layer: "",
+ query: {
+ isspatial: false,
+ featurecoordsys: {
+ id:0,
+ string:"",
+ datumtransformid:0,
+ datumtransformstring:""
+ },
+ filtercoordsys: {
+ id:0,
+ string:"",
+ datumtransformid:0,
+ datumtransformstring:""
+ },
+ buffer:0,
+ where:"",
+ spatialfilter: {
+ relation: "envelope_intersection",
+ envelope: null
+ }
+ }
+ },
+
+ environment: {
+ separators: {
+ cs:" ",
+ ts:";"
+ }
+ },
+
+ layer: [],
+ workspaces: []
+ };
+
+ return OpenLayers.Util.extend(this, defaults);
+ },
+
+ CLASS_NAME: "OpenLayers.Format.ArcXML.Request"
+});
+
+OpenLayers.Format.ArcXML.Response = OpenLayers.Class({
+ initialize: function(params) {
+ var defaults = {
+ image: {
+ envelope:null,
+ output:''
+ },
+
+ features: {
+ featurecount: 0,
+ envelope: null,
+ feature: []
+ },
+
+ error:''
+ };
+
+ return OpenLayers.Util.extend(this, defaults);
+ },
+
+ CLASS_NAME: "OpenLayers.Format.ArcXML.Response"
+});
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-22 14:14:49 +0000