1 /* Copyright (c) 2009 MetaCarta, Inc., published under the Clear BSD
2 * license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the
3 * full text of the license. */
6 * @requires OpenLayers/Format/XML.js
7 * @requires OpenLayers/Geometry/Polygon.js
8 * @requires OpenLayers/Geometry/Point.js
9 * @requires OpenLayers/Geometry/MultiPolygon.js
10 * @requires OpenLayers/Geometry/LinearRing.js
14 * Class: OpenLayers.Format.ArcXML
15 * Read/Wite ArcXML. Create a new instance with the <OpenLayers.Format.ArcXML>
19 * - <OpenLayers.Format>
21 OpenLayers.Format.ArcXML = OpenLayers.Class(OpenLayers.Format.XML, {
24 * Property: fontStyleKeys
25 * {Array} List of keys used in font styling.
28 'antialiasing', 'blockout', 'font', 'fontcolor','fontsize', 'fontstyle',
29 'glowing', 'interval', 'outline', 'printmode', 'shadow', 'transparency'
34 * A get_image request destined for an ArcIMS server.
40 * A parsed response from an ArcIMS server.
45 * Constructor: OpenLayers.Format.ArcXML
46 * Create a new parser/writer for ArcXML. Create an instance of this class
47 * to begin authoring a request to an ArcIMS service. This is used
48 * primarily by the ArcIMS layer, but could be used to do other wild
49 * stuff, like geocoding.
52 * options - {Object} An optional object whose properties will be set on
55 initialize: function(options) {
56 this.request = new OpenLayers.Format.ArcXML.Request();
57 this.response = new OpenLayers.Format.ArcXML.Response();
60 if (options.requesttype == "feature") {
61 this.request.get_image = null;
63 var qry = this.request.get_feature.query;
64 this.addCoordSys(qry.featurecoordsys, options.featureCoordSys);
65 this.addCoordSys(qry.filtercoordsys, options.filterCoordSys);
67 if (options.polygon) {
69 qry.spatialfilter.polygon = options.polygon;
70 } else if (options.envelope) {
72 qry.spatialfilter.envelope = {minx:0, miny:0, maxx:0, maxy:0};
73 this.parseEnvelope(qry.spatialfilter.envelope, options.envelope);
75 } else if (options.requesttype == "image") {
76 this.request.get_feature = null;
78 var props = this.request.get_image.properties;
79 this.parseEnvelope(props.envelope, options.envelope);
81 this.addLayers(props.layerlist, options.layers);
82 this.addImageSize(props.imagesize, options.tileSize);
83 this.addCoordSys(props.featurecoordsys, options.featureCoordSys);
84 this.addCoordSys(props.filtercoordsys, options.filterCoordSys);
86 // if an arcxml object is being created with no request type, it is
87 // probably going to consume a response, so do not throw an error if
88 // the requesttype is not defined
93 OpenLayers.Format.XML.prototype.initialize.apply(this, [options]);
97 * Method: parseEnvelope
98 * Parse an array of coordinates into an ArcXML envelope structure.
101 * env - {Object} An envelope object that will contain the parsed coordinates.
102 * arr - {Array(double)} An array of coordinates in the order: [ minx, miny, maxx, maxy ]
104 parseEnvelope: function(env, arr) {
105 if (arr && arr.length == 4) {
115 * Add a collection of layers to another collection of layers. Each layer in the list is tuple of
116 * { id, visible }. These layer collections represent the
117 * /ARCXML/REQUEST/get_image/PROPERTIES/LAYERLIST/LAYERDEF items in ArcXML
119 * TODO: Add support for dynamic layer rendering.
122 * ll - {Array({id,visible})} A list of layer definitions.
123 * lyrs - {Array({id,visible})} A list of layer definitions.
125 addLayers: function(ll, lyrs) {
126 for(var lind = 0, len=lyrs.length; lind < len; lind++) {
132 * Method: addImageSize
133 * Set the size of the requested image.
136 * imsize - {Object} An ArcXML imagesize object.
137 * olsize - {OpenLayers.Size} The image size to set.
139 addImageSize: function(imsize, olsize) {
140 if (olsize !== null) {
141 imsize.width = olsize.w;
142 imsize.height = olsize.h;
143 imsize.printwidth = olsize.w;
144 imsize.printheight = olsize.h;
149 * Method: addCoordSys
150 * Add the coordinate system information to an object. The object may be
153 * featOrFilt - {Object} A featurecoordsys or filtercoordsys ArcXML structure.
154 * fsys - {String} or {OpenLayers.Projection} or {filtercoordsys} or
155 * {featurecoordsys} A projection representation. If it's a {String},
156 * the value is assumed to be the SRID. If it's a {OpenLayers.Projection}
157 * AND Proj4js is available, the projection number and name are extracted
158 * from there. If it's a filter or feature ArcXML structure, it is copied.
160 addCoordSys: function(featOrFilt, fsys) {
161 if (typeof fsys == "string") {
162 featOrFilt.id = parseInt(fsys);
163 featOrFilt.string = fsys;
165 // is this a proj4js instance?
166 else if (typeof fsys == "object" && fsys.proj !== null){
167 featOrFilt.id = fsys.proj.srsProjNumber;
168 featOrFilt.string = fsys.proj.srsCode;
176 * Check to see if the response from the server was an error.
179 * data - {String} or {DOMElement} data to read/parse. If nothing is supplied,
180 * the current response is examined.
183 * {Boolean} true if the response was an error.
185 iserror: function(data) {
189 ret = (this.response.error !== '');
191 data = OpenLayers.Format.XML.prototype.read.apply(this, [data]);
192 var errorNodes = data.documentElement.getElementsByTagName("ERROR");
193 ret = (errorNodes !== null && errorNodes.length > 0);
201 * Read data from a string, and return an response.
204 * data - {String} or {DOMElement} data to read/parse.
207 * {OpenLayers.Format.ArcXML.Response} An ArcXML response. Note that this response
208 * data may change in the future.
210 read: function(data) {
211 if(typeof data == "string") {
212 data = OpenLayers.Format.XML.prototype.read.apply(this, [data]);
216 if (data && data.documentElement) {
217 if(data.documentElement.nodeName == "ARCXML") {
218 arcNode = data.documentElement;
220 arcNode = data.documentElement.getElementsByTagName("ARCXML")[0];
227 error = data.firstChild.nodeValue;
228 source = data.firstChild.childNodes[1].firstChild.nodeValue;
233 message: "Error parsing the ArcXML request",
239 var response = this.parseResponse(arcNode);
245 * Generate an ArcXml document string for sending to an ArcIMS server.
248 * {String} A string representing the ArcXML document request.
250 write: function(request) {
252 request = this.request;
254 var root = this.createElementNS("", "ARCXML");
255 root.setAttribute("version","1.1");
257 var reqElem = this.createElementNS("", "REQUEST");
259 if (request.get_image != null) {
260 var getElem = this.createElementNS("", "GET_IMAGE");
261 reqElem.appendChild(getElem);
263 var propElem = this.createElementNS("", "PROPERTIES");
264 getElem.appendChild(propElem);
266 var props = request.get_image.properties;
267 if (props.featurecoordsys != null) {
268 var feat = this.createElementNS("", "FEATURECOORDSYS");
269 propElem.appendChild(feat);
271 if (props.featurecoordsys.id === 0) {
272 feat.setAttribute("string", props.featurecoordsys['string']);
275 feat.setAttribute("id", props.featurecoordsys.id);
279 if (props.filtercoordsys != null) {
280 var filt = this.createElementNS("", "FILTERCOORDSYS");
281 propElem.appendChild(filt);
283 if (props.filtercoordsys.id === 0) {
284 filt.setAttribute("string", props.filtercoordsys.string);
287 filt.setAttribute("id", props.filtercoordsys.id);
291 if (props.envelope != null) {
292 var env = this.createElementNS("", "ENVELOPE");
293 propElem.appendChild(env);
295 env.setAttribute("minx", props.envelope.minx);
296 env.setAttribute("miny", props.envelope.miny);
297 env.setAttribute("maxx", props.envelope.maxx);
298 env.setAttribute("maxy", props.envelope.maxy);
301 var imagesz = this.createElementNS("", "IMAGESIZE");
302 propElem.appendChild(imagesz);
304 imagesz.setAttribute("height", props.imagesize.height);
305 imagesz.setAttribute("width", props.imagesize.width);
307 if (props.imagesize.height != props.imagesize.printheight ||
308 props.imagesize.width != props.imagesize.printwidth) {
309 imagesz.setAttribute("printheight", props.imagesize.printheight);
310 imagesz.setArrtibute("printwidth", props.imagesize.printwidth);
313 if (props.background != null) {
314 var backgrnd = this.createElementNS("", "BACKGROUND");
315 propElem.appendChild(backgrnd);
317 backgrnd.setAttribute("color",
318 props.background.color.r + "," +
319 props.background.color.g + "," +
320 props.background.color.b);
322 if (props.background.transcolor !== null) {
323 backgrnd.setAttribute("transcolor",
324 props.background.transcolor.r + "," +
325 props.background.transcolor.g + "," +
326 props.background.transcolor.b);
330 if (props.layerlist != null && props.layerlist.length > 0) {
331 var layerlst = this.createElementNS("", "LAYERLIST");
332 propElem.appendChild(layerlst);
334 for (var ld = 0; ld < props.layerlist.length; ld++) {
335 var ldef = this.createElementNS("", "LAYERDEF");
336 layerlst.appendChild(ldef);
338 ldef.setAttribute("id", props.layerlist[ld].id);
339 ldef.setAttribute("visible", props.layerlist[ld].visible);
341 if (typeof props.layerlist[ld].query == "object") {
342 var query = props.layerlist[ld].query;
344 if (query.where.length < 0) {
348 var queryElem = null;
349 if (typeof query.spatialfilter == "boolean" && query.spatialfilter) {
350 // handle spatial filter madness
351 queryElem = this.createElementNS("", "SPATIALQUERY");
354 queryElem = this.createElementNS("", "QUERY");
357 queryElem.setAttribute("where", query.where);
359 if (typeof query.accuracy == "number" && query.accuracy > 0) {
360 queryElem.setAttribute("accuracy", query.accuracy);
362 if (typeof query.featurelimit == "number" && query.featurelimit < 2000) {
363 queryElem.setAttribute("featurelimit", query.featurelimit);
365 if (typeof query.subfields == "string" && query.subfields != "#ALL#") {
366 queryElem.setAttribute("subfields", query.subfields);
368 if (typeof query.joinexpression == "string" && query.joinexpression.length > 0) {
369 queryElem.setAttribute("joinexpression", query.joinexpression);
371 if (typeof query.jointables == "string" && query.jointables.length > 0) {
372 queryElem.setAttribute("jointables", query.jointables);
375 ldef.appendChild(queryElem);
378 if (typeof props.layerlist[ld].renderer == "object") {
379 this.addRenderer(ldef, props.layerlist[ld].renderer);
383 } else if (request.get_feature != null) {
384 var getElem = this.createElementNS("", "GET_FEATURES");
385 getElem.setAttribute("outputmode", "newxml");
386 getElem.setAttribute("checkesc", "true");
388 if (request.get_feature.geometry) {
389 getElem.setAttribute("geometry", request.get_feature.geometry);
392 getElem.setAttribute("geometry", "false");
395 if (request.get_feature.compact) {
396 getElem.setAttribute("compact", request.get_feature.compact);
399 if (request.get_feature.featurelimit == "number") {
400 getElem.setAttribute("featurelimit", request.get_feature.featurelimit);
403 getElem.setAttribute("globalenvelope", "true");
404 reqElem.appendChild(getElem);
406 if (request.get_feature.layer != null && request.get_feature.layer.length > 0) {
407 var lyrElem = this.createElementNS("", "LAYER");
408 lyrElem.setAttribute("id", request.get_feature.layer);
409 getElem.appendChild(lyrElem);
412 var fquery = request.get_feature.query;
413 if (fquery != null) {
415 if (fquery.isspatial) {
416 qElem = this.createElementNS("", "SPATIALQUERY");
418 qElem = this.createElementNS("", "QUERY");
420 getElem.appendChild(qElem);
422 if (typeof fquery.accuracy == "number") {
423 qElem.setAttribute("accuracy", fquery.accuracy);
425 //qElem.setAttribute("featurelimit", "5");
427 if (fquery.featurecoordsys != null) {
428 var fcsElem1 = this.createElementNS("", "FEATURECOORDSYS");
430 if (fquery.featurecoordsys.id == 0) {
431 fcsElem1.setAttribute("string", fquery.featurecoordsys.string);
433 fcsElem1.setAttribute("id", fquery.featurecoordsys.id);
435 qElem.appendChild(fcsElem1);
438 if (fquery.filtercoordsys != null) {
439 var fcsElem2 = this.createElementNS("", "FILTERCOORDSYS");
441 if (fquery.filtercoordsys.id === 0) {
442 fcsElem2.setAttribute("string", fquery.filtercoordsys.string);
444 fcsElem2.setAttribute("id", fquery.filtercoordsys.id);
446 qElem.appendChild(fcsElem2);
449 if (fquery.buffer > 0) {
450 var bufElem = this.createElementNS("", "BUFFER");
451 bufElem.setAttribute("distance", fquery.buffer);
452 qElem.appendChild(bufElem);
455 if (fquery.isspatial) {
456 var spfElem = this.createElementNS("", "SPATIALFILTER");
457 spfElem.setAttribute("relation", fquery.spatialfilter.relation);
458 qElem.appendChild(spfElem);
460 if (fquery.spatialfilter.envelope) {
461 var envElem = this.createElementNS("", "ENVELOPE");
462 envElem.setAttribute("minx", fquery.spatialfilter.envelope.minx);
463 envElem.setAttribute("miny", fquery.spatialfilter.envelope.miny);
464 envElem.setAttribute("maxx", fquery.spatialfilter.envelope.maxx);
465 envElem.setAttribute("maxy", fquery.spatialfilter.envelope.maxy);
466 spfElem.appendChild(envElem);
467 } else if(typeof fquery.spatialfilter.polygon == "object") {
468 spfElem.appendChild(this.writePolygonGeometry(fquery.spatialfilter.polygon));
472 if (fquery.where != null && fquery.where.length > 0) {
473 qElem.setAttribute("where", fquery.where);
478 root.appendChild(reqElem);
480 return OpenLayers.Format.XML.prototype.write.apply(this, [root]);
484 addGroupRenderer: function(ldef, toprenderer) {
485 var topRelem = this.createElementNS("", "GROUPRENDERER");
486 ldef.appendChild(topRelem);
488 for (var rind = 0; rind < toprenderer.length; rind++) {
489 var renderer = toprenderer[rind];
490 this.addRenderer(topRelem, renderer);
495 addRenderer: function(topRelem, renderer) {
496 if (renderer instanceof Array) {
497 this.addGroupRenderer(topRelem, renderer);
499 var renderElem = this.createElementNS("", renderer.type.toUpperCase() + "RENDERER");
500 topRelem.appendChild(renderElem);
502 if (renderElem.tagName == "VALUEMAPRENDERER") {
503 this.addValueMapRenderer(renderElem, renderer);
504 } else if (renderElem.tagName == "VALUEMAPLABELRENDERER") {
505 this.addValueMapLabelRenderer(renderElem, renderer);
506 } else if (renderElem.tagName == "SIMPLELABELRENDERER") {
507 this.addSimpleLabelRenderer(renderElem, renderer);
508 } else if (renderElem.tagName == "SCALEDEPENDENTRENDERER") {
509 this.addScaleDependentRenderer(renderElem, renderer);
515 addScaleDependentRenderer: function(renderElem, renderer) {
516 if (typeof renderer.lower == "string" || typeof renderer.lower == "number") {
517 renderElem.setAttribute("lower", renderer.lower);
519 if (typeof renderer.upper == "string" || typeof renderer.upper == "number") {
520 renderElem.setAttribute("upper", renderer.upper);
523 this.addRenderer(renderElem, renderer.renderer);
527 addValueMapLabelRenderer: function(renderElem, renderer) {
528 renderElem.setAttribute("lookupfield", renderer.lookupfield);
529 renderElem.setAttribute("labelfield", renderer.labelfield);
531 if (typeof renderer.exacts == "object") {
532 for (var ext=0, extlen=renderer.exacts.length; ext<extlen; ext++) {
533 var exact = renderer.exacts[ext];
535 var eelem = this.createElementNS("", "EXACT");
537 if (typeof exact.value == "string") {
538 eelem.setAttribute("value", exact.value);
540 if (typeof exact.label == "string") {
541 eelem.setAttribute("label", exact.label);
543 if (typeof exact.method == "string") {
544 eelem.setAttribute("method", exact.method);
547 renderElem.appendChild(eelem);
549 if (typeof exact.symbol == "object") {
552 if (exact.symbol.type == "text") {
553 selem = this.createElementNS("", "TEXTSYMBOL");
557 var keys = this.fontStyleKeys;
558 for (var i = 0, len = keys.length; i < len; i++) {
560 if (exact.symbol[key]) {
561 selem.setAttribute(key, exact.symbol[key]);
564 eelem.appendChild(selem);
571 addValueMapRenderer: function(renderElem, renderer) {
572 renderElem.setAttribute("lookupfield", renderer.lookupfield);
574 if (typeof renderer.ranges == "object") {
575 for(var rng=0, rnglen=renderer.ranges.length; rng<rnglen; rng++) {
576 var range = renderer.ranges[rng];
578 var relem = this.createElementNS("", "RANGE");
579 relem.setAttribute("lower", range.lower);
580 relem.setAttribute("upper", range.upper);
582 renderElem.appendChild(relem);
584 if (typeof range.symbol == "object") {
587 if (range.symbol.type == "simplepolygon") {
588 selem = this.createElementNS("", "SIMPLEPOLYGONSYMBOL");
592 if (typeof range.symbol.boundarycolor == "string") {
593 selem.setAttribute("boundarycolor", range.symbol.boundarycolor);
595 if (typeof range.symbol.fillcolor == "string") {
596 selem.setAttribute("fillcolor", range.symbol.fillcolor);
598 if (typeof range.symbol.filltransparency == "number") {
599 selem.setAttribute("filltransparency", range.symbol.filltransparency);
601 relem.appendChild(selem);
605 } else if (typeof renderer.exacts == "object") {
606 for (var ext=0, extlen=renderer.exacts.length; ext<extlen; ext++) {
607 var exact = renderer.exacts[ext];
609 var eelem = this.createElementNS("", "EXACT");
610 if (typeof exact.value == "string") {
611 eelem.setAttribute("value", exact.value);
613 if (typeof exact.label == "string") {
614 eelem.setAttribute("label", exact.label);
616 if (typeof exact.method == "string") {
617 eelem.setAttribute("method", exact.method);
620 renderElem.appendChild(eelem);
622 if (typeof exact.symbol == "object") {
625 if (exact.symbol.type == "simplemarker") {
626 selem = this.createElementNS("", "SIMPLEMARKERSYMBOL");
630 if (typeof exact.symbol.antialiasing == "string") {
631 selem.setAttribute("antialiasing", exact.symbol.antialiasing);
633 if (typeof exact.symbol.color == "string") {
634 selem.setAttribute("color", exact.symbol.color);
636 if (typeof exact.symbol.outline == "string") {
637 selem.setAttribute("outline", exact.symbol.outline);
639 if (typeof exact.symbol.overlap == "string") {
640 selem.setAttribute("overlap", exact.symbol.overlap);
642 if (typeof exact.symbol.shadow == "string") {
643 selem.setAttribute("shadow", exact.symbol.shadow);
645 if (typeof exact.symbol.transparency == "number") {
646 selem.setAttribute("transparency", exact.symbol.transparency);
648 //if (typeof exact.symbol.type == "string")
649 // selem.setAttribute("type", exact.symbol.type);
650 if (typeof exact.symbol.usecentroid == "string") {
651 selem.setAttribute("usecentroid", exact.symbol.usecentroid);
653 if (typeof exact.symbol.width == "number") {
654 selem.setAttribute("width", exact.symbol.width);
657 eelem.appendChild(selem);
665 addSimpleLabelRenderer: function(renderElem, renderer) {
666 renderElem.setAttribute("field", renderer.field);
667 var keys = ['featureweight', 'howmanylabels', 'labelbufferratio',
668 'labelpriorities', 'labelweight', 'linelabelposition',
670 for (var i=0, len=keys.length; i<len; i++) {
673 renderElem.setAttribute(key, renderer[key]);
677 if (renderer.symbol.type == "text") {
678 var symbol = renderer.symbol;
679 var selem = this.createElementNS("", "TEXTSYMBOL");
680 renderElem.appendChild(selem);
682 var keys = this.fontStyleKeys;
683 for (var i=0, len=keys.length; i<len; i++) {
686 selem.setAttribute(key, renderer[key]);
692 writePolygonGeometry: function(polygon) {
693 if (!(polygon instanceof OpenLayers.Geometry.Polygon)) {
695 message:'Cannot write polygon geometry to ArcXML with an ' +
696 polygon.CLASS_NAME + ' object.',
701 var polyElem = this.createElementNS("", "POLYGON");
703 for (var ln=0, lnlen=polygon.components.length; ln<lnlen; ln++) {
704 var ring = polygon.components[ln];
705 var ringElem = this.createElementNS("", "RING");
707 for (var rn=0, rnlen=ring.components.length; rn<rnlen; rn++) {
708 var point = ring.components[rn];
709 var pointElem = this.createElementNS("", "POINT");
711 pointElem.setAttribute("x", point.x);
712 pointElem.setAttribute("y", point.y);
714 ringElem.appendChild(pointElem);
717 polyElem.appendChild(ringElem);
724 * Method: parseResponse
725 * Take an ArcXML response, and parse in into this object's internal properties.
728 * data - {String} or {DOMElement} The ArcXML response, as either a string or the
729 * top level DOMElement of the response.
731 parseResponse: function(data) {
732 if(typeof data == "string") {
733 var newData = new OpenLayers.Format.XML();
734 data = newData.read(data);
736 var response = new OpenLayers.Format.ArcXML.Response();
738 var errorNode = data.getElementsByTagName("ERROR");
740 if (errorNode != null && errorNode.length > 0) {
741 response.error = this.getChildValue(errorNode, "Unknown error.");
743 var responseNode = data.getElementsByTagName("RESPONSE");
745 if (responseNode == null || responseNode.length == 0) {
746 response.error = "No RESPONSE tag found in ArcXML response.";
750 var rtype = responseNode[0].firstChild.nodeName;
751 if (rtype == "#text") {
752 rtype = responseNode[0].firstChild.nextSibling.nodeName;
755 if (rtype == "IMAGE") {
756 var envelopeNode = data.getElementsByTagName("ENVELOPE");
757 var outputNode = data.getElementsByTagName("OUTPUT");
759 if (envelopeNode == null || envelopeNode.length == 0) {
760 response.error = "No ENVELOPE tag found in ArcXML response.";
761 } else if (outputNode == null || outputNode.length == 0) {
762 response.error = "No OUTPUT tag found in ArcXML response.";
764 var envAttr = this.parseAttributes(envelopeNode[0]);
765 var outputAttr = this.parseAttributes(outputNode[0]);
767 if (typeof outputAttr.type == "string") {
771 type: outputAttr.type,
772 data: this.getChildValue(outputNode[0])
776 response.image = { envelope: envAttr, output: outputAttr };
779 } else if (rtype == "FEATURES") {
780 var features = responseNode[0].getElementsByTagName("FEATURES");
782 // get the feature count
783 var featureCount = features[0].getElementsByTagName("FEATURECOUNT");
784 response.features.featurecount = featureCount[0].getAttribute("count");
786 if (response.features.featurecount > 0) {
787 // get the feature envelope
788 var envelope = features[0].getElementsByTagName("ENVELOPE");
789 response.features.envelope = this.parseAttributes(envelope[0], typeof(0));
791 // get the field values per feature
792 var featureList = features[0].getElementsByTagName("FEATURE");
793 for (var fn = 0; fn < featureList.length; fn++) {
794 var feature = new OpenLayers.Feature.Vector();
795 var fields = featureList[fn].getElementsByTagName("FIELD");
797 for (var fdn = 0; fdn < fields.length; fdn++) {
798 var fieldName = fields[fdn].getAttribute("name");
799 var fieldValue = fields[fdn].getAttribute("value");
800 feature.attributes[ fieldName ] = fieldValue;
803 var geom = featureList[fn].getElementsByTagName("POLYGON");
805 if (geom.length > 0) {
806 // if there is a polygon, create an openlayers polygon, and assign
807 // it to the .geometry property of the feature
808 var ring = geom[0].getElementsByTagName("RING");
811 for (var rn = 0; rn < ring.length; rn++) {
812 var linearRings = [];
813 linearRings.push(this.parsePointGeometry(ring[rn]));
815 var holes = ring[rn].getElementsByTagName("HOLE");
816 for (var hn = 0; hn < holes.length; hn++) {
817 linearRings.push(this.parsePointGeometry(holes[hn]));
820 polys.push(new OpenLayers.Geometry.Polygon(linearRings));
825 if (polys.length == 1) {
826 feature.geometry = polys[0];
829 feature.geometry = new OpenLayers.Geometry.MultiPolygon(polys);
833 response.features.feature.push(feature);
837 response.error = "Unidentified response type.";
845 * Method: parseAttributes
848 * node - {<DOMElement>} An element to parse attributes from.
851 * {Object} An attributes object, with properties set to attribute values.
853 parseAttributes: function(node,type) {
855 for(var attr = 0; attr < node.attributes.length; attr++) {
856 if (type == "number") {
857 attributes[node.attributes[attr].nodeName] = parseFloat(node.attributes[attr].nodeValue);
859 attributes[node.attributes[attr].nodeName] = node.attributes[attr].nodeValue;
867 * Method: parsePointGeometry
870 * node - {<DOMElement>} An element to parse <COORDS> or <POINT> arcxml data from.
873 * {OpenLayers.Geometry.LinearRing} A linear ring represented by the node's points.
875 parsePointGeometry: function(node) {
877 var coords = node.getElementsByTagName("COORDS");
879 if (coords.length > 0) {
880 // if coords is present, it's the only coords item
881 var coordArr = this.getChildValue(coords[0]);
882 coordArr = coordArr.split(/;/);
883 for (var cn = 0; cn < coordArr.length; cn++) {
884 var coordItems = coordArr[cn].split(/ /);
885 ringPoints.push(new OpenLayers.Geometry.Point(parseFloat(coordItems[0]), parseFloat(coordItems[1])));
889 var point = node.getElementsByTagName("POINT");
890 if (point.length > 0) {
891 for (var pn = 0; pn < point.length; pn++) {
893 new OpenLayers.Geometry.Point(
894 parseFloat(point[pn].getAttribute("x")),
895 parseFloat(point[pn].getAttribute("y"))
903 return new OpenLayers.Geometry.LinearRing(ringPoints);
906 CLASS_NAME: "OpenLayers.Format.ArcXML"
909 OpenLayers.Format.ArcXML.Request = OpenLayers.Class({
910 initialize: function(params) {
916 color: { r:255, g:255, b:255 },
930 datumtransformstring:""
936 datumtransformstring:""
947 /* no support for legends */
970 datumtransformstring:""
976 datumtransformstring:""
981 relation: "envelope_intersection",
998 return OpenLayers.Util.extend(this, defaults);
1001 CLASS_NAME: "OpenLayers.Format.ArcXML.Request"
1004 OpenLayers.Format.ArcXML.Response = OpenLayers.Class({
1005 initialize: function(params) {
1021 return OpenLayers.Util.extend(this, defaults);
1024 CLASS_NAME: "OpenLayers.Format.ArcXML.Response"