/* Variable applicative indiquant que la classe KaInputFieldDate a été chargée */
_KaInputFieldDate_Loaded = true;

function KaInputFieldDate() {

	// Déclaration des champs
	//this.fDateValue = null;
	this.fMinValue = null;
	this.fMaxValue = null;
	this.fFormat = null;
	this.fDateSeparator = null;
	this.fRegExpSyntax = null;
	this.fDateDay = null;
	this.fDateMonth = null;
	this.fDateYear = null;
	
	
	
	/****************************************************************************************************
		this.setMinValue = function setMinValue(pMinValue)
		Méthode d'affectation du champ fMinValue
	*/
	this.setMinValue = function setMinValue(/*Number*/pMinValue) {
		if ((typeof(pMinValue) == 'number') && (pMinValue != null))  {
			var vMinValue = parseInt(pMinValue);
			var vMaxValue = null;
			
			if ((typeof(this.fMaxValue) == 'number') && (this.fMaxValue != null))  {
				vMaxValue = parseInt(this.fMaxValue);
			}
			
			if ((vMaxValue != null) && (vMinValue > vMaxValue)) {
				this.fMinValue = this.fMaxValue;
				this.fMaxValue = vMinValue;
			}
			else
				this.fMinValue = vMinValue;
		}
	}


	/****************************************************************************************************
		this.setMaxValue = function setMaxValue(pMaxValue)
		Méthode d'affectation du champ fMaxValue
	*/
	this.setMaxValue = function setMaxValue(/*Number*/pMaxValue) {
		if ((typeof(pMaxValue) == 'number') && (pMaxValue != null))  {
			var vMaxValue = parseInt(pMaxValue);
			var vMinValue = null;
			
			if ((typeof(this.fMinValue) == 'number') && (this.fMinValue != null))  {
				vMinValue = parseInt(this.fMinValue);
			}
			
			if ((vMinValue != null) && (vMaxValue < vMinValue)) {
				this.fMaxValue = this.fMinValue;
				this.fMinValue = vMaxValue;
			}
			else
				this.fMaxValue = vMaxValue;
		}
	}

	
	/****************************************************************************************************
		this.setFormat = function setFormat(pFormat)
		Méthode d'affectation du champ fFormat
	*/
	this.setFormat = function setFormat(/*String*/pFormat) {
		var vFormat = null;
		
		if ((typeof(pFormat) == 'string') && (pFormat != null))  {
			this.fRegExpSyntax = getRegExpSyntax(pFormat);
			
			if (this.fRegExpSyntax != null) {
				this.fFormat = pFormat;
				this.fDateSeparator = getDateSeparator(this.fFormat);
				this.fCharsAllowed += this.fDateSeparator;
			}
			else
				alert('** Le format de la date est inconnu !');
		}
	}


	/**
	 *	Initialisation du jour, du mois et de l'année de la date
	 */
	this.setDate = function setDate() {
		var vDateDay = null;
		var vDateMonth = null;
		var vDateYear = null;
		
		if ((typeof(this.fValue) != 'undefined') && (typeof(this.fFormat) != 'undefined') /*&& (this.fIsDateCorrectSyntax != null)*/) {
			var vDateSeparator = this.fDateSeparator;
			var vValue = this.fValue;
			var vFormat = this.fFormat.toLowerCase();

			if ((this.fDateSeparator == null) || (this.fDateSeparator.length == 0)) {
				// Cas où on n'a pas de séparateur entre les jours, les mois et les années dans le format de la date => la date a un format fixe
				vDateSeparator = '.';
				var vChar = null;

				vChar = this.fFormat.toLowerCase().charAt(0);
				vFormat = vChar;
				vValue = this.fValue.charAt(0);
				for (var vId = 1; vId < this.fFormat.length; vId++) {
					if (vChar != this.fFormat.toLowerCase().charAt(vId)) {
						vFormat += vDateSeparator;
						vValue += vDateSeparator;
					}
					
					vChar = this.fFormat.toLowerCase().charAt(vId);
					vFormat += vChar;
					vValue += this.fValue.charAt(vId);
				}
			}
			
			var vDateArray = vValue.split(vDateSeparator);
			var vFormatArray = vFormat.split(vDateSeparator);

			for (var vId = 0; vId < vFormatArray.length; vId++) {
				if (vFormatArray[vId].indexOf('j') > -1)
					vDateDay = toInteger(vDateArray[vId]);
				else if (vFormatArray[vId].indexOf('m') > -1)
					vDateMonth = toInteger(vDateArray[vId]);
				else if (vFormatArray[vId].indexOf('a') > -1)
					vDateYear = toInteger(vDateArray[vId]);
				else
					alert('** Le format de la date n\'est défini correctement');
			}

			if (vDateDay == null) // La saisie du jour n'est pas à définir dans la date
				vDateDay = 1;
				
			if (vDateYear < 100) // 2 chiffres définissent l'année
				vDateYear = 2000 + vDateYear;
		}
		
		this.fDateDay = vDateDay;
		this.fDateMonth = vDateMonth;
		this.fDateYear = vDateYear;
		
		return ((this.fDateDay != null) && (this.fDateMonth != null) && (this.fDateYear != null));
	}
	

	/**
	 *	Initialisation du jour
	 */
	this.setDateDay = function setDateDay() {
		var vDateDay = null;
		
		if ((typeof(this.fValue) != 'undefined') && (typeof(this.fFormat) != 'undefined') /*&& (this.fIsDateCorrectSyntax != null)*/) {
			var vPosDayDigit1 = -1;
			var vPosDayDigit2 = -1;
			
			vPosDayDigit1 = this.fFormat.toLowerCase().indexOf('j');
			if (vPosDayDigit1 > -1) {
				var vDigitDay1 = this.fValue.charAt(vPosDayDigit1);
				vDateDay = parseInt(vDigitDay1);
				
				vPosDayDigit2 = this.fFormat.toLowerCase().indexOf('j', vPosDayDigit1 + 1);
				if (vPosDayDigit2 > -1) {
					var vDigitDay2 = this.fValue.charAt(vPosDayDigit2);
					vDateDay = 10 * vDateDay + parseInt(vDigitDay2);
				}
			}
			else {
				// La saisie du jour n'est pas à définir dans la date
				vDateDay = 1;
			}
		}

		this.fDateDay = vDateDay;
		
		return (this.fDateDay != null);
	}


	/**
	 *	Initialisation du mois
	 */
	this.setDateMonth = function setDateMonth() {
		var vDateMonth = null;
		
		if ((typeof(this.fValue) != 'undefined') && (typeof(this.fFormat) != 'undefined') /*&& (this.fIsDateCorrectSyntax != null)*/) {
			var vPosMonthDigit1 = -1;
			var vPosMonthDigit2 = -1;
			
			vPosMonthDigit1 = this.fFormat.toLowerCase().indexOf('m');
			if (vPosMonthDigit1 > -1) {
				var vDigitMonth1 = this.fValue.charAt(vPosMonthDigit1);
				vDateMonth = parseInt(vDigitMonth1);
				
				vPosMonthDigit2 = this.fFormat.toLowerCase().indexOf('m', vPosMonthDigit1 + 1);
				if (vPosMonthDigit2 > -1) {
					var vDigitMonth2 = this.fValue.charAt(vPosMonthDigit2);
					vDateMonth =  10 * vDateMonth + parseInt(vDigitMonth2);
				}
			}
			/* Dans le cas où la saisie du mois deviendrait optionnel
			else {
				// Le mois n'est pas à définir dans la date
				vDateMonth = 1;
			}
			*/
		}

		this.fDateMonth = vDateMonth;

		return (this.fDateMonth != null);
	}


	/**
	 *	Initialisation de l'année
	 */
	this.setDateYear = function setDateYear() {
		var vDateYear = null;
		
		if ((typeof(this.fValue) != 'undefined') && (typeof(this.fFormat) != 'undefined') /*&& (this.fIsDateCorrectSyntax != null)*/) {
			var vPosYearDigit1 = -1;
			var vPosYearDigit2 = -1;
			var vPosYearDigit3 = -1;
			var vPosYearDigit4 = -1;
			
			vPosYearDigit1 = this.fFormat.toLowerCase().indexOf('a');
			if (vPosYearDigit1 > -1) {
				var vDigitYear1 = this.fValue.charAt(vPosYearDigit1);
				
				vPosYearDigit2 = this.fFormat.toLowerCase().indexOf('a', vPosYearDigit1 + 1);
				if (vPosYearDigit2 > -1) {
					var vDigitYear2 = this.fValue.charAt(vPosYearDigit2);
					
					vPosYearDigit3 = this.fFormat.toLowerCase().indexOf('a', vPosYearDigit2 + 1);
					if (vPosYearDigit3 > -1) {
						var vDigitYear3 = this.fValue.charAt(vPosYearDigit3);
						
						vPosYearDigit4 = this.fFormat.toLowerCase().indexOf('a', vPosYearDigit3 + 1);
						if (vPosYearDigit4 > -1) {
							var vDigitYear4 = this.fValue.charAt(vPosYearDigit4);
						}
					}

					if ((vDigitYear3 != '') && (vDigitYear4 != '')) {
						// 4 chiffres définissent l'année
						vDateYear = parseInt(1000 * vDigitYear1) + parseInt(100 * vDigitYear2) + parseInt(10 * vDigitYear3) + parseInt(vDigitYear4);
					}
					else {
						// 2 chiffres définissent l'année
						vDateYear = 2000 + (10 * parseInt(vDigitYear1)) + parseInt(vDigitYear2);
					}
				}
			}
		}
		this.fDateYear = vDateYear;
		
		return (this.fDateYear != null);
	}


	/****************************************************************************************************
		function getDateSeparator(pFormat)
		Fonction qui renvoie le caractère de séparation de la date correspondant à la syntaxe pFormat
		-> utilisée par la méthode setFormat()
		En entrée :
			pFormat = la syntaxe de la date
		En sortie : 
			Le caractère de séparation de la date correspondant à la syntaxe de la date
	*/
	function getDateSeparator(/*String*/pFormat) {
		var vDateSeparator = null;
	
		if ((typeof(pFormat) != 'undefined') && (pFormat != null) && (pFormat.length > 0)) {
			var vNum = 0;
			
			while ((vDateSeparator == null) && (vNum < gDateFormatSeparator.length)) {
				if (pFormat.indexOf(gDateFormatSeparator[vNum]) > -1)
					vDateSeparator = gDateFormatSeparator[vNum];
				vNum++;
			}
			if (vDateSeparator == null)
				vDateSeparator = '';
		}
		
		return vDateSeparator;
	}
	
	
	/****************************************************************************************************
		function getRegExpSyntax(pFormat)
		Fonction qui renvoie l'expression régulière correspondante à la syntaxe pFormat
		-> utilisée par la méthode setFormat()
		En entrée :
			pFormat = la syntaxe de la date
		En sortie : 
			L'expression régulière correspondante à la syntaxe de la date
	*/
	function getRegExpSyntax(/*String*/pFormat) {
		var vRegExpSyntax = null;
	
		if ((typeof(pFormat) != 'undefined') && (pFormat != null) && (pFormat.length > 0)) {
			var vMappingDateSyntaxRegexp = new MappingDateSyntaxRegexp();
	
			if (vMappingDateSyntaxRegexp != null) {
				var vPattern = vMappingDateSyntaxRegexp.getRegexp(pFormat);
				//vRegExpSyntax = new RegExp(vPattern);
				/* MODIFICATION ERE LE 07/03/2005 */
				vRegExpSyntax = vPattern;
			}
		}
		
		return vRegExpSyntax;
	}


	// Initialisation de l'objet KaInputFieldDate
	this.init(arguments);
}

if (_KaInputField_Loaded) {
	/* Héritage de l'objet KaInputField */
	KaInputFieldDate.prototype = new KaInputField();
	//KaInputFieldDate.prototype.constructor = KaInputFieldDate;
	KaInputFieldDate.superclass = KaInputField.prototype;
}
else
	alert('** KaInputFieldDate : La classe KaInputField n\'est pas chargée !');


/*
	Constructeur de la classe KaInputFieldDate
*/
KaInputFieldDate.prototype.init = function(/*Array*/pArguments) {
	// Appel à la méthode de la super classe
	//KaInputFieldDate.superclass.init.call(this, pArguments);
	KaInputFieldDate_init(this, pArguments);
}


/*
	Méthode de DEBUG
*/
KaInputFieldDate.prototype.debug = function() {
	// Appel à la méthode de la super classe
	//KaInputFieldDate.superclass.debug.call(this);
	KaInputFieldDate_debug(this);
}


/*
	Méthode de vérification du champ
*/
KaInputFieldDate.prototype.check = function() {
	// Appel à la méthode de la super classe
	//var vCheckOK = KaInputFieldDate.superclass.check.call(this);
	var vCheckOK = KaInputFieldDate_check(this);
	
	return vCheckOK;
}


/**
 *	Méthode de vérification syntaxique de la date fValue à l'aide de l'expression régulière correspondante
 */
KaInputFieldDate.prototype.isDateCorrectSyntax = function() {
	var vIsDateCorrectSyntax = false;

	if ((this.fRegExpSyntax != null) && (this.fValue != null))
		//vIsDateCorrectSyntax = this.fRegExpSyntax.test(this.fValue);
		/* MODIFICATION DE ERE LE 07/03/2005 */
		vIsDateCorrectSyntax = new RegExp(this.fRegExpSyntax).test(this.fValue);
		//this.fIsDateCorrectSyntax = vIsDateCorrectSyntax;

	return vIsDateCorrectSyntax;
}


function getNbDaysInMonth(/*Number*/pMonth) {
	var NbDaysInMonth = null;
	var DAYS_IN_MONTH = new Array(12);
	DAYS_IN_MONTH[1] = 31;
	DAYS_IN_MONTH[2] = 29;
	DAYS_IN_MONTH[3] = 31;
	DAYS_IN_MONTH[4] = 30;
	DAYS_IN_MONTH[5] = 31;
	DAYS_IN_MONTH[6] = 30;
	DAYS_IN_MONTH[7] = 31;
	DAYS_IN_MONTH[8] = 31;
	DAYS_IN_MONTH[9] = 30;
	DAYS_IN_MONTH[10] = 31;
	DAYS_IN_MONTH[11] = 30;
	DAYS_IN_MONTH[12] = 31;
	
	if ((pMonth > 0) && (pMonth < 13))
		NbDaysInMonth = DAYS_IN_MONTH[pMonth];
		
	return NbDaysInMonth;
}


/**
 *	Méthode de vérification lexicale de la date fValue
 */
KaInputFieldDate.prototype.isValidDate = function() {
	// Le jour, mois et année sont syntaxiquement correctes mais, est-ce pour autant un jour valide ?
	var vIsDayCorrect	= false;
	var vIsMonthCorrect	= false;
	var vIsYearCorrect	= false;
	
	// Vérification de la validité du jour
	if (this.fDateDay != null) {
		var vDateDayInt = parseInt(this.fDateDay);
		vIsDayCorrect	= (vDateDayInt > 0 && vDateDayInt < 32);
	}

	// Vérification de la validité du mois
	if (this.fDateMonth != null) {
		var vDateMonthInt = parseInt(this.fDateMonth);
		vIsMonthCorrect	= (vDateMonthInt > 0 && vDateMonthInt < 13);
	}

	// Vérification de la validité de l'année
	if ((this.fDateYear != null) && (vIsDayCorrect) && (vIsMonthCorrect)) {
		var vDateYearInt = parseInt(this.fDateYear);

		// Calcul du nombre de jours pour le mois
		var vNbDaysInMonth = getNbDaysInMonth(vDateMonthInt);

		if (vDateMonthInt == 2) {
			// Cas particulier : mois de Février
			// Ce mois a 29 jours pour les années divisibles par 4 sauf pour les siècles qui ne sont pas divisibles par 400
    	var vNbDaysInMonth = ((vDateYearInt % 4 == 0) && (!(vDateYearInt % 100 == 0) || (vDateYearInt % 400 == 0))) ? 29 : 28;
		}
		
		vIsYearCorrect = (vDateDayInt <= vNbDaysInMonth);
	}
	
	//alert(vIsDayCorrect + ':' + vIsMonthCorrect + ':' + vIsYearCorrect);
	
	return ((vIsDayCorrect) && (vIsMonthCorrect) && (vIsYearCorrect));
}



/****************************************************************************************************
	function checkMinValue(pMinValue, pValue)
	Fonction de vérification de la borne minimale
	-> utilisée par la méthode check()
	En entrée :
		pMinValue = la borne minimale
		pValue = La valeur à tester
	En sortie : 
		true si la valeur est supérieure ou égale à la borne minimale et false sinon
*/
function checkMinValue(/*Number*/pMinValue, /*Number*/pValue) {
	if ((pMinValue != null) && (pValue != null)) {
		if (pValue >= pMinValue)
			return true;
		else 
			return false;
	}
	return true;
}


/****************************************************************************************************
	function checkMaxValue(pMaxValue, pValue)
	Fonction de vérification de la borne maximale
	-> utilisée par la méthode check()
	En entrée :
		pMaxValue = la borne maximale
		pValue = La valeur à tester
	En sortie : 
		true si la valeur est inférieure ou égale à la borne maximale et false sinon
*/
function checkMaxValue(/*Number*/pMaxValue, /*Number*/pValue) {
	if ((pMaxValue != null) && (pValue != null)) {
		if (pValue <= pMaxValue)
			return true;
		else 
			return false;
	}
	return true;
}


/****************************************************************************************************
	function toInteger(pString)
	Fonction qui convertit une chaine de caractères en un type entier.
	Equivalent à la fonction Javascript parseInt() sauf lorsque pString commence par un zéro.
	En entrée :
		pString = la chaine de caractères à convertir en un type entier
	En sortie : 
		La valeur entière
*/
function toInteger(/*String*/pString) {
	var vInteger = null;
	var vUnit = 1;

	if (!isNaN(pString))
		for (var vId = pString.length - 1; vId >= 0; vId--) {
			vInteger += parseInt(vUnit * parseInt(pString.charAt(vId)));
			vUnit *= 10;
		}
		
	return vInteger;
}


/****************************************************************************
 * Ensemble des formats de Date gérés
 *

var gManagedDateFormat = new Array();
/* Format FR *
var vId = 0;
gManagedDateFormat[vId++] = 'JJMMAAAA';
gManagedDateFormat[vId++] = 'JJMMAA';
gManagedDateFormat[vId++] = 'JJ/MM/AAAA';
gManagedDateFormat[vId++] = 'jJ/mM/aaAA';
gManagedDateFormat[vId++] = 'JJ/MM/AA';
gManagedDateFormat[vId++] = 'jJ/mM/AA';
gManagedDateFormat[vId++] = 'JJ-MM-AAAA';
gManagedDateFormat[vId++] = 'jJ-mM-aaAA';
gManagedDateFormat[vId++] = 'JJ-MM-AA';
gManagedDateFormat[vId++] = 'jJ-mM-AA';

gManagedDateFormat[vId++] = 'MMAAAA';
gManagedDateFormat[vId++] = 'MMAA';
gManagedDateFormat[vId++] = 'MM/AAAA';
gManagedDateFormat[vId++] = 'mM/aaAA';
gManagedDateFormat[vId++] = 'MM/AA';
gManagedDateFormat[vId++] = 'mM/AA';
gManagedDateFormat[vId++] = 'MM-AAAA';
gManagedDateFormat[vId++] = 'mM-aaAA';
gManagedDateFormat[vId++] = 'MM-AA';
gManagedDateFormat[vId++] = 'mM-AA';

/* Format US *
var vId = 100;
gManagedDateFormat[vId++] = 'MMJJAAAA';
gManagedDateFormat[vId++] = 'MMJJAA';
gManagedDateFormat[vId++] = 'MM/JJ/AAAA';
gManagedDateFormat[vId++] = 'mM/jJ/aaAA';
gManagedDateFormat[vId++] = 'MM/JJ/AA';
gManagedDateFormat[vId++] = 'mM/jJ/AA';
gManagedDateFormat[vId++] = 'MM-JJ-AAAA';
gManagedDateFormat[vId++] = 'mM-jJ-aaAA';
gManagedDateFormat[vId++] = 'MM-JJ-AA';
gManagedDateFormat[vId++] = 'mM-jJ-AA';

/* Idem que pour le Format FR
gManagedDateFormat[vId++] = 'MMAAAA';
gManagedDateFormat[vId++] = 'MMAA';
gManagedDateFormat[vId++] = 'MM/AAAA';
gManagedDateFormat[vId++] = 'mM/aaAA';
gManagedDateFormat[vId++] = 'MM/AA';
gManagedDateFormat[vId++] = 'mM/AA';
gManagedDateFormat[vId++] = 'MM-AAAA';
gManagedDateFormat[vId++] = 'mM-aaAA';
gManagedDateFormat[vId++] = 'MM-AA';
gManagedDateFormat[vId++] = 'mM-AA';*

/* Format ISO *
var vId = 200;
gManagedDateFormat[vId++] = 'AAAAMMJJ';
gManagedDateFormat[vId++] = 'AAMMJJ';
gManagedDateFormat[vId++] = 'AAAA/MM/JJ';
gManagedDateFormat[vId++] = 'aaAA/mM/jJ';
gManagedDateFormat[vId++] = 'AA/MM/JJ';
gManagedDateFormat[vId++] = 'AA/mM/jJ';
gManagedDateFormat[vId++] = 'AAAA-MM-JJ';
gManagedDateFormat[vId++] = 'aaAA-mM-jJ';
gManagedDateFormat[vId++] = 'AA-MM-JJ';
gManagedDateFormat[vId++] = 'AA-mM-jJ';

gManagedDateFormat[vId++] = 'AAAAMM';
gManagedDateFormat[vId++] = 'AAMM';
gManagedDateFormat[vId++] = 'AAAA/MM';
gManagedDateFormat[vId++] = 'aaAA/mM';
gManagedDateFormat[vId++] = 'AA/MM';
gManagedDateFormat[vId++] = 'AA/mM';
gManagedDateFormat[vId++] = 'AAAA-MM';
gManagedDateFormat[vId++] = 'aaAA-mM';
gManagedDateFormat[vId++] = 'AA-MM';
gManagedDateFormat[vId++] = 'AA-mM';
*/

/****************************************************************************
 * Ensemble des caractères séparateur de Date gérés
 */
var gDateFormatSeparator = new Array();
var vId = 0;
gDateFormatSeparator[vId++] = '/';
gDateFormatSeparator[vId++] = '-';


/* TODO
	Définition des pattern définissant les différents formats de date gérés par la librairie
	Remarque : 
		- un caractère en majuscule dans un pattern indique son caractère obligatoire
		- un caractère en minuscule dans un pattern indique son caractère optionnel
*/
function MappingDateSyntaxRegexp() {

	var vId = 0;
	this.fSyntaxRegexp = new Array();
	
	/* Format FR */
	this.fSyntaxRegexp[vId++] = ['JJMMAAAA', '^[0-9]{8}$'];
	this.fSyntaxRegexp[vId++] = ['JJMMAA', '^[0-9]{6}$'];
	this.fSyntaxRegexp[vId++] = ['JJ/MM/AAAA', '^[0-9]{2}/[0-9]{2}/[0-9]{4}$'];
	this.fSyntaxRegexp[vId++] = ['jJ/mM/aaAA', '^[0-9]?[0-9]/[0-9]?[0-9]/([0-9]{2})?[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['JJ/MM/AA', '^[0-9]{2}/[0-9]{2}/[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['jJ/mM/AA', '^[0-9]?[0-9]/[0-9]?[0-9]/[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['JJ-MM-AAAA', '^[0-9]{2}-[0-9]{2}-[0-9]{4}$'];
	this.fSyntaxRegexp[vId++] = ['jJ-mM-aaAA', '^[0-9]?[0-9]-[0-9]?[0-9]-([0-9]{2})?[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['JJ-MM-AA', '^[0-9]{2}-[0-9]{2}-[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['jJ-mM-AA', '^[0-9]?[0-9]-[0-9]?[0-9]-[0-9]{2}$'];
	
	this.fSyntaxRegexp[vId++] = ['MMAAAA', '^[0-9]{6}$'];
	this.fSyntaxRegexp[vId++] = ['MMAA', '^[0-9]{4}$'];
	this.fSyntaxRegexp[vId++] = ['MM/AAAA', '^[0-9]{2}/[0-9]{4}$'];
	this.fSyntaxRegexp[vId++] = ['mM/aaAA', '^[0-9]?[0-9]/([0-9]{2})?[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['MM/AA', '^[0-9]{2}/[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['mM/AA', '^[0-9]?[0-9]/[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['MM-AAAA', '^[0-9]{2}-[0-9]{4}$'];
	this.fSyntaxRegexp[vId++] = ['mM-aaAA', '^[0-9]?[0-9]-([0-9]{2})?[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['MM-AA', '^[0-9]{2}-[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['mM-AA', '^[0-9]?[0-9]-[0-9]{2}$'];

	/* Format US */
	this.fSyntaxRegexp[vId++] = ['MMJJAAAA', '^[0-9]{8}$'];
	this.fSyntaxRegexp[vId++] = ['MMJJAA', '^[0-9]{6}$'];
	this.fSyntaxRegexp[vId++] = ['MM/JJ/AAAA', '^[0-9]{2}/[0-9]{2}/[0-9]{4}$'];
	this.fSyntaxRegexp[vId++] = ['mM/jJ/aaAA', '^[0-9]?[0-9]/[0-9]?[0-9]/([0-9]{2})?[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['MM/JJ/AA', '^[0-9]{2}/[0-9]{2}/[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['mM/jJ/AA', '^[0-9]?[0-9]/[0-9]?[0-9]/[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['MM-JJ-AAAA', '^[0-9]{2}-[0-9]{2}-[0-9]{4}$'];
	this.fSyntaxRegexp[vId++] = ['mM-jJ-aaAA', '^[0-9]?[0-9]-[0-9]?[0-9]-([0-9]{2})?[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['MM-JJ-AA', '^[0-9]{2}-[0-9]{2}-[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['mM-jJ-AA', '^[0-9]?[0-9]-[0-9]?[0-9]-[0-9]{2}$'];

	/* Format ISO */
	this.fSyntaxRegexp[vId++] = ['AAAAMMJJ', '^[0-9]{8}$'];
	this.fSyntaxRegexp[vId++] = ['AAMMJJ', '^[0-9]{6}$'];
	this.fSyntaxRegexp[vId++] = ['AAAA/MM/JJ', '^[0-9]{4}/[0-9]{2}/[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['aaAA/mM/jJ', '^([0-9]{2})?[0-9]{2}/[0-9]?[0-9]/[0-9]?[0-9]$'];
	this.fSyntaxRegexp[vId++] = ['AA/MM/JJ', '^[0-9]{2}/[0-9]{2}/[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['AA/mM/jJ', '^[0-9]{2}/[0-9]?[0-9]/[0-9]?[0-9]$'];
	this.fSyntaxRegexp[vId++] = ['AAAA-MM-JJ', '^[0-9]{4}-[0-9]{2}-[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['aaAA-mM-jJ', '^([0-9]{2})?[0-9]{2}-[0-9]?[0-9]-[0-9]?[0-9]$'];
	this.fSyntaxRegexp[vId++] = ['AA-MM-JJ', '^[0-9]{2}-[0-9]{2}-[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['AA-mM-jJ', '^[0-9]{2}-[0-9]?[0-9]-[0-9]?[0-9]$'];

	this.fSyntaxRegexp[vId++] = ['AAAAMM', '^[0-9]{6}$'];
	this.fSyntaxRegexp[vId++] = ['AAMM', '^[0-9]{4}$'];
	this.fSyntaxRegexp[vId++] = ['AAAA/MM', '^[0-9]{4}/[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['aaAA/mM', '^([0-9]{2})?[0-9]{2}/[0-9]?[0-9]$'];
	this.fSyntaxRegexp[vId++] = ['AA/MM', '^[0-9]{2}/[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['AA/mM', '^[0-9]{2}/[0-9]?[0-9]$'];
	this.fSyntaxRegexp[vId++] = ['AAAA-MM', '^[0-9]{4}-[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['aaAA-mM', '^([0-9]{2})?[0-9]{2}-[0-9]?[0-9]$'];
	this.fSyntaxRegexp[vId++] = ['AA-MM', '^[0-9]{2}-[0-9]{2}$'];
	this.fSyntaxRegexp[vId++] = ['AA-mM', '^[0-9]{2}-[0-9]?[0-9]$'];

	// Héritage de la méthode getRegexp() de la classe MappingSyntaxRegexp
	this.getRegexp = new MappingSyntaxRegexp().getRegexp;
}


function MappingSyntaxRegexp() {

	this.getRegexp = function getRegexp(pSyntax) {
		var vRegexp = null;
		var vSyntaxRegexpLength = this.fSyntaxRegexp.length;
		
		if ((typeof(pSyntax) != 'undefined') && (pSyntax != '') && (vSyntaxRegexpLength > 0)) {
			var vCount = 0;
			var vFound = false;

			while ((!vFound) && (vCount < vSyntaxRegexpLength)) {
				if (this.fSyntaxRegexp[vCount][0] == pSyntax) {
					vRegexp = this.fSyntaxRegexp[vCount][1];
					vFound = true;
				}
				vCount++;
			}
		}

		return vRegexp;
	}
}



/****************************************************************************************************
	function KaInputFieldDate_init(pKaInputFieldDate, pArguments)
	Fonction d'inititialisation de l'object pKaInputFieldDate avec les paramètres pArguments
	-> utilisée par la méthode KaInputFieldDate.prototype.init()
	En entrée :
		pKaInputFieldDate = L'objet de type KaInputFieldDate à initialiser
		pArguments = Les paramètres pour initialisation
*/
function 	KaInputFieldDate_init(/*KaInputFieldDate*/pKaInputFieldDate, /*Array*/pArguments) {
	// Appel à la fonction de la super classe
	KaInputField_init(pKaInputFieldDate, pArguments);
	
	// Initialisation des caractères autorisés
	pKaInputFieldDate.fCharsAllowed = DIGIT;
}


/****************************************************************************************************
	function KaInputFieldDate_debug(pKaInputFieldDate)
	Fonction de debug qui affiche les champs et leurs valeurs de l'object pKaInputFieldDate 
	-> utilisée par la méthode KaInputFieldDate.prototype.debug()
	En entrée :
		pKaInputFieldDate = L'objet de type KaInputFieldDate à initialiser
*/
function KaInputFieldDate_debug(/*KaInputFieldDate*/pKaInputFieldDate) {
	// Appel à la fonction de la super classe
	KaInputField_debug(pKaInputFieldDate);
	
	var vMessage = '';
	//vMessage += 'DateValue=' + this.fDateValue + LF;
	vMessage += 'MinValue=' + this.fMinValue + LF;
	vMessage += 'MaxValue=' + this.fMaxValue + LF;
	vMessage += 'Format=' + this.fFormat + LF;
	vMessage += 'DateSeparator=' + this.fDateSeparator + LF;
	vMessage += 'RegExpSyntax=' + this.fRegExpSyntax + LF;
	vMessage += 'DateDay=' + this.fDateDay + LF;
	vMessage += 'DateMonth=' + this.fDateMonth + LF;
	vMessage += 'DateYear=' + this.fDateYear + LF;

	alert(vMessage);
}


/****************************************************************************************************
	function KaInputFieldDate_check(pKaInputFieldDate)
	Fonction de vérification de la valeur fValue de l'object pKaInputFieldDate 
	-> utilisée par la méthode KaInputFieldDate.prototype.check()
	En entrée :
		pKaInputFieldDate = L'objet de type KaInputFieldDate à vérifier
*/
function KaInputFieldDate_check(/*KaInputFieldDate*/pKaInputFieldDate) {
	// Appel à la fonction de la super classe	
	var vCheckOK = KaInputField_check(pKaInputFieldDate);
	
	if ((vCheckOK) && (!pKaInputFieldDate.isDateCorrectSyntax())) {
		// Vérification syntaxique de la date fValue suivant l'expression régulière correspondante
		vCheckOK = false;
		pKaInputFieldDate.alertMessage('isDateCorrectSyntax_0', LOCALE);
	}

	if ((vCheckOK) && (!pKaInputFieldDate.setDate())) {
		// Vérification et Initialisation de la date
		vCheckOK = false;
		pKaInputFieldDate.alertMessage('setDate_0', LOCALE);
	}
	
	if ((vCheckOK) && (!pKaInputFieldDate.isValidDate())) {
		// Vérification de la validité de la date
		vCheckOK = false;
		pKaInputFieldDate.alertMessage('isValidDate_0', LOCALE);
	}

	if (!vCheckOK)
		pKaInputFieldDate.fComponent.focus();

	return vCheckOK;
}