// quickXML.js

//Description: Creates a new XML document, using the string provided in the optional argument,
//Description: or an empty document if the argument isn't provided.
//Return Type: DOMDocument
//Return Value: The new document.
function newDoc() {
	var xmlDOM = new ActiveXObject("MSXML2.FreeThreadedDOMDocument.3.0");

	xmlDOM.async = false;
	xmlDOM.preserveWhiteSpace = true;
	xmlDOM.validateOnParse = false;

	if (arguments.length == 0) {
		return xmlDOM;
	}

	xmlDOM.loadXML(arguments[0]);
	var error = xmlDOM.parseError;

	if (xmlDOM.parseError.errorCode != 0) {
		alert('Error parsing ' + error.url + ' at ' + error.line + ':' + error.linepos + ':\n' + error.reason);
		return;
	}

	return xmlDOM;
}

//Description: Creates a new document from a file.
//Return Type: DOMDocument
//Return Value: The new document.
function loadNewDoc(
	location	//Argument: String containing the location of the XML file
	) {

	var xmlDOM = newDoc();
	xmlDOM.load(location);
	return xmlDOM
}

// XML DOM functions

//Description: Creates an XML element, using the first argument as a tag.
//Description: Additional optional arguments may be used to create child nodes for this element.
//Return Type: XMLDOMElement
//Return Value: The XML element.
function qE(
	tag	//Argument: String containing the tag name for the new element
	) {

	var ele = xmlDoc.createElement(tag);
	var kids = arguments;
	var j = 1;
	var i;

	while (kids[0] != undefined) {
		for (i = j; i < kids.length; i++) {
			if (typeof kids[i] == "object") {
				if (kids[i][0] == undefined) {
					ele.appendChild(kids[i]);
				}
			} else {
				var eqPos = (kids[i] + "").indexOf("=");

				if (eqPos > 0) {
					ele.setAttribute(kids[i].substring(0, eqPos),
						kids[i].substring(eqPos + 1, kids[i].length));
				} else if (eqPos == 0) {
					ele.appendChild(textNode(kids[i].substring(1, kids[i].length)));
				} else {
					ele.appendChild(textNode(kids[i]));
				}
			}
		}

		kids = kids[i - 1];
		j = 0;
	}

	return ele;
}

//Description: Creates an XML text node.
//Return Type: XMLDOMTextNode
//Return Value: The text node.
function textNode(
	text	//Argument: String containing the text for the XML text node
	) {
	return xmlDoc.createTextNode(text)
}

/*function quickRequest(getType) {
	var args = new Array();

	for (var i = 1; i < arguments.length; i++) {
		args[i - 1] = arguments[i];
	}

	return qE("ARCXML", "version=1.1",
		qE("REQUEST",
			qE("GET_" + getType.toUpperCase(), args)))
}

function getServiceInfo() {
	var args = new Array()
	var services = new Array("envelope", "extensions", "fields", "renderer");
	var mask = new Array(false, false, false, false);
	var j;

	for (var i = 0; i < 4; i++) {
		for (j = 0; j < arguments.length; j++) {
			mask[i] = mask[i] || (services[i] == arguments[j])
		}
	}

	j = 0;

	for (i = 0; i < 4; i++) {
		if (!mask[i]) {
			args[j] = (services[i] + "=false");
			j++;
		}
	}

	return quickRequest("service_info", args);
}

function cdr() {	// takes an array, and returns an array with the first element removed - just as in LISP
	var args = new Array();

	for (var i = 1; i < arguments[0].length; i++) {
		args[i - 1] = arguments[0][i];
	}

	return args;
}*/

//Description: Converts an ArcXML response to an XML element
//Return Type: XMLDOMElement
//Return Value: The XML element.
function getXML(
	theString	//Argument: String containing the ArcXML code to convert to an XML element
	) {

	var arcXML = theString.substring(theString.indexOf('<ARCXML'), theString.length);
	arcXML = arcXML.replace(regexAmp, "&amp;");
	xmlDoc.loadXML(arcXML);
	return xmlDoc.documentElement;
}

// XSLT functions
/*function buildStylesheet() {
	return qE("xsl:stylesheet", "version=1.0", "xmlns:xsl=http://www.w3.org/1999/XSL/Transform", arguments);
}

function buildTemplate(match) {
	if (arguments.length > 1) {
		return qE("xsl:template", "match=" + match, cdr(arguments));
	} else {
		return qE("xsl:template", "match=" + match);
	}
}

function applyTemplates(select) {
	if (select != undefined) {
		return qE("xsl:apply-templates", "select=" + select);
	} else {
		return qE("xsl:apply-templates");
	}
}

function buildAttribute(name) {
	return qE("xsl:attribute", "name=" + name, cdr(arguments));
}

function valueOf(select) {
	return qE("xsl:value-of", "select=" + select);
}

function copyOf(select) {
	return qE("xsl:copy-of", "select=" + select);
}

function unitTransform() {
	unit = buildTemplate("@*|node()", qE("xsl:copy", applyTemplates("@*|node()")));

	if (arguments.length > 0) {
		xslt = buildStylesheet(unit, arguments);
	} else {
		xslt = buildStylesheet(unit);
	}

	return xslt;
}*/

//Description: Takes a stored query and generates a list of features.
function listChoices(
	locate	//Argument: String containing the name of a stored query
	) {

	storedQuery = storedQueries.selectSingleNode("//STOREDQUERY[@name='" + locate + "']");

	var idField = storedQuery.getAttribute("field");
	var params = new ArcXMLSample("#SHAPE# " + idField);
	var layerID = storedQuery.getAttribute("layer");
	selectType = storedQuery.getAttribute("type");

	params.layer = layerID;
	params.featureLimit = 6400;
	var arcXML = params.$text();

	sendToServer(imsQueryURL, arcXML, 1040);
}