vcc.arXmlObjects = [];
vcc.arXmlOnloadFunctions = [];
vcc.bCanApplyXslt = (window.XSLTProcessor && !(vcc.win && vcc.safari));
if (!vcc.bCanApplyXslt && window.ActiveXObject) {
	vcc.bCanApplyXslt = true;
	try {
		var objTest = new ActiveXObject("MSXML2.XSLTemplate");
	}
	catch(e) {
		vcc.bCanApplyXslt = false;
	}
}

vcc.createXmlObj = function(sXml, bAsync, fOnLoad, sNameSpaces) {
	if (typeof sXml != "string")
		return sXml;
	var xml;
	if (window.ActiveXObject) {
		xml = new ActiveXObject("MSXML.DOMDocument");
		try {
			xml.setProperty("SelectionLanguage", "XPath");
			if (sNameSpaces)
				xml.setProperty("SelectionNamespaces", sNameSpaces);
		}
		catch(e) {}
	}
	else if (window.XMLHttpRequest) {
		xml = new XMLHttpRequest();
	}
	else
		return null;
	xml.async = bAsync;
	vcc.arXmlObjects.push(xml);
	vcc.arXmlOnloadFunctions.push(fOnLoad);
	
	if (!sXml || sXml == "" || sXml.charAt(0) == "<") {
		if (window.ActiveXObject) { // IE
			xml.loadXML(sXml);
		}
		else if (window.DOMParser) { // Mozilla or Safari >= 2.0
			var oParser = new DOMParser();
			xml = oParser.parseFromString(sXml, "application/xml");
			/*if (sNameSpaces) {
				objRoot = xml.documentElement;
				var arNameSpaces = sNameSpaces.split(" ");
				for (var i = 0; i < arNameSpaces.length; i++) {
					var strNS = arNameSpaces[i];
					var strNameSpace = strNS.substring(strNS.indexOf(":") + 1,strNS.indexOf("="));
					var strNameSpaceUrl = strNS.substring(strNS.indexOf("'") + 1,strNS.length - 1);
					objRoot.setAttributeNS("xmlns",strNameSpace,strNameSpaceUrl);
					objRoot.removeAttribute(strNameSpace);
				}
			}*/
		}
		else if (window.XMLHttpRequest) { // Workaround for Safari < 2.0
			var sUrl = "data:text/xml;charset=utf-8," + encodeURIComponent(sXml);
			var req = new XMLHttpRequest();
			req.open("GET", sUrl);
			req.send(null);
			xml = req.responseXML;
		}
	}
	else {
		xml.onreadystatechange = new Function("vcc.onReadyStateChange_xmlObj(" + (vcc.arXmlObjects.length-1) + ")");
		if (window.ActiveXObject) {
			try {
				xml.load(sXml);
			}
			catch(e) {
				return null;
			}
		}
		else {
			xml.open("GET", sXml);
			xml.send("");
		}
	}
	return xml;
}

vcc.callAjax = function(sAssembly, sClass, sMethod, arParams, oFuncOnLoad, arClassParams, sCulture) {
	var sState = (!vcc.strAuthorMode || vcc.strAuthorMode == 'PresentationPublished') ? "2" : "1";
	var oXml = vcc.createXmlObj('<ajax assemblyname="' + sAssembly + '" classname="' + sClass + '"></ajax>');
	var oParams = oXml.createElement("params");
	oXml.documentElement.appendChild(oParams);
	if (arClassParams != null) {
		for (var i=0; i<arClassParams.length; i++) {
			var oParam = oXml.createElement("param");
			oParams.appendChild(oParam);
			oParam.setAttribute("type", "System.String");
			var oValue = oXml.createTextNode(arClassParams[i]);
			oParam.appendChild(oValue);
		}
	}
	var oMethod = oXml.createElement("method");
	oXml.documentElement.appendChild(oMethod);
	oMethod.setAttribute("methodname", sMethod);
	//var sCulture = (sCulture) ? sCulture : vcc.sAppCulture;
	oMethod.setAttribute("culture", vcc.sAppCulture);
	// methodname="' + sMethod + '" culture="' + vcc.sAppCulture + '" state="' + iState + '"/>');
	for (var i=0; i<arParams.length; i++) {
		var oParam = oXml.createElement("param");
		oMethod.appendChild(oParam);
		oParam.setAttribute("type", "System.String");
		var oValue = oXml.createTextNode(arParams[i]);
		oParam.appendChild(oValue);
	}
	var oXmlSend;
	if (window.ActiveXObject)
		oXmlSend = new ActiveXObject("Microsoft.XMLHTTP");
	else if (window.XMLHttpRequest)
		oXmlSend = new XMLHttpRequest();
	if (oXmlSend) {
		vcc.arXmlObjects.push(oXmlSend);
		vcc.arXmlOnloadFunctions.push(oFuncOnLoad);
		oXmlSend.onreadystatechange = new Function("vcc.onReadyStateChange_xmlObj(" + (vcc.arXmlObjects.length-1) + ")");
		oXmlSend.open("POST", "/_layouts/VolvoCars.Web.Sites/ajax.aspx", true);
		oXmlSend.send(vcc.serializeXml(oXml));
	}
}

vcc.onReadyStateChange_xmlObj = function(iXmlObj) {
	var oXml = vcc.arXmlObjects[iXmlObj];
	if (oXml.readyState == 4 && vcc.arXmlOnloadFunctions[iXmlObj]) {
		vcc.arXmlOnloadFunctions[iXmlObj](oXml);
	}
}

vcc.onReadyStateChange_xsltObj = function(iXsltObj, bReturnTransformed) {
	var oXslt = vcc.arXsltObjects[iXsltObj];
	if (oXslt.objXsltXml.readyState == 4) {
		if (oXslt.objXsltXml.status && oXslt.objXsltXml.status != 200) {
			vcc.showError("Xml error: " + oXslt.objXsltXml.status);
			//return;
		}
		if (!oXslt.objXml || !oXslt.objXml.documentElement)
			return;
		if (!vcc.bCanApplyXslt) {
			strTransformedXml = oXslt.objXsltXml.responseText;
		}
		else if (window.ActiveXObject) { // IE
			try {
				var objXslt = new ActiveXObject("MSXML2.XSLTemplate");
				objXslt.stylesheet = oXslt.objXsltXml;
				var objXsltProc = objXslt.createProcessor();
				objXsltProc.input = oXslt.objXml;
				if (oXslt.oParams) {
					for (i in oXslt.oParams) {
						objXsltProc.addParameter(i, oXslt.oParams[i], "");
					}
				}
				objXsltProc.transform();
				var strTransformedXml = objXsltProc.output;
			}
			catch (e) {
				var strTransformedXml = oXslt.objXml.transformNode(oXslt.objXsltXml);
			}
		}
		else { // Gecko, Opera
			var objXsltProc = new XSLTProcessor();
			objXsltProc.importStylesheet(oXslt.objXsltXml.responseXML);
			if (oXslt.oParams) {
				for (i in oXslt.oParams) {
					objXsltProc.setParameter(null, i, oXslt.oParams[i]);
				}
			}
			var objTransformedXml = objXsltProc.transformToDocument(oXslt.objXml);
			var objXMLSerializer = new XMLSerializer();
		    var strTransformedXml = objXMLSerializer.serializeToString(objTransformedXml);
		}
		if (oXslt.oFuncOnLoad)
			oXslt.oFuncOnLoad(strTransformedXml);
		return strTransformedXml;
	}
}

vcc.arXsltObjects = [];
vcc.transformXml = function(objXml, sXsltUrl, bAsync, oFuncOnLoad, oParams) {
	if (typeof objXml == "string")
		objXml = vcc.createXmlObj(objXml);
	
	var objXsltXml;
	if (window.ActiveXObject) {// IE
		try {
			objXsltXml = new ActiveXObject("MSXML2.FreeThreadedDOMDocument");
		}
		catch(e) {
			objXsltXml = new ActiveXObject("Microsoft.XMLHTTP");
		}
	}
	else if (window.XMLHttpRequest) // Mozilla, Safari
		objXsltXml = new XMLHttpRequest();
	if (!objXsltXml)
		return;
	
	var xslt = {};
	xslt.objXml = objXml;
	xslt.objXsltXml = objXsltXml;
	xslt.oParams = oParams;
	xslt.oFuncOnLoad = oFuncOnLoad;
	vcc.arXsltObjects.push(xslt);
	
	if (bAsync)
		objXsltXml.onreadystatechange = new Function("vcc.onReadyStateChange_xsltObj(" + (vcc.arXsltObjects.length-1) + ")");

	if (!vcc.bCanApplyXslt) {
		var objXsltXmlCall = vcc.createXmlObj("<applyxslt xslt=\"" + sXsltUrl + "\"></applyxslt>");
		var elmXmlDoc = objXsltXmlCall.createElement("xmldoc");
		objXsltXmlCall.documentElement.appendChild(elmXmlDoc);
		var sXml = vcc.serializeXml(objXml);
		
		//Split the XML doc in parts, Opera can't handle text nodes over 32 KB in size, and some others have a 4 KB limit.
		for (var i=0; i<sXml.length; i+=3000) {
			var elmPart = objXsltXmlCall.createElement("part");
			elmXmlDoc.appendChild(elmPart);
			var sXmlPart = sXml.substr(i, 3000);
			try {
				var oValue = objXsltXmlCall.createCDATASection(sXmlPart);
			}
			catch(e) {
				var oValue = objXsltXmlCall.createTextNode("<![CDATA[" + sXmlPart + "]]>");
			}
			elmPart.appendChild(oValue);
		}
		
		if (oParams) {
			var elmParams = objXsltXmlCall.createElement("params");
			objXsltXmlCall.documentElement.appendChild(elmParams);
			for (var i in oParams) {
				var elmParam = objXsltXmlCall.createElement("param");
				elmParams.appendChild(elmParam);
				elmParam.setAttribute("name", i);
				elmParam.setAttribute("value", escape(oParams[i]));
			}
		}
		objXsltXml.open("POST", "/_layouts/VolvoCars.Web.Sites/xslt/applyxslt.aspx", true);
		//objXsltXml.send(objXsltXmlCall.xml);
		objXsltXml.send(vcc.serializeXml(objXsltXmlCall));
		//alert(vcc.serializeXml(objXsltXmlCall))
	}
	else if (window.ActiveXObject) { // IE >= 6.0
		objXsltXml.async = bAsync;
		objXsltXml.load(sXsltUrl + "?version=" + vcc.sAppVersion);
	}
	else if (window.XMLHttpRequest) { // Gecko
		objXsltXml.open("GET", sXsltUrl + "?version=" + vcc.sAppVersion, bAsync); 
		objXsltXml.send(null);
	}
	return vcc.onReadyStateChange_xsltObj(vcc.arXsltObjects.length-1, true);
}

vcc.serializeXml = function(xmlNode) {
	var sXml;
	if (window.XMLSerializer) {
		// Gecko-based browsers, Safari, Opera.
		var oSerializer = new XMLSerializer();
		if (xmlNode)
			sXml = oSerializer.serializeToString(xmlNode);
	}
	else if (window.ActiveXObject)
		sXml = xmlNode.xml;
  return sXml;
}

vcc.getXmlNodeValue = function(oXml, strNodeName) {
	var aNodes = oXml.getElementsByTagName(strNodeName);
	if (aNodes.length == 0) return "";
	var oNode = aNodes[0];
	if (oNode == null || oNode.childNodes.length == 0) {
		return "";
	} else {
		var strOutput = "";
		for (var i = 0; i < oNode.childNodes.length; i++) {
			strOutput += oNode.childNodes[i].nodeValue;
		}
		return strOutput;
	}
}


//------------ DOM enhancements for Mozilla based (and Safari) browsers -------------------------------------

function _Node_getXML() {
    var objXMLSerializer = new XMLSerializer;
    var strXML = objXMLSerializer.serializeToString(this);
    return strXML;
}

if(document.implementation && document.implementation.hasFeature("XPath", "3.0") ) { 
	XMLDocument.prototype.selectNodes = function(cXPathString, xNode) { 
		if( !xNode ) { xNode = this; }
		var oNSResolver = this.createNSResolver(this.documentElement) 
		var aItems = this.evaluate(cXPathString, xNode, oNSResolver,
		XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null) 
		var aResult = [];
		for( var i = 0; i < aItems.snapshotLength; i++) { 
			aResult[i] = aItems.snapshotItem(i);
		} 
		return aResult;
	} 
	
	Element.prototype.selectNodes = function(cXPathString) { 
		if(this.ownerDocument.selectNodes) { 
			return this.ownerDocument.selectNodes(cXPathString, this);
		} 
		else {
			throw "For XML Elements Only";
		}
	} 

	XMLDocument.prototype.selectSingleNode = function(cXPathString, xNode) { 
		if( !xNode ) { xNode = this; }
		var xItems = this.selectNodes(cXPathString, xNode);
		if( xItems.length > 0 ) { 
			return xItems[0];
		} 
		else { 
			return null;
		} 
	} 

	Element.prototype.selectSingleNode = function(cXPathString) {
		if(this.ownerDocument.selectSingleNode) { 
			return this.ownerDocument.selectSingleNode(cXPathString, this);
		} 
		else{throw "For XML Elements Only";} 
	} 
}