var AjaxObject = {   
    currentAction: "",
    currentLoaderID: "",
    handleSuccess:function(o){   
        // This member handles the success response   
        // and passes the response object o to AjaxObject's   
        // processResult member.
        switch(this.currentAction)
        {
            case "login":
                Login.handleSuccess(o);
            break;
            case "logout":
                Login.handleLogoutSuccess(o);
            break;
            case "comment":
                Comment.handleSuccess(o);
            break;
            case "password":
                Login.handlePassRecoverySuccess(o);
            break;
            case "realpeople":
                Login.handleLogoutSuccess(o);
            break;
            case "register":
                RegistrationFull.handleSuccess(o);
            break;
            case "registerInline":
                Registration.handleSuccess(o);
            break;
			case "update":
				RegistrationFull.handleSuccess(o);
			break;
            default:
            break;
        }
        this.turnOffLoader(this.currentLoaderID);
    },

    handleFailure:function(o){   
       // Failure handler
       alert("failed to access server");
       if(this.loaderID) Utility.turnOff(this.currentLoaderID);
    },

    startRequest:function(type,data,loaderID) {
        this.currentAction = type;
        if(loaderID) this.currentLoaderID = loaderID;
        YAHOO.util.Connect.asyncRequest('POST', '/callback/post.aspx', callback, data);
        if(this.loaderID) Utility.turnOn(this.currentLoaderID);
    },
    turnOffLoader:function(loaderID)
    {
       if(loaderID) document.getElementById(loaderID).className = "hidden";
    },
    turnOnLoader:function(loaderID)
    {
       if(loaderID) document.getElementById(loaderID).className = "visible";
    }
};

var callback = {
    success:AjaxObject.handleSuccess,   
    failure:AjaxObject.handleFailure,   
    scope: AjaxObject
}
var XML = new Object();
/**
 * 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.
 */
XML.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
    return document.implementation.createDocument(namespaceURL, rootTagName, null);
  }
  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);
    }
    return doc;
  }
};
/**
 * Synchronously load the XML document at the specified URL and
 * return it as a Document object
 */

XML.load = function(url) {
    // Create a new document with the previously defined function
    var xmldoc = XML.newDocument();
    xmldoc.async = false;  // We want to load synchronously
    xmldoc.load(url);      // Load and parse
    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.
 */
XML.loadAsync = function(url, callback) {
    var xmldoc = XML.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);
};
XML.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 = XML.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;   
     }   
 };