var zXml = {
            useActiveX:(typeof ActiveXObject != "undefined"),
            useDom:document.implementation && document.implementation.createDocument,
            useXmlHttp:(typeof XMLHttpRequest != "undefined")
           };

zXml.ARR_XMLHTTP_VERS = ["MSXML2.XmlHttp.6.0"    , "MSXML2.XmlHttp.3.0"];
zXml.ARR_DOM_VERS     = ["MSXML2.DOMDocument.6.0", "MSXML2.DOMDocument.3.0"];

function zXmlHttp()
        {
        }


zXmlHttp.createRequest = function ()
                                 {
                                  WriteDebugMsg("CALL", 100, "zXmlHttp.creatRequest()");

                                  if (zXml.useActiveX)
                                    {
                                     if (!zXml.XMLHTTP_VER)
                                       {
                                        for (var i=0; i<zXml.ARR_XMLHTTP_VERS.length; i++)
                                           {
                                            try
                                               {
                                                new ActiveXObject(zXml.ARR_XMLHTTP_VERS[i]);

                                                zXml.XMLHTTP_VER = zXml.ARR_XMLHTTP_VERS[i];

                                                break;
                                               }

                                            catch (oError)
                                                 {
                                                  WriteDebugMsg("INFO", 100, "zXmlHttp.creatRequest() caught error");
                                                 }
                                           }
                                       }

                                     if (zXml.XMLHTTP_VER)
                                       {
                                        WriteDebugMsg("EXIT", 100, "zXmlHttp.creatRequest() {ActiveXObject}");

                                        return new ActiveXObject(zXml.XMLHTTP_VER);
                                       }

                                     throw new Error("Could not create XML HTTP Request.");
                                    }

                                  else if (zXml.useXmlHttp)
                                    {
                                     WriteDebugMsg("EXIT", 100, "zXmlHttp.creatRequest() {XMLHttpRequest}");

                                     return new XMLHttpRequest();
                                    }
                                   else
                                       {
                                        throw new Error("Your browser doesn't support an XML HTTP Request.");
                                       }

                                  WriteDebugMsg("EXIT", 100, "zXmlHttp.creatRequest() {error}");
                                 };

zXmlHttp.isSupported = function ()
                               {
                                return zXml.useXmlHttp||zXml.useActiveX;
                               };

function zXmlDom()
        {
        }

zXmlDom.createDocument = function ()
                                 {
                                  if (zXml.useDom)
                                    {
                                     var oXmlDom=document.implementation.createDocument("","",null);

                                     oXmlDom.parseError = {
                                                           valueOf:function ()
                                                                           {
                                                                            return this.errorCode;
                                                                           },

                                                           toString:function ()
                                                                            {
                                                                             return this.errorCode.toString()
                                                                            }
                                                          };

                                     oXmlDom.__initError__();

                                     oXmlDom.addEventListener(
                                                              "load",
                                                              function ()
                                                                      {
                                                                       this.__checkForErrors__();
                                                                       this.__changeReadyState__(4);
                                                                      },
                                                              false
                                                             );

                                     return oXmlDom;;
                                    }
                                   else if (zXml.useActiveX)
                                          {
                                           if (!zXml.DOM_VER)
                                             {
                                              for (var i=0; i<zXml.ARR_DOM_VERS.length; i++)
                                                 {
                                                  try
                                                     {
                                                      new ActiveXObject(zXml.ARR_DOM_VERS[i]);

                                                      zXml.DOM_VER=zXml.ARR_DOM_VERS[i];

                                                      break;
                                                     }

                                                  catch (oError)
                                                       {
                                                        ;
                                                       }
                                                 }
                                              }

                                            if (zXml.DOM_VER)
                                              {
                                               return new ActiveXObject(zXml.DOM_VER);
                                              }
                                             else
                                                 {
                                                  throw new Error("Could not create XML DOM document.");
                                                 }

                                          }
                                         else
                                             {
                                              throw new Error("Your browser doesn't support an XML DOM document.");
                                             }

                                 };

zXmlDom.isSupported = function ()
                              {
                               return zXml.useDom||zXml.useActiveX;
                              };

var oMozDocument = null;

if (typeof XMLDocument != "undefined")
  {
   oMozDocument = XMLDocument;
  }
 else if (typeof Document != "undefined")
        {
         oMozDocument = Document;
        }

      if (oMozDocument&&!window.opera)
        {
//         oMozDocument.prototype.readyState = 0;
         oMozDocument.prototype.onreadystatechange = null;
         oMozDocument.prototype.__changeReadyState__ = function (iReadyState)
                                                               {
                                                                this.readyState = iReadyState;

                                                                if (typeof this.onreadystatechange == "function")
                                                                  {
                                                                   this.onreadystatechange();
                                                                  }
                                                               };

         oMozDocument.prototype.__initError__ = function ()
                                                        {
                                                         this.parseError.errorCode = 0;
                                                         this.parseError.filepos   = -1;
                                                         this.parseError.line      = -1;
                                                         this.parseError.linepos   = -1;
                                                         this.parseError.reason    = null;
                                                         this.parseError.srcText   = null;
                                                         this.parseError.url       = null;
                                                        };

        oMozDocument.prototype.__checkForErrors__ = function ()
                                                            {
                                                             if (this.documentElement.tagName == "parsererror")
                                                               {
                                                                var reError = />([\s\S]*?)Location:([\s\S]*?)Line Number(\d+),Column(\d+):<sourcetext>([\s\S]*?)(?:\-*\^)/;

                                                                reError.test(this.xml);

                                                                this.parseError.errorCode = -999999;
                                                                this.parseError.reason    = RegExp.$1;
                                                                this.parseError.url       = RegExp.$2;
                                                                this.parseError.line      = parseInt(RegExp.$3);
                                                                this.parseError.linepos   = parseInt(RegExp.$4);
                                                                this.parseError.srcText   = RegExp.$5;
                                                               }
                                                             };

        oMozDocument.prototype.loadXML = function (sXml)
                                                 {
                                                  this.__initError__();
                                                  this.__changeReadyState__(1);

                                                  var oParser = new DOMParser();

                                                  var oXmlDom=oParser.parseFromString(sXml,"text/xml");

                                                  while (this.firstChild)
                                                       {
                                                        this.removeChild(this.firstChild);
                                                       }

                                                  for (var i=0; i<oXmlDom.childNodes.length; i++)
                                                     {
                                                      var oNewNode = this.importNode(oXmlDom.childNodes[i],true);

                                                      this.appendChild(oNewNode);
                                                     }

                                                  this.__checkForErrors__();

                                                  this.__changeReadyState__(4);
                                                 };

       oMozDocument.prototype.__load__ = oMozDocument.prototype.load;oMozDocument.prototype.load
                                       = function (sURL)
                                                 {
                                                  this.__initError__();
                                                  this.__changeReadyState__(1);
                                                  this.__load__(sURL);
                                                 };

       Node.prototype.__defineGetter__(
                                       "xml",
                                       function ()
                                               {
                                                var oSerializer = new XMLSerializer();

                                                return oSerializer.serializeToString(this,"text/xml");
                                               }
                                      );

       Node.prototype.__defineGetter__(
                                       "text",
                                       function ()
                                               {
                                                var sText = "";

                                                for (var i=0; i<this.childNodes.length; i++)
                                                   {
                                                    if (this.childNodes[i].hasChildNodes())
                                                      {
                                                       sText += this.childNodes[i].text;
                                                      }
                                                     else
                                                         {
                                                          sText += this.childNodes[i].nodeValue;
                                                         }
                                                    }

                                                return sText;
                                               }
                                      );
        }

  function zXslt()
          {
          }

  zXslt.transformToText = function (oXml,oXslt)
                                  {
                                   if (typeof XSLTProcessor != "undefined")
                                     {
                                      var oProcessor = new XSLTProcessor();

                                      oProcessor.importStylesheet(oXslt);

                                      var oResultDom = oProcessor.transformToDocument(oXml);

                                      var sResult = oResultDom.xml;

                                      if (sResult.indexOf("<transformiix:result") > -1)
                                        {
                                         sResult = sResult.substring(sResult.indexOf(">") + 1, sResult.lastIndexOf("<"));
                                        }

                                      return sResult;;
                                     }
                                    else if (zXml.useActiveX)
                                           {
                                            return oXml.transformNode(oXslt);
                                           }
                                          else
                                              {
                                               throw new Error("No XSLT engine found.");
                                              }
                                  };

 function zXPath()
         {
         }

 zXPath.selectNodes = function (oRefNode,sXPath,oXmlNs)
                              {
                               if (typeof XPathEvaluator!="undefined")
                                 {
                                  oXmlNs = oXmlNs||{};

                                  var nsResolver = function (sPrefix)
                                                           {
                                                            return oXmlNs[sPrefix];
                                                           };

                                  var oEvaluator = new XPathEvaluator();

                                  var oResult = oEvaluator.evaluate(
                                                                    sXPath,
                                                                    oRefNode,
                                                                    nsResolver,
                                                                    XPathResult.ORDERED_NODE_ITERATOR_TYPE,
                                                                    null
                                                                   );

                                  var aNodes = new Array;

                                  if (oResult != null)
                                    {
                                     var oElement=oResult.iterateNext();

                                     while (oElement)
                                          {
                                           aNodes.push(oElement);

                                           oElement = oResult.iterateNext();
                                          }
                                    }

                                  return aNodes;
                                 }
                                else if (zXml.useActiveX)
                                       {
                                        if (oXmlNs)
                                          {
                                           var sXmlNs = "";

                                           for (var sProp in oXmlNs)
                                              {
                                               sXmlNs += "xmlns:" + sProp + "=\'" + oXmlNs[sProp] + "\' ";
                                              }

                                           oRefNode.ownerDocument.setProperty("SelectionNamespaces", sXmlNs);
                                          };

                                        return oRefNode.selectNodes(sXPath);
                                       }
                                      else
                                          {
                                           throw new Error("No XPath engine found.");
                                          }
                              };

 zXPath.selectSingleNode = function (oRefNode,sXPath,oXmlNs)
                                   {
                                    if (typeof XPathEvaluator != "undefined")
                                      {
                                       ;oXmlNs=oXmlNs||{};

                                       var nsResolver = function (sPrefix)
                                                                {
                                                                 return oXmlNs[sPrefix];
                                                                };

                                       var oEvaluator = new XPathEvaluator();

                                       var oResult = oEvaluator.evaluate(
                                                                         sXPath,
                                                                         oRefNode,
                                                                         nsResolver,
                                                                         XPathResult.
                                                                         FIRST_ORDERED_NODE_TYPE,
                                                                         null
                                                                        );

                                       if (oResult != null)
                                         {
                                          return oResult.singleNodeValue;
                                         }
                                        else
                                            {
                                             return null;
                                            };
                                      }
                                     else if (zXml.useActiveX)
                                            {
                                             if (oXmlNs)
                                               {
                                                var sXmlNs = "";

                                                for (var sProp in oXmlNs)
                                                   {
                                                    sXmlNs += "xmlns:\'" + sProp + "=" + oXmlNs[sProp] + "\' ";
                                                   }

                                                oRefNode.ownerDocument.setProperty("SelectionNamespaces", sXmlNs);
                                              };

                                             return oRefNode.selectSingleNode(sXPath);
                                            }
                                           else
                                               {
                                                throw new Error("No XPath engine found.");
                                               }
                                   };

 function zXMLSerializer()
         {
         }

 zXMLSerializer.prototype.serializeToString = function (oNode)
                                                      {
                                                       var sXml = "";

                                                       switch (oNode.nodeType)
                                                             {
                                                              case 1:
                                                                     sXml= "<" + oNode.tagName;

                                                                     for (var i=0; i<oNode.attributes.length; i++)
                                                                         {
                                                                          sXml += " "   + oNode.attributes[i].name
                                                                               +  "=\"" + oNode.attributes[i].value
                                                                               +  "\"";
                                                                         }

                                                                     sXml += ">";

                                                                     for (var i=0; i<oNode.childNodes.length; i++)
                                                                        {
                                                                         sXml += this.serializeToString(oNode.childNodes[i]);
                                                                        }

                                                                     sXml += "</" + oNode.tagName + ">";

                                                                     break;

                                                              case 3:
                                                                     sXml=oNode.nodeValue;

                                                                     break;

                                                              case 4:
                                                                     sXml = "<![CDATA[" + oNode.nodeValue + "]]>";

                                                                     break;

                                                              case 7:
                                                                     sXml= "<?" + oNode.nodevalue + "?>";

                                                                     break;

                                                              case 8:
                                                                     sXml = "<!--" + oNode.nodevalue + "-->";

                                                                     break;

                                                              case 9:
                                                                     for (var i=0; i<oNode.childNodes.length; i++)
                                                                        {
                                                                         sXml += this.serializeToString(oNode.childNodes[i]);
                                                                        }

                                                                     break;
                                                             };

                                                       return sXml;
                                                      };