function XMLDOM()
{
/*
 * Create a new Document object. If no arguments are specified,
 * the document will be empty. If a root tag is specified, the document
 * will contain that single root tag. If the root tag has a namespace 
 * prefix, the second argument must specify the URL that identifies the
 *namespace.
 */ 
var _isIE;
if(navigator.appName.lastIndexOf("Microsoft")!=-1)
	_isIE=true;
else
	_isIE=false;
	
this.newDocument = function(rootTagName, namespaceURL) 
{
    if (!rootTagName) rootTagName = "";
    if (!namespaceURL) namespaceURL = "";

    if (document.implementation && document.implementation.createDocument) 
    {
        // This is the W3C standard way to do it
        var xmldoc=document.implementation.createDocument(namespaceURL,rootTagName, null);
        return xmldoc;
    }
    else 
    { // This is the IE way to do it
        // Create an empty document as an ActiveX object
        // If there is no root element, this is all we have to do
        var doc = new ActiveXObject("MSXML2.DOMDocument"); 

        // If there is a root tag, initialize the document
        if (rootTagName) 
        {
            // Look for a namespace prefix 
            var prefix = "";
            var tagname = rootTagName;
            var p = rootTagName.indexOf(':');
            if (p != -1) 
            {
                prefix = rootTagName.substring(0, p);
                tagname = rootTagName.substring(p+1);
            } 

            // If we have a namespace, we must have a namespace prefix
            // If we don't have a namespace, we discard any prefix
            if (namespaceURL) 
            { 
                if (!prefix) prefix = "a0"; // What Firefox uses
            }
            else prefix = ""; 

            // Create the root element (with optional namespace) as a
            // string of text
            var text = "<" + (prefix?(prefix+":"):"") + tagname +
                (namespaceURL
                 ?(" xmlns:" + prefix + '="' + namespaceURL +'"')
                 :"") +
                "/>";
            // And parse that text into the empty document
            doc.loadXML(text);
        }
         if(_isIE)
			doc.setProperty("SelectionLanguage", "XPath"); 
        return doc;
    }
}


/**
 * Synchronously load the XML document at the specified URL and
 * return it as a Document object
 */ 
this.load = function(url) 
{
    // Create a new document with the previously defined function
    var xmldoc = this.newDocument(); 
    xmldoc.async = false;  // We want to load synchronously
    xmldoc.load(url);      // Load and parse
    if(_isIE)
		xmldoc.setProperty("SelectionLanguage", "XPath");  
    return xmldoc;         // Return the document
};


/**
 * Asynchronously load and parse an XML document from the specified URL.
 * When the document is ready, pass it to the specified callback function. 
 * This function returns immediately with no return value.
 */ 
this.loadAsync = function(url, callback) {
    var xmldoc = this.newDocument();

    // If we created the XML document using createDocument, use
    // onload to determine when it is loaded
    if (document.implementation && document.implementation.createDocument) {
        xmldoc.onload = function() { callback(xmldoc); };
    }
    // Otherwise, use onreadystatechange as with XMLHttpRequest
    else { 
        xmldoc.onreadystatechange = function() {
            if (xmldoc.readyState == 4) callback(xmldoc);
        };
    } 

    // Now go start the download and parsing
    xmldoc.load(url);
} 

/**
 * Parse the XML document contained in the string argument and return
 * a Document object that represents it. 
 */
this.parse = function(text) {
    if (typeof DOMParser != "undefined") {
        // Mozilla, Firefox, and related browsers
        return (new DOMParser()).parseFromString(text, "application/xml");
    }
    else if (typeof ActiveXObject != "undefined") { 
        // Internet Explorer.
        var doc = this.newDocument( );   // Create an empty document
        doc.loadXML(text);              //  Parse text into it
        return doc;                     // Return it
    }
    else {
        // As a last resort, try loading the document from a data: URL
        // This is supposed to work in Safari. Thanks to Manos Batsis and
        // his Sarissa library (sarissa.sourceforge.net) for this technique.
        var url = "data:text/xml;charset=utf-8," + encodeURIComponent(text);
        var request = new XMLHttpRequest();
        request.open("GET", url, false);
        request.send(null);
        return request.responseXML;
    }
} 

/**
 * Return a Document object that holds the contents of the <xml> tag 
 * with the specified id. If the <xml> tag has a src attribute, an XML 
 * document is loaded from that URL and returned instead.
  * 
 * Since data islands are often looked up more than once, this function caches
 * the documents it returns.
 */ 
this.getDataIsland = function(id) {
    var doc;

    // Check the cache first
    doc = this.getDataIsland.cache[id];
    if (doc) return doc; 

    // Look up the specified element
    doc = document.getElementById(id); 

    // If there is a "src" attribute, fetch the Document from that URL
    var url = doc.getAttribute('src');
    if (url) { 
        doc = this.load(url);
    }
    // Otherwise, if there was no src attribute, the content of the <xml>
    // tag is the document we want to return. In Internet Explorer, doc is
    // already the document object we want. In other browsers, doc refers to
    // an HTML element, and we've got to copy the content of that element
    // into a new document object
    else if (!doc.documentElement) {// If this is not already a document... 

        // First, find the document element within the <xml> tag. This is
        // the first child of the <xml> tag that is an element, rather
        // than text, comment, or processing instruction
        var docelt = doc.firstChild;
        while(docelt != null) {
            if (docelt.nodeType == 1 /*Node.ELEMENT_NODE*/) break;
            docelt = docelt.nextSibling;
        } 

        // Create an empty document
        doc = newDocument(); 

        // If the <xml> node had some content, import it into the new document
        if (docelt) doc.appendChild(doc.importNode(docelt, true));
    } 

    // Now cache and return the document 
    this.getDataIsland.cache[id] = doc;
    return doc;
}
this.getDataIsland.cache = {}; // Initialize the cache 

this.getXml =function (node) 
{
	if(node.xml)
		return node.xml;
	
	if (node.ownerDocument && node.ownerDocument.implementation && new XMLSerializer())
	{
		xmlSerializerObj = new XMLSerializer();
		return xmlSerializerObj.serializeToString(node);;
	}

	if (node.ownerDocument && node.ownerDocument.implementation && node.ownerDocument.implementation.createLSSerializer())
	{
		xmlSerializerObj = node.ownerDocument.implementation.createLSSerializer();
		return xmlSerializerObj.writeToString(node);
	}
	
	return "";	
}


this.doXPath = function(xpathExp,docObj)
{  
	if(!docObj)
		return null;

	if(_isIE)
	{//IE
		return docObj.selectNodes(xpathExp);
	}
	else
	{//Mozilla
		
		var nodeObj = docObj;
		var rowsCol = new Array();
    	var col = docObj.evaluate(xpathExp, nodeObj, null, XPathResult.ANY_TYPE,null);
    	var thisColMemb = col.iterateNext();
	    while (thisColMemb) {
		    rowsCol[rowsCol.length] = thisColMemb;
			thisColMemb = col.iterateNext();
    	}
	    return rowsCol;
	}
}

};