function checkDateDays( dateField, dateFormat )
{
  var sContent = new String( dateField.value );
  if( !sContent.match( /\// ) )
  {
    if( !sContent.match( /^\d+$/ ) )
    {
      alert( LANG_incorrect_days_format );
      focusObject( dateField );
      dateField.select();
      return false;
    }
  }
  else
  {
    var dDate = autoParseDate(dateField.value, true);
    if( dDate )
      dateField.value = formatDate(dDate, dateFormat);
    else
    {
      alert( LANG_incorrect_date_format );
      focusObject( dateField );
      dateField.select();
      return false;
    }
  }
  return true;
}

//bAlwaysReturnTrue: pour la recopie des valeurs (par exemple: alo_by_periods), on veut juste l'affichage
// d'erreur mais pas de return false qui interrompe le javascript.
function checkAndUpdateDateField( pDateField, sDateFormat, bNoAlert,bAlwaysReturnTrue )
{
  if(pDateField.value == "")
    return true;
  
  var dDate = autoParseDate(pDateField.value, true);
  if(dDate instanceof Date)
  {
    pDateField.value = formatDate(dDate, sDateFormat);
    return true;
  }
  
  // check si c'est le format J+n jours
  var sDate = new String( pDateField.value );
  if( sDate.match("^[djDJ][+-][0-9]+$") )
  {
    return true;
  }
  
  if ( !bNoAlert )
  {
    alert( LANG_incorrect_date_format );
  }
  
  focusObject( pDateField );  
  pDateField.select();
  
  if(bAlwaysReturnTrue)
    return true;

  return false;
}


function checkAndUpdateHourField( pHourField, bNoAlert )
{
  if(pHourField.value == "")
    return true;
  
  var sHour = new String( pHourField.value );
  
  //reformatage si nécessaire
  if( sHour.match("^([0-1][0-9])$") )
  {
    pHourField.value = new String(sHour.valueOf()+':00');
  }
  if( sHour.match("^(2[0-3])$") )
  {
    pHourField.value = new String(sHour.valueOf()+':00');
  }
  
  var regexpRes = sHour.match("^([0-1][0-9])([0-5][0-9])$");
  if( regexpRes != null && regexpRes.length != 0 )
  {
    pHourField.value = new String( regexpRes[1] + ':' + regexpRes[2] );
  }
  else
  {
    regexpRes = sHour.match("^(2[0-3])([0-5][0-9])$");
    if( regexpRes != null && regexpRes.length != 0 )
    {
      pHourField.value = new String( regexpRes[1] + ':' + regexpRes[2] );
    }
  }
  
  sHour = new String( pHourField.value );
  if( sHour.match("^([0-1][0-9]):([0-5][0-9])$") || sHour.match("^(2[0-3]):([0-5][0-9])$") )
  {
    return true;
  }
  
  if ( !bNoAlert )
  {
    alert( LANG_incorrect_hour_format );
  }
  
  focusObject( pHourField );  
  pHourField.select();
  
  return false;
}

function formatFixedDate(dateObject)
{
  if(!dateObject)
    return "";
  // beaucoup trop lent d'utiliser la méthode formatDate
  // pour ce format très simple
  var nDay = dateObject.getDate();
  var sDay;
  if( nDay < 10 )
    sDay = "0"+nDay;
  else
    sDay = nDay;
  var nMonth = dateObject.getMonth()+1;
  var sMonth;
  if( nMonth < 10 )
    sMonth = "0"+nMonth;
  else
    sMonth = nMonth;
  return ""+dateObject.getFullYear()+"-"+sMonth+"-"+sDay;
}

function formatFixedDateTime(dateObject)
{
  if(!dateObject)
    return "";
  // beaucoup trop lent d'utiliser la méthode formatDate
  // pour ce format très simple
  var nDay = dateObject.getDate();
  var sDay;
  if( nDay < 10 )
    sDay = "0"+nDay;
  else
    sDay = nDay;
  var nMonth = dateObject.getMonth()+1;
  var sMonth;
  if( nMonth < 10 )
    sMonth = "0"+nMonth;
  else
    sMonth = nMonth;
    
  var nHour = dateObject.getHours();
  var sHour;
  if( nHour < 10 )
    sHour = "0"+ nHour;
  else
    sHour = nHour;
    
  var nMin  = dateObject.getMinutes();
  var sMin;
  if( nMin < 10 )
    sMin = "0"+ nMin;
  else
    sMin = nMin;
  
  var nSec  = dateObject.getSeconds();
  var sSec;
  if (nSec < 10)
    sSec = "0"+ nSec;
  else
    sSec = nSec;
    
  return ""+dateObject.getFullYear()+"-"+sMonth+"-"+sDay+" "+ sHour +":"+ sMin +":"+ sSec;
}



function parseFixedDate(strDate)
{
  // beaucoup trop lent d'utiliser la méthode parseDate
  // pour ce format très simple
  var sDate = new String(strDate);
  if( sDate.match("^(.*?)-(.*?)-(.*?)$") )
  {
    return new Date(RegExp.$1, RegExp.$2-1, RegExp.$3);
  }
  return null;
}

function parseFixedDateTime(strDateTime)
{
  var sDate = new String(strDateTime);
  if( sDate.match("^(.*?)-(.*?)-(.*?) (.*?):(.*?):(.*?)$") )
  {
    return new Date(RegExp.$1, RegExp.$2-1, RegExp.$3, RegExp.$4, RegExp.$5, RegExp.$6);
  }
  return null;
}

function parseDate(strDate, sFormat)
{
  if(strDate == "")
    return null;
  if(!sFormat)
    sFormat = DEFAULT_DATE_FORMAT;
  var iTime = getDateFromFormat(strDate, sFormat );
  if(iTime)
    return new Date(iTime);
  else
    return null;
}

function formatDate(dDate, sFormat)
{
  if(!dDate)
    return "";
  if(!sFormat)
    sFormat = DEFAULT_DATE_FORMAT;

  return _formatDate(dDate, sFormat);
}

function formatDateTime(dDate, sFormat)
{
  if(!dDate)
    return "";
  if(!sFormat)
    sFormat = DEFAULT_DATETIME_FORMAT;

  sFormat = sFormat.replace('II', 'mm');
  sFormat = sFormat.replace('SS', 'ss');

  return _formatDate(dDate, sFormat);
}



function parseDateMonth(sDate, sFormat)
{
  var dDate = parseDate(sDate, sFormat);
  if(dDate)
    return dDate.getMonth();
  return null;
}

function parseDateYear(sDate, sFormat)
{
  var dDate = parseDate(sDate, sFormat);
  if(dDate)
    return dDate.getFullYear();
  return null;
}

function datesCompare(d1, d2)
{
  if(d1 == d2)
    return 0;
  if(d1 == null || d2 == null)
    return -1;
  return d2.getTime() - d1.getTime();
}

function datesEquals( d1, d2)
{
  if(d1 == d2)
    return true;
  if(d1 == null || d2 == null)
    return false;
  if(d1.getDate() == d2.getDate() &&
     d1.getMonth() == d2.getMonth() &&
     d1.getYear() == d2.getYear() )
    return true;
  return false;
}

function datesDayDiff(d1, d2)
{
  if(d1 == null || d2 == null)
    return null;
  var nd1 = new Date(d1.getTime());
  var nd2 = new Date(d2.getTime());
  nd1.setHours(0,0,0,0);
  nd2.setHours(0,0,0,0);
  var nDiff = nd2.getTime() - nd1.getTime();
  return Math.round(nDiff / 86400000); // (1000 * 60 * 60 * 24)
}

function datesStart(d, n)
{
  if(!d || n == null)
    return null;
  var ret = new Date(d.getTime());
  ret.setDate(ret.getDate()-n);
  return ret;
}

function dateAddDays(d,n)
{
  var ret = new Date(d.getTime());
  ret.setDate(ret.getDate()+ n*1);
  return ret;
}

function dateAddWorkingDays(d,n)
{
  var ret = new Date(d.getTime());
  var absN = Math.abs(n);
  while(absN)
  {
    if(n>0)
    {
      ret.setDate(ret.getDate()+1);
    }
    else
    {
      ret.setDate(ret.getDate()-1);
    }
    //getDay() Returns the day of a Date object (from 0-6. 0=Sunday, 1=Monday, etc.)
    if((ret.getDay()!=0)&&(ret.getDay()!=6))
    {
      absN--;
    }
  }
  return ret;
}

function dateAddMonths(d,n)
{
  var date = new Date( d.getYear(), d.getMonth() + n, d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds() );
  return date;
}

function datesEnd(d, n)
{
  if(!d || n == null)
    return null;
  var ret = new Date(d.getTime());
  ret.setDate(ret.getDate()+ n*1);
  return ret;
}

function calculateBirthdateFromAge(dDate, nAge)
{
  if(!dDate || !nAge)
    return null;
  var d = new Date(dDate.getFullYear() - nAge, dDate.getMonth(), dDate.getDate());
  return d;
}

function calculateAgeFromBirthdate(dBirthdate, dDate)
{
  if(!dDate || !dBirthdate)
    return null;
  var n1 = dBirthdate.getMonth()*100 + dBirthdate.getDate();
  var n2 = dDate.getMonth()*100 + dDate.getDate();
  var nAge = dDate.getFullYear() - dBirthdate.getFullYear();
  if(n2 < n1) 
    nAge--;
  return nAge;
}


//
// Calcul l'age : retourne également les mois
//
function calculateDecimalAgeFromBirthdateOld(dBirthdate, dDate)
{
  if(!dDate || !dBirthdate)
    return null;
  var n1 = dBirthdate.getMonth()*100 + dBirthdate.getDate();
  var n2 = dDate.getMonth()*100 + dDate.getDate();
  var nAge = dDate.getFullYear() - dBirthdate.getFullYear();
  if(n2 < n1)
    nAge--;
    
  var nMonth;
  if( dDate.getMonth() < dBirthdate.getMonth() )
  {
    nMonth = ( 12 - dBirthdate.getMonth() + dDate.getMonth() );
  }
  else
  {
    nMonth = ( dDate.getMonth() - dBirthdate.getMonth() );
  }
  
  if( nMonth >= 10 )
  {
    nAge += nMonth / 100;
  }
  else
  {
    nAge += nMonth / 10;
  }
  
  return nAge;
}


//
// Calcul l'age : retourne également les mois
//
function calculateDecimalAgeFromBirthdate(dBirthdate, dDate)
{
  if(!dDate || !dBirthdate)
    return null;
  
  // nbs de jours
  var nbDaysDiff = datesDayDiff( dBirthdate, dDate );

  var nAge = nbDaysDiff / 365;
  return nAge;
}

// ===================================================================
// Author: Matt Kruse <matt@mattkruse.com>
// WWW: http://www.mattkruse.com/
//
// NOTICE: You may use this code for any purpose, commercial or
// private, without any further permission from the author. You may
// remove this notice from your final code if you wish, however it is
// appreciated by the author if at least my web site address is kept.
//
// You may *NOT* re-distribute this code in any way except through its
// use. That means, you can include it in your product, or your web
// site, or any other form where the code is actually being used. You
// may not put the plain javascript up on your site for download or
// include it in your javascript libraries for download. 
// If you wish to share this code with others, please just point them
// to the URL instead.
// Please DO NOT link directly to my .js files from your site. Copy
// the files to your server and use them there. Thank you.
// ===================================================================

// HISTORY
// ------------------------------------------------------------------
// March 11, 2003: Added parseDate() function
// March 11, 2003: Added "NNN" formatting option. Doesn't match up
//                 perfectly with SimpleDateFormat formats, but 
//                 backwards-compatability was required.

// ------------------------------------------------------------------
// These functions use the same 'format' strings as the 
// java.text.SimpleDateFormat class, with minor exceptions.
// The format string consists of the following abbreviations:
// 
// Field        | Full Form          | Short Form
// -------------+--------------------+-----------------------
// Year         | YYYY (4 digits)    | YY (2 digits), Y (2 or 4 digits)
// Month        | MMM (name or abbr.)| MM (2 digits), M (1 or 2 digits)
//              | NNN (abbr.)        |
// Day of Month | DD (2 digits)      | D (1 or 2 digits)
// Day of Week  | EE (name)          | E (abbr)
// Hour (1-12)  | hh (2 digits)      | h (1 or 2 digits)
// Hour (0-23)  | HH (2 digits)      | H (1 or 2 digits)
// Hour (0-11)  | KK (2 digits)      | K (1 or 2 digits)
// Hour (1-24)  | kk (2 digits)      | k (1 or 2 digits)
// Minute       | mm (2 digits)      | m (1 or 2 digits)
// Second       | ss (2 digits)      | s (1 or 2 digits)
// AM/PM        | a                  |
//
// NOTE THE DIFFERENCE BETWEEN MM and mm! Month=MM, not mm!
// Examples:
//  "MMM D, Y" matches: January 01, 2000
//                      Dec 1, 1900
//                      Nov 20, 00
//  "M/D/YY"   matches: 01/20/00
//                      9/2/00
//  "MMM DD, YYYY hh:mm:ssa" matches: "January 01, 2000 12:30:45AM"
// ------------------------------------------------------------------

var MONTH_NAMES=new Array('January','February','March','April','May','June','July','August','September','October','November','December','Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec');
var DAY_NAMES=new Array('Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sun','Mon','Tue','Wed','Thu','Fri','Sat');
function LZ(x) {return(x<0||x>9?"":"0")+x}

// ------------------------------------------------------------------
// isDate ( date_string, format_string )
// Returns true if date string matches format of format string and
// is a valid date. Else returns false.
// It is recommended that you trim whitespace around the value before
// passing it to this function, as whitespace is NOT ignored!
// ------------------------------------------------------------------
function isDate(val,format) {
  var date=getDateFromFormat(val,format);
  if (date==0) { return false; }
  return true;
  }

// -------------------------------------------------------------------
// compareDates(date1,date1format,date2,date2format)
//   Compare two date strings to see which is greater.
//   Returns:
//   1 if date1 is greater than date2
//   0 if date2 is greater than date1 of if they are the same
//  -1 if either of the dates is in an invalid format
// -------------------------------------------------------------------
function compareDates(date1,dateformat1,date2,dateformat2) {
  var d1=getDateFromFormat(date1,dateformat1);
  var d2=getDateFromFormat(date2,dateformat2);
  if (d1==0 || d2==0) {
    return -1;
    }
  else if (d1 > d2) {
    return 1;
    }
  return 0;
  }

// ------------------------------------------------------------------
// formatDate (date_object, format)
// Returns a date in the output format specified.
// The format string uses the same abbreviations as in getDateFromFormat()
// ------------------------------------------------------------------
function _formatDate(date,format) {
  format=format+"";
  var result="";
  var i_format=0;
  var c="";
  var token="";
  var y=date.getYear()+"";
  var M=date.getMonth()+1;
  var d=date.getDate();
  var E=date.getDay();
  var H=date.getHours();
  var m=date.getMinutes();
  var s=date.getSeconds();
  var yyyy,yy,MMM,MM,dd,hh,h,mm,ss,ampm,HH,H,KK,K,kk,k;
  // Convert real date parts into formatted versions
  var value=new Object();
  if (y.length < 4) {y=""+(y-0+1900);}
  value["Y"]=""+y;
  value["YYYY"]=y;
  value["YY"]=y.substring(2,4);
  value["M"]=M;
  value["MM"]=LZ(M);
  value["MMM"]=MONTH_NAMES[M-1];
  value["NNN"]=MONTH_NAMES[M+11];
  value["D"]=d;
  value["DD"]=LZ(d);
  value["E"]=DAY_NAMES[E+7];
  value["EE"]=DAY_NAMES[E];
  value["H"]=H;
  value["HH"]=LZ(H);
  if (H==0){value["h"]=12;}
  else if (H>12){value["h"]=H-12;}
  else {value["h"]=H;}
  value["hh"]=LZ(value["h"]);
  if (H>11){value["K"]=H-12;} else {value["K"]=H;}
  value["k"]=H+1;
  value["KK"]=LZ(value["K"]);
  value["kk"]=LZ(value["k"]);
  if (H > 11) { value["a"]="PM"; }
  else { value["a"]="AM"; }
  value["m"]=m;
  value["mm"]=LZ(m);
  value["s"]=s;
  value["ss"]=LZ(s);
  while (i_format < format.length) {
    c=format.charAt(i_format);
    token="";
    while ((format.charAt(i_format)==c) && (i_format < format.length)) {
      token += format.charAt(i_format++);
      }
    if (value[token] != null) { result=result + value[token]; }
    else { result=result + token; }
    }
  return result;
  }
  
// ------------------------------------------------------------------
// Utility functions for parsing in getDateFromFormat()
// ------------------------------------------------------------------
function _isInteger(val) {
  var digits="1234567890";
  for (var i=0; i < val.length; i++) {
    if (digits.indexOf(val.charAt(i))==-1) { return false; }
    }
  return true;
  }
function _getInt(str,i,minlength,maxlength) {
  for (var x=maxlength; x>=minlength; x--) {
    var token=str.substring(i,i+x);
    if (token.length < minlength) { return null; }
    if (_isInteger(token)) { return token; }
    }
  return null;
  }
  
// ------------------------------------------------------------------
// getDateFromFormat( date_string , format_string )
//
// This function takes a date string and a format string. It matches
// If the date string matches the format string, it returns the 
// getTime() of the date. If it does not match, it returns 0.
// ------------------------------------------------------------------
function getDateFromFormat(val,format)
{
  val=val+"";
  format=format+"";
  var i_val=0;
  var i_format=0;
  var c="";
  var token="";
  var token2="";
  var x,y;
  var now=new Date();
  var year=null; //now.getYear();
  var month=now.getMonth()+1;
  var date=1;
  var hh= 0; //now.getHours();
  var mm= 0; //now.getMinutes();
  var ss= 0; //now.getSeconds();
  var ampm="";
  
  var nYTwoKLimit = new Date().getYear()-2000+5;
  if( nYTwoKLimit < -1000 ) // on mozilla browsers
    nYTwoKLimit = new Date().getYear()-100+5;
  
  while (i_format < format.length)
  {
    // Get next token from format string
    c=format.charAt(i_format);
    token="";
    while ((format.charAt(i_format)==c) && (i_format < format.length))
    {
      token += format.charAt(i_format++);
    }
    // Extract contents of value based on format token
    if (token=="YYYY" || token=="YY" || token=="Y")
    {
      if (token=="YYYY") { x=4;y=4; }
      if (token=="YY")   { x=2;y=2; }
      if (token=="Y")    { x=2;y=4; }
      year=_getInt(val,i_val,x,y);
      if (year==null) { return 0; }
      i_val += year.length;
      if (year.length==2)
      {
        if ( year > nYTwoKLimit) { year=1900+(year-0); }
        else { year=2000+(year-0); }
      }
    }
    else if (token=="MMM"||token=="NNN")
    {
      month=0;
      for (var i=0; i<MONTH_NAMES.length; i++)
      {
        var month_name=MONTH_NAMES[i];
        if (val.substring(i_val,i_val+month_name.length).toLowerCase()==month_name.toLowerCase())
        {
          if (token=="MMM"||(token=="NNN"&&i>11))
          {
            month=i+1;
            if (month>12) { month -= 12; }
            i_val += month_name.length;
            break;
          }
        }
      }
      if ((month < 1)||(month>12)) {return 0;}
    }
    else if (token=="EE"||token=="E")
    {
      for (var i=0; i<DAY_NAMES.length; i++)
      {
        var day_name=DAY_NAMES[i];
        if (val.substring(i_val,i_val+day_name.length).toLowerCase()==day_name.toLowerCase())
        {
          i_val += day_name.length;
          break;
        }
      }
    }
    else if (token=="MM"||token=="M")
    {
      month=_getInt(val,i_val,token.length,2);
      if(month==null||(month<1)||(month>12)){return 0;}
      i_val+=month.length;
    }
    else if (token=="DD"||token=="D")
    {
      date=_getInt(val,i_val,token.length,2);
      if(date==null||(date<1)||(date>31)){return 0;}
      i_val+=date.length;
    }
    else if (token=="hh"||token=="h")
    {
      hh=_getInt(val,i_val,token.length,2);
      if(hh==null||(hh<1)||(hh>12)){return 0;}
      i_val+=hh.length;
    }
    else if (token=="HH"||token=="H")
    {
      hh=_getInt(val,i_val,token.length,2);
      if(hh==null||(hh<0)||(hh>23)){return 0;}
      i_val+=hh.length;
    }
    else if (token=="KK"||token=="K")
    {
      hh=_getInt(val,i_val,token.length,2);
      if(hh==null||(hh<0)||(hh>11)){return 0;}
      i_val+=hh.length;
    }
    else if (token=="kk"||token=="k")
    {
      hh=_getInt(val,i_val,token.length,2);
      if(hh==null||(hh<1)||(hh>24)){return 0;}
      i_val+=hh.length;hh--;
    }
    else if (token=="mm"||token=="m")
    {
      mm=_getInt(val,i_val,token.length,2);
      if(mm==null||(mm<0)||(mm>59)){return 0;}
      i_val+=mm.length;
    }
    else if (token=="ss"||token=="s")
    {
      ss=_getInt(val,i_val,token.length,2);
      if(ss==null||(ss<0)||(ss>59)){return 0;}
      i_val+=ss.length;
    }
    else if (token=="a")
    {
      if (val.substring(i_val,i_val+2).toLowerCase()=="am") {ampm="AM";}
      else if (val.substring(i_val,i_val+2).toLowerCase()=="pm") {ampm="PM";}
      else {return 0;}
      i_val+=2;
    }
    else
    {
      if (val.substring(i_val,i_val+token.length)!=token) {return 0;}
      else {i_val+=token.length;}
    }
  }
  // If there are any trailing characters left in the value, it doesn't match
  if (i_val != val.length) { return 0; }
  // Is date valid for month?
  if ((month==4)||(month==6)||(month==9)||(month==11))
  {
    if (date > 30) { return 0; }
  }
  
  // fix year
  // evidemment ca risque de ne pas marcher pour fevrier
  if( year == null )
  {
    year = now.getYear();
    if ( year > 100 && year < 200 ) { year=1900+(year-0); } // bug mozilla
    try
    {
      var partialdate = new Date(year,month-1,date,hh,mm,ss,0);
      partialdate = dateAddDays( partialdate, 30 );
      if( partialdate < now )
      {
        year++;
      }
    }
    catch(ex) { return 0; }
  }

  if (month==2)
  {
    // Check for leap year
    if ( ( (year%4==0)&&(year%100 != 0) ) || (year%400==0) )
    { // leap year
      if (date > 29) { return 0; }
    }
    else
    {
      if (date > 28) { return 0; }
    }
  }

  // Correct hours value
  if (hh<12 && ampm=="PM") { hh=hh-0+12; }
  else if (hh>11 && ampm=="AM") { hh-=12; }
  if ( year > 100 && year < 200 ) { year=1900+(year-0); } // bug mozilla
  var newdate=new Date(year,month-1,date,hh,mm,ss,0);
  return newdate.getTime();
}

// ------------------------------------------------------------------
// parseDate( date_string [, prefer_euro_format] )
//
// This function takes a date string and tries to match it to a
// number of possible date formats to get the value. It will try to
// match against the following international formats, in this order:
// y-M-d   MMM d, y   MMM d,y   y-MMM-d   d-MMM-y  MMM d
// M/d/y   M-d-y      M.d.y     MMM-d     M/d      M-d
// d/M/y   d-M-y      d.M.y     d-MMM     d/M      d-M
// A second argument may be passed to instruct the method to search
// for formats like d/M/y (european format) before M/d/y (American).
// Returns a Date object or null if no patterns match.
// ------------------------------------------------------------------
function autoParseDate(val) {
  var preferEuro=(arguments.length==2)?arguments[1]:false;
  generalFormats=new Array('Y-M-D','MMM D, Y','MMM D,Y','Y-MMM-D','D-MMM-Y','MMM D');
  monthFirst=new Array('M/D/Y','M-D-Y','M.D.Y','MMM-D','M/D','M-D','MDY' );
  dateFirst =new Array('D/M/Y','D-M-Y','D.M.Y','D-MMM','D/M','D-M','DMY','DM','DMY' );
  var checkList=new Array('generalFormats',preferEuro?'dateFirst':'monthFirst',preferEuro?'monthFirst':'dateFirst');
  var d=null;
  for (var i=0; i<checkList.length; i++) {
    var l=window[checkList[i]];
    for (var j=0; j<l.length; j++) {
      d=getDateFromFormat(val,l[j]);
      if (d) { return new Date(d); }
      }
    }
  return null;
  }

// these functions *actually* use the sDateFormat parameter

function parseFormatedDate( sValue, sDateFormat )
{
  if( sDateFormat )
  {
    var nDate = getDateFromFormat( sValue, sDateFormat );
    return nDate ? new Date( nDate ) : null;
  }
  else
  {
    return autoParseDate( sValue, true );
  }
}

function isDateValid( pDateField, sDateFormat )
{
  var sContent = new String( pDateField.value );

  if( sContent == "" )
    return true;
  
  if( parseFormatedDate( sContent, sDateFormat ) )
    return true;
  
  return false;
}

function checkFormatedDateDays( pDateField, sDateFormat )
{
  var sContent = new String( pDateField.value );

  var dDate = parseFormatedDate( sContent, sDateFormat );

  if( dDate )
    pDateField.value = formatDate( dDate, sDateFormat );
  else
  {
    alert( LANG_incorrect_date_format );
    focusObject( pDateField );
    pDateField.select();
  }
}

function checkAndUpdateFormatedDateField( pDateField, sDateFormat)
{
  var sContent = new String( pDateField.value );

  if( sContent == "" )
    return true;

  var dDate = parseFormatedDate( sContent, sDateFormat );

  if( dDate instanceof Date )
  {
    pDateField.value = formatDate( dDate, sDateFormat );
    return true;
  }
  
  alert( LANG_incorrect_date_format );
  focusObject( pDateField );
  pDateField.select();
  return false;
}

function leaseInputCalculateEndDate( sName )
{
  var pStartDateInput = getDOMObject( sName + '_start_date' );
  var pEndDateInput = getDOMObject( sName + '_end_date' );
  var pNbMonthsDurationInput = getDOMObject( sName + '_nb_months_duration' );
  
  if( pStartDateInput.value && pNbMonthsDurationInput.value )
  {
    var dEndDate = dateAddMonths( parseDate(pStartDateInput.value), parseInt(pNbMonthsDurationInput.value) ); 
    setObjectProperty( pEndDateInput, 'value', formatDate( dEndDate ) );
  }
}

function checkFutureDate( pDateField )
{
  if( pDateField.value != '' &&
    autoParseDate(pDateField.value, true) > new Date() )
  {
    alert( LANG_date_is_in_the_future );
    focusObject( pDateField );
    setTimeout(function() { pDateField.focus(); }, 10);
    return false;
  }
  return true;
}