/**
* @since	2006/02/08
*/
if(typeof AjaxClassLoader == 'undefined')
{
	AjaxClassLoader = function(){};

	/**
	* Used to store all the registered classes.
	* 
	* @private
	*/
	AjaxClassLoader._classes = new Object();

	/**
	* Singleton pattern implementation.
	*/
	AjaxClassLoader.instance = null;
	AjaxClassLoader.getInstance = function()
	{
		if(AjaxClassLoader.instance == null)
			return AjaxClassLoader.instance = new AjaxClassLoader();
		
		return AjaxClassLoader.instance;
	}

	AjaxClassLoader.prototype._classPathBase = '';

	/**
	* Sets the location of the Javascript classes folder.
	* You can use relative or absolute URL. The URL is relative to the
	* HTML page that loads the AjaxClassLoader.js file.
	*
	* @param	url		The URL of the folder. 
	*
	* @public
	*/
	AjaxClassLoader.setClassFolder = function(url)
	{
		var sUrl = url;
		if(sUrl.charAt(-1) != '/')
			sUrl += '/';
		
		AjaxClassLoader.getInstance()._classPathBase = sUrl;
	}

	/**
	* Try to access the class object registered with the classpath
	* passed as parameter. If the class is not found, the method
	* returns null.
	*
	* @param	path	The path of the object.
	*			eg. : AjaxClassLoader.evaluate('com.mywebsite.myclasspath')
	*
	* @public
	*/
	AjaxClassLoader.evaluate = function(path)
	{
		var arr = path.split('.');
		var obj = AjaxClassLoader._classes;
		for(var i=0; i<arr.length; i++)
		{
			if(typeof obj[arr[i]] == 'undefined')
				return null;

			obj = obj[arr[i]];
		}
		return obj;
	}

	/**
	* Register the constructor method of a "class"
	* to make it accessible under the classpath passed
	* as the first method parameter.
	*
	* A class is only registered once.
	*
	* @param	path	The path of the object.
	*			eg. : AjaxClassLoader.getClassPathObject('com.mywebsite.myclasspath')
	*
	* @public
	*/
	AjaxClassLoader.register = function(path,constructor)
	{
		var arr = path.split('.');
		var obj = AjaxClassLoader._classes;
		var len = arr.length-1;
		for(var i=0; i<len; i++)
		{
			if(typeof obj[arr[i]] == 'undefined')
				obj[arr[i]] = {};
			obj = obj[arr[i]];
		}
		
		/**
		* The method is already registered with this classpath.
		* No need to register it again.
		*/
		var className = arr.pop();
		if(typeof obj[className] == 'undefined')
			obj[className] = constructor;
	}

	/**
	* Retrieves or creates a classPath object.
	*
	* @param	path	The path of the object.
	*			eg. : AjaxClassLoader.getClassPathObject('com.mywebsite.myclasspath')
	*
	* @public
	*/
	AjaxClassLoader.getClassPathObject = function(path)
	{
		var arr = path.split('.');
		var obj = AjaxClassLoader._classes;
		var len = arr.length;
		for(var i=0; i<len; i++)
		{
			if(typeof obj[arr[i]] == 'undefined')
				obj[arr[i]] = {};
			obj = obj[arr[i]];
		}
		return obj;
	}

	/**
	* Retrieves an instance of the Ajax object compatible with the browser.
	*
	* @private
	*/
	AjaxClassLoader.getXMLHttpRequest = function()
	{
		try
		{
			if(typeof XMLHttpRequest != 'undefined')
				return new XMLHttpRequest();
			else
			if(typeof ActiveXObject != 'undefined')
				return new ActiveXObject("Microsoft.XMLHTTP");
		}
		catch(error){return null}
	}

	/**
	* Loads a Javascript class file identified by its classpath and evaluate
	* the code that it contains to declare the class.
	*
	* @param	path	The fully qualified classPath of the class.
	*			eg. : AjaxClassLoader.getClassPathObject('com.mywebsite.myclasspath.MyClass') 
	*
	* @public
	*/
	AjaxClassLoader.load = function(path)
	{
		try{var oPath = eval('AjaxClassLoader._classes.' + path)}catch(error){}
		
		if(typeof oPath != 'undefined')
			return oPath;
		
		var sClassPathUrl = path.split('.').join('/');
		var sFilePath = AjaxClassLoader.getInstance()._classPathBase + sClassPathUrl + '.js';
		
		var xmlHttpRequest = AjaxClassLoader.getXMLHttpRequest();
		if(xmlHttpRequest == null)
			return null;

		xmlHttpRequest.open("GET", sFilePath, false);

		try{xmlHttpRequest.send(null);}
		catch(error)
		{
			//Mainly means that the file to load has not been found
			return null;
		}
		
		/**
		* Evaluates the code the that the Javascript file contains.
		*/
		document.write('<script type="text/javascript"><!--\n' + xmlHttpRequest.responseText + '\n--></script>');

		return AjaxClassLoader.evaluate(path);
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @description Ajoute le support des logs Javascript
* vers la console de debug Flash standard.
*
* @since	2008/02/29
*/
ClassJSLogger();
function ClassJSLogger()
{
	AjaxClassLoader.register('net.tekool.debug.JSLogger',JSLogger);

	function JSLogger(flashObject,flashCallback)
	{
		this.flashObject = flashObject;
		this.flashCallback = flashCallback;
	
		this.stack = new Array();

		var controller = this;
		this.flushInterval = setInterval(function(){controller.onJSLoggerFlush.call(controller)},1000);
	}

	JSLogger.flashObject = null;
	JSLogger.flashCallback = null;
	JSLogger.stack = null;
	JSLogger.flushInterval = null;

	JSLogger.prototype.log = function
	(
		o,
		type,
		classPath,
		instance,
		filter
	)
	{
		this.stack.push
		(
			[
				o,
				type,
				classPath,
				instance,
				filter
			]
		);
	}

	JSLogger.prototype.onJSLoggerFlush = function()
	{
		if(this.stack.length == 0)
			return;

		if(this.flashObject == null || this.flashObject[this.flashCallback] == null)
			return;

		for(var i=0; i<this.stack.length; i++)
		{
			var item = this.stack[i];
			try
			{
				this.flashObject[this.flashCallback]
				(
					item[0],
					item[1],
					item[2],
					item[3],
					item[4]
				);
			}
			catch (e)
			{
				throw(e);
			}
		}

		this.stack.splice(0,this.stack.length);
	}

	JSLogger.prototype.finalize = function()
	{
		clearInterval(this.flushInterval);
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @description Permet le support des logs Javascript
* vers une console de debug Flash ou Firebug.
*
* @since	2006/10/18
*/
ClassLog();
function ClassLog()
{
	AjaxClassLoader.register('net.tekool.debug.Log',Log);

	var JSLogger = AjaxClassLoader.load('net.tekool.debug.JSLogger');

	function Log()
	{
		/**
		* Le constructeur n'est pas exécuté lorsqu'il est appelé pour étendre la classe
		* ou autrement que par l'appel à la méthode d'initialisation du singleton.
		*/
		if(arguments[0] != Log.getInstance)
			return;

		this.initTime = new Date();
	}

	Log.NONE = 0;
	Log.FATAL = 1;
	Log.ERROR = 2;
	Log.WARN = 4;
	Log.INFO = 8;
	Log.DEBUG = 16;
	Log.ALL = 0xFFFF;

	Log.window = window;

	Log.JSLogger = null;
	Log.Firebug = false;
	Log.Safari = false;

	/**
	* Force la prise en charge de la console de Firebug
	* par la classe de Log.
	*
	* @rem La réactivation de la console Firebug aprés
	* une première activation+désactivation ne peut
	* fonctionner suite à un problème de référence.
	* .
	*/
	Log.logToFirebug = function(value)
	{
		var isFirefox = false;
		try{isFirefox = typeof window.frames.top.console.firebug != 'undefined'}catch(e){};
		if(!isFirefox)
			return;

		if(value)
		{

			try
			{
				Log.fatal = window.frames.top.console.fatal;
				Log.error = window.frames.top.console.error;
				Log.warn = window.frames.top.console.warn;
				Log.info = window.frames.top.console.info;
				Log.debug = window.frames.top.console.debug;

				Log.Firebug = true;
				
			}
			catch (e)
			{
			}
		}
		else
		{
			Log.fatal = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.FATAL,classPath,instance,filter)};
			Log.error = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.ERROR,classPath,instance,filter)};
			Log.warn = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.WARN,classPath,instance,filter)};
			Log.info = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.INFO,classPath,instance,filter)};
			Log.debug = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.DEBUG,classPath,instance,filter)};

			Log.Firebug = false;
		}
	}

	/**
	* Force la prise en charge de la console de Safari
	* par la classe de Log.
	*/
	Log.logToSafari = function(value)
	{
		var isSafari = false;
		try{isSafari = typeof window.frames.top.console.firebug == 'undefined'}catch(e){};
		if(!isSafari)
			return;

		if(value)
		{
			try
			{
				Log.fatal = function(o,classPath,instance,filter){window.frames.top.console.fatal(o)};
				Log.error = function(o,classPath,instance,filter){window.frames.top.console.error(o)};
				Log.warn = function(o,classPath,instance,filter){window.frames.top.console.warn(o)};
				Log.info = function(o,classPath,instance,filter){window.frames.top.console.info(o)};
				Log.debug = function(o,classPath,instance,filter){window.frames.top.console.debug(o)};

				Log.Safari = true;
				
			}
			catch (e)
			{
			}
		}
		else
		{
			Log.fatal = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.FATAL,classPath,instance,filter)};
			Log.error = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.ERROR,classPath,instance,filter)};
			Log.warn = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.WARN,classPath,instance,filter)};
			Log.info = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.INFO,classPath,instance,filter)};
			Log.debug = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.DEBUG,classPath,instance,filter)};

			Log.Safari = false;
		}
	}

	/**
	* Force la prise en charge du log par une console Flash.
	*
	* @param	object	DOMObject
	*			L'objet DOM correspondant à l'instance
	*			de l'animation Flash du logger Flash.
	*
	* @param	callback	String
	*			Le nom du callback externalinterface
	*		utilisé par l'animation Flash.
	*/
	Log.logToExternalInterface = function(object,callback)
	{
		if(object != null && callback != null && !Log.JSLogger)
			Log.JSLogger = new JSLogger(object,callback);
		else
		{
			Log.JSLogger.finalize();
			Log.JSLogger = null;
		}
	}

	/**
	* Implémentation pattern Singleton.
	*/
	Log.instance = null;
	Log.getInstance = function()
	{
		if(Log.instance == null)
			return Log.instance = new Log(Log.getInstance);
		
		return Log.instance;
	}

	Log.fatal = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.FATAL,classPath,instance,filter)}
	Log.error = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.ERROR,classPath,instance,filter)}
	Log.warn = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.WARN,classPath,instance,filter)}
	Log.info = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.INFO,classPath,instance,filter)}
	Log.debug = function(o,classPath,instance,filter){Log.getInstance().log(o,Log.DEBUG,classPath,instance,filter)}

	Log.prototype.initTime = null;

	Log.prototype.log = function
	(
		o,
		type,
		classPath,
		instance,
		filter
	)
	{
		if(Log.JSLogger)
			Log.JSLogger.log(o,type,classPath,instance,filter);
	}

	/**
	* Formate la chaîne pour l'afficher dans la console de debug.
	* //TODO permettre au logger de passer le timestamp sous forme
	* // de chaîne avant de pouvoir permettre de formater la chaîne envoyée
	*/
	Log.format = function
	(
		o,
		type,
		classPath,
		instance,
		filter
	)
	{
		return '';
	}

	//Log.logToFirebug(true);
	//Log.logToSafari(true);

}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2006/05/17
*/
ClassEventG();
function ClassEventG()
{
	AjaxClassLoader.register('net.tekool.events.EventG',EventG);

	/**
	* Le type de l'évènement porté par l'instance.
	* La propriété est en lecture seule, le type de l'évènement est déterminé
	* à la construction de l'instance et ne peut être modifié.
	* @readonly
	*/
	EventG.prototype.type = null;

	EventG.prototype.target = null;
	EventG.prototype.bubbles = false;
	EventG.prototype.cancelable = false;
	EventG.prototype.properties = null;
	EventG.prototype.status = null;

	function EventG
	(
		type,
		bubbles,
		cancelable,
		properties,
		status,
		target
	)
	{
		if(arguments[0] == EventG)
			return;
		
		if(type != null)
			this.type = type;
		
		if(bubbles != null)
			this.bubbles = bubbles;
			
		if(cancelable != null)
			this.cancelable = cancelable;
		
		if(properties != null)
			this.properties = properties;
		
		if(status != null)
			this.status = status;
		
		if(target != null)
			this.target = target;
	}

	EventG.prototype.preventDefault = function()
	{
		this.__isDefaultPrevented = true;
	}
	
	EventG.prototype.isDefaultPrevented = function()
	{
		return this.__isDefaultPrevented;
	}
	
	/**
	* Retourne une copie de l'instance courante.
	*/
	EventG.prototype.clone = function()
	{
		return new EventG
		(
			this.type,
			this.bubbles,
			this.cancelable,
			this.properties,
			this.status,
			this.target
		);
	}

	EventG.prototype.toString = function()
	{
		var sName = '';
		var sProperties = '';
		var sStatus = '';
		
		if(this.properties != null)
		{
			for(sName in this.properties)
				if(typeof this.properties[sName] != 'undefined')
					sProperties += sName + ':' + this.properties[sName].toString() + ',';
			
			if(sProperties == '')
				sProperties = this.properties.toString();
			else
				sProperties = '{' + sProperties.substr(0,sProperties.length-1) + '}';
		}
		
		if(this.status != null)
			sStatus = this.status.toString()
		
		return '[EventG] '
		+	'{ type:"' + (this.type || '') + '"'
		+	', bubbles:' + (this.bubbles.toString() || '')
		+	', cancelable:' + (this.cancelable || '')
		+	', properties:' + sProperties 
		+	', status:' + sStatus
		+	', target:' + (this.target || '')
		+	'}';
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2006/05/17
*/
ClassEventS();
function ClassEventS()
{
	AjaxClassLoader.register('net.tekool.events.EventS',EventS);

	var EventG = AjaxClassLoader.load('net.tekool.events.EventG');

	function EventS
	(
		type,
		properties,
		status,
		target
	)
	{
		EventG.call
		(
			this,
			type,
			null,
			null,
			properties,
			status,
			target
		);
	}
	EventS.prototype = new EventG(EventG);	
	
	/**
	* @override
	*/
	EventS.prototype.toString = function()
	{
		//Petite astuce pour économiser un peu de poids de fichier
		return '[EventS]' + EventG.prototype.toString.call(this).substr(8);
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2006/10/18
*/
ClassEventDispatcher();
function ClassEventDispatcher()
{
	AjaxClassLoader.register('net.tekool.events.EventDispatcher',EventDispatcher);

	function EventDispatcher()
	{
		this.listenerRepository = new Object();
	}

	EventDispatcher.QUEUE_PATTERN = '@_@';
	EventDispatcher.REFERENCE_NAME = '__eventDispatcher';
	EventDispatcher.prototype.listenerRepository = null;
	EventDispatcher.initialize = function(target)
	{
		var eventDispatcher = new EventDispatcher;
		
		target[EventDispatcher.REFERENCE_NAME] = eventDispatcher;
		target.dispatchEvent = eventDispatcher.dispatchEvent;
		target.addEventListener = eventDispatcher.addEventListener;
		target.removeEventListener = eventDispatcher.removeEventListener;
	}

	EventDispatcher.prototype.dispatchEvent = function(event)
	{
		if(typeof event == 'undefined')
			return;
		
		if(typeof event.type == 'undefined')
			return;
		
		var queue;
		try{ queue = this[EventDispatcher.REFERENCE_NAME].listenerRepository[EventDispatcher.QUEUE_PATTERN + event.type].slice(0);}
		catch(e){return};
		
		var len = queue.length;
		for(var i=0; i<len; i++)
		{
			var listener = queue[i];
			
			if(typeof event.target == 'undefined')
				event.target = this;
			
			if(typeof listener == 'function')
				listener.call(this,event);
			else
			{
				if(typeof listener.handleEvent != 'undefined')
					listener.handleEvent.call(listener,event);
				
				var handler = listener[event.type + 'Handler'];
				if(typeof handler != 'undefined')
					handler.call(listener,event);
			}
		}
	}

	EventDispatcher.prototype.addEventListener = function(type, listener)
	{
		var queue;
		try{ queue = this[EventDispatcher.REFERENCE_NAME].listenerRepository[EventDispatcher.QUEUE_PATTERN + type]}	catch(e){};
		if(typeof queue == 'undefined')
			queue = this[EventDispatcher.REFERENCE_NAME].listenerRepository[EventDispatcher.QUEUE_PATTERN + type] = new Array();
		
		var len = queue.length;
		for(var i=0; i<len; i++)
			if(queue[i] == listener)
				return;
		
		queue.push(listener);
	}

	EventDispatcher.prototype.removeEventListener = function(type, listener)
	{
		var queue;
		try{ queue = this[EventDispatcher.REFERENCE_NAME].listenerRepository[EventDispatcher.QUEUE_PATTERN + type]}	catch(e){};
		if(typeof queue == 'undefined')
			return;
		
		var len = queue.length;
		for(var i=0; i<len; i++)
			if(queue[i] == listener)
			{
				queue.splice(i,1);
				return;
			}
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2006/02/07
*/
ClassStringUtils();
function ClassStringUtils()
{
	AjaxClassLoader.register('net.tekool.utils.StringUtils',StringUtils);

	function StringUtils(){}

	/**
	* Retournes une copie de l'objet string de longueur *len*
	* complétée par la pattern *pattern* à la position définie
	* par *type*.
	*
	* @param
	*	str		: La chaîne originale
	*	len		: int "la longueur de la chaine desirée"
	*	pattern	: string "le motif de remplacement"
	*	type	: int  -1=STR_PAD_LEFT | 0=STR_PAD_BOTH | 1=STR_PAD_RIGHT
	* @return   string : "copie de l'objet original quelle que soit la valeur de retour"
	*/
	StringUtils.STR_PAD_LEFT = -1;
	StringUtils.STR_PAD_BOTH = 0;
	StringUtils.STR_PAD_RIGHT = 1;
	StringUtils.pad = function
	(
		str,
		len,
		pattern,
		type
	)
	{
		var strLen;
		var compLen;
		var patternLen;
		var pos;
		var i;
		var comp;

		if(pattern == null)
			return str;

		strLen = str.length;
		if(len<=strLen)
			return str;

		//Création du motif de remplacement
		compLen = len-strLen;
		patternLen = pattern.length;
		comp = '';
		for(i=0; i<compLen; i++)
			comp += pattern.charAt(i%patternLen);
		
		if(type == StringUtils.STR_PAD_BOTH)
		{
			pos = Math.floor(compLen/2);
			return comp.substr(0,pos)+str+comp.substr(pos);
		}
		else
			if(type == StringUtils.STR_PAD_LEFT)
				return comp+str;
		else
			return str+comp;
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2006/02/07
*/
ClassDateUtils();
function ClassDateUtils()
{
	var StringUtils = AjaxClassLoader.load('net.tekool.utils.StringUtils');

	AjaxClassLoader.register('net.tekool.utils.DateUtils',DateUtils);
	function DateUtils(){}

	/*
	 * Retourne la chaîne au format ISO 8601 correspondant à l'objet date
	 * Ex: 2002-08-08T13:41:07+0200
	 * http://www.w3.org/TR/NOTE-datetime
	 */
	DateUtils.getISO8601 = function(dDate)
	{
		if(typeof dDate == 'undefined')
			return null;

		var timestamp;
		var timezoneOffset;
		var Zdate;

		timestamp = dDate.getUTCFullYear().toString();
		timestamp += '-';
		timestamp += StringUtils.pad(dDate.getUTCMonth().toString(),2,'0',-1);
		timestamp += '-';
		timestamp += StringUtils.pad(dDate.getUTCDate().toString(),2,'0',-1) + 1;
		timestamp += 'T';
		timestamp += StringUtils.pad(dDate.getUTCHours().toString(),2,'0',-1);
		timestamp += ':';
		timestamp += StringUtils.pad(dDate.getUTCMinutes().toString(),2,'0',-1);
		timestamp += ':';
		timestamp += StringUtils.pad(dDate.getUTCSeconds().toString(),2,'0',-1);

		timezoneOffset = dDate.getTimezoneOffset();
		timestamp += timezoneOffset >= 0  ? '-' : '+';
		Zdate = new Date(0,0,1,0,0,0,0);
		Zdate.setMinutes(Math.abs(timezoneOffset));

		timestamp += StringUtils.pad(Zdate.getHours().toString(),2,'0',-1);
		timestamp += ':';
		timestamp += StringUtils.pad(Zdate.getMinutes().toString(),2,'0',-1);

		return timestamp;
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2006/29/06
*/
ClassEventProxy();
function ClassEventProxy()
{
	AjaxClassLoader.register('net.tekool.events.EventProxy',EventProxy);

	function EventProxy
	(
		target,
		func
	)
	{
		this.target = target;
		this.func = func;
		
		this.funcArguments = new Array();
		for(var i=2; i<arguments.length; i++)
			this.funcArguments.push(arguments[i]);
	}
	
	EventProxy.prototype.target = null;
	EventProxy.prototype.func = null;
	EventProxy.prototype.funcArguments = null;

	EventProxy.prototype.handleEvent = function(event)
	{		
		var args = [event].concat(this.funcArguments);
		
		if(typeof this.target.handleEvent != 'undefined')
			this.target.handleEvent.apply(this.target,args);
		
		if(this.func == null)
			this.target[event.type].apply(this.target,args);
		else
			this.func.apply(this.target,args);
	}
	
	EventProxy.prototype.toString = function()
	{
		return '[EventProxy - {target:"' + this.target.toString() + '", func:"' + this.func.toString() + '"} ]';
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2006/17/05
*/
ClassStatus();
function ClassStatus()
{
	AjaxClassLoader.register('net.tekool.core.Status',Status);
	
	function Status(code,message)
	{
		this.code = code.toString() || '';
		this.message = message.toString() || '';
	}
	Status.prototype.clone = function()
	{
		return new Status(this.code,this.message);
	}
	Status.prototype.toString = function()
	{
		return 'Status [ code : "' + this.code + '", message : "' + this.message + '" ]'
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2005/04/24
*/
ClassRelegate();
function ClassRelegate()
{
	AjaxClassLoader.register('net.tekool.utils.Relegate',Relegate);

	function Relegate(){}
	Relegate.create = function(t,f)
	{

		var a = new Array();
		for(var i=2; i<arguments.length; i++)
			a.push(arguments[i]);
		
		return function()
		{
			var b = new Array();
			for(var i=0; i<arguments.length; i++)
				b.push(arguments[i]);
			
			return f.apply
			(
				t,
				b.concat(a)
			);
		};
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2005/04/24
*/
ClassNumberType();
function ClassNumberType()
{
	AjaxClassLoader.register('net.tekool.type.NumberType',NumberType);

	function NumberType(){};

	/**
	* Détermines si le nombre passé en argument est un nombre à virgule ou non
	*
	* @param :
		- n le nombre sur lequel s'effectue la vérification
	* @return	Un booléen permettant de connaitre le résultat de la vérification
	*/
	NumberType.isFloat = function(n)
	{
		return n%1 != 0;
	}

	/**
	* Détermines si le nombre passé en argument est un entier ou non
	*
	* @param :
		- n le nombre sur lequel s'effectue la vérification
	* @return	Un booléen permettant de connaitre le résultat de la vérification
	*/
	NumberType.isInt = function(n)
	{
		return n%1 == 0;
	}

	/*
	 * Tente de transformer un objet en nombre
	 * Si la conversion ne peut se faire, retourne null
	 * 260ms@10000t
	 */
	NumberType.parse = function(o)
	{
		if(typeof o == 'undefined')
			return o;

		if(o == null || isNaN(o))
			return null;
		else
			return parseFloat(o);
	}
	
	/*
	 * Retourne un nombre quel que soit l'objet passé en argument
	 */
	NumberType.to = function(o)
	{
		if(typeof o == 'undefined')
			return 0;

		if(isNaN(o))
			return 0;
		else
			return parseFloat(o);
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2005/04/24
*/
ClassStringType();
function ClassStringType()
{
	AjaxClassLoader.register('net.tekool.type.StringType',StringType);

	function StringType(){};

	/**
	* Passe les chaînes de caractères vides à la valeur nulle.
	*/
	StringType.parse = function(o)
	{
		if(typeof o == 'undefined')
			return o;

		if(o == '')
			return null;
		else
			return o;
	}

	/**
	* Retourne une chaîne quel que soit l'objet passé en argument.
	* 
	* Retourne une chaîne vide, dés que l'objet passé en argument
	* est indéfini, ou une chaîne dont  la valeur primitive
	* n'équivaut pas à la valeur retournée par son évaluation.
	*/
	StringType.to = function(o)
	{
		if(typeof o == 'undefined')
			return '';

		var str = o.toString();
		if(str != o.valueOf())
			return '';
		
		return str;
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2006/10/17
*/
ClassProxyGeneric();
function ClassProxyGeneric()
{
	AjaxClassLoader.register('com.meetic.im.connector.ProxyGeneric',ProxyGeneric);

	var Log = AjaxClassLoader.load('net.tekool.debug.Log');
	var EventDispatcher = AjaxClassLoader.load('net.tekool.events.EventDispatcher');
	var EventProxy = AjaxClassLoader.load('net.tekool.events.EventProxy');
	var Status = AjaxClassLoader.load('net.tekool.core.Status');

	function ProxyGeneric()
	{
		//Le constructeur n'est pas exécuté lorsqu'il est appelé pour étendre la classe.
		if(arguments[0] == ProxyGeneric)
			return;
				
		EventDispatcher.initialize(this);
		
		this.eventProxyOnSend = new EventProxy(this,this.onSend);
		this.eventProxyOnReceive = new EventProxy(this,this.onReceive);
	}
	ProxyGeneric.classPath = 'com.meetic.im.connector.ProxyGeneric';

	ProxyGeneric.EVENT_SEND = 'sendResult';
	ProxyGeneric.EVENT_RECEIVE = 'receiveResult';

	ProxyGeneric.prototype.__status = null;
	ProxyGeneric.prototype.dispatchEvent = null;
	ProxyGeneric.prototype.addEventListener = null;
	ProxyGeneric.prototype.removeEventListener = null;

	ProxyGeneric.prototype.eventProxyOnSend = null;
	ProxyGeneric.prototype.eventProxyOnReceive = null;

	/**
	* Méthode chargée de transmettre le message au service pour lequel l'instance sert de transpondeur.
	* 
	* @param	methodName	Le nom de la méthode du service à invoquer.
	* @return	Quand le service pour lequel l'instance sert de transpondeur utilise un protocole
	* 			qui supporte les appels synchrones de méthode, l'objet *EventS* retourné contiendra
	* 			directement les données résultant de l'appel à la méthode du service.
	*/
	ProxyGeneric.prototype.send = function(methodName)
	{
		var aArguments = new Array();
		for(var i=1; i<arguments.length; i++)
			aArguments.push(arguments[i]);
		
		var event = new EventS
		(
			ProxyGeneric.EVENT_SEND,
			{
				methodName: methodName,
				arguments: aArguments
			}
		);
		
		return event;
	}

	/**
	* Invoquée à la réception d'un résultat d'appel de méthode sur le service pour
	* lequel l'instance sert de transpondeur.
	* Donne lieu à la diffusion de l'évènement *ProxyGeneric.EVENT_SEND*
	* 
	* @param	methodName	Le nom de la méthode du service à invoquer.
	*/
	ProxyGeneric.prototype.onSend = function(event)
	{
		this.__onSendResult(event);
		this.dispatchEvent(event);
	}
	ProxyGeneric.prototype.__onSendResult = function(event){};

	/**
	* Méthode donnant lieu à la diffusion de l'évènement *ProxyGeneric.EVENT_RECEIVE*
	* invoquée suite à la réception d'un résultat d'appel de méthode.
	* 
	* @param	event	L'objet transmis lors de la cascade d'evènements.
	*/
	ProxyGeneric.prototype.onReceive = function(event)
	{
		this.dispatchEvent(event);
	}

	/**
	* Donne accés l'objet *Status* informant d'une éventuelle erreur de communication générale avec
	* le service dont l'instance est transpondeur.
	*/
	ProxyGeneric.prototype.getStatus = function()
	{		
		return this.__status;
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2006/10/18
*/
ClassProxyJavascript();
function ClassProxyJavascript()
{
	AjaxClassLoader.register('com.meetic.im.connector.ProxyJavascript',ProxyJavascript);

	var Log = AjaxClassLoader.load('net.tekool.debug.Log');
	var Relegate = AjaxClassLoader.load('net.tekool.utils.Relegate');
	var StringType = AjaxClassLoader.load('net.tekool.type.StringType');
	var Status = AjaxClassLoader.load('net.tekool.core.Status');
	var EventDispatcher = AjaxClassLoader.load('net.tekool.events.EventDispatcher');
	var EventS = AjaxClassLoader.load('net.tekool.events.EventS');
	var ProxyGeneric = AjaxClassLoader.load('com.meetic.im.connector.ProxyGeneric');

	/**
	* Constructeur.
	*
	* @param	String		animationId					L'id de l'objet correspondant à l'animation Flash avec laquelle le
	*													transpondeur doit communiquer.
	*
	* @param	String		externalInterfaceCallBack	Le nom de la méthode "callBack" utilisée par Javascript pour
	*													communiquer avec *ExternalInterface* au travers de l'animation.
	*
	* @param	Window		[animationWindow]			Une référence vers l'objet *window* correspondant à la fenêtre qui
	*													contient l'animation avec laquelle le transpondeur doit communiquer.
	*/
	function ProxyJavascript
	(
		animationId,
		externalInterfaceCallBackName,
		animationWindow
	)
	{
		//Le constructeur n'est pas exécuté lorsqu'il est appelé pour étendre la classe.
		if(arguments[0] == ProxyJavascript)
			return;

		ProxyGeneric.call(this);
		
		if(typeof animationWindow == 'undefined')
			this.window = window;
		else
			this.window = animationWindow;

		var sCallbackName = StringType.to(externalInterfaceCallBackName);
		if(sCallbackName == '')
		{
			if(this.__status == null)
				this.__status = new Status(ProxyJavascript.classPath + ' 001', "Le nom du callback nécessaire à la communication par *ExternalInterface* n'est pas défini");
			
			return;
		}
		this.callbackName = ProxyJavascript.CALLBACK_PATTERN + sCallbackName;

		var animation = this.window.document.getElementById(animationId);
		if(typeof animation == 'undefined')
		{
			if(this.__status == null)
				this.__status = new Status(ProxyJavascript.classPath + ' 002', 'L\'animation avec laquelle le transpondeur doit communiquer n\'a pas été trouvée avec l\'id : "' + animationId + '"');
			return;
		}
		this.animationId = animationId;

		this.window[this.callbackName] = Relegate.create(this,this.onMessageFromFlash);
	}
	ProxyJavascript.classPath = 'com.meetic.im.connector.ProxyJavascript';

	ProxyJavascript.EVENT_SEND = ProxyGeneric.EVENT_SEND;
	ProxyJavascript.EVENT_RECEIVE = ProxyGeneric.EVENT_RECEIVE ;

	/**
	* Le motif de texte utilisé pour composer le nom du *callback* partagé par Flash et Javascript
	* pour communiquer à l'aide de *ExternalInterface*. Il doit impérativement être le même que
	* celui utilisé par le transpondeur Flash.
	*/
	ProxyJavascript.CALLBACK_PATTERN = 'ExternalInterfaceCallback_';

	/* ProxyJavascript extends ProxyGeneric */
	ProxyJavascript.prototype = new ProxyGeneric(ProxyGeneric);

	ProxyJavascript.prototype.callbackName = null;
	ProxyJavascript.prototype.animationId = null;
	ProxyJavascript.prototype.window = null;

	ProxyJavascript.prototype.onMessageFromFlash = function(methodName)
	{
		var aArguments = new Array();
		for(var i=0; i<arguments.length; i++)
			aArguments.push(arguments[i]);
		
		var event = new EventS(ProxyGeneric.EVENT_RECEIVE);
		var sMethodName = StringType.to(methodName);
		if(sMethodName == null)
		{
			var status = new Status(ProxyJavascript.classPath + ' 003', 'Nom de la méthode à invoquer non renseigné.');
			event.status = status;
			
			return event;
		}

		var args =  aArguments.slice(1);
		ProxyJavascript.stringifyNullifiedString(args);

		var properties =
		{
			'methodName' : methodName,
			'arguments' : args
		};
		event.properties = properties;

		this.onReceive(event);

		return event;
	}

	/**
	* Permet de résoudre le problème lié à ExternalInterface
	* lors de l'émission de données qui fait que  les chaînes
	* vides sont transformées en chaîne portant la valeur "null"
	* en toutes lettres.
	* 
	* @param	obj	Les données à traiter.
	*/
	ProxyJavascript.stringifyNullifiedString = function(o,parsed)
	{
		if(typeof o == 'undefined')
			return;
	
		var sName;
		for(sName in o)
		{
			var item = o[sName];

			if(item === '__@NULL@__')
				o[sName] = '';
			else
			{
				if(typeof item == 'object')
				{
					if(parsed == null)
						parsed = new Array();

					parsed.push(item);

					for(var i=0; i<parsed.length; i++)
						if(parsed[i] === item)
							continue;
					
					arguments.callee(item,parsed);
				}
			}
		}
	}

	/**
	* Correction d'un problème sous Firefox 3
	*/
	ProxyJavascript.prototype.getFlashMovie = function(movieName) 
	{
		var isIE = navigator.appName.indexOf("Microsoft") != -1;
		return (isIE) ? this.window[movieName] : this.window.document[movieName];
	}

	/**
	* @override no super
	*/
	ProxyJavascript.prototype.send = function(methodName)
	{
		var aArguments = new Array();
		for(var i=0; i<arguments.length; i++)
			aArguments.push(arguments[i]);
		
		var event = new EventS
		(
			ProxyGeneric.EVENT_SEND,
			null,
			null,
			this
		);

		/**
		* Une erreur générale interdit toute communication avec l'objet.
		*/
		if(this.__status != null)
			event.status = this.__status;
		
		var sMethodName = StringType.to(methodName);
		if(sMethodName == null)
		{
			event.status = new Status(ProxyJavascript.classPath + ' 003', "Nom de la méthode à invoquer non renseigné.");
			return event;
		}

		var externalInterfaceCallArguments = [this.callbackName,sMethodName].concat(aArguments.slice(1));
		try
		{
			var callback = this.getFlashMovie(this.animationId)[this.callbackName];
		}
		catch(e)
		{
			event.status = new Status(ProxyJavascript.classPath + ' 005', 'Le callback "' + this.callbackName + '" nécessaire à communiquer au travers de *ExternalInterface* n\'est pas déclaré sur l\'animation Flash');
			return event;
		}

		var result;
		try
		{
			result = this.getFlashMovie(this.animationId)[this.callbackName](externalInterfaceCallArguments);
		}
		catch(e)
		{
			event.status = status;
			return new Status(ProxyJavascript.classPath + ' 006', 'Le callback "' + this.callbackName + '" nécessaire à communiquer au travers de *ExternalInterface* n\'a pu être invoqué');
		}
		
		var properties = 
		{
			methodName : sMethodName,
			arguments : aArguments.slice(1),
			result : result
		}
		event.properties = properties;

		this.onSend(event);

		return event;
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2007/02/11
*/
ClassFlashPlayerVersion();
function ClassFlashPlayerVersion()
{
	AjaxClassLoader.register('com.meetic.im.flash.FlashPlayerVersion',FlashPlayerVersion);
	var NumberType = AjaxClassLoader.load('net.tekool.type.NumberType');

	function FlashPlayerVersion()
	{
		this.detect();
	}
	FlashPlayerVersion.classPath = 'com.meetic.im.flash.FlashPlayerVersion';

	/**
	* Implémentation du pattern Singleton.
	*/
	FlashPlayerVersion.instance = null;
	FlashPlayerVersion.getInstance = function()
	{
		if(FlashPlayerVersion.instance == null)
			return FlashPlayerVersion.instance = new FlashPlayerVersion(FlashPlayerVersion.getInstance);
		
		return FlashPlayerVersion.instance;
	}
	FlashPlayerVersion.prototype.major = 0;
	FlashPlayerVersion.prototype.minor = 0;
	FlashPlayerVersion.prototype.revision = 0;
	FlashPlayerVersion.prototype.detected = false;

	/**
	* Détermine si la version du lecteur Flash détectée est égale
	* ou supérieure à la version requise par les paramètres passés
	* en argument.
	*
	* @param	major	Le numéro de version principal. Représente le "7" de la version 7,0,19.
	* @param	minor	Le numéro de version secondaire. Représente le "0" de la version 7,0,19.
	* @param	revision	Le numéro de version de la revision. Représente le "19" de la version 7,0,19.
	*
	* @public
	*/
	FlashPlayerVersion.hasSufficientVersion = function
	(
		major,
		minor,
		revision
	)
	{
		return FlashPlayerVersion.getInstance().__hasSufficientVersion(major,minor,revision);
	}

	/**
	* Détermine si au moins une version du lecteur Flash est installée
	* au sein du navigateur de l'utilisateur.
	*
	* @public
	*/
	FlashPlayerVersion.hasFlashPlayer = function()
	{
		return FlashPlayerVersion.getInstance().__hasFlashPlayer();
	}

	/**
	* Indique le numéro de version du lecteur Flash installé
	* sous forme d'une chaîne de type "7,0,19".
	*
	* @public
	*/
	FlashPlayerVersion.toString = function()
	{
		return FlashPlayerVersion.getInstance().__toString();
	}

	/**
	* Retourne la version du lecteur Flash sous une forme intégralement numérique
	* - 6002100
	* - 7001900
	* - 8002200
	* ...
	* @public
	*/
	FlashPlayerVersion.getVersionFull = function()
	{
		return FlashPlayerVersion.getInstance().__getVersionFull();
	}

	/**
	* Détermine si la version du lecteur Flash installée
	* permet de faire une mise à jour du plug-in à l'aide
	* du module "Express Install".
	* - 6002100
	* - 7001900
	* - 8002200
	* ...
	* @public
	*/
	FlashPlayerVersion.hasExpressInstall = function()
	{
		return FlashPlayerVersion.getInstance().__hasExpressInstall();
	}

	/**
	* @private
	*/
	FlashPlayerVersion.prototype.setVersion = function
	(
		major,
		minor,
		revision
	)
	{
		this.major = NumberType.to(major);
		this.minor = NumberType.to(minor);
		this.revision = NumberType.to(revision);
	}

	/**
	* @private
	*/
	FlashPlayerVersion.prototype.detect = function()
	{
		if(this.detected)
			return;

		if
		(
			typeof navigator.plugins != 'undefined'
			&&
			navigator.mimeTypes.length
		)
		{
			var pluginObject = navigator.plugins["Shockwave Flash"];
			if
			(
				typeof pluginObject != 'undefined'
				&&
				typeof pluginObject.description == 'string'
			)
			{
				var arr = pluginObject.description.replace(/([a-zA-Z]|\s)+/, "").replace(/(\s+r|\s+b[0-9]+)/, ".").split(".");
				this.setVersion
				(
					parseInt(arr[0]),
					parseInt(arr[1]),
					parseInt(arr[2])
				);
			}
		}
		else
		{
			var activeXObject;
			var hasGetVariable;
			var version;

			try
			{
				activeXObject = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
				version = 7;
			}
			catch(e){}

			if(!(version >=7))
				try 
				{
					activeXObject = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
					version = 6;
				}
				catch(e){}

			if(!(version >=6))
				try
				{
					activeXObject = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
					version = 0; 
				}
				catch(e){}
			
			/**
			* Aucune version du lecteur Flash n'est installée.
			*/
			if(activeXObject == null || version == 0)
				return;

			/**
			* Dans certains cas d'installation/dé-sinstallation successives
			* de versions différentes du lecteur (8.0.24.0 -> 6.0.21.0 par 
			* exemple), la version détectée est enregistrée comme égale ou
			* supérieure à la version installée (donc capable d'exécuter 
			* *GetVariable* alors que l'appel provoque un crash de l'OCX).
			* On fait donc un test de la possibilité d'exécuter *GetVariable*
			* sur toutes les versions >= 6.
			*/
			try
			{
				/**
				* Provoque une capture d'erreur pour toutes les versions
				* du lecteur strictement inférieures à la version 6,0,47.
				* Permet d'éviter de provoquer le crash du navigateur sur
				* les versions du lecteur "6,0,21,0","6,0,22,0","6,0,23,0",
				* "6,0,29,0".
				*/
				activeXObject.AllowScriptAccess = "always";
				hasGetVariable = true;
			}
			catch(e){}

			/**
			* La version du lecteur est assuremment capable
			* de lire du contenu Flash 6 mais incapable de
			* donner accés à son numéro de version complet.
			*
			* Pour l'instant quand la version du lecteur est 
			* inférieure à la 6.0.47 elle est déclarée comme
			* étant égale à la 6.0.0.
			*/
			if(!hasGetVariable)
			{
				this.setVersion(6);
				return;
			}

			var arr = activeXObject.GetVariable("$version").split(" ")[1].split(",");
			this.setVersion
			(
				parseInt(arr[0]),
				parseInt(arr[1]),
				parseInt(arr[2])
			);
		}
	}

	/**
	* @private
	*/
	FlashPlayerVersion.prototype.__getVersionFull = function()
	{
		var major = this.major.toString();
		var minor;
		var revision;

		if(this.minor<10)
			minor = '0' + this.minor.toString();
		else
			minor = this.minor.toString();
			
		if(this.revision<10)
			revision = '0' + this.revision.toString();
		else
			revision = this.revision.toString();

		return parseInt(major + minor + revision + '00');
	}

	/**
	* @private
	*/
	FlashPlayerVersion.prototype.__hasSufficientVersion = function(major,minor,revision)
	{
		var nMajor = NumberType.to(major);
		var nMinor = NumberType.to(minor);
		var nRevision = NumberType.to(revision);

		var plugin = typeof navigator.plugins != 'undefined';
		var vista = navigator.userAgent.toUpperCase().indexOf("WINDOWS NT 6.0") > -1;

		/**
		* IE 9.0.16.0
		*/
		if(!plugin && this.major == 9 && this.revision == 16)
			return false;

		/**
		* IE Vista <9.0.28.0.
		*/
		if(!plugin && vista && FlashPlayerVersion.getVersionFull()<9002800)
			return false;

		/**
		* FF-Safari-Opera 9.0.20.0
		*/
		if(plugin && this.major == 9 && this.revision == 20)
			return false;

		if(this.major < nMajor) return false;
		if(this.major > nMajor) return true;
		if(this.minor < nMinor) return false;
		if(this.minor > nMinor) return true;
		if(this.revision < nRevision) return false;

		return true;
	}

	/**
	* @private
	*/
	FlashPlayerVersion.prototype.__hasFlashPlayer = function()
	{
		return this.major > 0;
	}

	/**
	* @private
	*/
	FlashPlayerVersion.prototype.__hasExpressInstall = function()
	{
		var isWindows = navigator.platform.substr(0,3) == "Win";
		var isMac = navigator.platform.substr(0,3) == "Mac";
				
		if(!isWindows && !isMac)
			return false;

		return this.__getVersionFull() >= 6006500;
	}

	FlashPlayerVersion.prototype.__toString = function()
	{
		return this.major + ',' + this.minor + ',' + this.revision;
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @since	2007/03/11
*/
ClassConfigSniffer();
function ClassConfigSniffer()
{
	AjaxClassLoader.register('com.meetic.im.sniffer.ConfigSniffer',ConfigSniffer);

	var StringType = AjaxClassLoader.load('net.tekool.type.StringType');
	var FlashPlayerVersion = AjaxClassLoader.load('com.meetic.im.flash.FlashPlayerVersion');

	function ConfigSniffer(){}

	/**
	* Implémentation du pattern Singleton
	*/
	ConfigSniffer.instance = null;
	ConfigSniffer.getInstance = function()
	{
		if(ConfigSniffer.instance == null)
			return ConfigSniffer.instance = new ConfigSniffer(ConfigSniffer.getInstance);
		return ConfigSniffer.instance;
	}

	ConfigSniffer.prototype.propertyArray = new Array();

	/**
	* @public
	*/
	ConfigSniffer.getServerString = function()
	{
		return ConfigSniffer.getInstance().__getServerString();
	}

	/**
	* @public
	*/
	ConfigSniffer.getProperty = function(name)
	{
		return ConfigSniffer.getInstance().__getProperty(name);
	}
	
	/**
	* @public
	*/
	ConfigSniffer.toString = function()
	{
		return ConfigSniffer.getInstance().__toString();
	}


	ConfigSniffer.prototype.executeBrowserSniffer = function()
	{
		/**
		* Seule manière d'assurer une intégration permettant
		* la maintenance du script d'origine.
		*/

		// JavaScript Browser Sniffer
		// Eric Krok, Andy King, Michel Plungjan Jan. 31, 2002
		// see http://www.webreference.com/ for more information


		// convert all characters to lowercase to simplify testing
		var agt=navigator.userAgent.toLowerCase();
		var appVer = navigator.appVersion.toLowerCase();
		
		// *** BROWSER VERSION ***

		var is_minor = parseFloat(appVer);
		var is_major = parseInt(is_minor);

		var is_opera = (agt.indexOf("opera") != -1);
		var is_opera2 = (agt.indexOf("opera 2") != -1 || agt.indexOf("opera/2") != -1);
		var is_opera3 = (agt.indexOf("opera 3") != -1 || agt.indexOf("opera/3") != -1);
		var is_opera4 = (agt.indexOf("opera 4") != -1 || agt.indexOf("opera/4") != -1);
		var is_opera5 = (agt.indexOf("opera 5") != -1 || agt.indexOf("opera/5") != -1);
		var is_opera6 = (agt.indexOf("opera 6") != -1 || agt.indexOf("opera/6") != -1); // 020128- abk
		var is_opera7 = (agt.indexOf("opera 7") != -1 || agt.indexOf("opera/7") != -1); // 021205- dmr
		var is_opera8 = (agt.indexOf("opera 8") != -1 || agt.indexOf("opera/8") != -1); // 09-19-2006 jonw 
		var is_opera9 = (agt.indexOf("opera 9") != -1 || agt.indexOf("opera/9") != -1); // 09-19-2006 jonw

		var is_opera5up = (is_opera && !is_opera2 && !is_opera3 && !is_opera4);
		var is_opera6up = (is_opera && !is_opera2 && !is_opera3 && !is_opera4 && !is_opera5); // new020128
		var is_opera7up = (is_opera && !is_opera2 && !is_opera3 && !is_opera4 && !is_opera5 && !is_opera6); // new021205 -- dmr
		var is_opera8up = (is_opera && !is_opera2 && !is_opera3 && !is_opera4 && !is_opera5 && !is_opera6 && !is_opera7); // 09-19-2006 - jonw
		var is_opera9up = (is_opera && !is_opera2 && !is_opera3 && !is_opera4 && !is_opera5 && !is_opera6 && !is_opera7 &&!is_opera8); // 09-19-2006 - jonw

		// Note: On IE, start of appVersion return 3 or 4
		// which supposedly is the version of Netscape it is compatible with.
		// So we look for the real version further on in the string
		// And on Mac IE5+, we look for is_minor in the ua; since 
		// it appears to be more accurate than appVersion - 06/17/2004

		var is_mac = (agt.indexOf("mac")!=-1);
		var iePos  = appVer.indexOf('msie');
		if (iePos !=-1) {
		   if(is_mac) {
			   var iePos = agt.indexOf('msie');
			   is_minor = parseFloat(agt.substring(iePos+5,agt.indexOf(';',iePos)));
		   }
		   else is_minor = parseFloat(appVer.substring(iePos+5,appVer.indexOf(';',iePos)));
		   is_major = parseInt(is_minor);
		}

		// ditto Konqueror
										  
		var is_konq = false;
		var kqPos   = agt.indexOf('konqueror');
		if (kqPos !=-1) {                 
		   is_konq  = true;
		   is_minor = parseFloat(agt.substring(kqPos+10,agt.indexOf(';',kqPos)));
		   is_major = parseInt(is_minor);
		}                                 

		var is_getElementById   = (document.getElementById) ? "true" : "false"; // 001121-abk
		var is_getElementsByTagName = (document.getElementsByTagName) ? "true" : "false"; // 001127-abk
		var is_documentElement = (document.documentElement) ? "true" : "false"; // 001121-abk

		var is_safari = ((agt.indexOf('safari')!=-1)&&(agt.indexOf('mac')!=-1))?true:false;
		var is_khtml  = (is_safari || is_konq);

		var is_gecko = ((!is_khtml)&&(navigator.product)&&(navigator.product.toLowerCase()=="gecko"))?true:false;
		var is_gver  = 0;
		if (is_gecko) is_gver=navigator.productSub;

		var is_fb = ((agt.indexOf('mozilla/5')!=-1) && (agt.indexOf('spoofer')==-1) &&
					 (agt.indexOf('compatible')==-1) && (agt.indexOf('opera')==-1)  &&
					 (agt.indexOf('webtv')==-1) && (agt.indexOf('hotjava')==-1)     &&
					 (is_gecko) && (navigator.vendor=="Firebird"));
		var is_fx = ((agt.indexOf('mozilla/5')!=-1) && (agt.indexOf('spoofer')==-1) &&
					 (agt.indexOf('compatible')==-1) && (agt.indexOf('opera')==-1)  &&
					 (agt.indexOf('webtv')==-1) && (agt.indexOf('hotjava')==-1)     &&
					 (is_gecko) && ((navigator.vendor=="Firefox")||(agt.indexOf('firefox')!=-1)));
		var is_moz   = ((agt.indexOf('mozilla/5')!=-1) && (agt.indexOf('spoofer')==-1) &&
						(agt.indexOf('compatible')==-1) && (agt.indexOf('opera')==-1)  &&
						(agt.indexOf('webtv')==-1) && (agt.indexOf('hotjava')==-1)     &&
						(is_gecko) && (!is_fb) && (!is_fx) &&
						((navigator.vendor=="")||(navigator.vendor=="Mozilla")||(navigator.vendor=="Debian")));
		if ((is_moz)||(is_fb)||(is_fx)) {  // 032504 - dmr
		   var is_moz_ver = (navigator.vendorSub)?navigator.vendorSub:0;
		   if(is_fx&&!is_moz_ver) {
			   is_moz_ver = agt.indexOf('firefox/');
			   is_moz_ver = agt.substring(is_moz_ver+8);
			   is_moz_ver = parseFloat(is_moz_ver);
		   }
		   if(!(is_moz_ver)) {
			   is_moz_ver = agt.indexOf('rv:');
			   is_moz_ver = agt.substring(is_moz_ver+3);
			   is_paren   = is_moz_ver.indexOf(')');
			   is_moz_ver = is_moz_ver.substring(0,is_paren);
		   }
		   is_minor = is_moz_ver;
		   is_major = parseInt(is_moz_ver);
		}
	   var is_fb_ver = is_moz_ver;
	   var is_fx_ver = is_moz_ver;

		var is_nav  = ((agt.indexOf('mozilla')!=-1) && (agt.indexOf('spoofer')==-1)
					&& (agt.indexOf('compatible') == -1) && (agt.indexOf('opera')==-1)
					&& (agt.indexOf('webtv')==-1) && (agt.indexOf('hotjava')==-1)
					&& (!is_khtml) && (!(is_moz)) && (!is_fb) && (!is_fx));

		// Netscape6 is mozilla/5 + Netscape6/6.0!!!
		// Mozilla/5.0 (Windows; U; Win98; en-US; m18) Gecko/20001108 Netscape6/6.0
		// Changed this to use navigator.vendor/vendorSub - dmr 060502   
		// var nav6Pos = agt.indexOf('netscape6');
		// if (nav6Pos !=-1) {
		if ((navigator.vendor)&&
			((navigator.vendor=="Netscape6")||(navigator.vendor=="Netscape"))&&
			(is_nav)) {
		   is_major = parseInt(navigator.vendorSub);
		   // here we need is_minor as a valid float for testing. We'll
		   // revert to the actual content before printing the result. 
		   is_minor = parseFloat(navigator.vendorSub);
		}

		var is_nav2 = (is_nav && (is_major == 2));
		var is_nav3 = (is_nav && (is_major == 3));
		var is_nav4 = (is_nav && (is_major == 4));
		var is_nav4up = (is_nav && is_minor >= 4);  // changed to is_minor for
													// consistency - dmr, 011001
		var is_navonly      = (is_nav && ((agt.indexOf(";nav") != -1) ||
							  (agt.indexOf("; nav") != -1)) );

		var is_nav6   = (is_nav && is_major==6);    // new 010118 mhp
		var is_nav6up = (is_nav && is_minor >= 6); // new 010118 mhp

		var is_nav5   = (is_nav && is_major == 5 && !is_nav6); // checked for ns6
		var is_nav5up = (is_nav && is_minor >= 5);

		var is_nav7   = (is_nav && is_major == 7);
		var is_nav7up = (is_nav && is_minor >= 7);

		var is_nav8   = (is_nav && is_major == 8);
		var is_nav8up = (is_nav && is_minor >= 8);

		var is_ie   = ((iePos!=-1) && (!is_opera) && (!is_khtml));
		var is_ie3  = (is_ie && (is_major < 4));

		var is_ie4   = (is_ie && is_major == 4);
		var is_ie4up = (is_ie && is_minor >= 4);
		var is_ie5   = (is_ie && is_major == 5);
		var is_ie5up = (is_ie && is_minor >= 5);
		
		var is_ie5_5  = (is_ie && (agt.indexOf("msie 5.5") !=-1)); // 020128 new - abk
		var is_ie5_5up =(is_ie && is_minor >= 5.5);                // 020128 new - abk
		
		var is_ie6   = (is_ie && is_major == 6);
		var is_ie6up = (is_ie && is_minor >= 6);

		var is_ie7   = (is_ie && is_major == 7);
		var is_ie7up = (is_ie && is_minor >= 7);

	// KNOWN BUG: On AOL4, returns false if IE3 is embedded browser
		// or if this is the first browser window opened.  Thus the
		// variables is_aol, is_aol3, and is_aol4 aren't 100% reliable.

		var is_aol   = (agt.indexOf("aol") != -1);
		var is_aol3  = (is_aol && is_ie3);
		var is_aol4  = (is_aol && is_ie4);
		var is_aol5  = (agt.indexOf("aol 5") != -1);
		var is_aol6  = (agt.indexOf("aol 6") != -1);
		var is_aol7  = ((agt.indexOf("aol 7")!=-1) || (agt.indexOf("aol7")!=-1));
		var is_aol8  = ((agt.indexOf("aol 8")!=-1) || (agt.indexOf("aol8")!=-1));

		var is_webtv = (agt.indexOf("webtv") != -1);
		
		// new 020128 - abk
		
		var is_TVNavigator = ((agt.indexOf("navio") != -1) || (agt.indexOf("navio_aoltv") != -1)); 
		var is_AOLTV = is_TVNavigator;

		var is_hotjava = (agt.indexOf("hotjava") != -1);
		var is_hotjava3 = (is_hotjava && (is_major == 3));
		var is_hotjava3up = (is_hotjava && (is_major >= 3));

		// end new
		
		// *** JAVASCRIPT VERSION CHECK ***
		// Useful to workaround Nav3 bug in which Nav3
		// loads <SCRIPT LANGUAGE="JavaScript1.2">.
		// updated 020131 by dragle
		var is_js;
		if (is_nav2 || is_ie3) is_js = 1.0;
		else if (is_nav3) is_js = 1.1;
		else if ((is_opera5)||(is_opera6)) is_js = 1.3; // 020214 - dmr
		else if (is_opera7up) is_js = 1.5; // 031010 - dmr
		else if (is_khtml) is_js = 1.5;   // 030110 - dmr
		else if (is_opera) is_js = 1.1;
		else if ((is_nav4 && (is_minor <= 4.05)) || is_ie4) is_js = 1.2;
		else if ((is_nav4 && (is_minor > 4.05)) || is_ie5) is_js = 1.3;
		else if (is_nav5 && !(is_nav6)) is_js = 1.4;
		else if (is_hotjava3up) is_js = 1.4; // new 020128 - abk
		else if (is_nav6up) is_js = 1.5;

		// NOTE: In the future, update this code when newer versions of JS
		// are released. For now, we try to provide some upward compatibility
		// so that future versions of Nav and IE will show they are at
		// *least* JS 1.x capable. Always check for JS version compatibility
		// with > or >=.

		else if (is_nav && (is_major > 5)) is_js = 1.4;
		else if (is_ie && (is_major > 5)) is_js = 1.3;
		else if (is_moz) is_js = 1.5;
		else if (is_fb||is_fx) is_js = 1.5; // 032504 - dmr
		
		// what about ie6 and ie6up for js version? abk
		
		// HACK: no idea for other browsers; always check for JS version 
		// with > or >=
		else is_js = 0.0;
		// HACK FOR IE5 MAC = js vers = 1.4 (if put inside if/else jumps out at 1.3)
		if ((agt.indexOf("mac")!=-1) && is_ie5up) is_js = 1.4; // 020128 - abk
		
		// Done with is_minor testing; revert to real for N6/7
		if (is_nav6up) {
		   is_minor = navigator.vendorSub;
		}

		// *** PLATFORM ***
		var is_win   = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
		// NOTE: On Opera 3.0, the userAgent string includes "Windows 95/NT4" on all
		//        Win32, so you can't distinguish between Win95 and WinNT.
		var is_win95 = ((agt.indexOf("win95")!=-1) || (agt.indexOf("windows 95")!=-1));

		// is this a 16 bit compiled version?
		var is_win16 = ((agt.indexOf("win16")!=-1) ||
				   (agt.indexOf("16bit")!=-1) || (agt.indexOf("windows 3.1")!=-1) ||
				   (agt.indexOf("windows 16-bit")!=-1) );

		var is_win31 = ((agt.indexOf("windows 3.1")!=-1) || (agt.indexOf("win16")!=-1) ||
						(agt.indexOf("windows 16-bit")!=-1));
		
		var is_winme = ((agt.indexOf("win 9x 4.90")!=-1));    // new 020128 - abk
		var is_win2k = ((agt.indexOf("windows nt 5.0")!=-1) || (agt.indexOf("windows 2000")!=-1)); // 020214 - dmr
		var is_winxp = ((agt.indexOf("windows nt 5.1")!=-1) || (agt.indexOf("windows xp")!=-1)); // 020214 - dmr
		var is_winvista = agt.indexOf("windows nt 6.0")!=-1;

		// NOTE: Reliable detection of Win98 may not be possible. It appears that:
		//       - On Nav 4.x and before you'll get plain "Windows" in userAgent.
		//       - On Mercury client, the 32-bit version will return "Win98", but
		//         the 16-bit version running on Win98 will still return "Win95".
		var is_win98 = ((agt.indexOf("win98")!=-1) || (agt.indexOf("windows 98")!=-1));
		var is_winnt = ((agt.indexOf("winnt")!=-1) || (agt.indexOf("windows nt")!=-1));
		var is_win32 = (is_win95 || is_winnt || is_win98 ||
						((is_major >= 4) && (navigator.platform == "Win32")) ||
						(agt.indexOf("win32")!=-1) || (agt.indexOf("32bit")!=-1));

		var is_os2   = ((agt.indexOf("os/2")!=-1) ||
						(navigator.appVersion.indexOf("OS/2")!=-1) ||
						(agt.indexOf("ibm-webexplorer")!=-1));

		var is_mac    = (agt.indexOf("mac")!=-1);
		if (is_mac) { is_win = !is_mac; } // dmr - 06/20/2002
		var is_mac68k = (is_mac && ((agt.indexOf("68k")!=-1) ||
								   (agt.indexOf("68000")!=-1)));
		var is_macppc = (is_mac && ((agt.indexOf("ppc")!=-1) ||
									(agt.indexOf("powerpc")!=-1)));
		var is_macosx = (is_mac && (agt.indexOf("os x")!=-1));

		var is_sun   = (agt.indexOf("sunos")!=-1);
		var is_sun4  = (agt.indexOf("sunos 4")!=-1);
		var is_sun5  = (agt.indexOf("sunos 5")!=-1);
		var is_suni86= (is_sun && (agt.indexOf("i86")!=-1));
		var is_irix  = (agt.indexOf("irix") !=-1);    // SGI
		var is_irix5 = (agt.indexOf("irix 5") !=-1);
		var is_irix6 = ((agt.indexOf("irix 6") !=-1) || (agt.indexOf("irix6") !=-1));
		var is_hpux  = (agt.indexOf("hp-ux")!=-1);
		var is_hpux9 = (is_hpux && (agt.indexOf("09.")!=-1));
		var is_hpux10= (is_hpux && (agt.indexOf("10.")!=-1));
		var is_aix   = (agt.indexOf("aix") !=-1);      // IBM
		var is_aix1  = (agt.indexOf("aix 1") !=-1);
		var is_aix2  = (agt.indexOf("aix 2") !=-1);
		var is_aix3  = (agt.indexOf("aix 3") !=-1);
		var is_aix4  = (agt.indexOf("aix 4") !=-1);
		var is_linux = (agt.indexOf("inux")!=-1);
		var is_sco   = (agt.indexOf("sco")!=-1) || (agt.indexOf("unix_sv")!=-1);
		var is_unixware = (agt.indexOf("unix_system_v")!=-1);
		var is_mpras    = (agt.indexOf("ncr")!=-1);
		var is_reliant  = (agt.indexOf("reliantunix")!=-1);
		var is_dec   = ((agt.indexOf("dec")!=-1) || (agt.indexOf("osf1")!=-1) ||
			   (agt.indexOf("dec_alpha")!=-1) || (agt.indexOf("alphaserver")!=-1) ||
			   (agt.indexOf("ultrix")!=-1) || (agt.indexOf("alphastation")!=-1));
		var is_sinix = (agt.indexOf("sinix")!=-1);
		var is_freebsd = (agt.indexOf("freebsd")!=-1);
		var is_bsd = (agt.indexOf("bsd")!=-1);
		var is_unix  = ((agt.indexOf("x11")!=-1) || is_sun || is_irix || is_hpux ||
					 is_sco ||is_unixware || is_mpras || is_reliant ||
					 is_dec || is_sinix || is_aix || is_linux || is_bsd || is_freebsd);

		var is_vms   = ((agt.indexOf("vax")!=-1) || (agt.indexOf("openvms")!=-1));
	// additional checks, abk
		var is_anchors = (document.anchors) ? "true":"false";
		var is_regexp = (window.RegExp) ? "true":"false";
		var is_option = (window.Option) ? "true":"false";
		var is_all = (document.all) ? "true":"false";
	// cookies - 990624 - abk
		document.cookie = "cookies=true";
		var is_cookie = (document.cookie) ? "true" : "false";
		var is_images = (document.images) ? "true":"false";
		var is_layers = (document.layers) ? "true":"false"; // gecko m7 bug?
	// new doc obj tests 990624-abk
		var is_forms = (document.forms) ? "true" : "false";
		var is_links = (document.links) ? "true" : "false";
		var is_frames = (window.frames) ? "true" : "false";
		var is_screen = (window.screen) ? "true" : "false";

	// java
		var is_java = (navigator.javaEnabled());

		///////////////////////////////////////////////////

		//Browser
		switch(true)
		{
			case is_ie:
			{
				var index = appVer.indexOf('netscape/');
				if(index != -1)
					this.setBrowser('netscape',appVer.substr(index+9,appVer.length)); //Internet Explorer mode under Netscape
				else
					this.setBrowser('explorer',appVer.substr(appVer.indexOf('msie ')+5,3));
				break;
			}

			case is_fx:		this.setBrowser('firefox',agt.substr(agt.indexOf('firefox/')+8,agt.length));	break;
			case is_fb:		this.setBrowser('firebird',is_minor);	break;
			case is_moz:	this.setBrowser('mozilla',is_minor);	break;
			case is_opera:	this.setBrowser('opera',is_minor);		break;
			case is_konq:	this.setBrowser('konqueror',is_minor);	break;
			case is_safari:
			{
				this.setBrowser('safari',appVer.substr(appVer.indexOf('safari/')+7,5));

				break;
			}

			case is_nav:
			{
				var index = agt.indexOf('camino/');
				if(index == -1)
					this.setBrowser('netscape',is_minor);
				else
					this.setBrowser('camino',agt.substr(index+7,5));

				break;
			}

			case is_aol:	this.setBrowser('aol',is_minor);		break;
		}

		//OS
		switch(true)
		{
			//Windows
			case is_winvista :	this.setOS('windows vista');		break;
			case is_winxp :		this.setOS('windows xp');			break;
			case is_win2k :		this.setOS('windows 2000');			break;
			case is_winme :		this.setOS('windows me');			break;
			case is_win98 :		this.setOS('windows 98');			break;
			case is_win95 :		this.setOS('windows 95');			break;

			//Mac
			case is_macosx :	this.setOS('macintosh osx');		break;
			case is_macppc :	this.setOS('macintosh ppc');		break;
			case is_mac68k :	this.setOS('macintosh 68k');		break;

			case is_sun :		this.setOS('sun');					break;
			case is_irix :		this.setOS('irix');					break;
			case is_hpux :		this.setOS('hpux');					break;
			case is_aix :		this.setOS('aix');					break;
			case is_linux :		this.setOS('linux');				break;
			case is_sco :		this.setOS('sco');					break;
			case is_unixware :	this.setOS('unixware');				break;
			case is_mpras :		this.setOS('mpras');				break;
			case is_reliant :	this.setOS('reliant');				break;
			case is_dec :		this.setOS('dec');					break;
			case is_sinix :		this.setOS('sinix');				break;
			case is_freebsd	:	this.setOS('freebsd');				break;
			case is_bsd	:		this.setOS('bsd');					break;
			case is_unix :		this.setOS('unix');					break;
			case is_vms	:		this.setOS('vms');					break;
		}

		this.setJs(is_js);
		this.setJava(is_java);
	}

	ConfigSniffer.prototype.addProperty = function(name,value)
	{
		this.propertyArray.push([name,value]);
	}

	ConfigSniffer.prototype.setNavigatorProperty = function()
	{
		var sName;

		for(sName in navigator)
		{
			var value = navigator[sName];

			switch(typeof value)
			{
				case 'string':
					if(typeof value.toString == 'function' && value != '')
						this.addProperty('n_' + sName, value.toString());
				break;

				case 'number':
					try{this.addProperty('n_' + sName, (value+0) )}catch(e){};
				break;

				case 'boolean':
					try{this.addProperty('n_' + sName, (value?true:false) )}catch(e){};
				break;
			}
		}
	}

	ConfigSniffer.prototype.setOS = function(name)
	{
		this.addProperty('os', name);
	}

	ConfigSniffer.prototype.setBrowser = function(name,version)
	{
		this.addProperty('browser', name + ' ' + version.toString());
	}

	ConfigSniffer.prototype.setJs = function(version)
	{
		this.addProperty('js','v' + version);
	}

	ConfigSniffer.prototype.setJava = function(value)
	{
		this.addProperty('java',value ? true: false);
	}

	ConfigSniffer.prototype.setFlash = function()
	{
		this.addProperty('flash', FlashPlayerVersion.getVersionFull());
	}

	ConfigSniffer.prototype.setConfig = function()
	{
		if(this.propertyArray.length != 0)
			return;

		this.executeBrowserSniffer();
		this.setFlash();
		this.setNavigatorProperty();
	}

	ConfigSniffer.prototype.__getProperty = function(name)
	{
		this.setConfig();

		var lsName = name.toString().toLowerCase();
		var len = this.propertyArray.length;
		for(var i=0; i<len; i++)
			if(this.propertyArray[i][0].toLowerCase() == lsName)
				return this.propertyArray[i][1];
	}

	ConfigSniffer.prototype.__getServerString = function()
	{
		this.setConfig();

		var serverString = '';
		for(var i=0; i<this.propertyArray.length; i++)
		{
			var item = this.propertyArray[i];
			var name = item[0];
			var value = item[1];

			var sValue;
			switch(typeof value)
			{
				case 'boolean':
					sValue = value ? '1' : '0';
				break;

				default:
					sValue = value.toString();
			}

			serverString += '&' + name + '=' + escape(sValue);
		}
		
		return serverString;
	}

	ConfigSniffer.prototype.__toString = function()
	{
		this.setConfig();

		var out = '{\n';
		for(var i=0; i<this.propertyArray.length; i++)
		{
			var item = this.propertyArray[i];
			var name = item[0];
			var value = item[1];
			var sValue;

			switch(typeof value)
			{
				case 'boolean':
					sValue = value ? 'true' : 'false';
				break;

				case 'string':
					sValue = '"' + value + '"';
				break;

				default:
					sValue = value.toString();
			}

			out += '\n\t' + name + ' : ' + sValue;
			
			if(i+1 < this.propertyArray.length)
				out += ',';
		}
		
		out += '\n}'
		
		return out;
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @description Classe permettant la communication avec le meeticMessenger desktop.
* @since	2008/01/23
*/
ClassDesktopProxy();
function ClassDesktopProxy()
{
	AjaxClassLoader.register('com.meetic.im.connector.DesktopProxy',DesktopProxy);

	var Relegate = AjaxClassLoader.load('net.tekool.utils.Relegate');
	var Log = AjaxClassLoader.load('net.tekool.debug.Log');
	var EventDispatcher = AjaxClassLoader.load('net.tekool.events.EventDispatcher');
	var EventS = AjaxClassLoader.load('net.tekool.events.EventS');
	var Log = AjaxClassLoader.load('net.tekool.debug.Log');

	function DesktopProxy()
	{
		//Le constructeur n'est pas exécuté lorsqu'il est appelé pour étendre la classe.
		if(arguments[0] == DesktopProxy)
			return;
	
		this.relegateCheck = Relegate.create(this,this.check);
		EventDispatcher.initialize(this);

		this.activeXObjectCreate();
	}

	/**
	* Le délai (exprimé en millisecondes) séparant chaque test
	* d'existence de la connection du messenger desktop.
	*/
	DesktopProxy.CHECK_DESKTOP_CONNECTION_DELAY = 1000;

	DesktopProxy.EVENT_CONNECT = 'eventConnect';
	DesktopProxy.EVENT_DISCONNECT = 'eventDisconnect';

	DesktopProxy.prototype.activeXObject = null;
	DesktopProxy.prototype.relegateCheck = null;
	DesktopProxy.prototype.checkInterval = null;
	DesktopProxy.prototype.lastCheckDesktopConnection = null;
	DesktopProxy.prototype.sessionID = null;
	DesktopProxy.prototype.userPseudo = null;
	DesktopProxy.prototype.desktopIsRunning = false;

	/**
	* Renseigne sur la présence effective du meeticMessenger desktop
	*/
	DesktopProxy.prototype.isConnected = function()
	{//return true
		try 
		{
			if(this.activeXObject.CurrentPseudo === this.userPseudo)
				return true;
			else
				return false;
		}
		catch(e) 
		{
			//Log.error('DesktopProxy::isConnected() -> ' + e.message);
			return false;
		}
	}

	/**
	* Lance le processus de détection de la présence du meeticMessenger
	*/
	DesktopProxy.prototype.start = function(sessionID,userPseudo)
	{
		if(this.activeXObject === null)
			return;

		this.sessionID = sessionID;
		this.userPseudo = userPseudo;

		this.stop();
		this.checkInterval = setInterval(this.relegateCheck,DesktopProxy.CHECK_DESKTOP_CONNECTION_DELAY);
		this.check();
	}

	/**
	* Arrête le processus de détection de la présence du meeticMessenger
	*/
	DesktopProxy.prototype.stop = function()
	{
		clearTimeout(this.startCheckDesktopConnectionInterval);
		this.startCheckDesktopConnectionInterval = null;
	}

	/**
	* @private
	*/
	DesktopProxy.prototype.hasActiveX = function()
	{
		return this.activeXObject != null;
	};

	/**
	* @private
	*/
	DesktopProxy.prototype.activeXObjectCreate = function()
	{
		try
		{
			var activeXObject = new ActiveXObject("MeeticMessenger.IEIntegration");

			if(activeXObject == null)
				this.activeXObject = null;
			else
				this.activeXObject = activeXObject;
		}
		catch (e)
		{
			//Log.error('DesktopProxy::activeXObjectCreate() -> ' + e.message);
			this.activeXObject = null;
		}
	}

	/**
	* @private
	*/
	DesktopProxy.prototype.activeXObjectHandShake = function()
	{
		try
		{
			var result = this.activeXObject.Handshake(this.sessionID);
			if(!result)
				Log.error('DesktopProxy::activeXObjectHandShake -> handshake result ' + result);
		}
		catch(e)
		{
			Log.error('DesktopProxy::activeXObjectHandShake("' + this.sessionID + '") -> ' + e.message);
		}
	}

	/**
	* @private
	*/
	DesktopProxy.prototype.check = function()
	{
		this.checkDesktopPresence();
		this.activeXObjectHandShake();
		this.checkDesktopConnection();
	}

	/**
	* @private
	*/
	DesktopProxy.prototype.checkDesktopPresence = function()
	{
		var isRunning = false;
		try
		{
			isRunning = this.activeXObject.IsRunning
		}
		catch(e){}

		this.desktopIsRunning = isRunning;
	}

	/**
	* @private
	*/
	DesktopProxy.prototype.checkDesktopConnection = function()
	{
		if(this.lastCheckDesktopConnection === null && this.isConnected())
		{
			this.lastCheckDesktopConnection = true;
			return;
		}

		if(this.lastCheckDesktopConnection === null && !this.isConnected())
		{
			this.lastCheckDesktopConnection = false;
			return;
		}

		if(this.lastCheckDesktopConnection === false && this.isConnected())
		{
			this.lastCheckDesktopConnection = true;
			return this.onDesktopConnected();
		}

		if(this.lastCheckDesktopConnection === true && !this.isConnected())
		{
			this.lastCheckDesktopConnection = false;
			return this.onDesktopDisconnected();
		}
	}
	
	/**
	* @private
	*/
	DesktopProxy.prototype.onDesktopConnected = function()
	{
		this.dispatchEvent(new EventS(DesktopProxy.EVENT_CONNECT));
	}

	/**
	* @private
	*/
	DesktopProxy.prototype.onDesktopDisconnected = function()
	{
		this.dispatchEvent(new EventS(DesktopProxy.EVENT_DISCONNECT));
	}
}

//----------------------------------------------------------------------------------------------------------------------------------------------//
//------------------------------------------------------------------ FICHIER -------------------------------------------------------------------//
//----------------------------------------------------------------------------------------------------------------------------------------------//

/**
* @description Classe de gestion du cookie.
* @since	2008/02/15
*/
ClassCookieProxy();
function ClassCookieProxy()
{
	AjaxClassLoader.register('net.tekool.dom.cookie.CookieProxy',CookieProxy);

	var Relegate = AjaxClassLoader.load('net.tekool.utils.Relegate');
	var Log = AjaxClassLoader.load('net.tekool.debug.Log');
	var EventDispatcher = AjaxClassLoader.load('net.tekool.events.EventDispatcher');
	var EventS = AjaxClassLoader.load('net.tekool.events.EventS');

	function CookieProxy()
	{
		//Le constructeur n'est pas exécuté lorsqu'il est appelé pour étendre la classe.
		if(arguments[0] == DesktopProxy)
			return;
	
		this.relegateCheck = Relegate.create(this,this.check);
		EventDispatcher.initialize(this);

		this.activeXObjectCreate();
	}

	/**
	* Retourne une valeur du cookie.
	*/
	CookieProxy.cookieGet = function(sName)
	{
		var aCookie = document.cookie.split("; ");
		for(var i=0; i<aCookie.length; i++)
		{
			var aCrumb = aCookie[i].split("=");
			if(sName == aCrumb[0])
			{
				if(aCrumb[1] == '@@NOT_A_VALUE@@')
					return '';
				else
					return unescape(aCrumb[1]);
			}
		}
		return null;
	}

	/**
	* Affecte une nouvelle valeur au cookie.
	*/
	CookieProxy.cookieSet = function
	(
		sName,
		sValue,
		dExpires,
		sPath,
		sDomain,
		bSecure
	)
	{
		if(sName == null || sName == '')
			return;

		var sValueIn = sValue;
		if(sValueIn == null || sValueIn == '')
			sValueIn = '@@NOT_A_VALUE@@';

		var dExpiresIn = dExpires;
		if(dExpiresIn == null || typeof dExpiresIn.toGMTString == 'undefined')
			dExpiresIn = null;

		var sPathIn = sPath;
		if(sPathIn == null || sPathIn == '')
			sPathIn = null;

		var sDomainIn = sDomain;
		if(sDomainIn == null || sDomainIn == '')
			sDomainIn = null;

		var bSecureIn = bSecure;
		if(bSecureIn != null)
			bSecureIn = bSecure ? true : false;

		var sCookie = '';
		sCookie += sName + '=' + escape(sValueIn) + ';';

		if(dExpiresIn != null)
			sCookie += 'expires=' + dExpiresIn.toGMTString() + ';';
	
		if(sPathIn != null)
			sCookie += 'path=' + sPathIn + ';';

		if(sDomainIn != null)
			sCookie += 'domain=' + sDomainIn + ';';

		if(bSecureIn != null)
			sCookie += 'secure=' + bSecureIn + ';';

		document.cookie = sCookie;
	}

	CookieProxy.cookieDelete = function(sName)
	{
		document.cookie = sName + '=; expires=' + new Date(1970,0,0).toGMTString();
	}
}