//******************************************************************************************************************
//******************************************************************************************************************
//					GESTION DES CHAINES DE CARACTERES
//******************************************************************************************************************
//******************************************************************************************************************


//------------------------------------------------------------------------------------------------------------------
// Function : Asc
// Description	: Retourne un caractere representant le code ascii du premier caractere de la string passé en
//			argument.
// Parameters : String = Un caractere valide.
//			Si le code du caractere n'est pas compris
//			entre 32-126, la fonction retourne 0.
// Returns	: Integer
//------------------------------------------------------------------------------------------------------------------
function Asc(string)
{
	var symbols = " !\"#$%&'()*+'-./0123456789:;<=>?@";
	var loAZ = "abcdefghijklmnopqrstuvwxyz";
	symbols += loAZ.toUpperCase();
	symbols += "[\\]^_`";
	symbols += loAZ;
	symbols += "{|}~";
	var loc;
	loc = symbols.indexOf(string);
	if (loc > -1)
	{ 
		Ascii_Decimal = 32 + loc;
		return (32 + loc);
	}
	return (0);
}
//------------------------------------------------------------------------------------------------------------------
// Function : Chr
// Description	: Renvoie un caractere correspondant au code specifié dans l'argument.
// Parameters : CharCode = un Long representant un code caractere.
// Returns	: String
//------------------------------------------------------------------------------------------------------------------
function Chr(CharCode)
{
	return String.fromCharCode(CharCode);
}
//------------------------------------------------------------------------------------------------------------------
// InStr: Returns a Long specifying the position of the first 
//				occurrence of one string within another. Is String1
//				or String2 are null, false is returned.
// Parameters:
//			String1 = String expression being searched.
//			String2 = String expression sought
// Returns: Integer
//------------------------------------------------------------------------------------------------------------------
function InStr(String1, String2)
{
	var a = 0;

	if (String1 == null || String2 == null)
		return (false);

	String1 = String1.toLowerCase();
	String2 = String2.toLowerCase();

	a = String1.indexOf(String2);
	if (a == -1)
		return 0;
	else
		return a + 1;
}
//------------------------------------------------------------------------------------------------------------------
// IsValidFileName: Returns a Boolean value indicating whether a
//								 file name is available
// Parameters:
// Expression = Variant containing an expression or
//									 string expression.
// Returns: Boolean
//------------------------------------------------------------------------------------------------------------------
function IsValidFileName(Expression)
{
	Expression = Expression.toLowerCase();
	RefString = "*'\"<>|";

	if (Expression.length < 1)
		return (false);

	for (var i = 0; i < Expression.length; i++)
	{
		var ch = Expression.substr(i, 1)
		var a = RefString.indexOf(ch, 0)
		if (a != -1)
			return (false);
	}
	return(true);
}
//------------------------------------------------------------------------------------------------------------------
// IsAlphanumeric: Returns a Boolean value indicating whether an
//								 expression can be evaluated as a number or
//								 char.
// Parameters:
//			Expression = Variant containing a numeric expression or 
//									 string expression.
// Returns: Boolean
//------------------------------------------------------------------------------------------------------------------
function IsAlphanumeric(Expression)
{
	Expression = Expression.toLowerCase();
	RefString = "abcdefghijklmnopqrstuvwxyz0123456789 ";

	if (Expression.length < 1) 
		return (false);

	for (var i = 0; i < Expression.length; i++) 
	{
		var ch = Expression.substr(i, 1)
		var a = RefString.indexOf(ch, 0)
		if (a == -1)
			return (false);
	}
	return(true);
}
//------------------------------------------------------------------------------------------------------------------
// IsChar: Returns a Boolean value indicating whether an 
//				 expression can be evaluated as a character (this 
//				 not only includes alpha chars but all symbols such as
//				 @#$%^&|\_+-/*="!?,.:;'(){}<>[]
//
// Parameters:
//		- Expression = Variant containing a numeric expression or 
//									 string expression.
//
// Returns: Boolean
//------------------------------------------------------------------------------------------------------------------
function IsChar(Expression)
{
	Expression = Expression.toLowerCase();
	RefString = "0123456789";

	if (Expression.length < 1) 
		return (false);

	for (var i = 0; i < Expression.length; i++) 
	{
		var ch = Expression.substr(i, 1)
		var a = RefString.indexOf(ch, 0)
		if (a != -1)
			return (false);
	}
	return(true);
}
//------------------------------------------------------------------------------------------------------------------
// IsEmail: Returns a Boolean if the specified Expression is a
//					valid e-mail address. If Expression is null, false
//					is returned.
// Parameters:
//			Expression = e-mail to validate.
// Returns: Boolean
//------------------------------------------------------------------------------------------------------------------
function IsEmail(Expression)
{
	if (Expression == null)
		return (false);

	var supported = 0;
	if (window.RegExp)
	{
		var tempStr = "a";
		var tempReg = new RegExp(tempStr);
		if (tempReg.test(tempStr)) supported = 1;
	}
	if (!supported) 
		return (Expression.indexOf(".") > 2) && (Expression.indexOf("@") > 0);
	var r1 = new RegExp("(@.*@)|(\\.\\.)|(@\\.)|(^\\.)");
	var r2 = new RegExp("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$");
	return (!r1.test(Expression) && r2.test(Expression));
}
//------------------------------------------------------------------------------------------------------------------
// Function : Left
// Description	: Extrait un nombre de caracteres spécifié à partir de la gauche de la chaine passé en argument.
// Parameters : String = Chaine de caracteres à partir de laquelle l'extraction est faite.
//				 Si String est nulle la fonction retourne false.
//			Length = Nombre indiquant le nombre de caracteres à extraire.
//				 Si Length=0, la fonction retourne la la chaine ("")
//				 Si Length est supérieur à la taille de la chaine la chaine complete est retournée.
// Returns	: String
//------------------------------------------------------------------------------------------------------------------
function Left(String, Length)
{
	if (String == null)
		return (false);

	return String.substr(0, Length);
}
//------------------------------------------------------------------------------------------------------------------
// Function : Len
// Description	: Retourne la longueur d'une chaine de caracteres.
// Parameters : string = Chaine de caracteres valide.
// Returns	: Long
//			False, si le parametre string est nulle.
//------------------------------------------------------------------------------------------------------------------
function Len(string)
{
	if (string == null)
		return (false);
	return String(string).length;
}
//------------------------------------------------------------------------------------------------------------------
// Function : LTrim
//------------------------------------------------------------------------------------------------------------------
function LTrim(sValue) {
	var i;
	var sCar = new String;
	var sStr = new String;
	sStr = '';
	for(i=0;i<sValue.length;i++) {
		sCar = sValue.charAt(i);
		if (sCar != ' ') {
			sStr = sValue.substring(i,sValue.length);
			return(sStr);
		}
	}
	return(sStr);
}

//------------------------------------------------------------------------------------------------------------------
// Function : LTrim
//------------------------------------------------------------------------------------------------------------------
function Trim(sValue) {
	return LTrim(RTrim(sValue))
}


//------------------------------------------------------------------------------------------------------------------
// Function : memoValid
//------------------------------------------------------------------------------------------------------------------

function memoValid(sValue,lTailleMaxi){
	if(sValue.length >lTailleMaxi)
	 return false
	else
	 return true;
}
//------------------------------------------------------------------------------------------------------------------
// Mid: Returns a String containing a specified number of 
//			characters from a string
//
// Parameters:
//			String = String expression from which characters are 
//							 returned. If string contains null, false is 
//							 returned.
//			Start  = Number. Character position in string at which 
//							 the part to be taken begins. If Start is 
//							 greater than the number of characters in 
//							 string, Mid returns a zero-length string ("").
//			Length = Number of characters to return. If omitted 
//							 false is returned. 
//
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function Mid(str, start, ilen)
{
	if (str == null)
		return (false);

	if (start > str.length)
		return '';

	if (ilen == null || ilen.length == 0)
		return (false);
		
	return str.substr((start - 1), ilen);
}
//------------------------------------------------------------------------------------------------------------------
// Replace: Returns a string in which a specified substring has 
//					been replaced with another substring a specified 
//					number of times.
//
// Parameters:
//			Expression = String expression containing substring to 
//									 replace
//			Find			 = Substring being searched for.
//			Replace 	 = Replacement substring.
//
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function Replace(Expression, Find, Replace)
{
	var temp = Expression;
	var a = 0;

	for (var i = 0; i < Expression.length; i++) 
	{
		a = temp.indexOf(Find);
		if (a == -1)
			break
		else
			temp = temp.substring(0, a) + Replace + temp.substring((a + Find.length));
	}

	return temp;
}
//------------------------------------------------------------------------------------------------------------------
// ReturnString: Returns a String containing a repeating 
//							 character string of the length specified
//
// Parameters:
//			Number		= Length of the returned string. If number 
//									is less than 1, false is returned.
//			Character = Character code specifying the character or 
//									string expression whose first character is 
//									used to build the return string. If character 
//									contains null, false is returned. 
//
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function ReturnString(Number, Character)
{
	var temp = '';

	if (Number < 1)
		return (false);

	if (Character.length == 0)
		return (false);

	if (Character.length > 1)
		Character = Character.charAt(0);

	for (var i = 0; i < Number; i++)
	{
		temp = temp + Character
	}

	return temp;
}
//------------------------------------------------------------------------------------------------------------------
// ReverseString: Returns a string in which the character order 
//								of a specified string is reversed
// Parameters:
//			Expression = The expression argument is the string whose 
//									 characters are to be reversed. If expression 
//									 is a zero-length string (""), a zero-length 
//									 string is returned. If expression is null,
//									 false is returned.
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function ReverseString(Expression)
{
	if (Expression == null)
		return (false);

		var dest = '';
		for (var i = (Expression.length - 1); i >= 0; i--)
		dest = dest + Expression.charAt(i);
		return dest;
}
//------------------------------------------------------------------------------------------------------------------
// Function : Right
// Description	: Extrait un nombre de caracteres spécifié à partir de la droite de la chaine passé en argument.
// Parameters : String = Chaine de caracteres à partir de laquelle l'extraction est faite.
//				 Si String est nulle la fonction retourne false.
//			Length = Nombre indiquant le nombre de caracteres à extraire.
//				 Si Length=0, la fonction retourne la la chaine ("")
//				 Si Length est supérieur à la taille de la chaine la chaine complete est retournée.
// Returns	: String
//------------------------------------------------------------------------------------------------------------------
function Right(String, Length)
{
	if (String == null)
		return (false);

		var dest = '';
		for (var i = (String.length - 1); i >= 0; i--)
		dest = dest + String.charAt(i);

	String = dest;
	String = String.substr(0, Length);
	dest = '';

		for (var i = (String.length - 1); i >= 0; i--)
		dest = dest + String.charAt(i);

	return dest;
}

function RTrim(sValue) {
	var i;
	var sCar = new String;
	var sStr = new String;
	sStr = '';
	for(i=sValue.length-1;i>=0;i--) {
		sCar = sValue.charAt(i);
		if (sCar != ' ') {
			sStr = sValue.substring(0,i+1);
			return(sStr);
		}
	}
	return(sStr);
}
//------------------------------------------------------------------------------------------------------------------
// Space: Returns a String consisting of the specified number 
//				of spaces
// Parameters:
//			Number = Number of spaces you want in the string.
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function Space(Number)
{
	var temp = '';

	if (Number < 1)
		return '';

	for (var i = 0; i < Number; i++)
	{
		temp = temp + ' ';
	}
	return temp;
}
//------------------------------------------------------------------------------------------------------------------
// Function : strValid
//------------------------------------------------------------------------------------------------------------------
function strValid(sValue) {
	var i;
	var sCar = new String;
	var sStr = new String;
	for (i=0; i<sValue.length; i++) {
		sCar = sValue.charAt(i);
		if (	(sCar=="'") || (sCar=="&") || (sCar=="|") || 
			(sCar=="<") || (sCar==">") || (sCar=="(") || 
			(sCar==")") || (sCar==":") || (sCar=="!") || 
			(sCar=="_") || (sCar==";") || 
			(sCar=="¤") || (sCar=="#") || (sCar=="\"") || (sCar=="%") ) {
			sStr = sStr + " ";
		} else {
			sStr = sStr + sCar;
		}
	}
	sStr = LTrim(RTrim(sStr));
	return(sStr);
}


//******************************************************************************************************************
//******************************************************************************************************************
//					GESTION DES NOMBRES
//******************************************************************************************************************
//******************************************************************************************************************


//------------------------------------------------------------------------------------------------------------------
// FormatCurrency: Returns an expression formatted as a currency 
//								 value using the currency symbol $.
//
// Parameters:
//			Expression = Expression to be formatted.
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function FormatCurrency(Expression)
{
	var iNumDecimals = 2;
	var dbInVal = Expression;
	var bNegative = false;
	var iInVal = 0;
	var strInVal
	var strWhole = "", strDec = "";
	var strTemp = "", strOut = "";
	var iLen = 0;

	if (dbInVal < 0)
	{
		bNegative = true;
		dbInVal *= -1;
	}

	dbInVal = dbInVal * Math.pow(10, iNumDecimals)
	iInVal = parseInt(dbInVal);
	if ((dbInVal - iInVal) >= .5)
	{
		iInVal++;
	}
	strInVal = iInVal + "";
	strWhole = strInVal.substring(0, (strInVal.length - iNumDecimals));
	strDec = strInVal.substring((strInVal.length - iNumDecimals), strInVal.length);
	while (strDec.length < iNumDecimals)
	{
		strDec = "0" + strDec;
	}
	iLen = strWhole.length;
	if (iLen >= 3)
	{
		while (iLen > 0)
		{
			strTemp = strWhole.substring(iLen - 3, iLen);
			if (strTemp.length == 3)
			{
				strOut = "," + strTemp + strOut;
				iLen -= 3;
			}
			else
			{
				strOut = strTemp + strOut;
				iLen = 0;
			}
		}
		if (strOut.substring(0, 1) == ",")
		{
			strWhole = strOut.substring(1, strOut.length);
		}
		else
		{
			strWhole = strOut;
		}
	}
	if (bNegative)
	{
		return "-$" + strWhole + "." + strDec;
	}
	else
	{
		return "$" + strWhole + "." + strDec;
	}
}
//------------------------------------------------------------------------------------------------------------------
// FormatNumber : Returns an expression formatted as a number.
//
// Parameters:
//			sValue		= Expression to be formatted.
//			iNbrEntier	= 
//			iNbrDecimal = 								 
//												
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function FormatNumber(sValue, iNbrEntier, iNbrDecimal) {
	var strE="";
	var strD="";
	var iPosPoint=0;
	var inE=0;
	var inD=0;
	var iLongDecimal=0;
		
	// L'entrée n'est pas un nombre valide
	if (IsNumber(sValue) == false) {
		return(null);
	}

	// C'est bien un nombre, vérifions le format
	for(var i=0; i<sValue.length; i++) {
		if (sValue.substr(i,1) == ".") {
			iPosPoint = i;
		}
	}
	if (iPosPoint > 0) {
		inE = iPosPoint;
		inD = sValue.length - iPosPoint - 1;
	} else {
		inE = sValue.length;
		inD =0;
	}
		
	// Le nombre de décimal est trop important
	if (inD > iNbrDecimal) {
		return(null);
	}
	// Le nombre de partie entière est trop important
	if (inE > iNbrEntier) {
		return(null);
	}
	
	strE = sValue.substr(0,inE);
	if (iPosPoint>0)
		strD = sValue.substr(iPosPoint+1);

	iLongDecimal=strD.length;
	for(var i=iLongDecimal; i<iNbrDecimal; i++) {
		strD = strD + "0";
	}

	if (Number(strE) < 0) {
		return(null);
	}

	if (iNbrDecimal>0)
		return(strE + "." + strD);
	else
		return(strE);
	
}
//------------------------------------------------------------------------------------------------------------------
// FormatNumber_bis: Returns an expression formatted as a number.
//
// Parameters:
//			Expression						= Expression to be formatted.
//			NumDigitsAfterDecimal = Numeric value indicating how
//															many places to the right of the
//															decimal are displayed.
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function FormatNumberBis(Expression, NumDigitsAfterDecimal)
{
	var iNumDecimals = NumDigitsAfterDecimal;
	var dbInVal = Expression;
	var bNegative = false;
	var iInVal = 0;
	var strInVal
	var strWhole = "", strDec = "";
	var strTemp = "", strOut = "";
	var iLen = 0;

	if (dbInVal < 0)
	{
		bNegative = true;
		dbInVal *= -1;
	}

	dbInVal = dbInVal * Math.pow(10, iNumDecimals)
	iInVal = parseInt(dbInVal);
	if ((dbInVal - iInVal) >= .5)
	{
		iInVal++;
	}
	strInVal = iInVal + "";
	strWhole = strInVal.substring(0, (strInVal.length - iNumDecimals));
	strDec = strInVal.substring((strInVal.length - iNumDecimals), strInVal.length);
	while (strDec.length < iNumDecimals)
	{
		strDec = "0" + strDec;
	}
	iLen = strWhole.length;
	if (iLen >= 3)
	{
		while (iLen > 0)
		{
			strTemp = strWhole.substring(iLen - 3, iLen);
			if (strTemp.length == 3)
			{
				strOut = "" + strTemp + strOut;
				iLen -= 3;
			}
			else
			{
				strOut = strTemp + strOut;
				iLen = 0;
			}
		}
		if (strOut.substring(0, 1) == ",")
		{
			strWhole = strOut.substring(1, strOut.length);
		}
		else
		{
			strWhole = strOut;
		}
	}
	if (bNegative)
	{
		return "-" + strWhole + "." + strDec;
	}
	else
	{
		return strWhole + "." + strDec;
	}
}
//------------------------------------------------------------------------------------------------------------------
// FormatNumberNeg	: 
//
// Parameters:
//			sValue		= Expression to be formatted.
//			iNbrEntier	= 
//			iNbrDecimal = 								 
//												
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function FormatNumberNeg(sValue, iNbrEntier, iNbrDecimal) {
	var strE="";
	var strD="";
	var iPosPoint=0;
	var inE=0;
	var inD=0;
	var iLongDecimal=0;
	
	// L'entrée n'est pas un nombre valide
	if (IsNumber(sValue) == false) {
		return(null);
	}

	// C'est bien un nombre, vérifions le format
	for(var i=0; i<sValue.length; i++) {
		if (sValue.substr(i,1) == ".") {
			iPosPoint = i;
		}
	}
	if (iPosPoint > 0) {
		inE = iPosPoint;
		inD = sValue.length - iPosPoint - 1;
	} else {
		inE = sValue.length;
		inD =0;
	}
		
	// Le nombre de décimal est trop important
	if (inD > iNbrDecimal) {
		return(null);
	}
	// Le nombre de partie entière est trop important
	if (inE > iNbrEntier) {
		return(null);
	}
	
	strE = sValue.substr(0,inE);
	if (iPosPoint>0)
		strD = sValue.substr(iPosPoint+1);

	iLongDecimal=strD.length;
	for(var i=iLongDecimal; i<iNbrDecimal; i++) {
		strD = strD + "0";
	}

	if (iNbrDecimal>0)
		return(strE + "." + strD);
	else
		return(strE);
	
}
//------------------------------------------------------------------------------------------------------------------
// FormatPercent: Returns an expression formatted as a 
//								percentage (multipled by 100) with a 
//								trailing % character
//
// Parameters:
//			Expression = Expression to be formatted.
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function FormatPercent(Expression, NumDigitsAfterDecimal)
{
	var iNumDecimals = NumDigitsAfterDecimal;
	var dbInVal = Expression * 100;
	var bNegative = false;
	var iInVal = 0;
	var strInVal
	var strWhole = "", strDec = "";
	var strTemp = "", strOut = "";
	var iLen = 0;

	if (dbInVal < 0)
	{
		bNegative = true;
		dbInVal *= -1;
	}

	dbInVal = dbInVal * Math.pow(10, iNumDecimals)
	iInVal = parseInt(dbInVal);
	if ((dbInVal - iInVal) >= .5)
	{
		iInVal++;
	}
	strInVal = iInVal + "";
	strWhole = strInVal.substring(0, (strInVal.length - iNumDecimals));
	strDec = strInVal.substring((strInVal.length - iNumDecimals), strInVal.length);
	while (strDec.length < iNumDecimals)
	{
		strDec = "0" + strDec;
	}
	iLen = strWhole.length;
	if (iLen >= 3)
	{
		while (iLen > 0)
		{
			strTemp = strWhole.substring(iLen - 3, iLen);
			if (strTemp.length == 3)
			{
				strOut = "," + strTemp + strOut;
				iLen -= 3;
			}
			else
			{
				strOut = strTemp + strOut;
				iLen = 0;
			}
		}
		if (strOut.substring(0, 1) == ",")
		{
			strWhole = strOut.substring(1, strOut.length);
		}
		else
		{
			strWhole = strOut;
		}
	}
	if (bNegative)
	{
		return "-" + strWhole + "." + strDec + "%";
	}
	else
	{
		return strWhole + "." + strDec + "%";
	}
}
//------------------------------------------------------------------------------------------------------------------
// Function : IsNumber
//------------------------------------------------------------------------------------------------------------------
function IsNumber(sValue) {
	return((isNaN(sValue))?false:true);
}
//------------------------------------------------------------------------------------------------------------------
// Function : MinInferieurAuMax
//------------------------------------------------------------------------------------------------------------------
function MinInferieurAuMax(sNbMin,sNbMax)
{

		if (IsNumber(sNbMin) == false || sNbMin=="" )
			return(true);
		if (IsNumber(sNbMax) == false || sNbMin=="")
			return(true);

		if (parseFloat(sNbMin)==0)
			return(true);
		
		if (parseFloat(sNbMax)==0)
			return(true);

		if (parseFloat(sNbMin)>parseFloat(sNbMax))
			return(false);
		else
			return(true);
} 
//------------------------------------------------------------------------------------------------------------------
// Sgn: Returns an Integer indicating the sign of a number. If
//			Integer is not a number the functions return false.
//
// Parameters:
//			Integer = The number argument can be any valid numeric 
//								expression.
//
// Returns: Integer 			-1 If Integer < 0
//												 0 If Integer = 0
//												 1 If Integer > 0
//										 false If Parameter IS NOT NUMERIC
//------------------------------------------------------------------------------------------------------------------
function Sgn(Integer)
{
	Number = Integer.toLowerCase();
	RefString = "0123456789-";

	if (Number.length < 1) 
		return (false);

	for (var i = 0; i < Number.length; i++) 
	{
		var ch = Number.substr(i, 1)
		var a = RefString.indexOf(ch, 0)
		if (a == -1)
			return (false);
	}
	if (Integer < 0)
		return (-1);
	else if (Integer == 0)
		return (0);
	else
		return (1);
}

function cleanTime( value )
{
	var tmp = value.split(":");
	var str = "";
	if (tmp.length != 3 || tmp[0].length == 0 || tmp[1].length == 0 || tmp[2].length == 0)
	{
		return "00:00:00";
	}else{
		tmp[0] = new Number(tmp[0]).toString();
		tmp[1] = new Number(tmp[1]).toString();
		tmp[2] = new Number(tmp[2]).toString();
		if ( tmp[0] < 10 )
		{
			tmp[0] = "0" + tmp[0];
		}
		if ( tmp[1] < 10 )
		{
			tmp[1] = "0" + tmp[1];
		}
		if ( tmp[2] < 10 )
		{
			tmp[2] = "0" + tmp[2];
		}
	}
	return tmp[0] + ":" + tmp[1] + ":" + tmp[2];
}

//******************************************************************************************************************
//******************************************************************************************************************
//					GESTION DES DATES
//******************************************************************************************************************
//******************************************************************************************************************

//------------------------------------------------------------------------------------------------------------------
// Function : checkTime
//------------------------------------------------------------------------------------------------------------------
function checkTime(sTime)
{
	var tmp = sTime.split(":");
	var str = "";
	if (tmp.length != 3 || tmp[0].length == 0 || tmp[1].length == 0 || tmp[2].length == 0)
	{
		str = getRes('checktime_tools_1');
	}else{
		if ( tmp[0] >= 0 && tmp[0] < 24 )
		{
			if ( tmp[1] >= 0 && tmp[1] < 60 )
			{
				if ( tmp[2] >= 0 && tmp[2] < 60 )
				{
					// Format correct !
				}else{
					str = getRes('checktime_tools_2');
				}
			}else{
				str = getRes('checktime_tools_3');
			}
		}else{
			str = getRes('checktime_tools_4');
		}
	}
	return str;
}
//------------------------------------------------------------------------------------------------------------------
// Function : checkDate
//------------------------------------------------------------------------------------------------------------------
function checkDate(myValue){
	//variable declarations!
	var mNames = "JanFebMarAprMayJunJulAugSepOctNovDec";
	var mValues = "312831303130313130313031";
	var alertMsg = "";
	var wrongDate = true;

	if (myValue=="") 
		return "";

	if (myValue.length<10 || myValue.length>10 ){
		return "Veuillez entrer une date au format jj/mm/aaaa !";
	}
 
	if ( (myValue.substring(2,3) != "/" ) || (myValue.substring(5,6) != "/") ) {
		return "Veuillez entrer une date au format jj/mm/aaaa !";
	}

	myDD		= parseInt(myValue.substring(0,2),10);		// extract Date
	myMM		= parseInt(myValue.substring(3,5),10);			// extract Month
	myYYYY	= parseInt(myValue.substring(6,10),10); 	// extract Year
	
	
	if ( (isNaN(myDD)) || (isNaN(myMM)) || ( isNaN(myYYYY)) ){
		return	"Veuillez entrer une date au format jj/mm/aaaa !";
		
	}


	if ( (myMM > 12) || (myMM <= 0) ){
		return "Problème dans le mois,veuillez entrer une date au format jj/mm/aaaa !";
	}

	var lastDate = 0;

	if (myMM == 2){
		if (isLeapYear(myYYYY)) {
			lastDate = 29;
		}
		else{
			lastDate = 28;
		}
	} 
	else {
		lastDate = mValues.substring((myMM-1)*2, (myMM-1)*2+2);
	}

	if ( (myDD > lastDate) || (myDD <=0) ){
		return "Problème dans le jour,veuillez entrer une date au format jj/mm/aaaa !";
	}

	return "";
}
//------------------------------------------------------------------------------------------------------------------
// Function : DateMinInferieurDateMax
//------------------------------------------------------------------------------------------------------------------
function DateMinInferieurDateMax(sDateMin,sDateMax)
{
	if (sDateMin=="" || sDateMax=="")
		return(true);
	if (checkDate(sDateMin)!="" || checkDate(sDateMax)!="" )
		return(true);
	if(MakeEnglishDate(sDateMin)>MakeEnglishDate(sDateMax))
		return(false);
	else
		return(true);


}
//------------------------------------------------------------------------------------------------------------------
// Function : FormatDate
//------------------------------------------------------------------------------------------------------------------
function FormatDate(dteValue) {
	var dte;
	var NumDay;
	var NumMonth;
	var NumYear;
	var strD;
	var strM;
	var strY;
	if(dteValue=="")
	 return "";

//	dte = MakeEnglishDate(dteValue);
	dte = dteValue;
	
	NumDay = dte.getDate();
	NumMonth = dte.getMonth() + 1;
	NumYear = dte.getFullYear();
	
	strD = "00" + NumDay;
	strD = strD.substr(strD.length-2);
	strM = "00" + NumMonth;
	strM = strM.substr(strM.length-2);
	strY = "0000" + NumYear;
	strY = strY.substr(strY.length-4);
	return(strD + "/" + strM + "/" + strY);
}
//------------------------------------------------------------------------------------------------------------------
// Function : isLeapYear
//------------------------------------------------------------------------------------------------------------------
function isLeapYear (Year) { 
	if (((Year % 4)==0) && ((Year % 100)!=0) || ((Year % 400)==0)) { 
		return (true);
	} else 
	{
	 return (false) ;
	}
}
//------------------------------------------------------------------------------------------------------------------
// Function : MakeEnglishDate
//------------------------------------------------------------------------------------------------------------------
function MakeEnglishDate(sDate)
{
	var tmp;
	var EnglishDate;
	
	tmp= sDate.split("/");
	EnglishDate= new Date(parseInt(tmp[2],10),parseInt(tmp[1],10)-1,parseInt(tmp[0],10));
	
	return EnglishDate;

}
//------------------------------------------------------------------------------------------------------------------
// Function : Now
//------------------------------------------------------------------------------------------------------------------
function Now() {
	var dte = new Date();
	return(FormatDate(dte));
}


//******************************************************************************************************************
//******************************************************************************************************************
//					GESTION DES TABLEAUX
//******************************************************************************************************************
//******************************************************************************************************************


//------------------------------------------------------------------------------------------------------------------
// Join: Returns a string created by joining a number of 
//			 substrings contained in an array.
//
// Parameters:
//			array 		= One-dimensional array containing substrings 
//									to be joined
//			Delimiter = String character used to separate the 
//									substrings in the returned string. 
//									If delimiter is a zero-length string (""), 
//									all items in the list are concatenated 
//									with no delimiters. 
//
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function Join(array, Delimiter)
{
	var temp = '';

	if (array.length == 0)
		return '';

	if (Delimiter.length == 0)
		Delimiter = ' ';

	for (var i = 0; i < array.length; i++)
	{
		temp = temp + array[i]
		if (i < array.length - 1)
			temp = temp + Delimiter;
	}
	return temp;
}
//------------------------------------------------------------------------------------------------------------------
// LBound: Returns a Long containing the smallest available 
//				 subscript for the indicated dimension of an array
//
// Parameters:
//			array = Array to verify
//
// Returns: Integer 			(-1 if Array does not contain
//														any subscript)
//------------------------------------------------------------------------------------------------------------------
function LBound(array)
{
	var i = 0;
	var temp = '';

	if (array.length == 0)
		return (-1);

	for (i = 0; i < array.length; i++)
	{
		temp = array[i]
		if (temp != null)
		{
			var temp = i;
			return temp;
		}
	}
	return (-1);
}
//------------------------------------------------------------------------------------------------------------------
// Split: Returns a zero-based, one-dimensional array containing 
//				a specified number of substrings
//
// Parameters:
//			Expression = String expression containing substrings and 
//									 delimiters. If expression is a zero-length 
//									 string(""), Split returns an empty array, 
//									 that is, an array with no elements and no 
//									 data.
//			Delimiter  = String character used to identify substring 
//									 limits. If delimiter is a zero-length 
//									 string (""), a single-element array 
//									 containing the entire expression string 
//									 is returned.
//
// Returns: String
//------------------------------------------------------------------------------------------------------------------
function Split(Expression, Delimiter)
{
	var temp = Expression;
	var a, b = 0;
	var array = new Array();

	if (Delimiter.length == 0)
	{
		array[0] = Expression;
		return (array);
	}

	if (Expression.length == '')
	{
		array[0] = Expression;
		return (array);
	}

	Delimiter = Delimiter.charAt(0);

	for (var i = 0; i < Expression.length; i++) 
	{
		a = temp.indexOf(Delimiter);
		if (a == -1)
		{
			array[i] = temp;
			break;
		}
		else
		{
			b = (b + a) + 1;
			var temp2 = temp.substring(0, a);
			array[i] = temp2;
			temp = Expression.substr(b, Expression.length - temp2.length);
		}
	}

	return (array);
}
//------------------------------------------------------------------------------------------------------------------
// UBound: Returns a Long containing the largest available 
//				 subscript for the indicated dimension of an array
//
// Parameters:
//			array = Array to verify
//
// Returns: Integer 			(-1 if Array does not contain
//														any subscript)
//------------------------------------------------------------------------------------------------------------------
function UBound(array)
{
	return (array.length - 1);
}


//******************************************************************************************************************
//******************************************************************************************************************
//					AUTRES
//******************************************************************************************************************
//******************************************************************************************************************


//------------------------------------------------------------------------------------------------------------------
// Function : SelectOptionItem
//------------------------------------------------------------------------------------------------------------------
function SelectOptionItem(oOption, sValue)
{
	var oColl = oOption.options;
	for(var i = 0; i < oColl.length; i++) {
		if (oColl[i].value == sValue) {
			oOption.selectedIndex = oColl[i].index;
		}
	}
}