function loadXMLDoc(dname, param, request)
{
	var	ajax = Ajax ();
	
	if (! request)
		request='';

	if  (param)
		ajax.onreadystatechange= function() {AjaxDone(ajax, param);};

	var method = request ? "POST" : "GET";
	ajax.open(method ,dname, param ? true : false);
	ajax.send(request);
	
	return param ? true : ajax.responseXML;
}

function XSLTransform (xml, xsl)
{
	var	ret;
	// code for IE
	if (window.ActiveXObject)
	{
		ret = xml.transformNode(xsl);
	}
	// code for Mozilla, Firefox, Opera, etc.
	else if (document.implementation && document.implementation.createDocument)
	{
		try
		{
			ret = xsl.transformToFragment(xml,document);
		}
		catch (e)
		{
			alert (e);
			var wnd = window.open ();
//			wnd.document = xml;
			var	doc = Serialize(xml);
			wnd.document.write (Serialize (xml));
			wnd.document.close ();
			ret = e;
		}
	}
	return ret;
}

//	IE doesn't include external files - force it
function XSLIncludes (xsl, path)
{
	/*
Browser name: BrowserDetect.browser
Browser version: BrowserDetect.version
OS name: BrowserDetect.OS
	*/
	if (BrowserDetect.browser != 'Firefox')
	{
		if (xsl.ownerDocument)	//	Back to root
			xsl = xsl.ownerDocument;

		do
		{
			var	inc = Select (xsl, "//xsl:include");
			for (var i = 0; i < inc.length; i++)
			{
				var	hr = inc [i].getAttribute ('href');
				var	doc = loadXMLDoc (path+hr, false);
				var	dest = doc.createDocumentFragment ();
				dest.appendChild (doc.createComment ("++++ Begin "+path+hr+" ++++"));
				for (var n = doc.documentElement.firstChild; n; n = n.nextSibling)
				{
					var	ins = doc.importNode ? doc.importNode (n, true) : n.cloneNode (true);
					dest.appendChild (ins);
				}
				dest.appendChild (doc.createComment ("++++ End "+path+hr+" ++++"));

				var	ins = xsl.importNode ? xsl.importNode (dest, true) : dest.cloneNode (true);
				inc [i].parentNode.replaceChild (ins, inc [i]);
			}
		}
		while (inc.length);	//	Nested include
	}
	var	test = Serialize (xsl);
}

function Select (src, path)
{
	var		ret = Array ();	//	Convert both to simple array
	var		fnd, node;
	var		doc = src.ownerDocument ? src.ownerDocument : src;

	if  (doc.evaluate)
	{
		var	nsr = new XPathEvaluator().createNSResolver (doc.documentElement);
		fnd = doc.evaluate (path, src, nsr, XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
//		ret = ret.singleNodeValue;
		while (node = fnd.iterateNext ())
			ret.push (node);
	}
	else
	{
		if  (! src.ownerDocument)
			src = doc.documentElement;

		fnd = src.selectNodes (path);
		if  (fnd)
		{
			for (var i = 0; node = fnd.item (i); i++)
				ret.push (node);
		}
	}
	return ret;
}

function Ajax ()
{
	try {return new XMLHttpRequest();} catch (e) {};		// Firefox, Opera 8.0+, Safari
	try {return new ActiveXObject("Msxml2.XMLHTTP");} catch (e) {};	// Internet Explorer
	try {return new ActiveXObject("Microsoft.XMLHTTP");} catch (e) {};
	return null;
}

function DomDoc ()
{
	try {return document.implementation.createDocument ("", "", null);} catch (e) {};		// Firefox, Opera 8.0+, Safari
	try {return new ActiveXObject("Msxml2.DOMDocument");} catch (e) {};	// Internet Explorer
	return null;
}

function Serialize (xmlNode)
{
	try {return (new XMLSerializer()).serializeToString(xmlNode);} catch (e) {}	// Gecko- and Webkit-based browsers (Firefox, Chrome), Opera.
	try {return xmlNode.xml;}	catch (e) {}	// Internet Explorer.
	alert('Xmlserializer not supported');		// Other browsers without XML Serializer
   return "";
}

function Unserialize (doc, str)
{
	var	xmlDoc, ret;
	if (doc.ownerDocument)
		doc = doc.ownerDocument;

	if (window.DOMParser)
	{
		var parser=new DOMParser();
		xmlDoc = parser.parseFromString(str,"text/xml");
		ret = doc.importNode (xmlDoc.documentElement, true);
	}
	else // Internet Explorer
	{
		xmlDoc = DomDoc ();
		xmlDoc.async="false";
		xmlDoc.loadXML(str);
		ret = xmlDoc.documentElement.cloneNode (true);
	}
	return ret; 
}

/*
	XSL, being the worst system EVER escapes CDATA
	Try and fix this before uploading
*/
function XmlUnescape (val)
{
	val = val.replace (/&lt;/g, "<");
	val = val.replace (/&gt;/g, ">");
	val = val.replace (/&amp;/g, "&");
	return val;
}

/*	Not strictly speaking Ajax, but useful to know	*/

var BrowserDetect = {
	init: function () {
		this.browser = this.searchString(this.dataBrowser) || "An unknown browser";
		this.version = this.searchVersion(navigator.userAgent)
			|| this.searchVersion(navigator.appVersion)
			|| "an unknown version";
		this.OS = this.searchString(this.dataOS) || "an unknown OS";
	},
	searchString: function (data) {
		for (var i=0;i<data.length;i++)	{
			var dataString = data[i].string;
			var dataProp = data[i].prop;
			this.versionSearchString = data[i].versionSearch || data[i].identity;
			if (dataString) {
				if (dataString.indexOf(data[i].subString) != -1)
					return data[i].identity;
			}
			else if (dataProp)
				return data[i].identity;
		}
	},
	searchVersion: function (dataString) {
		var index = dataString.indexOf(this.versionSearchString);
		if (index == -1) return;
		return parseFloat(dataString.substring(index+this.versionSearchString.length+1));
	},
	dataBrowser: [
		{
			string: navigator.userAgent,
			subString: "Chrome",
			identity: "Chrome"
		},
		{ 	string: navigator.userAgent,
			subString: "OmniWeb",
			versionSearch: "OmniWeb/",
			identity: "OmniWeb"
		},
		{
			string: navigator.vendor,
			subString: "Apple",
			identity: "Safari",
			versionSearch: "Version"
		},
		{
			prop: window.opera,
			identity: "Opera"
		},
		{
			string: navigator.vendor,
			subString: "iCab",
			identity: "iCab"
		},
		{
			string: navigator.vendor,
			subString: "KDE",
			identity: "Konqueror"
		},
		{
			string: navigator.userAgent,
			subString: "Firefox",
			identity: "Firefox"
		},
		{
			string: navigator.vendor,
			subString: "Camino",
			identity: "Camino"
		},
		{		// for newer Netscapes (6+)
			string: navigator.userAgent,
			subString: "Netscape",
			identity: "Netscape"
		},
		{
			string: navigator.userAgent,
			subString: "MSIE",
			identity: "Explorer",
			versionSearch: "MSIE"
		},
		{
			string: navigator.userAgent,
			subString: "Gecko",
			identity: "Mozilla",
			versionSearch: "rv"
		},
		{ 		// for older Netscapes (4-)
			string: navigator.userAgent,
			subString: "Mozilla",
			identity: "Netscape",
			versionSearch: "Mozilla"
		}
	],
	dataOS : [
		{
			string: navigator.platform,
			subString: "Win",
			identity: "Windows"
		},
		{
			string: navigator.platform,
			subString: "Mac",
			identity: "Mac"
		},
		{
			   string: navigator.userAgent,
			   subString: "iPhone",
			   identity: "iPhone/iPod"
	    },
		{
			string: navigator.platform,
			subString: "Linux",
			identity: "Linux"
		}
	]

};
BrowserDetect.init();