function deleteChildren(theParent) {
	
	if(theParent) {	
		while(theParent.hasChildNodes())
		{
			theParent.removeChild(theParent.firstChild);
		}
	}
}


function FactoryXMLHttpRequest() {
	
	if(window.XMLHttpRequest) {
		return new XMLHttpRequest();
	}	
	else if(window.ActiveXObject) {
		var msxmls = new Array(
			'Msxml2.XMLHTTP.5.0',
			'Msxml2.XMLHTTP.4.0',
			'Msxml2.XMLHTTP.3.0',
			'Msxml2.XMLHTTP',
			'Microsoft.XMLHTTP');
		
		for (var i = 0; i < msxmls.length; i++) {
			try {
				return new ActiveXObject(msxmls[i]);
			} catch (e) {
			}
		}
	}
	throw new Error("Could not instantiate XMLHttpRequest");
}

/************* Classe Asynchronious ******
 *
 * Utilisation : 
 * var asynchronous = new Asynchronous();
 * asynchronous.complete = [fonction]; <-- fonction qui gère la réception des données
 * asynchronous.call(url) <-- pour lancer le callback sur l'url donnée
 *
 * note : pour plusieurs requetes simultanées, utiliser plusieurs objetss
 */
function Asynchronous( ) {
	this._xmlhttp = new FactoryXMLHttpRequest();
}

function Asynchronous_call(url) {
	var instance = this;
	this._xmlhttp.open('GET', url, true);
	this._xmlhttp.onreadystatechange = function() {
	switch(instance._xmlhttp.readyState) {
		case 1:
			instance.loading();
			break;
		case 2:
			instance.loaded();
			break;
		case 3:
			instance.interactive();
			break;
		case 4:
			instance.complete(instance._xmlhttp.status,
			instance._xmlhttp.statusText,
			instance._xmlhttp.responseText, instance._xmlhttp.responseXML);
			break;
		}
	}
	this._xmlhttp.send(null);
}

function Asynchronous_loading() { }
function Asynchronous_loaded() { }
function Asynchronous_interactive() { }
function Asynchronous_complete(status, statusText, responseText, responseHTML) { }

Asynchronous.prototype.loading = Asynchronous_loading;
Asynchronous.prototype.loaded = Asynchronous_loaded;
Asynchronous.prototype.interactive = Asynchronous_interactive;
Asynchronous.prototype.complete = Asynchronous_complete;
Asynchronous.prototype.call = Asynchronous_call;


/**
 *************** Classe AsyncFactory - gestion dynamique des Asynchronious ******************
 *
 * Principe : la classe maintient un tableau d'objets Asynchronous. Lorqu'on veut envoyer une requête XMLHttp,
 * on demande à cette classe de nous allouer un objet Asynchronous. La classe nous renvoie alors un Asynchronous prêt à être utilisé.
 */
 function AsyncFactory()
 {
 	this.asyncs = new Array();
 }
 
 /**
  * renvoie un objet Asynchronous utilisable pour une requête
  */
 function AsyncFactory_get()
 {
 	var i;
 	//alert("Il y en a "+this.asyncs.length);
 	if(this.asyncs.length > 0)
 	{
 		//recherche un Asynchronious dispo
 		for(i = 0; i < this.asyncs.length; i++) {
 			//alert(this.asyncs[i].readyState);
 			if(this.asyncs[i].readyState == 0 || this.asyncs[i].readyState == 4) {
 				//alert ("objet "+ i + " choisi");
 				return this.asyncs[i];
 			}
 		}
 		//ici, aucun Asnchronious n'est dispo. On en crée un nouveau
 		//alert("aucun dispo. création");
 		return this.create();
 	}
 	else
 	{
 		//ici, il n'y a pas l'Asynchronious. On en crée un nouveau
 		//alert("aucun présent. création");
 		return this.create();
 	}
 }
 
 function AsyncFactory_create()
 {
 	var n = this.asyncs.length 
 	this.asyncs[n] = new Asynchronous();
 	return this.asyncs[n];
 }

//prototypes
AsyncFactory.prototype.get = AsyncFactory_get;
AsyncFactory.prototype.create = AsyncFactory_create;

Async = new AsyncFactory();