// ===================================================================
// Author: Matt Kruse <matt@ajaxtoolbox.com>
// WWW: http://www.AjaxToolbox.com/
//
// NOTICE: You may use this code for any purpose, commercial or
// private, without any further permission from the author. You may
// remove this notice from your final code if you wish, however it is
// appreciated by the author if at least my web site address is kept.
//
// You may *NOT* re-distribute this code in any way except through its
// use. That means, you can include it in your product, or your web
// site, or any other form where the code is actually being used. You
// may not put the plain javascript up on your site for download or
// include it in your javascript libraries for download. 
// If you wish to share this code with others, please just point them
// to the URL instead.
// Please DO NOT link directly to my .js files from your site. Copy
// the files to your server and use them there. Thank you.
// ===================================================================

// ===================================================================
// Modified by: Radu Galesanu
// Added a few enhancements to the AjaxRequest class
// Added AjaxResponse class
// Added AjaxEngine class
// ===================================================================

/**
 * The AjaxRequest class is a wrapper for the XMLHttpRequest objects which 
 * are available in most modern browsers. It simplifies the interfaces for
 * making Ajax requests, adds commonly-used convenience methods, and makes 
 * the process of handling state changes more intuitive.
 * An object may be instantiated and used, or the Class methods may be used 
 * which internally create an AjaxRequest object.
 */
function AjaxRequest() {
	var req = new Object();
	
	// -------------------
	// Instance properties
	// -------------------

	/**
	 * Timeout period (in ms) until an async request will be aborted, and
	 * the onTimeout function will be called
	 */
	req.timeout = null;
	
	/**
	 *	Since some browsers cache GET requests via XMLHttpRequest, an
	 * additional parameter called AjaxRequestUniqueId will be added to
	 * the request URI with a unique numeric value appended so that the requested
	 * URL will not be cached.
	 */
	req.generateUniqueUrl = true;
	
	/**
	 * The url that the request will be made to, which defaults to the current 
	 * url of the window
	 */
	req.url = window.location.href;
	
	/**
	 * The method of the request, either GET (default), POST, or HEAD
	 */
	req.method = "GET";
	
	/**
	 * Whether or not the request will be asynchronous. In general, synchronous 
	 * requests should not be used so this should rarely be changed from true
	 */
	req.async = true;
	
	/**
	 * The username used to access the URL
	 */
	req.username = null;
	
	/**
	 * The password used to access the URL
	 */
	req.password = null;
	
	/**
	 * The parameters is an object holding name/value pairs which will be 
	 * added to the url for a GET request or the request content for a POST request
	 */
	req.parameters = new Object();
	
	/**
	 * The sequential index number of this request, updated internally
	 */
	req.requestIndex = AjaxRequest.numAjaxRequests++;
	
	/**
	 * Indicates whether a response has been received yet from the server
	 */
	req.responseReceived = false;
	
	/**
	 * The name of the group that this request belongs to, for activity 
	 * monitoring purposes
	 */
	req.groupName = null;
	
	/**
	 * The query string to be added to the end of a GET request, in proper 
	 * URIEncoded format
	 */
	req.queryString = "";
	
	/**
	 * After a response has been received, this will hold the text contents of 
	 * the response - even in case of error
	 */
	req.responseText = null;
	
	/**
	 * After a response has been received, this will hold the XML content
	 */
	req.responseXML = null;
	
	/**
	 * After a response has been received, this will hold the status code of 
	 * the response as returned by the server.
	 */
	req.status = null;
	
	/**
	 * After a response has been received, this will hold the text description 
	 * of the response code
	 */
	req.statusText = null;
	
	/**
	 * An internal flag to indicate whether the request has been completed
	 */
	req.completed = false;
	
	/**
	 * An internal flag to indicate whether the request has been aborted
	 */
	req.aborted = false;
	
	/**
	 * The XMLHttpRequest object used internally
	 */
	req.xmlHttpRequest = null;

	// --------------
	// Event handlers
	// --------------
	
	/**
	 * A function reference assigned will be called if the request is aborted
	 */
	req.onAbort = null; 
	
	/**
	 * If a timeout period is set, and it is reached before a response is 
	 * received, a function reference assigned to onTimeout will be called
	 */
	req.onTimeout = null; 
	
	/**
	 * A function reference assigned will be called when readyState=1
	 */
	req.onLoading = null;

	/**
	 * A function reference assigned will be called when readyState=2
	 */
	req.onLoaded = null;

	/**
	 * A function reference assigned will be called when readyState=3
	 */
	req.onInteractive = null;

	/**
	 * A function reference assigned will be called when readyState=4
	 */
	req.onComplete = null;

	/**
	 * A function reference assigned will be called after onComplete, if 
	 * the statusCode=200
	 */
	req.onSuccess = null;

	/**
	 * A function reference assigned will be called after onComplete, if 
	 * the statusCode != 200
	 */
	req.onError = null;
	
	/**
	 * If this request has a group name, this function reference will be called 
	 * and passed the group name if this is the first request in the group to 
	 * become active
	 */
	req.onGroupBegin = null;

	/**
	 * If this request has a group name, and this request is the last request 
	 * in the group to complete, this function reference will be called
	 */
	req.onGroupEnd = null;

	// Get the XMLHttpRequest object itself
	req.xmlHttpRequest = AjaxRequest.getXmlHttpRequest();
	if (req.xmlHttpRequest==null) { return null; }
	
	// -------------------------------------------------------
	// Attach the event handlers for the XMLHttpRequest object
	// -------------------------------------------------------
	req.xmlHttpRequest.onreadystatechange = 
	function() {
		if (req==null || req.xmlHttpRequest==null) { return; }
		if (req.xmlHttpRequest.readyState==1) { req.onLoadingInternal(req); }
		if (req.xmlHttpRequest.readyState==2) { req.onLoadedInternal(req); }
		if (req.xmlHttpRequest.readyState==3) { req.onInteractiveInternal(req); }
		if (req.xmlHttpRequest.readyState==4) { req.onCompleteInternal(req); }
	};
	
	// ---------------------------------------------------------------------------
	// Internal event handlers that fire, and in turn fire the user event handlers
	// ---------------------------------------------------------------------------
	// Flags to keep track if each event has been handled, in case of 
	// multiple calls (some browsers may call the onreadystatechange 
	// multiple times for the same state)
	req.onLoadingInternalHandled = false;
	req.onLoadedInternalHandled = false;
	req.onInteractiveInternalHandled = false;
	req.onCompleteInternalHandled = false;
	req.onLoadingInternal = 
		function() {
			if (req.onLoadingInternalHandled) { return; }
			AjaxRequest.numActiveAjaxRequests++;
			if (AjaxRequest.numActiveAjaxRequests==1 && typeof(window['AjaxRequestBegin'])=="function") {
				AjaxRequestBegin();
			}
			if (req.groupName!=null) {
				if (typeof(AjaxRequest.numActiveAjaxGroupRequests[req.groupName])=="undefined") {
					AjaxRequest.numActiveAjaxGroupRequests[req.groupName] = 0;
				}
				AjaxRequest.numActiveAjaxGroupRequests[req.groupName]++;
				if (AjaxRequest.numActiveAjaxGroupRequests[req.groupName]==1 && typeof(req.onGroupBegin)=="function") {
					req.onGroupBegin(req.groupName);
				}
			}
			if (typeof(req.onLoading)=="function") {
				req.onLoading(req);
			}
			req.onLoadingInternalHandled = true;
		};
	req.onLoadedInternal = 
		function() {
			if (req.onLoadedInternalHandled) { return; }
			if (typeof(req.onLoaded)=="function") {
				req.onLoaded(req);
			}
			req.onLoadedInternalHandled = true;
		};
	req.onInteractiveInternal = 
		function() {
			if (req.onInteractiveInternalHandled) { return; }
			if (typeof(req.onInteractive)=="function") {
				req.onInteractive(req);
			}
			req.onInteractiveInternalHandled = true;
		};
	req.onCompleteInternal = 
		function() {
			if (req.onCompleteInternalHandled || req.aborted) { return; }
			req.onCompleteInternalHandled = true;
			AjaxRequest.numActiveAjaxRequests--;
			if (AjaxRequest.numActiveAjaxRequests==0 && typeof(window['AjaxRequestEnd'])=="function") {
				AjaxRequestEnd(req.groupName);
			}
			if (req.groupName!=null) {
				AjaxRequest.numActiveAjaxGroupRequests[req.groupName]--;
				if (AjaxRequest.numActiveAjaxGroupRequests[req.groupName]==0 && typeof(req.onGroupEnd)=="function") {
					req.onGroupEnd(req.groupName);
				}
			}
			req.responseReceived = true;
			req.status = req.xmlHttpRequest.status;
			req.statusText = req.xmlHttpRequest.statusText;
			req.responseText = req.xmlHttpRequest.responseText;
			req.responseXML = req.xmlHttpRequest.responseXML;
			if (typeof(req.onComplete)=="function") {
				req.onComplete(req);
			}
			if (req.xmlHttpRequest.status==200) {
				if (typeof(req.onSuccess)=="function") {
					req.onSuccess(req);
				}
			}
			else if (typeof(req.onError)=="function") {
				req.onError(req);
			}

			// Clean up so IE doesn't leak memory
			delete req.xmlHttpRequest['onreadystatechange'];
			req.xmlHttpRequest = null;
			req.completed = true;
		};
	req.onCancelInternal = 
		function(handler) {
			if (req!=null && req.xmlHttpRequest!=null && !req.onCompleteInternalHandled) {
				req.aborted = true;
				req.xmlHttpRequest.abort();
				AjaxRequest.numActiveAjaxRequests--;
				if (AjaxRequest.numActiveAjaxRequests==0 && typeof(window['AjaxRequestEnd'])=="function") {
					AjaxRequestEnd(req.groupName);
				}
				if (req.groupName!=null) {
					AjaxRequest.numActiveAjaxGroupRequests[req.groupName]--;
					if (AjaxRequest.numActiveAjaxGroupRequests[req.groupName]==0 && typeof(req.onGroupEnd)=="function") {
						req.onGroupEnd(req.groupName);
					}
				}
				if (typeof(handler)=="function") {
					handler(req);
				}
			// Opera won't fire onreadystatechange after abort, but other browsers do. 
			// So we can't rely on the onreadystate function getting called. Clean up here!
			delete req.xmlHttpRequest['onreadystatechange'];
			req.xmlHttpRequest = null;
			}
		};
	req.onAbortInternal = 
		function() {
			req.onCancelInternal(req.onAbort);
		};
	req.onTimeoutInternal = 
		function() {
			req.onCancelInternal(req.onTimeout);
		};

	// ----------------
	// Instance methods
	// ----------------
	/**
	 * The process method is called to actually make the request. It builds the
	 * querystring for GET requests (the content for POST requests), sets the
	 * appropriate headers if necessary, and calls the 
	 * XMLHttpRequest.send() method
	*/
	req.process = 
		function() {
			if (req.xmlHttpRequest!=null) {
				// Some logic to get the real request URL
				if (req.generateUniqueUrl && req.method=="GET") {
					req.parameters["AjaxRequestUniqueId"] = new Date().getTime() + "" + req.requestIndex;
				}
				var content = null; // For POST requests, to hold query string
				for (var i in req.parameters) {
					if (req.queryString.length>0) { req.queryString += "&"; }
					req.queryString += encodeURIComponent(i) + "=" + encodeURIComponent(req.parameters[i]);
				}
				if (req.method=="GET") {
					if (req.queryString.length>0) {
						req.url += ((req.url.indexOf("?")>-1)?"&":"?") + req.queryString;
					}
				}
				req.xmlHttpRequest.open(req.method,req.url,req.async,req.username,req.password);
				if (req.method=="POST") {
					if (typeof(req.xmlHttpRequest.setRequestHeader)!="undefined") {
						req.xmlHttpRequest.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
					}
					content = req.queryString;
				}
				if (req.timeout>0) {
					setTimeout(req.onTimeoutInternal,req.timeout);
				}
				req.xmlHttpRequest.send(content);
                                if (!req.async) {
					req.onCompleteInternal(req);
                                }
			}
		};

	/**
	 * An internal function to handle an Object argument, which may contain
	 * either AjaxRequest field values or parameter name/values
	 */
	req.handleArguments = 
		function(args, params) {
			if (typeof(args)!="undefined" && args!=null) {
				for (var i in args) {
					req[i] = args[i];
				}
			}
			if (typeof(params)!="undefined" && params!=null) {
				req.parameters = params;
			}
		};

	/**
	 * Returns the results of XMLHttpRequest.getAllResponseHeaders().
	 * Only available after a response has been returned
	 */
	req.getAllResponseHeaders =
		function() {
			if (req.xmlHttpRequest!=null) {
				if (req.responseReceived) {
					return req.xmlHttpRequest.getAllResponseHeaders();
				}
				alert("Cannot getAllResponseHeaders because a response has not yet been received");
			}
		};

	/**
	 * Returns the the value of a response header as returned by 
	 * XMLHttpRequest,getResponseHeader().
	 * Only available after a response has been returned
	 */
	req.getResponseHeader =
		function(headerName) {
			if (req.xmlHttpRequest!=null) {
				if (req.responseReceived) {
					return req.xmlHttpRequest.getResponseHeader(headerName);
				}
				alert("Cannot getResponseHeader because a response has not yet been received");
			}
		};

	return req;
}

// ---------------------------------------
// Static methods of the AjaxRequest class
// ---------------------------------------

/**
 * Returns an XMLHttpRequest object, either as a core object or an ActiveX 
 * implementation. If an object cannot be instantiated, it will return null;
 */
AjaxRequest.getXmlHttpRequest = function() {
	if (window.XMLHttpRequest) {
		return new XMLHttpRequest();
	}
	else if (window.ActiveXObject) {
		// Based on http://jibbering.com/2002/4/httprequest.html
		/*@cc_on @*/
		/*@if (@_jscript_version >= 5)
		try {
			return new ActiveXObject("Msxml2.XMLHTTP");
		} catch (e) {
			try {
				return new ActiveXObject("Microsoft.XMLHTTP");
			} catch (E) {
				return null;
			}
		}
		@end @*/
	}
	else {
		return null;
	}
};

/**
 * See if any request is active in the background
 */
AjaxRequest.isActive = function() {
	return (AjaxRequest.numActiveAjaxRequests>0);
};

/**
 * Make a GET request. Pass an object containing request arguments and an
 * object containing the request parameters.
 */
AjaxRequest.get = function(args,params) {
	return AjaxRequest.doRequest("GET",args,params);
};

/**
 * Make a POST request. Pass an object containing request arguments and an
 * object containing the request parameters.
 */
AjaxRequest.post = function(args,params) {
	return AjaxRequest.doRequest("POST",args,params);
};

/**
 * The internal method used by the .get() and .post() methods
 */
AjaxRequest.doRequest = function(method,args,params) {
	if (typeof(args)!="undefined" && args!=null ||
            typeof(params)!="undefined" && params!=null) {
		var myRequest = new AjaxRequest();
		myRequest.method = method;
		myRequest.handleArguments(args,params);
		myRequest.process();
                return myRequest;
	}
	return null;
}	;

/**
 * Abort a request. Pass the object returned by the AjaxRequest.get  and
 * AjaxRequest.post calls.
 */
AjaxRequest.abort = function(req) {
	req.onAbortInternal();
};

/**
 * Submit a form. The requested URL will be the form's ACTION, and the request 
 * method will be the form's METHOD.
 * Returns true if the submittal was handled successfully, else false so it 
 * can easily be used with an onSubmit event for a form, and fallback to 
 * submitting the form normally.
 */
AjaxRequest.submit = function(theform, args, params) {
	var myRequest = new AjaxRequest();
	if (myRequest==null) { return false; }
	var serializedForm = AjaxRequest.serializeForm(theform);
	myRequest.method = theform.method.toUpperCase();
	myRequest.url = theform.action;
	myRequest.handleArguments(args,params);
	myRequest.queryString = serializedForm;
	myRequest.process();
	return true;
};

/**
 * Serialize a form into a format which can be sent as a GET string or a POST 
 * content.It correctly ignores disabled fields, maintains order of the fields 
 * as in the elements[] array. The 'file' input type is not supported, as 
 * its content is not available to javascript. This method is used internally
 * by the submit class method.
 */
AjaxRequest.serializeForm = function(theform) {
	var els = theform.elements;
	var len = els.length;
	var queryString = "";
	this.addField = 
		function(name,value) { 
			if (queryString.length>0) { 
				queryString += "&";
			}
			queryString += encodeURIComponent(name) + "=" + encodeURIComponent(value);
		};
	for (var i=0; i<len; i++) {
		var el = els[i];
		if (!el.disabled) {
			switch(el.type) {
				case 'text': case 'password': case 'hidden': case 'textarea': 
					this.addField(el.name,el.value);
					break;
				case 'select-one':
					if (el.selectedIndex>=0) {
						this.addField(el.name,el.options[el.selectedIndex].value);
					}
					break;
				case 'select-multiple':
					for (var j=0; j<el.options.length; j++) {
						if (el.options[j].selected) {
							this.addField(el.name,el.options[j].value);
						}
					}
					break;
				case 'checkbox': case 'radio':
					if (el.checked) {
						this.addField(el.name,el.value);
					}
					break;
			}
		}
	}
	return queryString;
};

// -----------------------
// Static Class variables
// -----------------------

/**
 * The number of total AjaxRequest objects currently active and running
 */
AjaxRequest.numActiveAjaxRequests = 0;

/**
 * An object holding the number of active requests for each group
 */
AjaxRequest.numActiveAjaxGroupRequests = new Object();

/**
 * The total number of AjaxRequest objects instantiated
 */
AjaxRequest.numAjaxRequests = 0;


/******************************************************\
                 A J A X  R E S P O N S E
\******************************************************/

/**
 * The AjaxResponse class is a convenient way to dispatch AJAX XML responses
 * It dispatches the following XML response format:
 *   <Response>
 *     <RequestStatus>
 *       <Error>0/1</Error>
 *       <Code>code<Code>
 *       <Message>message</Message>
 *     <RequestStatus>
 *     <Instructions>
 *       <Instruction index="index">
 *         <Command>command</Command>
 *         [additional instruction tags]
 *       </Instruction>
 *       [ ... more Instruction tags ... ]
 *     </Instructions>
 *   </Response>
 *
 * The Instruction commands and their additional tags are thus:
 *
 *   <Command>setInnerHTML</Command> - updates innerHTML for given objects
 *   <Object id="id">innerHTML</Object>
 *   [ ... Object tags ... ]
 *
 *   <Command>setCSSAttributes</Command> - sets CSS attribute values
 *   <Attribute object_id="id" name="name">value</Attribute>
 *   [ ... more Attribute objects ... ]
 *
 *   <Command>setCookie</Command> - rets or clears one cookie
 *   <CookieName>name</CookieName>
 *   <CookieValue>value</CookieValue>
 *   <CookiePath>path</CookiePath>
 *
 *   <Command>addScript</Command> - appends a script
 *   <Script>source</Script>
 *
 *   <Command>evalScript</Command> - runs a script without appending it
 *   <Script>source</Script>
 *
 *   <Command>setInputValues</Command> - sets form input values
 *   <Form>form</Form>
 *   <Input name="name">value</Input>
 *   [ ... more Input tags ... ]
 *
 *   <Command>setData</Command> - sets key values in a hash that will be passed
 *                                to the onSuccess handler
 *   <Variable name="name">value</Variable>
 *   [ ... more Variable tags ... ]
 */

var AjaxResponse = {};

/**
 * A convenient way to specify default handlers for the handleResponse method.
 * NOTE: These handlers are NOT the handlers for the AjaxRequest call.
 * The handleResponse method is called when a successful AjaxRequest call is
 * made, as part of its onSuccess handler.
 * The possible handlers are:
 *   - onFatalError: called when an unexpected error occurs while parsing the
 *                   XML response
 *   - onError: called when the Error is set to 1 in the RequestStatus section
 *   - onInfo : called when the Error is set to 0 and the Message is not empty
 *   - onSuccess: called when Error is 0; passes the response DOM object and
 *                the hash built from the setData commands
 */
AjaxResponse.defaultHandlers = {
  'onFatalError' : function(msg) {alert(msg);},
  'onError' : function(msg) {alert(msg);},
  'onInfo' : function(msg) {alert(msg);},
  'onSuccess' : function(response, data) {}
};

AjaxResponse.setDefaultHandler = function(type, handler) {
  AjaxResponse.defaultHandlers[type] = handler;
}

/**
 * A few DOM parsing shortcuts
 */
AjaxResponse.getNodes = function(o, n) {
  try {
    return o.getElementsByTagName(n);
  } catch(e) {}
};

AjaxResponse.getNode = function(o, n) {
  return AjaxResponse.getNodes(o, n)[0];
};

AjaxResponse.getValue = function(o) {
  try {
    return o.firstChild.nodeValue;
  } catch(e) {
    return '';
  }
}

AjaxResponse.getNodeValue = function(o, n) {
  return AjaxResponse.getValue(AjaxResponse.getNode(o, n));
};

/*
 * A common error handler
 */
AjaxResponse.handleResponseError = function(handler, message, code) {
  if (!message.length) {
    message = 'A fatal error has occurred while processing your request';
  }
  if (code.length) {
    handler(message + ' ' + code + '.');
  } else {
    handler(message);
  }
};

/*
 * The XML Instruction interpreter (the AjaxResponse core)
 */
AjaxResponse.handleInstruction = function(node, response_data) {
  var command = AjaxResponse.getNodeValue(node, 'Command');
  switch (command) {
    case 'setInnerHTML':
      var object = AjaxResponse.getNodes(node, 'Object');
      for (var i=0; i<object.length; i++) {
        var id = object[i].getAttribute('id');
        var inner_html = AjaxResponse.getValue(object[i]);
        if (document.getElementById(id).innerHTML != inner_html) {
          document.getElementById(id).innerHTML = inner_html;
        }
      }
      break;
      
    case 'setCSSAttributes':
      var attribute = AjaxResponse.getNodes(node, 'Attribute');
      for (var i=0; i<attribute.length; i++) {
        var object_id = attribute[i].getAttribute('object_id');
        var name = attribute[i].getAttribute('name');
        var value = AjaxResponse.getValue(attribute[i]);
        document.getElementById(object_id).style[name] = value;
      }
      break;
      
    case 'setCookie':
      var cookie_name = AjaxResponse.getNodeValue(node, 'CookieName');
      var cookie_value = AjaxResponse.getNodeValue(node, 'CookieValue');
      var cookie_path = AjaxResponse.getNodeValue(node, 'CookiePath');
      if (cookie_name.length != 0 || cookie_value.length != 0) {
        var cookie = cookie_name + "=" + escape(cookie_value);
        if (cookie_path.length) {
          cookie += '; path=' + cookie_path;
        }
        // TODO: add all cookie params here
        document.cookie = cookie;
      }
      break;
      
    case 'addScript':
      var script = AjaxResponse.getNodeValue(node, 'Script');
      var head = AjaxResponse.getNode(document, 'head');
      var s = document.createElement('script');
      head.appendChild(s);
      s.text = script;
      break;
      
    case 'evalScript':
      var script = AjaxResponse.getNodeValue(node, 'Script');
      eval(script);
      break;
      
    case 'setInputValues':
      var form = AjaxResponse.getNodeValue(node, 'Form');
      var input = AjaxResponse.getNodes(node, 'Input');
      for (var i=0; i<input.length; i++) {
        var name = input[i].getAttribute('name');
        var value = AjaxResponse.getValue(input[i]);
        document.forms[form].elements[name].value = value;
      }
      break;

    case 'setTitle':
      var title = AjaxResponse.getNodeValue(node, 'Title');
      document.title = title;
      break;
      
    case 'setData':
      var variable = AjaxResponse.getNodes(node, 'Variable');
      for (var i=0; i<variable.length; i++) {
        var name = variable[i].getAttribute('name');
        var value = AjaxResponse.getValue(variable[i]);
        response_data[name] = value;
      }
      break;
  }
};

/*
 * The handler that should be called from an AjaxRequest onSubmit handler
 * Arguments:
 *   - the AjaxRequest object
 *   - the AjaxRequest arguments
 *   - the ajaxResponse handlers
 */
AjaxResponse.handleResponse = function(req, args, phandlers) {
  var handlers = {};
  for (var i in AjaxResponse.defaultHandlers) {
    if (typeof(phandlers) != 'undefined' && typeof(phandlers[i]) != 'undefined') {
      handlers[i] = phandlers[i];
    } else {
      handlers[i] = AjaxResponse.defaultHandlers[i];
    }
  }
  var response_data = {};

  var code = '';
  var message = '';

  try {
    if (req.responseXML.normalize) {
      req.responseXML.normalize();
    }
    var response = AjaxResponse.getNode(req.responseXML, 'Response');
    var request_status = AjaxResponse.getNode(response, 'RequestStatus');
    var error = AjaxResponse.getNodeValue(request_status, 'Error');
    try {
      message = AjaxResponse.getNodeValue(request_status, 'Message');
      code = AjaxResponse.getNodeValue(request_status, 'Code');
    } catch (e) {}
    if (error == '1') {
      AjaxResponse.handleResponseError(handlers.onError, message, code);
      return false;
    }

    var instructions = AjaxResponse.getNodes(response, 'Instructions');
    if (instructions.length) {
      var instruction = AjaxResponse.getNodes(instructions[0], 'Instruction');
      for (var i=0; i<instruction.length; i++) {
        var node = instruction[i];
        if (node.getAttribute('index') - 0 != i) {
          throw "Error";
        }
        AjaxResponse.handleInstruction(node, response_data);
      }
    }

    if (error == '0') {
      handlers.onSuccess(response, response_data);
      if (message.length) {
        handlers.onInfo(message);
      }
    }

    return false;
  } catch (e) {
    if (!message.length) {
      if (typeof(e.message) != 'undefined') {
        message = e.message;
        if (typeof(e.line) != 'undefined') {
          message += '[' + e.line + ']';
        }
        message += '<hr>';
      }
      message += req.responseText.substring(0, 200);
    }
    AjaxResponse.handleResponseError(handlers.onFatalError, message, code);
    return true;
  }
};


/******************************************************\
                  A J A X   E N G I N E
\******************************************************/

/**
 * The AjaxEngine class is a collection of static methods used for grouping
 * multiple AjaxRequest calls. It addresses the issue of double/multiple
 * clicks that should, or should not, generate multiple server calls and
 * other common issues such as priorities, throttling etc.
 * In addition to AjaxRequest's arguments and parameters, AjaxEngine defines
 * an id for a type of request, a set of default handlers that can be set for
 * the AjaxRequest calls and an additional set of handlers to be passes _TO_
 * the default handlers.
 */
var AjaxEngine = {};

/**
 * Default handlers are a convenient way to set AjaxRequest common handlers
 * (such as onError, onGroupBegin and onGroupEnd handlers) one time and use
 * them for each call automatically. Default handlers will be called with the
 * following arguments: the XMLHttpRequest object, the AjaxRequest arguments
 * and the additional handlers given at call time.
 */
AjaxEngine.defaultHandlers = {};

/**
 * Method for setting a default handler (AjaxRequest argument)
 */
AjaxEngine.setDefaultHandler = function(type, handler) {
  AjaxEngine.defaultHandlers[type] = handler;
};

/**
 * Object to store the request info
 */
AjaxEngine.callsPool = {};

/*
 * Method to clear the info for a request type
 */
AjaxEngine.initializeCallInfo = function(id) {
  AjaxEngine.callsPool[id] = {
    'timeout' : null,
    'request' : null,
    'args' : null,
    'params' : null,
    'handlers' : null
  }
};

/*
 * The call to AjaxRequest
 */
AjaxEngine.makeAjaxRequestCall = function(id) {
  AjaxEngine.callsPool[id].request = 
    AjaxRequest.post(AjaxEngine.callsPool[id].args, AjaxEngine.callsPool[id].params);
};

/*
 * Closure to set a handler
 */
AjaxEngine.storeDefaultHandler = function(i, id) {
  return function(req) {
    AjaxEngine.defaultHandlers[i](
      req,
      AjaxEngine.callsPool[id].args,
      AjaxEngine.callsPool[id].handlers
    );
  }
}

/*
 * The general call method. An AjaxEngine call receives the following arguments:
 *   - id: method type, or group (should be the same for calls originating
 *     from the same event)
 *   - args: arguments to pass to the AjasRequest object
 *   - params: XMLHttpRequest query parameters
 *   - handlers: handlers to be passed to the default handlers
 *   - timeout: delay for the call (used for throttling, with "REPLACE" calls)
 */
AjaxEngine.makeCall = function(id, args, params, handlers, timeout) {
  AjaxEngine.initializeCallInfo(id);
  AjaxEngine.callsPool[id].args = args;
  for (var i in AjaxEngine.defaultHandlers) {
    if (typeof(AjaxEngine.callsPool[id].args[i] != 'function')) {
      AjaxEngine.callsPool[id].args[i] = AjaxEngine.storeDefaultHandler(i, id);
    }
  }
  AjaxEngine.callsPool[id].params = params;
  AjaxEngine.callsPool[id].handlers = handlers;
  if (typeof(timeout) != 'undefined' && parseInt(timeout) > 0) {
    AjaxEngine.callsPool[id].timeout = setTimeout('AjaxEngine.makeAjaxRequestCall("' + id + '")', timeout);
  } else {
    AjaxEngine.makeAjaxRequestCall(id);
  }
}


/*
 * "INSERT" calls are one-time only calls. While an "INSERT" call is active,
 * all subsequent request of the same type will be ignored. Typically,
 * this is used for double submit protection.
 * Thumb rule: use "INSERT" calls when you INSERT data in your system
 * based on user's input (signups, post comments, upload files).
 */
AjaxEngine.makeInsertCall = function(id, args, params, handlers, timeout) {
  if (typeof(AjaxEngine.callsPool[id]) != 'undefined' &&
      AjaxEngine.callsPool[id].req != null &&
      !AjaxEngine.callsPool[id].req.completed &&
      !AjaxEngine.callsPool[id].req.aborted) {
    // Another request in progress, ignore current request
    return;
  }
  AjaxEngine.makeCall(id, args, params, handlers, timeout);
}

/*
 * "REPLACE" calls are made every time they are issued. If a request
 * of the same type is in progress it will be cancelled. Typically, this
 * is used for stateful calls such as autocompletion, login etc.
 * Thumb rule: use "REPLACE" calls when you FETCH data from your system
 * based on the user's input (content updates) OR when you UPDATE content
 * in your system based on user's input (edit).
 */
AjaxEngine.makeReplaceCall = function(id, args, params, handlers, timeout) {
  AjaxEngine.cancelPendingCall(id);
  AjaxEngine.makeCall(id, args, params, handlers, timeout);
};

/*
 * Cancels a pending call
 */
AjaxEngine.cancelPendingCall = function(id) {
  if (typeof(AjaxEngine.callsPool[id]) != 'undefined') {
    if (AjaxEngine.callsPool[id].timeout != null) {
      clearTimeout(AjaxEngine.callsPool[id].timeout);
    }
    if (AjaxEngine.callsPool[id].request != null) {
      AjaxRequest.abort(AjaxEngine.callsPool[id].request);
    }
  }
  AjaxEngine.initializeCallInfo(id);
};

/******************************************************\
                  B I N D I N G S
\******************************************************/

/**
 * A convenient binding between AjaxRequest's onSuccess handler, AjaxResponse's handleResponse
 * method and AjaxResponse's handlers
 */
                  
AjaxEngine.setDefaultHandler('onSuccess', function(req, args, handlers) {AjaxResponse.handleResponse(req, args, handlers);});