/****************************************************************************************************
																																					Librairie JAVASCRIPT

	Version 1.0 (05/10/2000) :
	function getDayInTxt(pNumberDay, pLanguage)
	function convertMinToHourMin(pMin)
	function convertHourMinToMin(pHourMin)
	function getDateDay(pSeparateur, pLanguage)
	function getDateNextDay(pDate, pSeparateur, pLanguage)
	function getShortDate6(pDate)
	function isDateCorrect(pDate, pLabel)
	function checkDate(pString, pSyntax)
	function findDateMax(pDate1, pDate2)
	function isTimeCorrect(pTime, pLabel, pNbDigits)
	function findTimeMax(pTime1, pTime2)
	function isFieldTimeValid(pField, pFieldName, pFieldLengthMin, pFieldLengthMax, isFieldMandatory)
	function isFieldDateValid(pField, pFieldName, pFieldLengthMin, pFieldLengthMax, isFieldMandatory)

****************************************************************************************************/


/****************************************************************************************************
	function getDayInTxt(pNumberDay, pLanguage)
	Cette fonction renvoie le jour de la semaine en toute lettre en fonction de son numéro
	En entrée : pNumberDay = une chaine de caractères contenant un chiffre de 1 à 7 (ex: '3')
									 pLanguage = une chaine de caractères qui définit la langue à considérer. Ce paramètre est optionnel.
									 Les valeurs possibles sont :
									 	- 'us' pour l'anglais
									 	- 'fr' pour le français
									 Par contre, s'il n'est pas défini dans l'appel de la fonction, la langue appliquée par défaut sera 'us'.
	En sortie : Renvoie la correspondance du jour en fonction de son numéro (ex: 'Mercredi')

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					21/09/2000 			OLD							IE4+ et Netscape3+				Code original
		1.1						02/10/2000			OLD							IE4+ et Netscape3+				Gestion de la langue
*/
function getDayInTxt(pNumberDay, pLanguage) {
	vResult = '';
	vDays_us = new Array('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday');
	vDays_fr = new Array('Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche');

	if (typeof(pNumberDay) == 'number') {
		if ((typeof(pLanguage) == 'string') && (pLanguage == 'fr')) { // langue française
			if ((pNumberDay > 0) && (pNumberDay <= vDays_fr.length)) 
				vResult = vDays_fr[pNumberDay - 1];
		}
		else { // langue anglaise par défaut
			if ((pNumberDay > 0) && (pNumberDay <= vDays_us.length)) 
				vResult = vDays_us[pNumberDay - 1];
		}
	}
	return vResult;
}



/****************************************************************************************************
	function convertMinToHourMin(pMin)
	Cette fonction convertit une heure exprimée en minutes au format heure minute (ex: 195 -> 0315)
	En entrée : pMin = une heure exprimée en minutes (ex: 195)
	En sortie : Une chaine de caracterès représentant l'heure pMin en heures et minutes (ex : 0315)

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					02/10/2000 			OLD							IE4+ et Netscape3+				Code original
*/
function convertMinToHourMin(pMin) {
	vResult = '';

	if (typeof(pMin) == 'number') {
		var vH = parseInt(pMin / 60);
		if (isNaN(vH)) vH = 0;
		var vM = parseInt(pMin % 60);
		if (isNaN(vM)) vM = 0;
		vH_Str = vH.toString();
		vM_Str = vM.toString();
		if (vH < 10) vH_Str = '0' + vH_Str;
		if (vM < 10) vM_Str = '0' + vM_Str;
		vResult = vH_Str + vM_Str;
	}
	return vResult;
}



/****************************************************************************************************
	function convertHourMinToMin(pHourMin)
	Cette fonction convertit une heure au format heure et minute en minutes (ex: 0315 -> 195)
	En entrée : pHourMin = une heure au format HHMM
	En sortie : Un entier représentant pHourMin en minutes

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					02/10/2000 			OLD							IE4+ et Netscape3+				Code original
*/
function convertHourMinToMin(pHourMin) {
	var vResult = -1;

	if ((typeof(pHourMin) == 'string') && (pHourMin.length == 4) && (!isNaN(parseInt(pHourMin)))) {
		var vH_int = parseInt(pHourMin.charAt(0)) *10 + parseInt(pHourMin.charAt(1));
		var vM_int = parseInt(pHourMin.charAt(2)) *10 + parseInt(pHourMin.charAt(3));
		vResult = vH_int *60 + vM_int;
	}
	return vResult;
}



/****************************************************************************************************
	function getDateDay(pSeparateur, pLanguage)
	Cette fonction renvoie la date du jour sur 8 caractères : 2 pour le jour, 2 pour le mois et 4 pour l'année
	En entrée : pSeparateur = une chaine de caractères qui définit le séparateur de jour, mois et annee. Ce paramètre est optionnel.
										S'il n'est pas défini, la chaine de sortie n'aura pas de séparateur.
									 pLanguage = une chaine de caractères qui définit la langue à considérer. Ce paramètre est optionnel.
										Les valeurs possibles sont :
									 	- 'us' pour l'anglais (le format de la date sera : MMDDYYYY)
									 	- 'fr' pour le français (le format de la date sera : DDMMYYYY)
	En sortie : Une chaine de caractères représentant la date du jour formattée suivant le séparateur et la langue

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					21/09/2000 			OLD							IE4+ et Netscape3+				Code original
		1.1						02/10/2000			OLD							IE4+ et Netscape3+				Gestion de la langue		
*/
function getDateDay(pSeparateur, pLanguage) {
	var vResult = '';
	var theDay = '';
	var theMonth = '';
	var theYear = '';
	var vSeparateur = '';
	
	theDate = new Date();
	theDay = theDate.getDate();
	theMonth = theDate.getMonth() + 1;
	theYear = theDate.getYear();
	if (parseInt(theDay) < 10) theDay = '0' + theDay;
	if (parseInt(theMonth) < 10) theMonth = '0' + theMonth;
	if (parseInt(theYear) < 100) theYear = '19' + theYear;
	if (typeof(pSeparateur) == 'string') vSeparateur = pSeparateur;

	if ((typeof(pLanguage) == 'string') && (pLanguage == 'fr')) { // langue française	
		vResult = theDay + vSeparateur + theMonth + vSeparateur + theYear;
	}
	else { // langue anglaise par défaut
		vResult = theMonth + vSeparateur + theDay + vSeparateur + theYear;
	}
	return vResult;
}



/****************************************************************************************************
	function getDateNextDay(pDate, pSeparateur, pLanguage)
	Cette fonction renvoie la date du jour suivant la date définie par le paramètre d'entrée
	En entrée : pDate = une chaine de caractères représentant une date au format DDMMYYYY
									 pSeparateur = une chaine de caractères qui définit le séparateur de jour, mois et annee. Ce paramètre est optionnel.
										S'il n'est pas défini, la chaine de sortie n'aura pas de séparateur.
									 pLanguage = une chaine de caractères qui définit la langue à considérer. Ce paramètre est optionnel.
										Les valeurs possibles sont :
									 	- 'us' pour l'anglais (le format de la date sera : MMDDYYYY)
									 	- 'fr' pour le français (le format de la date sera : DDMMYYYY)
	En sortie : Une chaine de caractères représentant la date du jour suivant la date d'entrée (pDate) et formattée suivant le séparateur et la langue

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					21/09/2000 			OLD							IE4+ et Netscape3+				Code original
		1.1						02/10/2000			OLD							IE4+ et Netscape3+				Gestion de la langue		
*/
function getDateNextDay(pDate, pSeparateur, pLanguage) {
	var vResult = '';
	var vSeparateur = '';	
	
	if ((typeof(pDate) == 'string') && (pDate.length == 8)) {
		if (typeof(pSeparateur) == 'string') vSeparateur = pSeparateur;
		vJour = parseInt(pDate.charAt(0)) * 10 + parseInt(pDate.charAt(1));
		vMois = parseInt(pDate.charAt(2)) * 10 + parseInt(pDate.charAt(3)) - 1;
		vAnnee = parseInt(pDate.charAt(4) + pDate.charAt(5) + pDate.charAt(6) + pDate.charAt(7));
		vDateNextDay = new Date(vAnnee, vMois, vJour+1);
		
		if (vDateNextDay.getDate() < 10) vJourStr = '0' + vDateNextDay.getDate();
		else vJourStr = '' + vDateNextDay.getDate() + '';
		if (vDateNextDay.getMonth()+1 < 10) vMoisStr = '0' + (vDateNextDay.getMonth()+1);
		else vMoisStr = '' + (vDateNextDay.getMonth() + 1) + '';
		if (vDateNextDay.getYear() < 100) vAnneeStr = '19' + vDateNextDay.getYear();
		else vAnneeStr = '' + vDateNextDay.getYear() + '';
		
		if ((typeof(pLanguage) == 'string') && (pLanguage == 'fr')) { // langue française	
			vResult = vJourStr + vSeparateur + vMoisStr + vSeparateur + vAnneeStr;
		}
		else { // langue anglaise par défaut
			vResult = vMoisStr + vSeparateur + vJourStr + vSeparateur + vAnneeStr;
		}
	}
	return vResult;
}



/****************************************************************************************************
	function getShortDate6(pDate)
	Cette fonction renvoie la date définie sur 8 caractères par le paramètre d'entrée en 6 caractères
	En entrée : pDate = une chaine de caractères représentant une date au format DDMMYYYY
	En sortie : Une chaine de caractère représentant la date d'entrée (pDate) mais au format DDMMYY

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					21/09/2000 			OLD							IE4+ et Netscape3+				Code original
*/
function getShortDate6(pDate) {
	var vResult = '';

	if ((typeof(pDate) == 'string') && (pDate.length == 8))
		vResult = pDate.substring(0, 4) + pDate.substring(6, 8);

	return vResult;
}



/****************************************************************************************************
	function isDateCorrect(pDate, pLabel)
	Cette fonction permet de vérifier la date définie par le paramètre pDate
	En entrée : pDate = une chaine de caractères représentant une date au format DDMMYYYY
									 pLabel = une chaine de caractères correspondant au label du champ pDate
	En sortie : "true" si pDate est une date valide contenue entre le 31011970 et le 31122055 et, "false" sinon 
	(par ex: 31132000 ou 29021999 sont invalides)

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					21/09/2000 			OLD							IE4+ et Netscape3+				Code original
*/
function isDateCorrect(pDate, pLabel) {
	var vMessage 	= '';
	var vIsCorrect 	= false;
	
	if ((typeof(pDate) == 'string') && (typeof(pLabel) == 'string')) {
		var vDateMin = new Date(1970, 01, 01);
		var	vTextMin = vDateMin.getYear();
		if (vTextMin < 100) vTextMin = '19' + vTextMin;
		if (vDateMin.getMonth() < 10) vTextMin += '0' + vDateMin.getMonth(); else vTextMin += vDateMin.getMonth();
		if (vDateMin.getDate() < 10) vTextMin += '0' + vDateMin.getDate(); else vTextMin += vDateMin.getDate();
	
		var vDateMax=new Date(2056, 01, 01);
		var	vTextMax = vDateMax.getFullYear();
		if (vTextMax < 100) vTextMax = '19' + vTextMax;
		if (vDateMax.getMonth() < 10) vTextMax += '0' + vDateMax.getMonth(); else vTextMax += vDateMax.getMonth();
		if (vDateMax.getDate() < 10) vTextMax += '0' + vDateMax.getDate(); else vTextMax += vDateMax.getDate();

		if (pDate.length == 8) { // le paramètre pDate est sur 8 caractères
			// Vérification que le paramètre pDate ne contient bien que des chiffres (ce code est obligatoire pour Netscape 3)
			var isNumber = true;
			var vCpt = 0;
			while ((isNumber) && (vCpt < pDate.length)) {
				isNumber = ((pDate.charAt(vCpt) >= '0') && (pDate.charAt(vCpt) <= '9'));
				vCpt++;
			}

			if (isNumber) { // pDate est bien un nombre
				aJour = parseInt(pDate.charAt(0)) * 10 + parseInt(pDate.charAt(1));
				aMois = parseInt(pDate.charAt(2)) * 10 + parseInt(pDate.charAt(3)) - 1;
				aAnnee = parseInt(pDate.charAt(4) + pDate.charAt(5) + pDate.charAt(6) + pDate.charAt(7));

				// Vérification des bornes de la date
				var vDate = pDate.substring(4, pDate.length) + pDate.substring(2, 4) + pDate.substring(0, 2);
				if ((vDate < vTextMin) || (vDate >= vTextMax)) {
					vMessage = 'La date de ' + pLabel + ' est invalide.\nElle doit être comprise entre le 31/01/1970 et le 31/12/2055';
					vIsCorrect = false;
				}
				else {
					aDate = new Date(aAnnee, aMois, aJour);
					if (aDate.getDate() < 10) aJourStr = '0' + aDate.getDate();
					else aJourStr = '' + aDate.getDate() + '';
					if (aDate.getMonth() + 1 < 10) aMoisStr = '0' + (aDate.getMonth() + 1);
					else aMoisStr = '' + (aDate.getMonth() + 1) + '';
					if (aDate.getYear() < 100) aAnneeStr = '19' + aDate.getYear();
					else aAnneeStr = '' + aDate.getFullYear() + '';
			
					if (pDate != aJourStr + aMoisStr + aAnneeStr) {
						vMessage = 'La date de ' + pLabel + ' est invalide';
						vIsCorrect = false;
					}
					else
						vIsCorrect = true; // la date est correcte
				}
			}
			else {
				vMessage = 'La valeur de ' + pLabel + ' doit définir une date au format JJ/MM/AAAA';
				vIsCorrect = false;
			}
		}
		else 	{
			vMessage = 'La date de ' + pLabel + ' doit être sur 8 caractères';
			vIsCorrect = false;
		}
	}

	if (vMessage.length > 0) alert(vMessage);
	return vIsCorrect;
}



/****************************************************************************************************
	function checkDate(pString, pSyntax)
	Cette fonction permet de vérifier qu'une chaîne de caractères pString est bien formatée selon la grammaire définie par pSyntax
	En entrée : pString = une chaine de caractères représentant une date
									 pSyntax = une chaine de caractères définissant la syntaxe de formatage de la date
									 	Elle doit contenir 2 'J' (pour le jour), 2 'M' (pour le mois), 2 ou 4 'A' (pour l'année) et un délimiteur optionnel le '/' ou '-'
										Par ex : 'JJMMAA' ou 'MM/JJ/AAAA' ou 'AAAAMMJJ' ...
	En sortie : Une chaine de caractère vide si pString est formatée selon pSyntax et un message d'erreur sinon

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					25/09/2000 			OLD							IE4+ et Netscape3+				Code original
*/
function checkDate(pString, pSyntax) {
	var vMessage = '';

  if (typeof(pString) != 'string') return 'pString non définie'; // Date non définie
	if (typeof(pSyntax) != 'string') return 'pSyntax non définie'; // Syntaxe non définie
  if (pString.length == 0) return 'pString vide'; // Date vide
	if (pSyntax.length == 0) return 'Syntaxe de date incorrecte'; // Syntaxe de date incorrecte
  if (pString.length!=pSyntax.length) return 'Incohérence entre la date et sa syntaxe'; // Syntaxe et date incorrectes

	// Vérification de la syntaxe de date
	vSyntax = pSyntax.toUpperCase();
	var vCountJ = 0, vCountM = 0, vCountA = 0, vCountS1 = 0, vCountS2 = 0;
	for (i = 0; i < vSyntax.length; i++) {
		if (vSyntax.charAt(i) == 'J') vCountJ++;
		else
		if (vSyntax.charAt(i) == 'M') vCountM++;
		else
		if (vSyntax.charAt(i) == 'A') vCountA++;
		else
		if (vSyntax.charAt(i) == '/') vCountS1++;
		else
		if (vSyntax.charAt(i) == '-') vCountS2++;
		else {
			return 'Syntaxe de date incorrecte'; // Syntaxe de date incorrecte
		}
	}
	if ( (vCountJ !=2) || (vCountM != 2) || ((vCountA != 2) && (vCountA != 4)) 
		|| ((vCountS1 > 0) && ((vCountS2 > 0) || (vCountS1 != 2))) 
		|| ((vCountS2 > 0) && (vCountS2 != 2)) )
		return 'Syntaxe de date incorrecte'; // Syntaxe de date incorrecte
	vPosJ = vSyntax.indexOf('J');
	if (vPosJ + 1 < vSyntax.length) {
		if (vSyntax.charAt(vPosJ + 1) != 'J') return 'Syntaxe de date incorrecte'; // Syntaxe de date incorrecte
	}
	vPosM = vSyntax.indexOf('M');
	if (vPosM + 1 < vSyntax.length) {
		if (vSyntax.charAt(vPosM + 1) != 'M') return 'Syntaxe de date incorrecte'; // Syntaxe de date incorrecte
	}
	vPosA = vSyntax.indexOf('A');
	for (i = vPosA; i < vPosA + vCountA; i++) {
		if (vSyntax.charAt(i) != 'A') return 'Syntaxe de date incorrecte'; // Syntaxe de date incorrecte
	}

	var vJour = '', vMois = '', vAnnee = '';		
	for (i = 0; i < vSyntax.length; i++) {
		if ((vSyntax.charAt(i) != '/') && (vSyntax.charAt(i) != '-')) { // C'est soit J, M ou A
			if ((pString.charAt(i) < '0') || (pString.charAt(i) > '9')) return 'Date incorrecte'; // incorrecte
		}
		if (vSyntax.charAt(i) == 'J') vJour += pString.charAt(i);
		else
		if (vSyntax.charAt(i) == 'M') vMois += pString.charAt(i);
		else
		if (vSyntax.charAt(i) == 'A') vAnnee += pString.charAt(i);
	}
	return '';
	//alert('The field \'' + nomChamp + '\' must be in date format (DD/MM/YYYY).');
}



/****************************************************************************************************
	function findDateMax(pDate1, pDate2)
	Cette fonction permet de trouver la plus grande de deux dates
	En entrée : pDate1 = une chaine de caractères représentant une date au format DDMMYYYY
									 pDate2 = une chaine de caractères représentant une date au format DDMMYYYY
	En sortie : Elle retourne 1 si pDate1 est postérieure à pDate2, 2 si pDate1 est antérieure à pDate2 et 0 si elles sont identiques

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					21/09/2000 			OLD							IE4+ et Netscape3+				Code original
*/
function findDateMax(pDate1, pDate2) {
  if (typeof(pDate1) != 'string') return -1; // pDate1 non définie
	if (typeof(pDate2) != 'string') return -1; // pDate2 non définie
	if ((pDate1.length != 8) || (pDate2.length != 8)) return -1; // pDate1 ou pDate2 mal définis

	if (pDate1 == pDate2) return 0;
	else {
		aJour1 = pDate1.charAt(0) + pDate1.charAt(1);
		aMois1 = pDate1.charAt(2) + pDate1.charAt(3);
		aAnnee1 = pDate1.charAt(4) + pDate1.charAt(5) + pDate1.charAt(6) + pDate1.charAt(7);
		aDate1 = parseInt(aAnnee1 + aMois1 + aJour1) ;
		
		aJour2 = pDate2.charAt(0) + pDate2.charAt(1);
		aMois2 = pDate2.charAt(2) + pDate2.charAt(3);
		aAnnee2 = pDate2.charAt(4) + pDate2.charAt(5) + pDate2.charAt(6) + pDate2.charAt(7);
		aDate2 = parseInt(aAnnee2 + aMois2 + aJour2);

		if (aDate1 > aDate2) return 1;
		else return 2;
	}
}



/****************************************************************************************************
	function isTimeCorrect(pTime, pLabel, pNbDigits)
	Cette fonction permet de vérifier l'heure définie par le paramètre pTime
	En entrée : pTime = une chaine de caractères représentant une heure au format HHMM
									 pLabel = une chaine de caractères correspondant au label du champ pTime
									 pNbDigits = un nombre entier définissant le nombre de caractères à considérer pour la date (soit 4 soit 6)
	En sortie : "true" si pTime est une heure valide et "false" sinon (par ex: 2506 ou 0171 sont invalides)

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					22/09/2000 			OLD							IE4+ et Netscape3+				Code original
*/
function isTimeCorrect(pTime, pLabel, pNbDigits) {
	var vMessage = '';
	var vIsCorrect = false;
		
	if ((typeof(pTime) == 'string') && (typeof(pLabel) == 'string')) {

		if (typeof(pNbDigits) == 'undefined') pNbDigits = 4; // Par défaut, l'heure est sur 4 caractères
		
		if (pTime.length == pNbDigits) {
			if ((pTime.length == 4) || (pTime.length == 6)) {
				vHour = parseInt(pTime.charAt(0)) * 10 + parseInt(pTime.charAt(1));
				vMinute = parseInt(pTime.charAt(2)) * 10 + parseInt(pTime.charAt(3));
				if (pTime.length == 6) {
					vSecond = parseInt(pTime.charAt(4)) * 10 + parseInt(pTime.charAt(5));
					if (vSecond > 59) vMessage = 'L\'heure de ' + pLabel + ' est invalide.\nLes secondes doivent être comprises entre 00 et 59.';
				}
				if (vMinute > 59) vMessage = 'L\'heure de ' + pLabel + ' est invalide.\nLes minutes doivent être comprises entre 00 et 59.';
				if (vHour > 23) vMessage = 'L\'heure de ' + pLabel + ' est invalide.\nLes heures doivent être comprises entre 00 et 23.';
			}
			else vMessage = 'L\'heure de ' + pLabel + ' doit être sur 4 ou 6 caractères';
		}
		else vMessage = 'L\'heure de ' + pLabel + ' doit être sur ' + pNbDigits + ' caractères';
	}
	else vMessage = 'Les paramètres pTime et pLabel sont indéfinis';

	if (vMessage.length > 0) alert(vMessage);
	else vIsCorrect = true;
	return vIsCorrect;
}


/****************************************************************************************************
	function findTimeMax(pTime1, pTime2)
	Cette fonction permet de trouver la plus grande de deux heures
	En entrée : pTime1 = une chaine de caractères représentant une heure au format HHMMSS
									 pDate2 = une chaine de caractères représentant une heure au format HHMMSS
	En sortie : Elle retourne 1 si pTime1 est postérieure à pTime2, 2 si pTime1 est antérieure à pTime2 et 0 si elles sont identiques

		Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					22/09/2000 			OLD							IE4+ et Netscape3+				Code original
*/
function findTimeMax(pTime1, pTime2) {
	if (typeof(pTime1) != 'string') return -1; // pTime1 non définie
	if (typeof(pTime2) != 'string') return -1; // pTime2 non définie
	
	while (pTime1.length < 6) pTime1 += '0'; // ajout de 0 pour le test de comparaison
	while (pTime2.length < 6) pTime2 += '0'; // ajout de 0 pour le test de comparaison
	
	if (pTime1 == pTime2) return 0;
	else {
		/*vTime1 = new Date();
		vTime1.setHours(parseInt(pTime1.charAt(0)) * 10 + parseInt(pTime1.charAt(1)));
		vTime1.setMinutes(parseInt(pTime1.charAt(2)) * 10 + parseInt(pTime1.charAt(3)));
		vTime1.setSeconds(parseInt(pTime1.charAt(4)) * 10 + parseInt(pTime1.charAt(5)));
	
		vTime2 = new Date();
		vTime2.setHours(parseInt(pTime2.charAt(0)) * 10 + parseInt(pTime2.charAt(1)));
		vTime2.setMinutes(parseInt(pTime2.charAt(2)) * 10 + parseInt(pTime2.charAt(3)));
		vTime2.setSeconds(parseInt(pTime2.charAt(4)) * 10 + parseInt(pTime2.charAt(5)));
		
		if (vTime1 > vTime2) return 1;
		else return 2;*/
		if (pTime1 > pTime2) return 1;
		else return 2;
	}
}



/****************************************************************************************************
	function isFieldTimeValid(pField, pFieldName, pFieldLengthMin, pFieldLengthMax, isFieldMandatory)
	Cette fonction permet de vérifier que la chaine de caractères correspondant à la valeur du champ pField est correctement 
	formatée et désigne une heure au format HHMM ou HHMMSS
	En entrée : pField = le nom d'un composant HTML de type <INPUT> (ex: 'document.monForm.monChamp')
									 pFieldName = Le libellé du composant HTML défini par pField
									 pFieldLengthMin = un entier définissant la taille minimale de la valeur du champ
									 pFieldLengthMax = un entier définissant la taille maximale de la valeur du champ
									 isFieldMandatory = un booléen qui définit le caractère obligatoire ou non de la valeur du champ.
									 	S'il est à "true", le champ doit obligatoirement avoir une valeur et non si à "false"
	En sortie : "true" si la valeur du champ est correctement formatée et "false" sinon

	Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					03/10/2000 			OLD							IE4+ et Netscape3+				Code original
*/
function isFieldTimeValid(pField, pFieldName, pFieldLengthMin, pFieldLengthMax, isFieldMandatory) {
	var vFieldLength = pField.value.length;
	var vFieldValue = pField.value;
	var vIsValid = true;

	if (((pFieldLengthMin != 4) && (pFieldLengthMin != 6)) || ((pFieldLengthMax != 4) && (pFieldLengthMax != 6)) || (pFieldLengthMin != pFieldLengthMax)) {	
		alert ('La définition de la valeur mini et maxi du champ ' + pFieldName + ' est fausse');
		vIsValid = false;
	}
	else {
		// vérification que vFieldValue ne contient bien que des chiffres
		var isNumber = true;
		var vCpt = 0;
		while ((isNumber) && (vCpt < vFieldLength)) {
			isNumber = ((vFieldValue.charAt(vCpt) >= '0') && (vFieldValue.charAt(vCpt) <= '9'));
			vCpt++;
		}
		if (!isNumber) {
			alert('La saisie de ' + pFieldName + ' n\'est pas valide. Le caractère \'' + vFieldValue.charAt(vCpt - 1) + '\' est interdit.');
			vIsValid = false;
		}
		else
			if (vFieldValue.length > 0) vIsValid = isTimeCorrect(vFieldValue, pFieldName, pFieldLengthMin);
	}
	
	if (vIsValid)	{
		if (vFieldLength > 0) { 
			if (pFieldLengthMin > 0) { 
				if (vFieldLength < pFieldLengthMin) {
					alert('La taille minimum du champ ' + pFieldName + ' est de ' + pFieldLengthMin + ' caractères.'); 
					vIsValid = false; 
				} 
			}
			if (vFieldLength > pFieldLengthMax) {
				alert('La taille maximum du champ ' + pFieldName + ' est de ' + pFieldLengthMax + ' caractères.'); 
				vIsValid = false; 
			} 
		}
		else { // if (vFieldLength > 0)
			if (isFieldMandatory) {
		  	alert('Le champ ' + pFieldName + ' est obligatoire.'); 
				vIsValid = false;
			}
		}
	}
	
	if (!vIsValid) pField.focus();	

	return vIsValid;
}



/****************************************************************************************************
	function isFieldDateValid(pField, pFieldName, pFieldLengthMin, pFieldLengthMax, isFieldMandatory)
	Cette fonction permet de vérifier que la chaine de caractères correspondant à la valeur du champ pField est correctement 
	formatée et désigne une date au format DDMMYYYY
	En entrée : pField = le nom d'un composant HTML de type <INPUT> (ex: 'document.monForm.monChamp')
									 pFieldName = Le libellé du composant HTML défini par pField
									 pFieldLengthMin = un entier définissant la taille minimale de la valeur du champ
									 pFieldLengthMax = un entier définissant la taille maximale de la valeur du champ
									 isFieldMandatory = un booléen qui définit le caractère obligatoire ou non de la valeur du champ.
									 	S'il est à "true", le champ doit obligatoirement avoir une valeur et non si à "false"
	En sortie : "true" si la valeur du champ est correctement formatée et "false" sinon

	Version				Date								Auteur					Navigateurs										Description des modifications
	---------		 ----------------		-----------			--------------------------		--------------------------------------------------
		1.0 					03/10/2000 			OLD							IE4+ et Netscape3+				Code original
*/
function isFieldDateValid(pField, pFieldName, pFieldLengthMin, pFieldLengthMax, isFieldMandatory) {
	var vFieldLength = pField.value.length;
	var vFieldValue = pField.value;
	var vIsValid = true;

	if ((pFieldLengthMin != 8) && (pFieldLengthMax != 8)) {
		alert ('La définition de la valeur mini et maxi du champ ' + pFieldName + ' est fausse');
		vIsValid = false;
	}
	else {
		// vérification que vFieldValue ne contient bien que des chiffres
		var isNumber = true;
		var vCpt = 0;
		while ((isNumber) && (vCpt < vFieldLength)) {
			isNumber = ((vFieldValue.charAt(vCpt) >= '0') && (vFieldValue.charAt(vCpt) <= '9'));
			vCpt++;
		}
		if (!isNumber) {
			alert('La saisie de ' + pFieldName + ' n\'est pas valide. Le caractère \'' + vFieldValue.charAt(vCpt - 1) + '\' est interdit.');
			vIsValid = false;
		}
		else
			if (vFieldValue.length > 0) vIsValid = isDateCorrect(vFieldValue, pFieldName);
	}

	if (vIsValid)	{
		if (vFieldLength > 0) { 
			if (pFieldLengthMin > 0) { 
				if (vFieldLength < pFieldLengthMin) {
					alert('La taille minimum du champ ' + pFieldName + ' est de ' + pFieldLengthMin + ' caractères.'); 
					vIsValid = false; 
				} 
			}
			if (vFieldLength > pFieldLengthMax) {
				alert('La taille maximum du champ ' + pFieldName + ' est de ' + pFieldLengthMax + ' caractères.'); 
				vIsValid = false; 
			} 
		}
		else { // if (vFieldLength > 0)
			if (isFieldMandatory) {
		  	alert('Le champ ' + pFieldName + ' est obligatoire.'); 
				vIsValid = false;
			}
		}
	}

	if (!vIsValid) pField.focus();
	
	return vIsValid;
}

function valideDate(pValue, pStr) {
/*		
	vString = checkDate(pValue, 'JJ/MM/AAAA');
	var mm  = pValue.substring(0, 2);
	var theleft = pValue.indexOf("/") + 1;
	var theright = pValue.lastIndexOf("/");
	var jj  = pValue.substring(theleft, theright);
	var aa  = pValue.substring(theright + 1, pValue.length);
	var vDate = mm + jj + aa;
	var flag = isDateCorrect(vDate, pStr);
	return flag;
*/
	if ((pValue.length > 0) && (pValue.length == 'JJ/MM/AAAA'.length)) {
		var vMessage = checkDate(pValue, 'JJ/MM/AAAA');
		if (vMessage.length > 0) {
			alert(vMessage);
			return false;
		}
		var vDate = pValue.substring(0,2) + pValue.substring(3,5) + pValue.substring(6,10);
		if (!isDateCorrect(vDate, pStr)) return false;
		return true;
	}
	else {
			alert('Date incorrecte');
			return false;
	}
}