//#########################################################
//#########################################################
//---- AJAX Static object
//#########################################################
//#########################################################

function $DXAJAX(){} // creates object container for adding static methods

$DXAJAX.PostToObject = function(TargetObject, strURL, strParams)
{
    var ResponseDelegate = function(AjaxResponse)   
                            {
                               TargetObject.innerHTML = AjaxResponse;                  
                            };
    
    var A = new DXAJAXObject(ResponseDelegate);
        A.GetPage(strURL,strParams);
};

$DXAJAX.GetToObject = function(TargetObject, strURL)
{
    var ResponseDelegate = function(AjaxResponse)   
                            {
                               TargetObject.innerHTML = AjaxResponse;                  
                            };
                    
    var A = new DXAJAXObject(ResponseDelegate);
        A.GetPage(strURL);
};

$DXAJAX.GetForDelegate = function(ResponseDelegate, strURL)
{
    var A = new DXAJAXObject(ResponseDelegate);
        A.GetPage(strURL);
};

$DXAJAX.PostForDelegate = function(ResponseDelegate, strURL, strParams)
{
    var A = new DXAJAXObject(ResponseDelegate);
        A.GetPage(strURL, strParams);
};

$DXAJAX.GetAlertResponse = function(strURL)
{
    var A = new DXAJAXObject(function(AjaxResponse)
    {
        window.alert(AjaxResponse);
    });
        A.GetPage(strURL);
};

$DXAJAX.PostAlertResponse = function(strURL, strParams)
{
    var A = new DXAJAXObject(function(AjaxResponse)
    {
        window.alert(AjaxResponse);
    });
        A.GetPage(strURL, strParams);
};

//#########################################################
//#########################################################
//---- AJAX Object
//#########################################################
//#########################################################


function DXAJAXObject(ResponseDelegate)
{
	this.ResponseDelegate = ResponseDelegate;
	
	//====================================================
	//	ResponseDelegate = Return Function
	//	The Return Function must handle the HTTP response
	//	as a single parameter
	//	ex. HandleHTTP(responseText)
	//====================================================
	
	DXAJAXObject.prototype.resetHandler = function(NewResponseDelegate)
	{
		this.ResponseDelegate = NewResponseDelegate;
	};
	
	//====================================================
	//	GetPage
	//====================================================
	DXAJAXObject.prototype.GetPage = function(URL,PostData)
	{
		var My = this; // to overcome scope, and pass 'this' into functions
		var http_request = this.createXMLHttpRequest();

		if (!http_request) 
		{
			alert('Cannot create an XML HTTP instance');
			return false;
		}
		
		http_request.onreadystatechange = function()
		{
		    
			if (http_request.readyState == 4) 
			{
				//0 = uninitialized
				//1 = loading
				//2 = loaded
				//3 = interactive
				//4 = complete
				if (http_request.status == 200) 
				{
                    //200: OK 
                    //204: No Content 
                    //400: Bad Request 
                    //401: Unauthorized 
                    //403: Forbidden 
                    //404: Not Found 
                    //405: Method Not Allowed 
                    //500: Internal Server Error 
                    //501: Not Implemented 
                    //503: Service Unavailable 
                    /*
                    responseXML or responseText is determined by the MIME type 
                    of the responding document... needs to be set on that end
                    7/24/07
                    
                    OK, IE is of course different.
                    Mozilla automatically detects the MIME type based on content...
                    IE apparently does is soley on the header.
                    So, I have parsed the header, and it works as expected now.
                    7/24/07
                    
                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                    for debugging
                    alert(http_request.getAllResponseHeaders());
                    alert(http_request.getResponseHeader("Content-Type"));
                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                    */
                    
                    if (http_request.getResponseHeader("Content-Type").toLowerCase().indexOf("text/xml") > -1)
                    {
                        My.ResponseDelegate(http_request.responseXML);
                    }
                    else
                    {
                        My.ResponseDelegate(http_request.responseText);
                    }
				}
				else
				{
				    window.alert("The server returned response: " + http_request.status);
				    return;
				}
			}
		};     
		if (PostData == undefined)
		{
		  var PrLang = "aspx";
		    if("asp" == PrLang)
		    {
			    http_request.open('GET', 'proxy.'+ PrLang +'?url=' + URLEncode(URL), true);		    
		    }
		    else
		    {
			    http_request.open('GET', '/proxy.'+ PrLang +'?url=' + URLEncode(URL), true);		    
		    }
			http_request.send(null);
		}
		else
		{
			http_request.open('POST', URL, true);
            http_request.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
            http_request.setRequestHeader("Content-length", PostData.length);
            http_request.setRequestHeader("Connection", "close");
			http_request.send(PostData);		
		}
	};
	//====================================================
	//	createXMLHttpRequest
	//	creates necessary object for AJAX transport
	//====================================================
	DXAJAXObject.prototype.createXMLHttpRequest = function()
	{
		var types = [
		'Microsoft.XMLHTTP',
		'MSXML2.XMLHTTP.5.0',
		'MSXML2.XMLHTTP.4.0',
		'MSXML2.XMLHTTP.3.0',
		'MSXML2.XMLHTTP'
		];
		
		for (var i = 0; i < types.length; i++) 
		{
			try 
			{
				return new ActiveXObject(types[i]);
			}	 
			catch(e) { /* do nothing */ } 
		}
		
		try 
		{
			return new XMLHttpRequest();
		} 
		catch(e) { /* do nothing */ } 
		
		return false; // XMLHttpRequest not supported
	};
	
}


// ====================================================================
//       URLEncode and URLDecode functions
//
// Copyright Albion Research Ltd. 2002
// http://www.albionresearch.com/
//
// You may copy these functions providing that 
// (a) you leave this copyright notice intact, and 
// (b) if you use these functions on a publicly accessible
//     web site you include a credit somewhere on the web site 
//     with a link back to http://www.albionresearch.com/
//
// If you find or fix any bugs, please let us know at albionresearch.com
//
// SpecialThanks to Neelesh Thakur for being the first to
// report a bug in URLDecode() - now fixed 2003-02-19.
// And thanks to everyone else who has provided comments and suggestions.
// ====================================================================
function URLEncode(plaintext)
{
	// The Javascript escape and unescape functions do not correspond
	// with what browsers actually do...
	var SAFECHARS = "0123456789" +					// Numeric
					"ABCDEFGHIJKLMNOPQRSTUVWXYZ" +	// Alphabetic
					"abcdefghijklmnopqrstuvwxyz" +
					"-_.!~*'()";					// RFC2396 Mark characters
	var HEX = "0123456789ABCDEF";
	
	var encoded = "";
	for (var i = 0; i < plaintext.length; i++ ) {
		var ch = plaintext.charAt(i);
	    if (ch == " ") {
		    encoded += "+";				// x-www-urlencoded, rather than %20
		} else if (SAFECHARS.indexOf(ch) != -1) {
		    encoded += ch;
		} else {
		    var charCode = ch.charCodeAt(0);
			if (charCode > 255) {
			    alert( "Unicode Character '" 
                        + ch 
                        + "' cannot be encoded using standard URL encoding.\n" +
				          "(URL encoding only supports 8-bit characters.)\n" +
						  "A space (+) will be substituted." );
				encoded += "+";
			} else {
				encoded += "%";
				encoded += HEX.charAt((charCode >> 4) & 0xF);
				encoded += HEX.charAt(charCode & 0xF);
			}
		}
	} // for

	return encoded;
};

function URLDecode(encoded)
{
   // Replace + with ' '
   // Replace %xx with equivalent character
   // Put [ERROR] in output if %xx is invalid.
   var HEXCHARS = "0123456789ABCDEFabcdef"; 
   var plaintext = "";
   var i = 0;
   while (i < encoded.length) {
       var ch = encoded.charAt(i);
	   if (ch == "+") {
	       plaintext += " ";
		   i++;
	   } else if (ch == "%") {
			if (i < (encoded.length-2) 
					&& HEXCHARS.indexOf(encoded.charAt(i+1)) != -1 
					&& HEXCHARS.indexOf(encoded.charAt(i+2)) != -1 ) {
				plaintext += unescape( encoded.substr(i,3) );
				i += 3;
			} else {
				alert( 'Bad escape combination near ...' + encoded.substr(i) );
				plaintext += "%[ERROR]";
				i++;
			}
		} else {
		   plaintext += ch;
		   i++;
		}
	} // while

   return plaintext;
};