//* FILE **********************************************************************
//*                                                                          **
//* NAME: inputTextWithOnChange.h                                            **
//*                                                                          **
//* GOAL: Print a INPUT TEXT Form element, with data consistency check       **
//*       done by fCheckInputType, which needs FormChek.js to work           **
//*       Don't forget to include FormChek.js before inputTextWithOnChange   **
//*                                                                          **
//*       Checked types:                                                     **
//*       number, positiveNumber, notNullInt, int, positiveInt, year         **
//*       dateMM/DD/YYYY, percent, quarter, positive1decimalFloat, stEmail   **
//*       -> other types are assumed to be custom regular expression         **
//*                                                                          **
//*****************************************************************************
//*                                                                          **
//* MODIFICATIONS:                                                           **
//*                                                                          **
//* Version  Date         Author  Comment                                    **
//*                                                                          **
//* 1.0         Dec 1999  MV      Original version                           **
//* 1.01     11 Feb 2000  MV      Add positive1decimalFloat type             **
//*                               and default to regExp                      **
//*                               piFunctionCall now needs "top." prefixe    **
//* 1.02     15 Feb 2000  MV      piFunctionCall optionnal parameter         **
//* 1.03     11 Oct 2000  MV      fInputTextWithOnChange piDisplayZeroValue  **
//* 1.04     27 Feb 2001  MV      Added positiveNotNullInt                   **
//* 1.05     27 Nov 2001  MV      fInputTextWithOnChange piNoScreenModif     **
//* 1.06     28 Nov 2001  MV      Debug: use fFilterStringQuot               **
//* 1.07     19 Feb 2002  MV      Added stEmail type                         **
//* 1.08     02 Jul 2002  MV      years must be within [1970 - 2099]         **
//* 1.2      05 Dec 2002  MV      Added fInputPcsDate and dateDDMMMYYYY      **
//* 1.3      21 Jan 2003  MV      Add fCheckRollback, fSetInputTextValue     **
//* 1.31     21 Feb 2003  MV      fSetInputTextValue launch onChange code    **
//*                                                                          **
//* FILE **********************************************************************

//*************
//* CONSTANTS *
//*************
var reDate = /^\d\d\/\d\d\/\d\d\d\d$/;
var reDateUS = /^\d\d\/\d\d\/\d\d\d\d$/;
var reSiren = /^(\d){9}$/;
var reSiret = /^(\d){14}$/;
var reCnuf = /^(\d){5,8}$/;

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: isDateValid                                                        **
//* GOAL: renvoie true si (year, month, day) forme une date valide           **
//*                                                                          **
//***************************************************************** FUNCTION **
function isDateValid(year, month, day)
{
  if (! isDate(year, month, day))
  {
    return false;
  }
  else
  {
    // year in [1900 - 2099]
    if (year < 1900 || year > 2099)
    {
      alert('Année invalide : "' + year + '". L\'année doit être comprise entre [1900 - 2099].');
      return false;
    }
  }
  return true;

} // isDateValid

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: fConvertJJMMAAAAToDate                                             **
//* GOAL: Converti la chaine date (Ex: 25/02/1974) et renvoie un objet Date  **
//*                                                                          **
//***************************************************************** FUNCTION **
function fConvertJJMMAAAAToDate(piDateText)
{
  if (piDateText && piDateText != '')
  {
    day =   piDateText.slice(0,2);
    month = piDateText.slice(3,5);  
    year =  piDateText.slice(6,10);

    if (isDateValid(year, month, day))
      return new Date(year, month-1, day);
    else
      alert('Date invalide: "' + piDateText + '".');
  }
} // fConvertJJMMAAAAToDate

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: fCheckInputType                                                    **
//* GOAL: checks that piInputField is from piType type. Warns user if not.   **
//*       piAlertString is the optionnal warn message that is printed.       **
//*       piGravite: 'ERREUR' (par défaut) efface le contenu si invalide     **
//*                  'WARNING' warning mais n'efface pas le contenu          **
//*                  'DESACTIVE'  ne fait pas du tout le check               **
//*                                                                          **
//***************************************************************** FUNCTION **
function fCheckInputType(piInputField, piType, piAlertString, piGravite)
{
  var alertString=''; // Optional warning string
	var gravite = 'ERREUR';

  if (piAlertString)
    alertString = piAlertString;
  if (piGravite)
    gravite = piGravite;

	if (gravite == 'DESACTIVE')
		return true;

  switch (piType)
  {
    case '' :
      break;

    case 'notnullstr':
	if (piInputField.value=='')
	{
		alert('Vous devez entrer une valeur : '+ piInputField.value + alertString);
		piInputField.focus();
		return false;
	}
	break;

    case 'number' :
      if (piInputField.value.length)
	    {
        var fv = parseFloat(piInputField.value, 10);
        if (isNaN(fv))
	      {
          alert('Vous devez entrer une nombre dans ce champ et utiliser le \'.\' pour les nombres à virgule: "'+ piInputField.value + '".' + alertString);
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
						piInputField.focus();
					}
          return false;
        }
        else
        {
          if (piInputField.value != fv)
          {
            alert('Vous devez utiliser le \'.\' pour les nombres à virgule: "'+ piInputField.value + '".' + alertString);
          }
          if (gravite == 'ERREUR')
					{
          	piInputField.value = fv;
					}
        }
      }
      break;

    case 'positiveNumber' :
      if (piInputField.value.length)
	    {
        if (! isFloat(piInputField.value))
	      {
          alert('Vous devez entrer une nombre positif dans ce champ et utiliser le \'.\' pour les nombres à virgule: "'+ piInputField.value + '"');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
						piInputField.focus();
					}
          return false;
        }
        else
        {
          piInputField.value = parseFloat(piInputField.value, 10);
        }
      }
      break;

    case 'notNullInt' :
      if (String(parseInt(piInputField.value, 10)) != piInputField.value )
	    {
        alert('Vous devez entrer un entier non nul: "' + piInputField.value + '"');
        if (gravite == 'ERREUR')
				{
        	piInputField.value = '0';
				}
        return false;
      }
      else
      {
        piInputField.value = parseInt(piInputField.value, 10);
      }
      break;

    case 'int' :
      if (piInputField.value.length)
	    {
	      if (!isSignedInteger(piInputField.value))
        {
          alert('Vous devez entrer un entier : "' + piInputField.value + '"');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
						piInputField.focus();
					}
          return false;
        }
        else
        {
          piInputField.value = parseInt(piInputField.value, 10);
        }
      }
      break;

    case 'positiveInt' :
      if (piInputField.value.length)
	    {
	      // integer >= 0
        if (!isNonnegativeInteger(piInputField.value))
        {
          if (piAlertString)
            alert(alertString);
          else
            alert('Vous devez entrer un entier positif: "' + piInputField.value + '".');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
						piInputField.focus();
					}
          return false;
        }
        else
        {
          piInputField.value = parseInt(piInputField.value, 10);
        }
      }
      break;

    case 'positiveNotNullInt' :
      if (piInputField.value.length)
	    {
	      // integer > 0
        if (!isPositiveInteger(piInputField.value))
        {
          if (piAlertString)
            alert(alertString);
          else
            alert('Vous devez entrer un entier > 0: "' + piInputField.value + '".');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
						piInputField.focus();
					}
          return false;
        }
        else
        {
          piInputField.value = parseInt(piInputField.value, 10);
        }
      }
      break;

    case 'year' :
      if (piInputField.value.length)
	    {
        var y = parseInt(piInputField.value, 10);
        if (String(y) != piInputField.value || y < 1970 || y > 2099)
	      {
          alert('Invalid year : "' + piInputField.value + '". Please enter an integer within [1970 - 2099] range.');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
					}
          return false;
        }
      }
      break;

    case 'date' :
      theDate = piInputField.value;
      if (theDate.length)
      {
        if (! reDate.test(theDate))
				{
          alert('Format de date invalide: "' + theDate + '". Veuillez entrer une date au format (JJ/MM/AAAA).'+ alertString);
          if (gravite == 'ERREUR')
					{
						piInputField.value = '';
					}
          return false;
        }
        else
        {
          if (!fConvertJJMMAAAAToDate(theDate))
          {
	          if (gravite == 'ERREUR')
						{
            	piInputField.value = '';
						}
            return false;
          }
        }
      }
      break;

    case 'dateMM/DD/YYYY' :
      theDate = piInputField.value;
      if (theDate.length)
	    {
        if (! reDateUS.test(theDate))
	      {
          alert('Invalid date format : "' + theDate + '". Please enter a date in this format(MM/DD/YYYY).');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
					}
          return false;
        }
        else
        {
          if (!fConvertMMDDYYYYToDate(theDate))
          {
            if (gravite == 'ERREUR')
						{
  	          piInputField.value = '';
						}
            return false;
          }
        }
      }
      break;

    case 'dateDDMMMYYYY' :
      theDate = piInputField.value;
      if (theDate.length)
	    {
        if (isDateDDMMMYYYY(theDate, true))
        {
          if (fConvertDDMMMYYYYToDate(theDate))
            break;
        }
        if (gravite == 'ERREUR')
				{
        	piInputField.value = '';
				}
        return false;
      }
    break;

    case 'pcsDate' :
      theDate = piInputField.value;
      if (theDate.length)
	    {
        var upr = theDate.toUpperCase();
        if (upr != theDate)
        {
          theDate = upr;
          piInputField.value = theDate;
        }

        var d = fConvertStringToPcsDate(theDate);
        if (d)
        {
          if (reDateUS.test(theDate))
            piInputField.value = fConvertDateToDDMMMYYYY(d);
          break;
        }
        if (gravite == 'ERREUR')
				{
        	piInputField.value = '';
				}
        return false;
      }
    break;

    case 'percent' :
      if (piInputField.value.length)
	    {
        if (isNaN(parseFloat(piInputField.value, 10)) )
	      {
          alert('Vous devez saisir un pourcentage entre [0..100]');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
						piInputField.focus();
					}
          return false;
        }
        else
        {
          if ((parseFloat(piInputField.value, 10) > 100) ||
              (parseFloat(piInputField.value, 10) < 0))
	        {
            alert('Veuillez saisir un pourcentage entre [0..100]\nPar exemple: 12.5');
            if (gravite == 'ERREUR')
						{
            	piInputField.value = '';
							piInputField.focus();
						}
            return false;
          }
          else
          {
            piInputField.value = parseFloat(piInputField.value, 10);
          }
        }
      }
      break;

    case 'quarter' :
      val = piInputField.value;
      if (val.length)
	    {
        reQuarter = /^[1-9]\d\d\dQ[1-4]$/;
        if (! reQuarter.test(val))
	      {
          alert('Invalid Quarter format : "' + val + '". Please enter a quarter in this format: "YYYYQn" (where n is in [1-4]).');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
					}
          return false;
        }
      }
      break;

    case 'positive1decimalFloat' :
      val = piInputField.value;
      if (val.length)
	    {
        rePositive1decimalFloat = /^(\d)+(\.)?(\d)*$/;
        if (! rePositive1decimalFloat.test(val))
	      {
          if (piAlertString)
            alertString = piAlertString;
          else
            alertString = '\nVeuillez saisir un nombre décimal valide. Exemple: 12 ou bien 3.14';
          alert('Nombre invalide : "' + val + '". ' + alertString);
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
					}
          return false;
        }
      }
      break;

    case 'email' :
      val = piInputField.value;
      if (val.length)
	    {
        if (!isEmail(val))
	      {
          if (piAlertString)
            alertString = piAlertString;
          else
            alertString = 'Veuillez entrer une adresse mail valide. (Ex: jacques.durand@societe.com)';
          alert('Email incorrect: "' + val + '". ' + alertString);
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
					  piInputField.focus();
					}
          return false;
        }
      }
      break;

    case 'urlHttp' :
      val = piInputField.value;
      if (val.length)
	    {
        if (!isUrlHttp(val))
	      {
          if (piAlertString)
            alertString = piAlertString;
          else
            alertString = 'Veuillez entrer une addresse web valide. (Ex: www.ingenicat.fr)';
          alert('Adresse web incorrecte: "' + val + '". ' + alertString);
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
						piInputField.focus();
					}
          return false;
        }
      }
      break;

    case 'tel' :
      val = piInputField.value;
      if (val.length)
	    {
        if (!isInternationalPhoneNumber(val) || val.length < 9)
	      {
          if (piAlertString)
            alertString = piAlertString;
          else
            alertString = 'Veuillez entrer un numéro sans espaces ni points. 10 chiffres pour la France (Ex: 0476709495)';
          alert('Numéro invalide: "' + val + '". ' + alertString);
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
						piInputField.focus();
					}
          return false;
        }
      }
      break;

    case 'siren' :
      val = piInputField.value;
      if (val.length)
	    {
        if (! reSiren.test(val))
	      {
          alert('Numéro de SIREN invalide : "' + val + '".\nVeuillez entrer un numéro composé de 9 chiffres sans espaces');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
					}
          return false;
        }
      }
      break;

    case 'siret' :
      val = piInputField.value;
      if (val.length)
	    {
        if (! reSiret.test(val))
	      {
          alert('Numéro de SIRET invalide : "' + val + '".\nVeuillez entrer un numéro composé de 14 chiffres sans espaces');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
					}
          return false;
        }
      }
      break;

    case 'cnuf' :
      val = piInputField.value;
      if (val.length)
	    {
        if (! reCnuf.test(val))
	      {
          alert('CNUF invalide : "' + val + '".\nVeuillez entrer un numéro composé de 5 à 8 chiffres sans espaces');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
					}
          return false;
        }
      }
      break;

    case 'ean13' :
      if (piInputField.value.length)
	    {
        // Vérifier la conformité d'un code EAN
        // (European Article Numbering) sur 13 caractères
        // et renvoyer un message d'erreur le cas échéant

        if (piInputField.value.length != 13)
        {
          alert('La longueur du code EAN est de ' + piInputField.value.length + ' caractère(s) au lieu de 13');
          if (gravite == 'ERREUR')
					{
          	piInputField.value = '';
        }
          piInputField.focus();
          return false;
        }

        // sCodeEAN13 = "9780201134476" ' Exemple de code EAN valide
        var i;
        var sCar = "";
        var iChiffre = "";
        var iSommePair = 0;
        var iSommeImpair = 0;
        var z = "";
        var m = "";
        var iSommeCtrl = "";

        for (i = 1; i <= piInputField.value.length; i++)
        {
          sCar = piInputField.value.substring(i - 1, i);
          if (isNaN(sCar))
          {
            alert('Le code EAN n\'est pas numérique');
            if (gravite == 'ERREUR')
						{
            	piInputField.value = '';
          }
            piInputField.focus();
            return false;
          }

          iChiffre = parseInt(sCar);

          if (i == 13)
          {
            // Soit x la somme des chiffres pairs et
            // y la somme des chiffres impairs
            // On calcule z = 3x + y
            // Soit m le premier nombre divisible par 10
            // supérieur ou égal à z
            // La somme de contrôle est m - z
            iSommeCtrl = iChiffre;
            z = (3 * parseInt(iSommePair)) + parseInt(iSommeImpair);
            for (j = z; j < z + 10; j++)
            {
              if (j % 10 == 0)
              {
                if (j - z == iSommeCtrl)
                {
                  return true;
                }
                else
                {
                  alert('Le code EAN n\'est pas conforme');
                  if (gravite == 'ERREUR')
									{
                  	piInputField.value = '';
                	}
                  piInputField.focus();
                  return false;
                }
              }
            }
          }

          if (i % 2 == 0)
          {
            iSommePair = parseInt(iSommePair) + parseInt(iChiffre);
          }
          else
          {
            iSommeImpair = parseInt(iSommeImpair) + parseInt(iChiffre);
          }
        }
      }
      break;

    default :
      val = piInputField.value;
      if (val.length)
	    {
        re = new RegExp(piType);
        if (! re.test(val))
	      {
          if (gravite == 'ERREUR')
					{
	          if (confirm('Ce texte n\'est pas conforme, il va être effacé : "' + val + '". ' + alertString))
						{
		          piInputField.value = '';
							piInputField.focus();
						}
					}
					else
					{
						alert('Ce texte n\'est pas conforme : "' + val + '". ' + alertString);
					}
          return false;
        }
      }
      break;
  }
  return true;
}


//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: fCheckNombre                                                       **
//* GOAL: vérifie que piInputField est un nombre conforme                    **
//*       piDecimales :   nb de décimales après la virgule                   **
//*       piMin :         valeur minimum                                     **
//*       piMac :         valeur maximum                                     **
//*       piAlertString : message de warning en cas de non conformité        **
//*       piGravite: 'ERREUR' (par défaut) efface le contenu si invalide     **
//*                  'WARNING' warning mais n'efface pas le contenu          **
//*                  'DESACTIVE'  ne fait pas du tout le check               **
//*                                                                          **
//***************************************************************** FUNCTION **
function fCheckNombre(piInputField, piDecimales, piMin, piMax, piAlertString, piGravite)
{
  var alertString=''; // Optional warning string
  var gravite = 'ERREUR';
	var conforme = true;

  if (piAlertString)
    alertString = piAlertString;

	if (piGravite)
    gravite = piGravite;
	if (gravite == 'DESACTIVE')
		return true;

	if (piInputField.value.length)
	{
		var fv = parseFloat(piInputField.value, 10);
		if (isNaN(fv))
		{
			alert('Vous devez entrer une nombre dans ce champ et utiliser le \'.\' pour les nombres à virgule: "'+ piInputField.value + '".' + alertString);
			fv = '';
			conforme = false;
		}
		else
		{
			if (piInputField.value != fv)
			{
				alert('Vous devez utiliser le \'.\' pour les nombres à virgule: "'+ piInputField.value + '".' + alertString);
				conforme = false;
			}

			if (piMin != '')
			{
				if (fv < piMin)
				{
					alert('La valeur minimum est '+piMin);
					fv = piMin;
					conforme = false;
				}
			}

			if (piMax != '')
			{
				if (fv > piMax)
				{
					alert('La valeur maximum est '+piMax);
					fv = piMax;
					conforme = false;
				}
			}
		}

    if (piInputField.value != fv)
		{
			if (gravite == 'ERREUR')
			{
				piInputField.value = fv;
			}
		}

		if (piDecimales != '' && fv != '')
		{
			fv = fFormatAtDecimal(fv, piDecimales);
      if (piInputField.value != fv)
			{
				piInputField.value = fv;
			}
		}
	}

	if (conforme)
	{
		return true;
	}
	else
	{
		if (gravite == 'ERREUR')
		{
			piInputField.focus();
		}
		return false;
	}
}

function fTrim(input)
{
  var ret = input.replace(/^\s*/, '');
  return ret.replace(/\s*$/, '');
}
function fLtrim(input)
{
  return input.replace(/^\s*/, '');
}
function fRtrim(input)
{
	return ret.replace(/\s*$/, '');
}

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: fCheckTexteFormat                                                  **
//* GOAL: vérifie que piInputField est un texte bien formatte                **
//*       piNbCarMax: nb max de Caractères avant troncation                  **
//*       piCasse: 'lower', 'upper', 'capitalise'                            **
//*       piAlertString: message de warning spécifique si troncation         **
//*       piGravite: 'ERREUR','WARNING','DESACTIVE'                          **
//*                                                                          **
//* Exemples à mettre dans la zone de saisie FonctionJS du DefChamp          **
//*       fCheckTexteFormat(this, 200)                                       **
//*       fCheckTexteFormat(this, false, 'capitalise')                       **
//*       fCheckTexteFormat(this, false, 'lower')                            **
//*       fCheckTexteFormat(this, false, 'upper')                            **
//*       fCheckTexteFormat(this, 100, 'capitalise')                         **
//*       fCheckTexteFormat(this, 10, 'upper', 'Max 10 car pour la Réf.')    **
//*       fCheckTexteFormat(this, 10, 'lower', false, 'ERREUR')              **
//***************************************************************** FUNCTION **
function fCheckTexteFormat(piInputField, piNbCarMax, piCasse, piAlertString, piGravite)
{
  var alertString=''; // Optional warning string
  var gravite = 'ERREUR';
	var conforme = true;

  if (piAlertString)
	{
    alertString = piAlertString;
	}
	else if (piNbCarMax)
	{
		alertString = 'Texte limité à '+piNbCarMax+' caractères. Le texte va être tronqué.';
	}

	if (piGravite)
    gravite = piGravite;
	if (gravite == 'DESACTIVE')
		return true;

	var v = fTrim(piInputField.value);
	if (v.length)
	{
		if (piNbCarMax && v.length > piNbCarMax)
		{
			conforme = false;
			if (alertString)
			{
				alert(alertString);
			}
			v = v.substring(0, piNbCarMax);
		}
		if (piCasse == 'lower')
		{
			v = v.toLowerCase();
		}
		else if (piCasse == 'upper')
		{
			v = v.toUpperCase();
		}
    else if (piCasse == 'capitalise')
		{
			v = v.substring(0, 1).toUpperCase() + v.substring(1).toLowerCase();
		}
	}
	piInputField.value = v;

	if (conforme)
	{
		return true;
	}
	else
	{
		if (gravite == 'ERREUR')
		{
			piInputField.focus();
		}
		return false;
	}
}

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: fInputTextWithOnChange                                             **
//* GOAL: print a FORM INPUT item, with onChange JS handler that checks type.**
//*       Optionnal piAlertString is alerted if check type fails             **
//*                                                                          **
//***************************************************************** FUNCTION **
function fInputTextWithOnChange(piType, piSize, piMaxLen, piName, piValue, piFunctionCall, piAlertString, piDisplayZeroValue, piNoScreenModif)
{
	var ret;
  if (piType == 'number' || piType == 'int' || piType == 'positiveNumber')
  {
    FloatValue = parseFloat(piValue);
    if (! piDisplayZeroValue && FloatValue == 0)
		{
	    piValue='';
		}
  }

	ret='<INPUT TYPE="TEXT" SIZE="' + piSize + '" MAXLENGTH="' + piMaxLen + '" NAME="' + piName + '" VALUE="' + fFilterStringQuot(piValue) + '" OnChange="';
  if (piNoScreenModif == undefined || !piNoScreenModif)
  {
    ret += 'top.setScreenModif(true);';
  }
  
  if (piAlertString && piAlertString != '')
	{
    ret+=' top.fCheckInputType(this, \'' + piType + '\', \'' + piAlertString + '\');';
	}
  else
	{
    ret+=' top.fCheckInputType(this, \'' + piType + '\');';
	}

  if (piFunctionCall && piFunctionCall != '')
	{
    ret+= ' ' + piFunctionCall + ';';
	}

	ret+='">';
  return ret;
}

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: fInputPcsDate                                                      **
//* GOAL: return code for a FORM INPUT used to input PCS standard date       **
//*                                                                          **
//***************************************************************** FUNCTION **
function fInputPcsDate(piName, piValue, piFunctionCall, piAlertString, piNoScreenModif)
{
	var ret;
  var dateString = '';

  // convert piValue into ddmmmyyyy format if needed
  if (piValue && piValue != '')
  {
    dateString = piValue;
    if (!isDateDDMMMYYYY(dateString))
    {
      var d = fConvertStringToPcsDate(dateString);
      if (d)
      {
        dateString = fConvertDateToDDMMMYYYY(d);
      }
    }
  }
  
	ret='<INPUT TYPE="TEXT" SIZE="10" MAXLENGTH="10" NAME="' + piName + '" VALUE="' + dateString + '" OnChange="';
  if (piNoScreenModif == undefined || !piNoScreenModif)
  {
    ret += 'top.setScreenModif(true);';
  }
  
  if (piAlertString && piAlertString != '')
	{
    ret+=' top.fCheckInputType(this, \'pcsDate\', \'' + piAlertString + '\');';
	}
  else
	{
    ret+=' top.fCheckInputType(this, \'pcsDate\');';
	}

  if (piFunctionCall && piFunctionCall != '')
	{
    ret+= ' ' + piFunctionCall + ';';
	}

  ret+='" onFocus="top.getCalendarFor(this)">';

  return ret;

} // fInputPcsDate

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: _fGetRollbackInput                                                 **
//* GOAL: Private function to return piInputField's Rollback input           **
//*       Return undefined if none                                           **
//*                                                                          **
//***************************************************************** FUNCTION **
function _fGetRollbackInput(piInputField)
{
  var hidRollbackName = 'hid_'+ piInputField.name + '_rollback'; // format printed in cHtmlRollbackableInput.cpp
  var hidRollback = piInputField.form.elements[hidRollbackName];

  return hidRollback;

} // _fGetRollbackInput

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: fCheckRollback                                                     **
//* GOAL: If linked input value if invalid, rollback to previous value       **
//*       If you use this, use fSetInputTextValue to change this field value **
//*                                                                          **
//***************************************************************** FUNCTION **
function fCheckRollback(piInputField, piType, piAlertString)
{
  var hidRollback = _fGetRollbackInput(piInputField);

  if (fCheckInputType(piInputField, piType, piAlertString))
  {
    if (hidRollback)
    {
      hidRollback.value = piInputField.value;
    }
    setScreenModif(true);
  }
  else
  {
    if (hidRollback)
    {
      piInputField.value = hidRollback.value;
    }
    else
    {
      setScreenModif(true);
    }
  }
} // fCheckRollback

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: fSetInputTextValue                                                 **
//* GOAL: Set piInputField's value and update its Rollback input             **
//*                                                                          **
//***************************************************************** FUNCTION **
function fSetInputTextValue(piInputField, value)
{
  piInputField.value = value;
  setScreenModif(true);

  var hidRollback = _fGetRollbackInput(piInputField);
  if (hidRollback)
  {
    hidRollback.value = piInputField.value;
  }

  // launch onChange code if any
  if (piInputField.onchange)
    piInputField.onchange();

} // fSetInputTextValue

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: isNumberKey                                                        **
//* GOAL: Renvoi true si la touche frappée est numérique                     **
//*                                                                          **
//***************************************************************** FUNCTION **
function isNumberKey(evt)
{
   var charCode = (evt.which) ? evt.which : event.keyCode
   if (charCode > 31 && (charCode < 48 || charCode > 57))
      return false;

   return true;

}

//* FUNCTION ******************************************************************
//*                                                                          **
//* NAME: isDecimalKey                                                        **
//* GOAL: Renvoi true si la touche frappée est numérique ou décimale                     **
//*                                                                          **
//***************************************************************** FUNCTION **
function isDecimalKey(evt)
{
   var charCode = (evt.which) ? evt.which : event.keyCode
   if (charCode > 31 && (charCode < 46 || charCode == 47 || charCode > 57))
      return false;

   return true;

}