/*
functions.js
prototype.js
DOMElement.js
callback.js
serializer.js
*/

var AJAX =
{
	RST_UNINITIALIZED		: 0x0000,
	RST_OPENED 				: 0x0001,
	RST_HEADERS_RECEIVED	: 0x0002,
	RST_LOADING				: 0x0003,
	RST_COMPLETED			: 0x0004,
	RST_ABORTED				: 0x1000,
	RST_ERROR				: 0x1001,

    EVENT_INIT      		: 'EVENT_INIT',
    EVENT_OPENED	   		: 'EVENT_OPENED',
    EVENT_HEADERS_RECEIVED  : 'EVENT_HEADERS_RECEIVED',
	EVENT_LOADING			: 'EVENT_LOADING',
    EVENT_COMPLETE  		: 'EVENT_COMPLETE',
    EVENT_ABORT     		: 'EVENT_ABORT',
    EVENT_ERROR     		: 'EVENT_ERROR',
	EVENT_TIMEOUT			: 'EVENT_TIMEOUT',

	RUN_BEFORE				: 'RUN_BEFORE',
	RUN_AFTER				: 'RUN_AFTER',
	RUN_BOTH				: 'RUN_BOTH',

	inObject : function(k){ return typeof this[k] != 'undefined'; }
};


function Ajax(url, method, autoabort, serializeType)
{
    this.url			= isUndefined(url) || isNull(url) ? null : url;									// ezt az URL-t fogja meghívni a requestnél, ha ott nincs megadva új
	this.method     	= isUndefined(method) || isNull(method) ? 'POST' : method.toUpperCase();        // GET, POST, CONNECT, DELETE, HEAD, OPTIONS, PUT, TRACE, TRACK (default:POST)
    this.autoabort  	= isUndefined(autoabort) || isNull(autoabort) ? true : autoabort;				// ha van már folyamatban adott callIDjű kérés akkor automatikusan leállítja
	this.serializeType	= isUndefined(serializeType) ? 'URL' : serializeType.toUpperCase();
	this.requestList	= new Array();						// ez tárolja a requestIdx[callId] alapján a lekérdezéseke
	this.requestIdx		= new Object();						// index a requestList tömbhöz
	this.events			= new Object();						// globális eventek
	this.lastCall		= null;								// az utolsó lekérés azonosítója
	this.encoding		= 'utf-8';


	this.addEvent(AJAX.EVENT_COMPLETE,{"obj":this,"method":"execCommandQueue"},AJAX.RUN_BEFORE);
};

Ajax.prototype.getURL = function()
{
	return this.url;
};

/**
 * Létrehoz egy http kérést és eltárolja a kéréshez
 * szükséges paramétereket.
 *
 * @param param {Object} átatandó paraméterek
 * @param events {Object} eseménykezelő callbackek
 * @param callID {String} kérés szöveges azonosítója (default: a rendszer generálja)
 * @param async {Boolean} szinkron vagy aszinkron hívás legyen, (default: true = aszinkron)
 * @param url {String} meghívandó URL (default: az objektum létrehozásakor megadott)
 * @param urlargs {Object} meghívandó URL paraméterei
 * @return {String} Kérés azonosítója
 *         {False} ha a kérés során hiba lépett fel
 */
Ajax.prototype.request = function(param, events, callID, async, url, urlargs)
{
	param	= isUndefined(param) || isNull(param) ? new Object() : param;
	events	= isUndefined(events) || isNull(events) ? new Object() : events;
	callID	= isUndefined(callID) || isNull(callID) ? 'CALL_'+this.requestList.length : callID;
	async	= isUndefined(async) || isNull(async) ? true : async;
	url		= isUndefined(url) || isNull(url) ? this.url : url;

    if( isObject(urlargs) )
        for(key in urlargs)
            if( !isFunction(urlargs[key]) )
                url = setURLArgument(url,key,urlargs[key]);

	if(this.autoabort && !isUndefined(this.requestIdx[callID]))
	{
		this.abort(callID);
	}

	if(isUndefined(this.requestIdx[callID]))
	{
		this.requestIdx[callID] = this.requestList.length;
		this.requestList.push(new AjaxRequest(this));
	}
	else
	{
		this.requestList[this.requestIdx[callID]] = new AjaxRequest(this);
	}
	this.lastCall = callID;

	for(var k in events)
	{
		if(AJAX.inObject(k)) this.addEvent(k, events[k], null, true);
	}

	//this.addEvent(AJAX.EVENT_COMPLETE, {obj:this, method:'execCommandQueue'}, null, false);
	this.requestList[this.requestIdx[callID]].serializeType = this.serializeType
	this.requestList[this.requestIdx[callID]].clearParams();
	this.requestList[this.requestIdx[callID]].request(this.method, url, async, param);

	return callID;
};

/**
 * Megszakítja az adott azonosítójú kérést.
 *
 * @param callID {String} kérés szöveges azonosítója
 * @return {True} ha a megszakítás sikeres volt
 *         {False} ha a megszakítás során hiba lépett fel, vagy nem volt adott azonosítójú kérés elindítva
 */
Ajax.prototype.abort = function(callID)
{
	var req = this._getRequest(callID);
	if(req)
	{
		req.abort();
		cid = req.callID;
		delete this.requestList[this.requestIdx[cid]];
		this.requestList[this.requestIdx[cid]] = new AjaxRequest(this);
		return true;
	}
	return false;
};

/**
 * Visszaadja az adott azonosítójú kérés állapotát.
 *
 * @param callID {String} kérés szöveges azonosítója
 * @return {Number} ha érvényes és lekézdezhető a kérés állapota (RST_... konstansok)
 *         {Null} ha érvénytelen a kérés
 */
Ajax.prototype.getState = function(callID)
{
	var req = this._getRequest(callID);
	if(req)
		return req.getState();
	return null;
};

/**
 * Visszaadja az adott azonosítójú kérésnek visszaküldött tartalmat.
 *
 * @param callID {String} kérés szöveges azonosítója
 * @return {String} ha érvényes és lekézdezhető a kérés válasz tartalma
 *         {Null} ha érvénytelen a kérés
 */
Ajax.prototype.getResponseText = function(callID)
{
	var req = this._getRequest(callID);
	if(req)
		return req.getResponseText();
	return null;
};

/**
 * Visszaadja az adott azonosítójú kérésnek visszaküldött tartalmat Document objektumként.
 *
 * @param callID {String} kérés szöveges azonosítója
 * @return {Document} ha érvényes és lekézdezhető a kérés válasz tartalma
 *         {Null} ha érvénytelen a kérés
 */
Ajax.prototype.getResponseXML = function(callID)
{
	var req = this._getRequest(callID);
	if(req)
		return req.getResponseXML();
	return null;
};

/**
 * Visszaadja az adott azonosítójú kérésnek visszaküldött tartalmat objektumként ha lehetséges.
 *
 * @param callID {String} kérés szöveges azonosítója
 * @return {String} ha érvényes és lekézdezhető a kérés válasz tartalma
 *         {Null} ha érvénytelen a kérés
 */
Ajax.prototype.getResponseObject = function(callID)
{
	var req = this._getRequest(callID);
	if(req)
		return req.getResponseObject();
	return null;
};

/**
 * Headert ad a kéréshez
 *
 * @param name {String} Header neve (http://www.w3.org/TR/XMLHttpRequest/#setrequestheader)
 * @param value {String} Header értéke
 */
Ajax.prototype.addHeader = function(name, value)
{
	var req = this._getRequest(callID);
	if(req)
		return req.addHeader(name, value);
	return false;
};

/**
 * Eseményeket lehet hozzárendelni vele az objektumhoz
 *
 * @param event {Number} AJAX.EVENT_... konstansok valamelyike
 * @param cb {CallBack,Function,Object} Végrehajtandó függvény megadása 3 féle módszerrel lehet:
 * 				1.: new CallBack(function(ajax, myParam){ ajax...; myParam...; }, myParam)
 * 				2.: function(ajax){ ajax.. }
 * 				3.: {obj:window, method:'method', param:'param'}
 * @param type {String} Mikor fusson le a globális esemény értékei: before,after,both;
 */
Ajax.prototype.addEvent = function(event, cb, type, override)
{
	type 	= isUndefined(type) || isNull(type) ? '' : type;
	var req = this._getRequest();
	if(type == '')
	{
		if(req)
			return req.addEvent(event, cb, override);
	}
	else
	{
		var evt = type+event;

		if(cb instanceof CallBack)
		var evtcb = cb;
		else if(isFunction(cb))
			var evtcb = new CallBack(cb);
		else if(isObject(cb))
			var evtcb = new CallBack(function(ajax, cb){ var obj = isObject(cb.obj) && !isNull(cb.obj) ? cb.obj : window; if(isFunction(obj[cb.method])) obj[cb.method](ajax, cb.param) }, cb);
		else
			return false;

		if(isUndefined(this.events[evt])) this.events[evt] = new Array();
		this.events[evt].push(evtcb);
	}
	return false;
};

/**
 * Visszaad egy request objektumot, ha megvan adva az id akkor azt próbálja meg visszaadni, ha nincs akkor az utoljára használtat
 *
 * @param callID {String} kérés szöveges azonosítója
 * @return {AjaxRequest} ha létezik a megadott azonosítóval rendelkező kérés
 * 		   {Null} ha nem létezik
 */
Ajax.prototype._getRequest = function(callID)
{
	callID = isUndefined(callID) ? this.lastCall : callID;
	if(!isUndefined(this.requestIdx[callID]))
		if(this.requestList[this.requestIdx[callID]] instanceof AjaxRequest)
		{
			this.requestList[this.requestIdx[callID]].callID = callID;
			return this.requestList[this.requestIdx[callID]];
		}
	return null;
};

/**
 * Globális eseményeket futtat le
 *
 * @param event {String} event neve, értékei: AJAX.EVENT_...
 * @param param {Mixed} elsődleges paraméter a lefuttatott események számára default: this
 */
Ajax.prototype._executeEvents = function(event, param)
{
	if(!isUndefined(this.events[event]))
	{
		for(var k=0 ; k<this.events[event].length ; k++)
		{
			this.events[event][k].execute(isUndefined(param) ? this : param);
		}
	}
};

Ajax.prototype.execCommandQueue = function(axreq)
{
	var responseObj = axreq.getResponseObject();
	if( (responseObj != null) && (responseObj.commands) )
        for(var i=0;i < responseObj.commands.length;i++)
        {
            var command = responseObj.commands[i].command;
            var param = responseObj.commands[i].param;
            switch( command.toUpperCase() )
            {
                case 'CMDSETCONTENT':   var node = document.getElementById(param.nodeid);
                                        if( (node) && (node.innerHTML) )
                                        {
			                                node.innerHTML = '';
											node.innerHTML = param.content;
			                                this.evalScriptTags(param.content);
			                            }
                                        break;
            }
        }
};

Ajax.prototype.evalScriptTags = function(content)
{
    var pattern     = '<script[^>]*>([\\S\\s]*?)<\/script>';
    var matchAll = new RegExp(pattern, 'img');
    var matchOne = new RegExp(pattern, 'im');
    var listScript = (content.match(matchAll) || []).map(function(scriptTag){
      return (scriptTag.match(matchOne) || ['', ''])[1];
    });

    listScript.map(function(script){eval(script)});
}









/**
 * Ez az objektum kezeli az ajax kéréseket, feladat létrehozni,inicializálni,események kezelése,kérést megindítani
 *
 * @param parent {Ajax} létrehozó objektum
 */
function AjaxRequest(parent)
{
	this.serializeType	= 'JSON';						// Adat átalakítás módja: JSON/URL
	this.headers		= new Object();					// Ezeket a headerket csatolja a kéréshez
	this.events			= new Object();					// Az összes event listája amik kölünböző helyeken futnak le a kulcsuk az AJAX.EVENT_...
	this.params			= new Object();					// Küldendő paraméterek
	this.state			= AJAX.RST_UNINITIALIZED;		// Jelenlgi kérés aktuális állapota
	this.parent			= parent;
	this.engaged		= false;
	this.aborted		= false;

	this.http			= this.getHTTPRequestObject();	// XmlHttpRequest objektum
	this.init();
};

/**
 * Inicializálja a Request objectet, header hozzáadás, onreadystatechange beállítása
 * @return {Boolean} siker esetén true egyébként false;
 */
AjaxRequest.prototype.init = function()
{
	if(isNull(this.http)) return false;

	this.addHeader('Cache-Control', 'no-cache');
	this.addHeader('If-Modified-Since', 'Wed, 31 Dec 1980 00:00:00 GMT');
	this.addHeader('Expires', 'Wed, 31 Dec 1980 00:00:00 GMT');
	this.addHeader('Content-type', 'application/x-www-form-urlencoded;charset='+this.parent.encoding);

	return true;
};

/**
 * Kérést intéz a szerver felé
 *
 * @param method {String} milyen kérést intézzen lásd: Ajax::method
 * @param url {String} Kérés url-je
 * @param async {Boolean} A kérés szinkor vagy aszinkron módban fusson true=aszinkron
 * @param param {Mixed} Milyen paramétereket küldjön el a kérés során, paraméterek küldési módjai:
 * 						JSON: type=JSON&data=JSON szabványnak megfelelően kódolt adat
 * 						URL: type=URL&URL-ben továbbított kulcsok és értékek
 * @return {Boolean} ha sikerült elindítani a kérést, ha nem false
 */
AjaxRequest.prototype.request = function(method, url, async, param)
{
	if(isNull(this.http) || this.engaged) return false;

	this.aborted = false;

	for(var k in param)
	{
		if(!isFunction(param[k])) this.addParam(k, param[k]);
	}

	this._executeEvents(AJAX.RUN_BEFORE+AJAX.EVENT_INIT, undefined, true);
	this._executeEvents(AJAX.RUN_BOTH+AJAX.EVENT_INIT, undefined, true);
	this._executeEvents(AJAX.EVENT_INIT);
	this._executeEvents(AJAX.RUN_BOTH+AJAX.EVENT_INIT, undefined, true);
	this._executeEvents(AJAX.RUN_AFTER+AJAX.EVENT_INIT, undefined, true);

	var self = this;
	this.http.onreadystatechange = function()
	{
		if(self.http.readyState == AJAX.RST_OPENED)
		{
			self.state = AJAX.RST_OPENED;
			self._executeEvents(AJAX.RUN_BEFORE+AJAX.EVENT_OPENED, undefined, true);
			self._executeEvents(AJAX.RUN_BOTH+AJAX.EVENT_OPENED, undefined, true);
			self._executeEvents(AJAX.EVENT_OPENED);
			self._executeEvents(AJAX.RUN_BOTH+AJAX.EVENT_OPENED, undefined, true);
			self._executeEvents(AJAX.RUN_AFTER+AJAX.EVENT_OPENED, undefined, true);
		}
	}

	this.http.open(method, url, async);
	this.setHeader();
	this.http.send(this._makeUrlEncodedParam());

	this.http.onreadystatechange = function(){ self._onReadyStateChange(self.http.readyState); }

	this.engaged = true;

	if(!async)
		this._onReadyStateChange(AJAX.RST_COMPLETED);
	return this;
	//return true;
};

/**
 * Megszakítja a kérést
 */
AjaxRequest.prototype.abort = function()
{
	if(isNull(this.http)) return false;
	this.aborted = true;
	this.http.abort();
	return true;
};

/**
 * Headert ad a kéréshez még az AjaxRequest::request()-t előtt kell
 *
 * @param name {String} Header neve
 * @param value {String} Értéke
 */
AjaxRequest.prototype.addHeader = function(name, value)
{
	this.headers[name] = value;
};

/**
 * Paramétert ad a kéréshez még az AjaxRequest::request()-t előtt kell
 *
 * @param name {String} Paraméter neve
 * @param value {Mixed} Értéke
 */
AjaxRequest.prototype.addParam = function(name, value)
{
	if(isUndefined(this.params)) this.params = new Object();
	this.params[name] = value;
};

/**
 * Eseményeket lehet hozzáadni a kéréshez
 *
 * @param event {String} Event típúsa AJAX.EVENT_...
 * @param cb {CallBack,Function,Object} Lásd: Ajax::addEvent()
 * @param override {Boolean} Ha true akkor az ez eleőtt hozzárendelt eseményeket törli ebben a típúsban
 */
AjaxRequest.prototype.addEvent = function(event, cb, _override)
{
	if(cb instanceof CallBack)
		var evtcb = cb;
	else if(isFunction(cb))
		var evtcb = new CallBack(cb);
	else if(isObject(cb))
		var evtcb = new CallBack(function(ajax, cb){ var obj = isObject(cb.obj) && !isNull(cb.obj) ? cb.obj : window; if(isFunction(obj[cb.method])) obj[cb.method](ajax, cb.param) }, cb);
	else
		return false;

	if(_override)
	{
		delete this.events[event];
		this.events[event] = new Array();
		this.events[event].push(evtcb);
	}
	else
	{
		if(isUndefined(this.events[event])) this.events[event] = new Array();
		this.events[event].push(evtcb);
	}

	return true;
};

/**
 * Beállítja a kérés headerjeit
 */
AjaxRequest.prototype.setHeader = function()
{
	if(isNull(this.http)) return false;
	for(var k in this.headers)
	{
		if(isFunction(this.headers[k])) continue;
		this.http.setRequestHeader(k, this.headers[k]);
	}
	return true;
};

/**
 * Visszaadja az XMLHttpRequest objektumot ha tudja ha nem akkor null-t
 * @return {Object} ha vissza tudja adni
 * 		   {Null} ha nem
 */
AjaxRequest.prototype.getHTTPRequestObject = function()
{
	if(typeof window.XMLHttpRequest != 'undefined')
	{
		return new XMLHttpRequest();
	}
	else
	{
		var list = ['Microsoft.XMLHTTP', 'MSXML2.XMLHTTP.5.0', 'MSXML2.XMLHTTP.4.0', 'MSXML2.XMLHTTP.3.0', 'MSXML2.XMLHTTP'];
		for (var i=0 ; i<list.length ; i++)
		{
			try
			{
				return new ActiveXObject(list[i]);
			}
			catch(e)
			{
				alert('Your Browser NOT support XMLHttpRequest');
			}
		}
	}

	return null;
};

/**
 * Visszaadja a kérés eredményét szöveges formában (state: AJAX.RST_COMPLETED)
 */
AjaxRequest.prototype.getResponseText = function()
{
	if(isNull(this.http)) return null;
	return this.http.responseText;
};

/**
 * Visszadja a kérés eredményét DOMDocument formában ha lehetséges (state: AJAX.RST_COMPLETED)
 */
AjaxRequest.prototype.getResponseXML = function()
{
	if(isNull(this.http)) return null;
	return this.http.responseXML;
};

/**
 * Visszaadja a kérés eredményét objektum formában ha lehetséges (state: AJAX.RST_COMPLETED)
 */
AjaxRequest.prototype.getResponseObject = function()
{
	if(isNull(this.http)) return null;
	try
	{
		return eval('('+this.getResponseText()+')');
	}
	catch(e)
	{
		return null;
	}
};

/**
 * Visszaadja az összes kapott headert a kérés során (state: AJAX.RST_HEADERS_RECEIVED)
 */
AjaxRequest.prototype.getAllResponseHeaders = function()
{
	if(isNull(this.http)) return null;
	return this.http.getAllResponseHeaders();
};

/**
 * Visszaad egy bizonyos nevű headert abból amit a kérés során kapott, ha meg van adva a neve, na nincs akkor mindet (state: AJAX.RST_HEADERS_RECEIVED)
 *
 * @param name {String} Header neve
 */
AjaxRequest.prototype.getResponseHeader = function(name)
{
	if(isNull(this.http)) return null;
	if(isUndefined(name)) return this.getAllResponseHeaders();
	return this.http.getResponseHeader(name);
};

/**
 * Visszaadja a kérés jelenlegi állapotát
 */
AjaxRequest.prototype.getState = function()
{
	return this.state;
};

/**
 * Törli az eddig hozzárendelt aparamétereket
 */
AjaxRequest.prototype.clearParams = function()
{
	this.params = new Object();
};

/**
 * Törli az eddig hozzárendelt eseményeket
 */
AjaxRequest.prototype.clearEvents = function()
{
    this.events = new Object();
};

/**
 * Amikor a kérés állapota változik akkor hívódik meg ez a függvény
 *
 * @param readyState {Number} Kérés állapota
 */
AjaxRequest.prototype._onReadyStateChange = function(readyState)
{
	if( this.aborted )
	{
		this._executeEvents(AJAX.EVENT_ABORT, this);

		this.state = AJAX.RST_ABORTED;
		this.engaged = false;
		this.http.onreadystatechange = new Function;
		this.aborted = false;
	}
	else
	{
		switch(readyState)
		{
			case AJAX.RST_HEADERS_RECEIVED:
				this.state = AJAX.RST_HEADERS_RECEIVED;
				this._executeEvents(AJAX.RUN_BEFORE+AJAX.EVENT_HEADERS_RECEIVED, undefined, true);
				this._executeEvents(AJAX.RUN_BOTH+AJAX.EVENT_HEADERS_RECEIVED, undefined, true);
				this._executeEvents(AJAX.EVENT_HEADERS_RECEIVED);
				this._executeEvents(AJAX.RUN_BOTH+AJAX.EVENT_HEADERS_RECEIVED, undefined, true);
				this._executeEvents(AJAX.RUN_AFTER+AJAX.EVENT_HEADERS_RECEIVED, undefined, true);
			break;

			case AJAX.RST_LOADING:
				this.state = AJAX.RST_LOADING;
				this._executeEvents(AJAX.RUN_BEFORE+AJAX.EVENT_LOADING, undefined, true);
				this._executeEvents(AJAX.RUN_BOTH+AJAX.EVENT_LOADING, undefined, true);
				this._executeEvents(AJAX.EVENT_LOADING);
				this._executeEvents(AJAX.RUN_BOTH+AJAX.EVENT_LOADING, undefined, true);
				this._executeEvents(AJAX.RUN_AFTER+AJAX.EVENT_LOADING, undefined, true);
			break;

			case AJAX.RST_COMPLETED:
				this.state = AJAX.RST_COMPLETED;
				this._executeEvents(AJAX.RUN_BEFORE+AJAX.EVENT_COMPLETE, undefined, true);
				this._executeEvents(AJAX.RUN_BOTH+AJAX.EVENT_COMPLETE, undefined, true);
				this._executeEvents(AJAX.EVENT_COMPLETE);
				this._executeEvents(AJAX.RUN_BOTH+AJAX.EVENT_COMPLETE, undefined, true);
				this._executeEvents(AJAX.RUN_AFTER+AJAX.EVENT_COMPLETE, undefined, true);
				this.engaged = false;
				this.http.onreadystatechange = new Function;
			break;
		}
	}
};

/**
 * Eseményeket futatt le
 *
 * @param event {String} Event típusa
 * @param param {Mixed} Elsődleges paraméter default:this
 * @param parentEvt {Boolean} ha true akkor a parent eseménykezelőjét hívja meg
 */
AjaxRequest.prototype._executeEvents = function(event, param, parentEvt)
{
	if(parentEvt) this.parent._executeEvents(event, this);

	if(!isUndefined(this.events[event]))
	{
		for(var k=0 ; k<this.events[event].length ; k++)
		{
			this.events[event][k].execute(isUndefined(param) ? this : param);
		}
	}
};

/**
 * Összeállítja és átalakítja a megadott paramétereket a AjaxRequest::serializeType -ban megadottak szerint
 */
AjaxRequest.prototype._makeUrlEncodedParam = function()
{
	var res = new Array();
	if( this.params && this.params['qs'] )
	{
		res.push(this.params['qs']);
		delete this.params['qs'];
	}

	res.push('_type='+this.serializeType);
	if(this.serializeType == 'JSON')
		res.push('_data='+encodeURIComponent(Serializer[this.serializeType](this.params)));
	if(this.serializeType == 'URL')
		res.push(Serializer[this.serializeType](this.params));
	return res.join('&');
};


/*
var JS_DUMP_ENABLE = true;

var xhr = new Ajax('ajax_test.php', 'POST', true, 'JSON');
//xhr.addEvent(AJAX.EVENT_COMPLETE, function(){ dump('before complete', null, 'AJAX') }, AJAX.RUN_BEFORE);
//xhr.addEvent(AJAX.EVENT_COMPLETE, function(){ dump('after complete', null, 'AJAX') }, AJAX.RUN_AFTER);
//xhr.addEvent(AJAX.EVENT_COMPLETE, function(){ dump('both complete', null, 'AJAX') }, AJAX.RUN_BOTH);

var evt = new Object();
//evt[AJAX.EVENT_COMPLETE] = function(ajax){ dump(ajax, null, 'AJAX') };
//evt[AJAX.EVENT_ABORTED] = function(ajax){ dump('aborted', null, 'AJAX') };



dump('<a herf="" onclick="xhr.request(ppp, evt)">CLICK MEEEE!!!!</a>');
*/
/*
var ppp =
{
	doThis:'shit',
	param:[1,2,4,'sdfsdfsd ','sdf sdfsd', 'sd dsg ']

};

var xhr = new Ajax('ajax_test.php', 'POST', true, 'URL');
	xhr.addEvent(AJAX.EVENT_INIT, function(){ dump('openedB') }, AJAX.RUN_BEFORE);
	xhr.addEvent(AJAX.EVENT_INIT, function(){ dump('openedA') }, AJAX.RUN_AFTER);
	xhr.addEvent(AJAX.EVENT_INIT, function(){ dump('openedBO') }, AJAX.RUN_BOTH);
	xhr.addEvent(AJAX.EVENT_COMPLETE, function(a){ dump(a.getResponseText()) }, AJAX.RUN_BEFORE);

addEvent(window, 'load', null, function(){
	dump('<a herf="" onclick="xhr.request(ppp)">CLICK MEEEE!!!!</a>');
});
*/