//'------------------------------------------------------------------------------------------------------------
//' cs_calendar.js
//' 27/10/2007
//' Steve Rowland
//'
//' recreates the popup calendar  functionality in client-side code
//'------------------------------------------------------------------------------------------------------------
//' History           Author                          Modification(s)
//'
//' 27/10/2007        Steve Rowland                   Created
//'------------------------------------------------------------------------------------------------------------

var csDateNow                  = new Date(Date.parse(new Date().toDateString()));
var csBaseYear                 = csDateNow.getFullYear();
// How many years do want to be valid and to show in the drop-down list?
var csWeekStart                = 1;    
var csWeekNumberDisplay        = false;    
var csWeekNumberBaseDay        = 4;    
var csShowInvalidDateMsg       = false,
    csShowOutOfRangeMsg        = false,
    csShowDoesNotExistMsg      = false,
    csShowInvalidAlert         = false,
    csShowDateDisablingError   = false,
    csShowRangeDisablingError  = false;
    
var csArrDelimiters            = ['/','-','.',',',' '];    
var csDateDisplayFormat        = 'dd/mm/yyyy';    
var csDateOutputFormat         = 'dd/mm/yyyy';    
var csZindex                   = 1;    
var csBlnStrict                = false;    
var csEnabledDay               = [true, true, true, true, true, true, true,
                                  true, true, true, true, true, true, true,
                                  true, true, true, true, true, true, true,
                                  true, true, true, true, true, true, true,
                                  true, true, true, true, true, true, true,
                                  true, true, true, true, true, true, true];
var csDisabledDates           = new Array();
var mydate                    = new Date()
    mydate.setDate(mydate.getDate()+1);
    csDisabledDates[1]        = [new Date(1970,1,1), new Date(mydate.getFullYear(),mydate.getMonth(),mydate.getDate())];    
var csActiveToday             = true;    
var csOutOfMonthDisable       = true;
var csOutOfMonthHide          = false;    
var csOutOfRangeDisable       = true;    
var csFormatTodayCell         = true;
var csTodayCellBorderColour   = 'yellow';    
var csAllowDrag               = false;    
var csClickToHide             = false;
var csTargetEle,
    csTriggerEle,
    csMonthSum                = 0,
    csBlnFullInputDate        = false,
    csPassEnabledDay          = new Array(),
    csSeedDate                = new Date(),
    csParmActiveToday         = true,
    csWeekStart               = csWeekStart%7,
    csToday,
    csDrag,
    csArrMonthNames,
    csArrWeekInits,
    csInvalidDateMsg,
    csOutOfRangeMsg,
    csDoesNotExistMsg,
    csInvalidAlert,
    csDateDisablingError,
    csRangeDisablingError;
 var csNextActionReturn, csNextAction;
/*CONST*/
var csDropDownYears           = 2;    
Date.prototype.add = function (sInterval, iNum)
{
    var dTemp = this;
    if (!sInterval || iNum == 0) return dTemp;
    switch (sInterval.toLowerCase())
    {
        case "ms":
            dTemp.setMilliseconds(dTemp.getMilliseconds() + iNum);
            break;
        case "s":
            dTemp.setSeconds(dTemp.getSeconds() + iNum);
            break;
        case "mi":
            dTemp.setMinutes(dTemp.getMinutes() + iNum);
            break;
        case "h":
            dTemp.setHours(dTemp.getHours() + iNum);
            break;
        case "d":
            dTemp.setDate(dTemp.getDate() + iNum);
            break;
        case "mo":
            dTemp.setMonth(dTemp.getMonth() + iNum);
            break;
        case "y":
            dTemp.setFullYear(dTemp.getFullYear() + iNum);
            break;
  }
  return dTemp;
}    
function csSetDefaults(){
  try{
    csSetLanguage();
  }catch (exception){// English
    csToday               = 'Today:';
    csDrag                = '';
    csArrMonthNames       = ['January','February','March','April','May','June',
                             'July','August','September','October','November','December'];
    csArrWeekInits        = ['S','M','T','W','T','F','S'];
    csInvalidDateMsg      = 'The entered date is invalid.\n';
    csOutOfRangeMsg       = 'The entered date is out of range.';
    csDoesNotExistMsg     = 'The entered date does not exist.';
    csInvalidAlert        = ['Invalid date (',') ignored.'];
    csDateDisablingError  = ['Error ',' is not a Date object.'];
    csRangeDisablingError = ['Error ',' should consist of two elements.'];
  }
} 
/*In-line CSS definitions*/
document.writeln(
  '<style type="text/css">'                                     +
      //'.cs           {padding:1px;vertical-align:middle;}'      +
      //'.csOuter      {padding:0px;vertical-align:middle;'       +
      //                'position:relative;top:-4px;}'            +
      'iframe.cs     {position:absolute;z-index:' + csZindex    +
                      ';top:0px;left:0px;visibility:hidden;'    +
                      'width:1px;height:1px;}'                  +
      'table.cs      {padding:0px;visibility:hidden;'           +
                      'position:absolute;cursor:default;'       +
                      'width:200px;top:0px;left:0px;'           +
                      'z-index:' + (csZindex+1)                 +
                      ';text-align:center;}'                    +
  '</style>');
Date.prototype.csFormat = function(csFormat){
  var charCount = 0,
  codeChar  = '',
  result    = '';
  for (var i=0;i<=csFormat.length;i++){
    if (i<csFormat.length && csFormat.charAt(i)==codeChar){
      charCount++;   
   }else{
      switch (codeChar){
        case 'y': case 'Y':
          result += (this.getFullYear()%Math.
                     pow(10,charCount)).toString().
                     csPadLeft(charCount);
           break;
        case 'm': case 'M':     
           result += (charCount<3) ? (this.getMonth()+1).toString().csPadLeft(charCount) : csArrMonthNames[this.getMonth()];
           break;
        case 'd': case 'D':     
           result += this.getDate().toString().csPadLeft(charCount);
           break;
        default:     
           while (charCount-- > 0){
            result += codeChar;
           }
      }
      if (i<csFormat.length){
       codeChar  = csFormat.charAt(i);
       charCount = 1;
      }
    }
  }
  return result;
};
String.prototype.csPadLeft = function(padToLength){
  var result = '';
  for (var i=0;i<(padToLength - this.length);i++){
    result += '0';
  }
  return (result + this);
};
Function.prototype.runsAftercs = function(){
  var func = this, args = new Array(arguments.length);
  for (var i=0;i<args.length;++i){
    args[i] = arguments[i];
  }
  return function(){
     for (var i=0;i<arguments.length;++i){
      args[args.length] = arguments[i];
     }
     
     return (args.shift()==csTriggerEle)?func.apply(this, args):null;
  };
};
function csID(id){
  return document.getElementById(id);
}
function showCal(csEle,csSourceEvent){
  csShow(csEle,csSourceEvent);
}
function csShow(csEle,csSourceEvent){
  var csDateValue = '';
  var count = 0;
  var monthCount = 0;
  var today = new Date();
  if (!csSourceEvent){
    csSourceEvent = window.event;
  }
  var csSourceEle = (csSourceEvent.target) ? csSourceEvent.target : csSourceEvent.srcElement;
  if(csSourceEvent.stopPropagation){
    csSourceEvent.stopPropagation();
  }else {
    csSourceEvent.cancelBubble = true;
  }
 csTriggerEle = csSourceEle;
  csParmActiveToday = true;
  for (var i=0;i<7;i++){
    csPassEnabledDay[(i+7-csWeekStart)%7] = true;
    for (var j=2;j<arguments.length;j++){
      if (arguments[j]==i){
        csPassEnabledDay[(i+7-csWeekStart)%7] = false;
        if (csDateNow.getDay()==i){
          csParmActiveToday = false;
        }
      }
    }
  }
  csSeedDate = csDateNow;
  if(csEle.value){
    csDateValue = csEle.value.replace(/^\s+/,'').replace(/\s+$/,'');
  }else{
    if (typeof csEle.value == 'undefined'){
      var csChildNodes = csEle.childNodes;
      for (var i=0;i<csChildNodes.length;i++){
        if (csChildNodes[i].nodeType == 3){
          csDateValue = csChildNodes[i].nodeValue.replace(/^\s+/,'').replace(/\s+$/,'');
          if (csDateValue.length > 0){
            csTriggerEle.csTextNode = csChildNodes[i];
            csTriggerEle.csLength   = csChildNodes[i].nodeValue.length;
            break;
          }
        }
      }
    }
  }
  /*set the global defaults*/
  csSetDefaults();
  csID('csDragText').innerHTML = csDrag;
  csID('csMonths').options.length = 0;
  for (var i=0;i<csArrMonthNames.length;i++){
    try{            
      csID('csMonths').add(new Option(csArrMonthNames[i],csArrMonthNames[i]), null);
    }catch (err){            
      csID('csMonths').add(new Option(csArrMonthNames[i],csArrMonthNames[i]));
    }
  }
  //{csID('csMonths').options[i] = new Option(csArrMonthNames[i],csArrMonthNames[i]);}
  csID('csMonthYears').options.length = 0;
  csID('csYears').options.length = 0;
  for (var i=0;i<csDropDownYears;i++){
   try{
      csID('csYears').add(new Option((csBaseYear+i),(csBaseYear+i)), null);
    }catch (err){
      csID('csYears').add(new Option((csBaseYear+i),(csBaseYear+i)));
    }
    if(csID('csMonthYears').options.length < csDropDownYears*csArrMonthNames.length && csID('csMonthYears').options.length < 18){
      for (var im=0;im<csArrMonthNames.length;im++){
          if( ((im >= today.getMonth()) && (csBaseYear+i == today.getFullYear())) || ( csBaseYear+i == today.getFullYear()+1 && monthCount <= 18)){
            try{
              csID('csMonthYears').add(new Option(csArrMonthNames[im] + ' ' + (csBaseYear+i), csArrMonthNames[im] + ' ' + (csBaseYear+i)), null);
            }catch(err){
              csID('csMonthYears').add(new Option(csArrMonthNames[im] + ' ' + (csBaseYear+i), csArrMonthNames[im] + ' ' + (csBaseYear+i)));
            }
            monthCount++;
          } 
          count++;
      }
    }
  }
  for (var i=0;i<csArrWeekInits.length;i++){
    csID('csWeekInit' + i).innerHTML = csArrWeekInits[(i+csWeekStart)%csArrWeekInits.length];
  }
  if(csDateValue.length == 0){            
    csBlnFullInputDate = false;
    if ((new Date(csBaseYear+csDropDownYears,0,0)) < csSeedDate || (new Date(csBaseYear,0,1)) > csSeedDate){  
      csSeedDate = new Date(csBaseYear + Math.floor(csDropDownYears / 2), 5, 1);
    }
  } else {
 function csInputFormat(){
      var csArrSeed   = new Array(),
          csArrInput  = csDateValue.split(new RegExp('[\\'+csArrDelimiters.join('\\')+']+','g'));
      var template    = ['D','M','Y'];             
      var result      = new Array();
      var csDateSequence;
      if (csArrInput[0]!=null){
        if (csArrInput[0].length==0){
          csArrInput.splice(0,1);
        }
        if (csArrInput[csArrInput.length-1].length==0){
          csArrInput.splice(csArrInput.length-1,1);
        }
      }
      csBlnFullInputDate = false;
      csDateOutputFormat = csDateOutputFormat.toUpperCase();
      for (var i=0;i<template.length;i++){
        if (csDateOutputFormat.search(template[i])>-1){
          result[csDateOutputFormat.search(template[i])] = template[i];
        }
      }
      csDateSequence = result.join('');
      switch (csArrInput.length){
        case 1:{
          if (csDateOutputFormat.indexOf('Y')>-1 && csArrInput[0].length>csDateOutputFormat.lastIndexOf('Y')){
            csArrSeed[0] = parseInt(csArrInput[0].substring(csDateOutputFormat.indexOf('Y'), csDateOutputFormat.lastIndexOf('Y')+1),10);
          } else {
            csArrSeed[0] = 0;
          }
          if (csDateOutputFormat.indexOf('M')>-1 && csArrInput[0].length>csDateOutputFormat.lastIndexOf('M')){
            csArrSeed[1] = csArrInput[0].substring(csDateOutputFormat.indexOf('M'),csDateOutputFormat.lastIndexOf('M')+1);
          }else{
            csArrSeed[1] = '6';
          }
          if (csDateOutputFormat.indexOf('D')>-1 && csArrInput[0].length>csDateOutputFormat.lastIndexOf('D')){
            csArrSeed[2] = parseInt(csArrInput[0].substring(csDateOutputFormat.indexOf('D'), csDateOutputFormat.lastIndexOf('D')+1),10);
          }else{
            csArrSeed[2] = 1;
          }
          if (csArrInput[0].length==csDateOutputFormat.length){
            csBlnFullInputDate = true;
          }
          break;
        }
        case 2:{
          csArrSeed[0] = parseInt(csArrInput[csDateSequence.replace(/D/i,'').search(/Y/i)],10); // Year
          csArrSeed[1] = csArrInput[csDateSequence.replace(/D/i,'').search(/M/i)];              // Month
          csArrSeed[2] = 1;                                                                     // Day
          break;
        }
        case 3:{
          csArrSeed[0] = parseInt(csArrInput[csDateSequence.search(/Y/i)],10);  // Year
          csArrSeed[1] = csArrInput[csDateSequence.search(/M/i)];               // Month
          csArrSeed[2] = parseInt(csArrInput[csDateSequence.search(/D/i)],10);  // Day
          csBlnFullInputDate = true;
          break;
        }
        default:{
          csArrSeed[0] = 0;     // Year
          csArrSeed[1] = 0;     // Month
          csArrSeed[2] = 0;     // Day
        }
      }
      var csExpValDay    = new RegExp('^(0?[1-9]|[1-2][0-9]|3[0-1])$'),
          csExpValMonth  = new RegExp('^(0?[1-9]|1[0-2]|' + csArrMonthNames.join('|') + ')$','i'),
          csExpValYear   = new RegExp('^([0-9]{1,2}|[0-9]{4})$');
      if (csExpValYear.exec(csArrSeed[0]) == null || csExpValMonth.exec(csArrSeed[1]) == null || csExpValDay.exec(csArrSeed[2])   == null){
      if (csShowInvalidDateMsg){
            alert(csInvalidDateMsg + csInvalidAlert[0] + csDateValue + csInvalidAlert[1]);
        }
        csBlnFullInputDate = false;
        csArrSeed[0] = csBaseYear + Math.floor(csDropDownYears/2); // Year
        csArrSeed[1] = '6';                                        // Month
        csArrSeed[2] = 1;                                          // Day
      }
      return csArrSeed;
    }
    csArrSeedDate = csInputFormat();
    if (csArrSeedDate[0]<100){
      csArrSeedDate[0] += (csArrSeedDate[0]>50)?1900:2000;
    }
    if (csArrSeedDate[1].search(/\d+/)!=0){
      month = csArrMonthNames.join('|').toUpperCase().search(csArrSeedDate[1].substr(0,3).toUpperCase());
      csArrSeedDate[1] = Math.floor(month/4)+1;
    }
    csSeedDate = new Date(csArrSeedDate[0],csArrSeedDate[1]-1,csArrSeedDate[2]);
  }
  if (isNaN(csSeedDate)){
    if (csShowInvalidDateMsg){
      alert(csInvalidDateMsg + csInvalidAlert[0] + csDateValue + csInvalidAlert[1]);
    }
    csSeedDate = new Date(csBaseYear + Math.floor(csDropDownYears/2),5,1);
    csBlnFullInputDate=false;
  }else{
    if ((new Date(csBaseYear,0,1)) > csSeedDate){
      if (csBlnStrict && csShowOutOfRangeMsg){
        alert(csOutOfRangeMsg);
      }
      csSeedDate = new Date(csBaseYear,0,1);
      csBlnFullInputDate=false;
    }else{
      if ((new Date(csBaseYear+csDropDownYears,0,0))<csSeedDate){
        if (csBlnStrict && csShowOutOfRangeMsg){
          alert(csOutOfRangeMsg);
        }
        csSeedDate = new Date(csBaseYear + Math.floor(csDropDownYears)-1,11,1);
        csBlnFullInputDate=false;
      }else{
        if (csBlnStrict && csBlnFullInputDate && (csSeedDate.getDate() != csArrSeedDate[2] || (csSeedDate.getMonth()+1) != csArrSeedDate[1] || csSeedDate.getFullYear()  != csArrSeedDate[0])){
          if (csShowDoesNotExistMsg){
            alert(csDoesNotExistMsg);
          }
          csSeedDate = new Date(csSeedDate.getFullYear(),csSeedDate.getMonth()-1,1);
          csBlnFullInputDate=false;
        }
      }
    }
  }
  for (var i=0;i<csDisabledDates.length;i++){
    if (!((typeof csDisabledDates[i] == 'object') && (csDisabledDates[i].constructor == Date))){
      if ((typeof csDisabledDates[i] == 'object') && (csDisabledDates[i].constructor == Array)){
        var csPass = true;
        if (csDisabledDates[i].length !=2){
         if (csShowRangeDisablingError){
            alert(csRangeDisablingError[0] + csDisabledDates[i] + csRangeDisablingError[1]);
          }
          csPass = false;
        }else{
          for (var j=0;j<csDisabledDates[i].length;j++){
            if (!((typeof csDisabledDates[i][j] == 'object') && (csDisabledDates[i][j].constructor == Date))){
              if (csShowRangeDisablingError){
                alert(  csDateDisablingError[0] + csDisabledDates[i][j] + csDateDisablingError[1]);
              }
              csPass = false;
            }
          }
        }
        if (csPass && (csDisabledDates[i][0] > csDisabledDates[i][1])){
          csDisabledDates[i].reverse();
        }
      }else{
        if (csShowRangeDisablingError){
          alert(csDateDisablingError[0] + csDisabledDates[i] + csDateDisablingError[1]);
        }
      }
    }
  }
  csMonthSum =  12*(csSeedDate.getFullYear()-csBaseYear)+csSeedDate.getMonth();
  csID('csYears' ).options.selectedIndex = Math.floor(csMonthSum/12);
  csID('csMonths').options.selectedIndex = (csMonthSum%12);
  csID('csMonthYears').value = csID('csMonths').value + ' ' + csID('csYears').value;
  csID('csDrag').style.display=(csAllowDrag)?'':'none';

  csShowMonth(0);
  csTargetEle=csEle;

  var inputFieldDetails = GetElementDetails(csEle);
  var parentElementDetails = GetElementDetails(csID('cs').offsetParent != null ? csID('cs').offsetParent : csID('cs').parentNode);
  
  csID('cs').style.top = inputFieldDetails.top + inputFieldDetails.height - parentElementDetails.top + 'px';
  csID('cs').style.left = inputFieldDetails.left - parentElementDetails.left + 'px';
  csID('cs').style.display = 'block';
  csID('cs').style.visibility = 'visible';
  csID('csIframe').style.top = csID('cs').style.top;
  csID('csIframe').style.left = csID('cs').style.left;
  csID('csIframe').style.position = 'absolute';
  csID('csIframe').style.width = csID('cs').offsetWidth + 'px';
  csID('csIframe').style.height = csID('cs').offsetHeight + 'px';
  csID('csIframe').width = parseInt(csID('cs').offsetWidth);
  csID('csIframe').height = parseInt(csID('cs').offsetHeight);
  csID('csIframe').style.display='block';
  csID('csIframe').style.visibility = 'visible';
  
}

    function csHide()
        {csID('cs').style.visibility='hidden';
         csID('csIframe').style.visibility='hidden';
         if (typeof csNextAction!='undefined' && csNextAction!=null)
             {csNextActionReturn = csNextAction();

              csNextAction = null;
             }
        };

    function csCancel(csEvt)
        {if (csClickToHide) {csHide();}
         csStopPropagation(csEvt);
        };

    function csStopPropagation(csEvt)
        {if (csEvt.stopPropagation)
                {csEvt.stopPropagation();}     // Capture phase
         else   {csEvt.cancelBubble = true;}   // Bubbling phase
        };

    function csBeginDrag(event)
        {var elementToDrag = csID('cs');

         var deltaX    = event.clientX,
             deltaY    = event.clientY,
             offsetEle = elementToDrag;

         do {deltaX   -= parseInt(offsetEle.offsetLeft,10);
             deltaY   -= parseInt(offsetEle.offsetTop ,10);
             offsetEle = offsetEle.offsetParent;
            }
         while (offsetEle.tagName!='BODY' &&
                offsetEle.tagName!='HTML');

         if (document.addEventListener)
                {document.addEventListener('mousemove',moveHandler,true);        // Capture phase
                 document.addEventListener('mouseup',  upHandler,  true);        // Capture phase
                }
         else   {elementToDrag.attachEvent('onmousemove',moveHandler); // Bubbling phase
                 elementToDrag.attachEvent('onmouseup',  upHandler);   // Bubbling phase
                 elementToDrag.setCapture();
                }

         csStopPropagation(event);

         function moveHandler(csEvt)
            {if (!csEvt) csEvt = window.event;

             elementToDrag.style.left = (csEvt.clientX - deltaX) + 'px';
             elementToDrag.style.top  = (csEvt.clientY - deltaY) + 'px';

             csID('csIframe').style.left = (csEvt.clientX - deltaX) + 'px';
             csID('csIframe').style.top  = (csEvt.clientY - deltaY) + 'px';

             csStopPropagation(csEvt);
            };

         function upHandler(csEvt)
            {if (!csEvt) csEvt = window.event;

             if (document.removeEventListener)
                    {document.removeEventListener('mousemove',moveHandler,true);     // Capture phase
                     document.removeEventListener('mouseup',  upHandler,  true);     // Capture phase
                    }
             else   {elementToDrag.detachEvent('onmouseup',  upHandler);   // Bubbling phase
                     elementToDrag.detachEvent('onmousemove',moveHandler); // Bubbling phase
                     elementToDrag.releaseCapture();
                    }

             csStopPropagation(csEvt);
            };
        };
        
    function csShowMonthYear(csBias)
    {
        var splitMonthYear = csID('csMonthYears').value.split(" ");
        csID('csMonths').value = splitMonthYear[0];
        csID('csYears').value = splitMonthYear[1];
        csID('csMonthYears').value = csID('csMonths').value + ' ' + csID('csYears').value;
        csShowMonth(csBias);
    }
    

    function csShowMonth(csBias)
        {
         var csShowDate  = new Date(Date.parse(new Date().toDateString())),
             csStartDate = new Date();

         
         csShowDate.setHours(12);

         csSelYears  = csID('csYears');
         csSelMonths = csID('csMonths');
         csSelMonthYears = csID('csMonthYears');
         
         

         if (csSelYears.options.selectedIndex>-1)
            {csMonthSum=12*(csSelYears.options.selectedIndex)+csBias;
             if (csSelMonths.options.selectedIndex>-1) {csMonthSum+=csSelMonths.options.selectedIndex;}
            }
         else
            {if (csSelMonths.options.selectedIndex>-1) {csMonthSum+=csSelMonths.options.selectedIndex;}}

         csShowDate.setFullYear(csBaseYear + Math.floor(csMonthSum/12),(csMonthSum%12),1);         
         
         csID('csWeek_').style.display=(csWeekNumberDisplay)?'':'none';

         if (window.opera)
            {csID('csMonths').style.display = 'inherit';
             csID('csYears' ).style.display = 'inherit';
           }

         
         csTemp = (12*parseInt((csShowDate.getFullYear()-csBaseYear),10)) + parseInt(csShowDate.getMonth(),10);

         if (csTemp > -1 && csTemp < (12*csDropDownYears))
            {csSelYears.options.selectedIndex=Math.floor(csMonthSum/12);
             csSelMonths.options.selectedIndex=(csMonthSum%12);

             csCurMonth = csShowDate.getMonth();

             csShowDate.setDate((((csShowDate.
                                    getDay()-csWeekStart)<0)?-6:1)+
                                 csWeekStart-csShowDate.getDay());

             var csCompareDateValue = new Date(csShowDate.getFullYear(),
                                                csShowDate.getMonth(),
                                                csShowDate.getDate()).valueOf();

             csStartDate = new Date(csShowDate);

             if (csID('csFoot'))
                {var csFoot = csID('csFoot');

                 function csFootOutput() {csSetOutput(csDateNow);};

                 if (csDisabledDates.length==0)
                    {if (csActiveToday && csParmActiveToday)
                        {csFoot.onclick     = csFootOutput;
                         csFoot.className   = 'csFoot';

                         if (csID('csIE'))
                            {csFoot.onmouseover  = csChangeClass;
                             csFoot.onmouseout   = csChangeClass;
                            }

                        }
                     else
                        {csFoot.onclick     = null;
                         csFoot.className   = 'csFootDisabled';

                         if (csID('csIE'))
                            {csFoot.onmouseover  = null;
                             csFoot.onmouseout   = null;
                            }

                         if (document.addEventListener)
                                {csFoot.addEventListener('click',csStopPropagation,false);}
                         else   {csFoot.attachEvent('onclick',csStopPropagation);}
                        }
                    }
                 else
                    {for (var k=0;k<csDisabledDates.length;k++)
                        {if (!csActiveToday || !csParmActiveToday ||
                             ((typeof csDisabledDates[k] == 'object')                   &&
                                 (((csDisabledDates[k].constructor == Date)             &&
                                   csDateNow.valueOf() == csDisabledDates[k].valueOf()
                                  ) ||
                                  ((csDisabledDates[k].constructor == Array)               &&
                                   csDateNow.valueOf() >= csDisabledDates[k][0].valueOf() &&
                                   csDateNow.valueOf() <= csDisabledDates[k][1].valueOf()
                                  )
                                 )
                             )
                            )
                            {csFoot.onclick     = null;
                             csFoot.className   = 'csFootDisabled';

                             if (csID('csIE'))
                                {csFoot.onmouseover  = null;
                                 csFoot.onmouseout   = null;
                                }

                             if (document.addEventListener)
                                    {csFoot.addEventListener('click',csStopPropagation,false);}
                             else   {csFoot.attachEvent('onclick',csStopPropagation);}
                             break;
                            }
                         else
                            {csFoot.onclick=csFootOutput;
                             csFoot.className='csFoot';

                             if (csID('csIE'))
                                {csFoot.onmouseover  = csChangeClass;
                                 csFoot.onmouseout   = csChangeClass;
                                }
                            }
                        }
                    }
                    csSelMonthYears.value = csSelMonths.value + ' ' + csSelYears.value;
                    var csNowDate = new Date();
                     if (csSelYears.value < csNowDate.getFullYear() || (csSelYears.value == csNowDate.getFullYear() && csSelMonths.selectedIndex <= csNowDate.getMonth()))
                     {
                        csID('csHeadLeft').style.visibility = "hidden";
                     }
                     else
                     {
                        csID('csHeadLeft').style.visibility = "";
                     }
                     
                     var curDate = new Date();
                     var departureMonth = csSelMonths.selectedIndex<9?'0'+(csSelMonths.selectedIndex+1):(csSelMonths.selectedIndex+1);
                     var Date1 = '01' + '/' + departureMonth + '/' + csSelYears.value;
                     var nDay = curDate.getDate().toString();
                     var nMonth = (curDate.getMonth()+1).toString();
        
                     nDay = '01';
                     if(nMonth.toString().length == 1)
                     {
                        nMonth = '0' + nMonth;
                     }  
                     var Date2 = nDay + '/' + nMonth + '/' + curDate.getFullYear().toString(); 
                     
                     curDate.DateDiff({interval:"m",date1:Date2,date2:Date1,delimiter:"/"});
                     var diff = curDate.difference;
	                 if(diff > 17)
	                 {
                        csID('csHeadRight').style.visibility = "hidden";
                     }
                     else
                     {
                        csID('csHeadRight').style.visibility = "";
                     }
                }

             function csSetOutput(csOutputDate)
                {if (typeof csTargetEle.value == 'undefined')
                      {csTriggerEle.csTextNode.replaceData(0,csTriggerEle.csLength,csOutputDate.csFormat(csDateOutputFormat));}
                 else 
                 {
                    csTargetEle.value = csOutputDate.csFormat(csDateOutputFormat);
                    ChangeDate(null,csTargetEle);
                 }
                 csHide();
                };

             function csCellOutput(csEvt)
                {var csEle = csEventTrigger(csEvt),
                     csOutputDate = new Date(csStartDate);

                 if (csEle.nodeType==3) csEle=csEle.parentNode;

                 csOutputDate.setDate(csStartDate.getDate() + parseInt(csEle.id.substr(7),10));

                 csSetOutput(csOutputDate);
                };

             function csChangeClass(csEvt)
                {var csEle = csEventTrigger(csEvt);

                 if (csEle.nodeType==3) {csEle=csEle.parentNode;}

                 switch (csEle.className)
                    {case 'csCells':
                        csEle.className = 'csCellsHover';
                        break;
                     case 'csCellsHover':
                        csEle.className = 'csCells';
                        break;
                     case 'csCellsExMonth':
                        csEle.className = 'csCellsExMonthHover';
                        break;
                     case 'csCellsExMonthHover':
                        csEle.className = 'csCellsExMonth';
                        break;
                     case 'csCellsWeekend':
                        csEle.className = 'csCellsWeekendHover';
                        break;
                     case 'csCellsWeekendHover':
                        csEle.className = 'csCellsWeekend';
                        break;
                     case 'csFoot':
                        csEle.className = 'csFootHover';
                        break;
                     case 'csFootHover':
                        csEle.className = 'csFoot';
                        break;
                     case 'csInputDate':
                        csEle.className = 'csInputDateHover';
                        break;
                     case 'csInputDateHover':
                        csEle.className = 'csInputDate';
                    }

                 return true;
                }

             function csEventTrigger(csEvt)
                {if (!csEvt) {csEvt = event;}
                 return csEvt.target||csEvt.srcElement;
                };

             function csWeekNumber(csInDate)
                {
                 var csInDateWeekBase = new Date(csInDate);                
                 

                 csInDateWeekBase.setDate(csInDateWeekBase.getDate()
                                            - csInDateWeekBase.getDay()
                                            + csWeekNumberBaseDay
                                            + ((csInDate.getDay()>
                                                csWeekNumberBaseDay)?7:0));

                 
                 var csFirstBaseDay = new Date(csInDateWeekBase.getFullYear(),0,1);

                 csFirstBaseDay.setDate(csFirstBaseDay.getDate()
                                            - csFirstBaseDay.getDay()
                                            + csWeekNumberBaseDay
                                        );

                 if (csFirstBaseDay < new Date(csInDateWeekBase.getFullYear(),0,1))
                    {csFirstBaseDay.setDate(csFirstBaseDay.getDate()+7);}

                 
                 var csStartWeekOne = new Date(csFirstBaseDay
                                                - csWeekNumberBaseDay
                                                + csInDate.getDay());

                 if (csStartWeekOne > csFirstBaseDay)
                    {csStartWeekOne.setDate(csStartWeekOne.getDate()-7);}

                 
                 var csWeekNo = '0' + (Math.round((csInDateWeekBase - csFirstBaseDay)/604800000,0) + 1);

                 

                 return csWeekNo.substring(csWeekNo.length-2, csWeekNo.length);
                };

             
             var csCells = csID('csCells');

             for (i=0;i<csCells.childNodes.length;i++)
                {var csRows = csCells.childNodes[i];
                 if (csRows.nodeType==1 && csRows.tagName=='TR')
                    {if (csWeekNumberDisplay)
                        {
                         csTmpEl = csRows.childNodes[0];
                         csTmpEl.innerHTML = csWeekNumber(csShowDate);
                         csTmpEl.style.borderColor =
                             (csTmpEl.currentStyle)
                                ?csTmpEl.currentStyle['backgroundColor']
                                :(window.getComputedStyle)
                                    ?document.defaultView.getComputedStyle(csTmpEl,null).getPropertyValue('background-color')
                                    :'';
                         csTmpEl.style.display='';
                        }
                     else
                        {csRows.childNodes[0].style.display='none';}

                     for (j=1;j<csRows.childNodes.length;j++)
                        {var csCols = csRows.childNodes[j];
                         if (csCols.nodeType==1 && csCols.tagName=='TD')
                            {csRows.childNodes[j].innerHTML=
                                csShowDate.getDate();
                             var csCell=csRows.childNodes[j],
                                 csDisabled =
                                    ((csOutOfRangeDisable &&
                                        (csShowDate <
                                            (new Date(csBaseYear,0,1,
                                                      csShowDate.getHours()))
                                         ||
                                         csShowDate >
                                            (new Date(csBaseYear+
                                                      csDropDownYears,0,0,
                                                      csShowDate.getHours()))
                                        )
                                     ) ||
                                     (csOutOfMonthDisable &&
                                        (csShowDate <
                                            (new Date(csShowDate.getFullYear(),
                                                      csCurMonth,1,
                                                      csShowDate.getHours()))
                                         ||
                                         csShowDate >
                                            (new Date(csShowDate.getFullYear(),
                                                      csCurMonth+1,0,
                                                      csShowDate.getHours()))
                                        )
                                     )
                                    )?true:false;

                             csCell.style.visibility =
                                (csOutOfMonthHide &&
                                    (csShowDate <
                                        (new Date(csShowDate.getFullYear(),
                                                  csCurMonth,1,
                                                  csShowDate.getHours()))
                                     ||
                                     csShowDate >
                                        (new Date(csShowDate.getFullYear(),
                                                  csCurMonth+1,0,
                                                  csShowDate.getHours()))
                                    )
                                )?'hidden':'inherit';

                             for (var k=0;k<csDisabledDates.length;k++)
                                {if ((typeof csDisabledDates[k]=='object') &&
                                     (csDisabledDates[k].constructor == Date) &&
                                     csCompareDateValue == csDisabledDates[k].valueOf()
                                    )
                                    {csDisabled = true;}
                                 else
                                    {if ((typeof csDisabledDates[k]=='object') &&
                                         (csDisabledDates[k].constructor == Array) &&
                                         csCompareDateValue >= csDisabledDates[k][0].valueOf() &&
                                         csCompareDateValue <= csDisabledDates[k][1].valueOf()
                                        )
                                        {csDisabled = true;}
                                    }
                                }

                             if (csDisabled ||
                                 !csEnabledDay[j-1+(7*((i*csCells.childNodes.length)/6))] ||
                                 !csPassEnabledDay[(j-1+(7*(i*csCells.childNodes.length/6)))%7]
                                )
                                {csRows.childNodes[j].onclick = null;

                                 if (csID('csIE'))
                                    {csRows.childNodes[j].onmouseover  = null;
                                     csRows.childNodes[j].onmouseout   = null;
                                    }

                                 csCell.className=
                                    (csShowDate.getMonth()!=csCurMonth)
                                        ?'csCellsExMonthDisabled'
                                        :(csBlnFullInputDate &&
                                          csShowDate.toDateString()==
                                          csSeedDate.toDateString())
                                            ?'csInputDateDisabled'
                                            :(csShowDate.getDay()%6==0)
                                                ?'csCellsWeekendDisabled'
                                                :'csCellsDisabled';

                                 csCell.style.borderColor =
                                     (csFormatTodayCell && csShowDate.toDateString()==csDateNow.toDateString())
                                        ?csTodayCellBorderColour
                                        :(csCell.currentStyle)
                                            ?csCell.currentStyle['backgroundColor']
                                            :(window.getComputedStyle)
                                                ?document.defaultView.getComputedStyle(csCell,null).getPropertyValue('background-color')
                                                :'';
                                }
                             else
                                {csRows.childNodes[j].onclick=csCellOutput;

                                 if (csID('csIE'))
                                    {csRows.childNodes[j].onmouseover  = csChangeClass;
                                     csRows.childNodes[j].onmouseout   = csChangeClass;
                                    }

                                 csCell.className=
                                     (csShowDate.getMonth()!=csCurMonth)
                                        ?'csCellsExMonth'
                                        :(csBlnFullInputDate &&
                                          csShowDate.toDateString()==
                                          csSeedDate.toDateString())
                                            ?'csInputDate'
                                            :(csShowDate.getDay()%6==0)
                                                ?'csCellsWeekend'
                                                :'csCells';

                                 csCell.style.borderColor =
                                     (csFormatTodayCell && csShowDate.toDateString() == csDateNow.toDateString())
                                        ?csTodayCellBorderColour
                                        :(csCell.currentStyle)
                                            ?csCell.currentStyle['backgroundColor']
                                            :(window.getComputedStyle)
                                                ?document.defaultView.getComputedStyle(csCell,null).getPropertyValue('background-color')
                                                :'';
                               }

                             csShowDate.setDate(csShowDate.getDate()+1);
                             csCompareDateValue = new Date(csShowDate.getFullYear(),csShowDate.getMonth(),csShowDate.getDate()).valueOf();
                            }
                        }
                    }
                }
            }

        
         if (window.opera)
            {csID('csMonths').style.display = 'inline';
             csID('csYears' ).style.display = 'inline';
             csID('csMonthYears').style = 'inline';
             csID('cs').style.visibility='hidden';
             csID('cs').style.visibility='inherit';
           }
        };

/*Start HTML*/
    document.writeln("<!--[if IE]><div id='csIE'></div><![endif]-->");
    document.writeln("<!--[if lt IE 7]><div id='csIElt7'></div><![endif]-->");
    document.write(
     "<iframe class='cs' " + (csID('csIElt7')?"src='/csblank.html '":'') +
             "id='csIframe' name='csIframe' frameborder='0'>" +
     "</iframe>" +
     "<table id='cs' class='cs'>" +
       "<tr class='csHead'>" +
         "<td class='csHead'>" +
           "<table class='csHead' id='csHead' width='100%' " +
                    "cellspacing='0' cellpadding='0'>" +
            "<tr id='csDrag' style='display:none;'>" +
                "<td colspan='4' class='csDrag' " +
                    "onmousedown='csBeginDrag(event);'>" +
                    "<div id='csDragText'></div>" +
                "</td>" +
            "</tr>" +
            "<tr class='csHead' >" +
                 "<td class='csHead'>" +
                    "<A title='Go to the previous month' class='navPrev' id='csHeadLeft' style='COLOR: #999999' href='#null' onclick='csShowMonth(-1);'>&nbsp;<<&nbsp;</A> " +                    
                 "</td>" +
                 "<td class='csHead'>" +
                    "<select id='csMonthYears' class='csHead' " +
                            "onchange='csShowMonthYear(0);' style='width:120px;align:center;'>" +
                    "</select>" +                 
                 "</td>" +
                 "<td class='csHead'>" +
                    "<A title='Go to the next month' class='navNext' id='csHeadRight' style='COLOR: #999999' href='#null' onclick='csShowMonth(1);'>&nbsp;>>&nbsp;</A> " +                    
                        "</td>" +
                "</tr>" +
              "</table>" +
            "</td>" +
          "</tr>" +
          "<tr class='cs'>" +
            "<td class='csOuter'>" +
                "<table class='csCells' align='center' cellSpacing='0'>" +                
                  "<tr><td class='csWeekNumberHead' id='csWeek_' ></td>");

    for (i=0;i<7;i++)
        {document.write(
                      "<td class='csWeek' id='csWeekInit" + i + "'></td>");
        }

    document.write("</tr>" +
                "</table>" +
              "<table class='csCells' align='center'>" +                
                "<tbody id='csCells' " +
                        "onClick='csStopPropagation(event);'>");

    for (i=0;i<6;i++)
        {document.write(
                    "<tr>" +
                      "<td class='csWeekNo' id='csWeek_" + i + "'></td>");
         for (j=0;j<7;j++)
            {document.write(
                        "<td class='csCells' id='csCell_" + (j+(i*7)) +
                        "'></td>");
            }

         document.write(
                    "</tr>");
        }

    document.write(
                "</tbody>");
                document.write(
                  "<tfoot class='csFoot'>" +
                    "<tr class='csFoot'>" +
                      "<td class='csFoot' id='csFoot' colspan='8'>" +
                      "<A class='closebutton' href='javascript:csHide();'>Close </A>" +
                      "</td>" +
                    "</tr>" +
                  "</tfoot>");
                


    document.write(
              "</table>" +
            "</td>" +
          "</tr>" +
        "</table>");
        /*End HTML*/
        
/*hidden fields for month and year values*/
document.write("<select id='csMonths' style='visibility:hidden' onchange='csShowMonth(0);'>" +
               "</select>" +        
               "<select id='csYears' style='visibility:hidden' onchange='csShowMonth(0);'>" +
               "</select>")

if (document.addEventListener){
  csID('cs'         ).addEventListener('click',csCancel,false);
  csID('csHeadLeft' ).addEventListener('click',csStopPropagation,false);
  csID('csMonths'   ).addEventListener('click',csStopPropagation,false);
  csID('csMonths'   ).addEventListener('change',csStopPropagation,false);
  csID('csYears'    ).addEventListener('click',csStopPropagation,false);
  csID('csYears'    ).addEventListener('change',csStopPropagation,false);
  csID('csHeadRight').addEventListener('click',csStopPropagation,false);
  
}else{
  csID('cs'         ).attachEvent('onclick',csCancel);
  csID('csHeadLeft' ).attachEvent('onclick',csStopPropagation);
  csID('csMonths'   ).attachEvent('onclick',csStopPropagation);
  csID('csMonths'   ).attachEvent('onchange',csStopPropagation);
  csID('csYears'    ).attachEvent('onclick',csStopPropagation);
  csID('csYears'    ).attachEvent('onchange',csStopPropagation);
  csID('csHeadRight').attachEvent('onclick',csStopPropagation);
}


if (document.addEventListener){
  document.addEventListener('click',csHide, false);
  
}else{
  document.attachEvent('onclick',csHide);
}
    
function ChangeDate(e,input,label){
        
  // get current date
  var curDate         = new Date();        
  var nDay            = curDate.getDate().toString();
  var nMonth          = (curDate.getMonth()+1).toString();
  var deptdate        = "";
  var sDate           = "";   
  var year;
  var month;
  var day;
  var departureDate;
  var adjMonth;
  var deptDay;
  var deptMonth;
  var deptYear;
  var Date1;
  var durationDrop;
  var diff;
  var d=new Date();
  d.setDate(d.getDate()+2);
      
  if(nDay.toString().length == 1){
      nDay = '0' + nDay;
  }
  
  if(nMonth.toString().length == 1){        
      nMonth = '0' + nMonth;
  }  
      
  sDate = nDay + '/' + nMonth + '/' + curDate.getFullYear().toString(); 
  
  // check that input date is valid
  
  if (typeof(input)!='undefined'){
    deptdate = input.value;
  
  }else{
    input = $("DepartureDate");
    deptdate = input.value;
  }
      
  if (!label){
  
    // label get for DatePickerControl.ascx
    label = $(input.id + '_label');
    
    if (!label){
  
      if(get_previousSibling(input).title == input.id){
          label = get_previousSibling(input);
      }
      else{
          label = $('DepartureDate_txtDateLabel');
      }
      
    }
    
  }
      
  // re-format input date		
 
  if(deptdate != undefined && deptdate != '' && isValidDate(deptdate)){

    dateArray = deptdate.split("/");
    day = dateArray[0];
    month = dateArray[1];
    year = dateArray[2];
	        
    if(year.toString().length == 2){
        year = '20' + year;
    }
	    
    departureDate = new Date();	        	        
    departureDate.setDate(15); // set to middle of month to prevent 31st issues
    adjMonth = 0;
    adjMonth = (month-1);
    departureDate.setMonth(adjMonth);
    departureDate.setDate(day);
    departureDate.setFullYear(year);	        
    if(departureDate<d)
    {
        input.value=FormatDate(d);
        return true;
    }
    deptDay = departureDate.getDate().toString();
    deptMonth = (departureDate.getMonth()+1).toString();
    deptYear =  departureDate.getFullYear().toString();
    
    if(deptDay.toString().length == 1){
      deptDay = '0' + deptDay;
    }
      
    if(deptMonth.toString().length == 1){
        deptMonth = '0' + deptMonth;
    } 
          
    Date1 = deptDay + '/' + deptMonth + '/' + deptYear;
          
  }else{
    return false;
  }             
      
  //Set the date before calling setCheckOut so that it can work with the new formatted date           
  input.value = Date1;
  label.innerHTML = getTheDay(Date1);
  if(typeof(CallDateChange) == 'function'){
    CallDateChange(input);
  }
  
  //Set the Departure date if available. Only available on Accom Search Form
  durationDrop=$("DG");
      
  if(durationDrop !="undefined" && durationDrop != null && input.id != "uxReturnDate")
  {
    if(durationDrop.value!="")
    {
     setCheckOut(parseInt(durationDrop.value));
    }
  }

  curDate.DateDiff({interval:"d",date1:sDate,date2:Date1,delimiter:"/"});
  diff = curDate.difference;
      
  if(diff <= 1){ // date selected is prior to 2 days hence	       
      return false;	 
             
  }else{	            		
    return true;	
  }
  
}
function GetDate(dateString){
  var dateStringArray = dateString.split("/");
  var inputDate;
  var dayString       = dateStringArray[0];
  var monthString     = dateStringArray[1];
  var yearString      = dateStringArray[2];
  if(yearString.length == 2){
    year = '20' + year;
  }
    inputDate = new Date();
    inputDate.setFullYear(yearString);	        
    inputDate.setDate(dayString);
    inputDate.setMonth(Number(monthString)-1);
  return inputDate;
}    
function getTheDay(dateIn){

    if(dateIn != null){
		var usDate;
		dateIn = dateIn.replace(/(\d+).(\d+).(\d+)/, '$3/$2/$1');
		dateIn = dateIn.replace(/^(\d\d\/)/, '20$1');
		iYear = dateIn.substring(0,4);
		iMonth = dateIn.substring(5,7);
		iDay = dateIn.substring(8,10);
		dateIn = iYear + '\/' + iMonth + '\/' + iDay;
		myDays = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
		myDate = new Date(dateIn);
		return myDays[myDate.getDay()];
	}
}


	var dtCh= "/";
	var minYear=1900;
	var maxYear=2100;
	function isInteger(s)
	{
		var i;
		for (i = 0; i < s.length; i++)
		{
			var c = s.charAt(i);
			if (((c < "0") || (c > "9"))) return false;
		}
		return true;
	}


	function stripCharsInBag(s, bag)
	{
		var i;
		var returnString = "";
		for (i = 0; i < s.length; i++)
		{
			var c = s.charAt(i);
			if (bag.indexOf(c) == -1) returnString += c;
		}
		return returnString;
	}


	function daysInFebruary (year)
	{
		return (((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0))) ? 29 : 28 );
	}


	function DaysArray(n)
	{
		for (var i = 1; i <= n; i++)
		{
			this[i] = 31
			if (i==4 || i==6 || i==9 || i==11) {this[i] = 30}
			if (i==2) {this[i] = 29}
		}
		return this
	}


	function isDate(dtStr)
	{
		var daysInMonth = DaysArray(12)
		var pos1=dtStr.indexOf(dtCh)
		var pos2=dtStr.indexOf(dtCh,pos1+1)
		var strDay=dtStr.substring(0,pos1)
		var strMonth=dtStr.substring(pos1+1,pos2)
		var strYear=dtStr.substring(pos2+1)
		strYr=strYear
		if (strDay.charAt(0)=="0" && strDay.length>1) strDay=strDay.substring(1)
		if (strMonth.charAt(0)=="0" && strMonth.length>1) strMonth=strMonth.substring(1)
		for (var i = 1; i <= 3; i++)
		{
			if (strYr.charAt(0)=="0" && strYr.length>1) strYr=strYr.substring(1)
		}
		month=parseInt(strMonth)
		day=parseInt(strDay)
		year=parseInt(strYr)
		if (pos1==-1 || pos2==-1)
		{
			return false
		}
		if (strMonth.length<1 || month<1 || month>12)
		{
			return false
		}
		if (strDay.length<1 || day<1 || day>31 || (month==2 && day>daysInFebruary(year)) || day > daysInMonth[month])
		{
			return false
		}
		if (strYear.length != 4 || year==0 || year<minYear || year>maxYear)
		{
			return false
		}
		if (dtStr.indexOf(dtCh,pos2+1)!=-1 || isInteger(stripCharsInBag(dtStr, dtCh))==false)
			{
			return false
			}
		return true
	}
function isValidDate(dateStr) 
   {
    var datePat = /^(\d{1,2})(\/|-)(\d{1,2})(\/|-)(\d{4})$/;
    var dateArray = dateStr.split('/');
    var day = dateArray[0];
    var month = dateArray[1];
    var year = dateArray[2];

    if(dateArray.length!=3){
        return false;
    }
 
    if(day.toString().length < 2)
    {
        day = '0' + day;
    }
    if(month.toString().length < 2)
    {
        month = '0' + month;
    }
    if(year.toString().length < 4)
    {
        year = '20' + year;
    }
    dateStr = day + '/' + month + '/' + year;
    var matchArray = dateStr.match(datePat);

    if (matchArray == null) 
    {            
        return false;
    }

    day = matchArray[1];
    month = matchArray[3];
    year = matchArray[5];

    if (month < 1 || month > 12) 
    {
        return false;
    }

    if (day < 1 || day > 31) 
    {
        return false;
    }

    if ((month==4 || month==6 || month==9 || month==11) && day==31) 
    {
        return false;
    }

    if (month == 2) 
    {
        var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
        if (day > 29 || (day==29 && !isleap)) 
        {
            return false;
        }
    }
    return true; // date is valid
}
	
	var oneMinute=1000*60;
	
	var intervalObject=new Object();
	intervalObject["yyyy"]={units:1000*60*60*24*365,measure:"year"};
	intervalObject["m"]={units:1000*60*60*24*30,measure:"month"};
	intervalObject["d"]={units:1000*60*60*24,measure:"day"};
	intervalObject["Q"]={units:intervalObject["m"].units*3,measure:"quarter"};
	intervalObject["H"]={units:oneMinute*60,measure:"hour"};
	intervalObject["N"]={units:oneMinute,measure:"minute"};
	intervalObject["S"]={units:1000,measure:"second"};
	
	
	function DateDiff(dateAddObj)
	{
	    this.interval=dateAddObj.interval;
		this.date1=dateAddObj.date1;
		this.date2=dateAddObj.date2;
		this.delimiter=dateAddObj.delimiter;
		this.calculate=calculate;
		this.calculate();		
	}

	Date.prototype.DateDiff=DateDiff;
	
	
	
	
	function calculate()
	{
		var paramDate1=new String(this.date1);
		splitDate1=paramDate1.split(this.delimiter);
		paramDateYear1=splitDate1[2];
		paramDateMonth1=splitDate1[1]-1;
		paramDateDay1=splitDate1[0];
		if(paramDateMonth1>12)
		{
		    // invalid month			
			return false;
		}
		if(paramDateDay1>31)
		{
			// Invalid Day
			return false;
		}
		
		
		var paramDate2=new String(this.date2);
		splitDate2=paramDate2.split(this.delimiter);
		paramDateYear2=splitDate2[2];
		paramDateMonth2=splitDate2[1]-1;
		paramDateDay2=splitDate2[0];
		if(paramDateMonth2>12)
		{
			// Invalid Month
			return false;
		}
		if(paramDateDay2>31)
		{
			// Invalid Day
			return false;
		}
		
				
		var paramDate1Object=new Date(paramDateYear1,paramDateMonth1,paramDateDay1);
		paramDate1Object.setHours(0);
		paramDate1Object.setMinutes(0);
		paramDate1Object.setSeconds(0);
		
		var paramDate1ObjectTime=paramDate1Object.getTime();		
		
		var paramDate2Object=new Date(paramDateYear2,paramDateMonth2,paramDateDay2);
		paramDate2Object.setHours(0);
		paramDate2Object.setMinutes(0);
		paramDate2Object.setSeconds(0);
		var paramDate2ObjectTime=paramDate2Object.getTime();
		
		if(paramDate2Object>paramDate1Object)
		{
			DSTAdjust=(paramDate2Object.getTimezoneOffset() - paramDate1Object.getTimezoneOffset()) * oneMinute;			
		}
		else
		{
			DSTAdjust=(paramDate1Object.getTimezoneOffset() - paramDate2Object.getTimezoneOffset()) * oneMinute;
		}
		
		if(typeof intervalObject[this.interval]!="undefined")
		{
			if(typeof intervalObject[this.interval].units=="undefined")
			{
				// Interval is invalid
				return false;
			}
			var negative = false;
			if( ((paramDate2ObjectTime-paramDate1ObjectTime) - DSTAdjust) < 0 )
			{
			    negative = true;
			}
			var diff=Math.abs(paramDate2ObjectTime-paramDate1ObjectTime) - DSTAdjust;			
			var timeDiff=Math.floor(diff/intervalObject[this.interval].units);
			if(timeDiff>1)
			{
				var rname=intervalObject[this.interval].measure + "s";
			}
			else
			{
				var rname=intervalObject[this.interval].measure;
			}
			if(negative)
			{
			    timeDiff = 0-timeDiff;
			}
			
			this.difference=parseInt(timeDiff);
		}
		else
		{
			this.difference=false;		
		}
		
	}
	
	function get_nextSibling(n)
    {
        y=n.nextSibling;
        while (y.nodeType!=1)
          {
          y=y.nextSibling;
          }
        return y;
    }
    
    function get_previousSibling(n)
    {
        y=n.previousSibling;
        while (y.nodeType!=1)
          {
          y=y.previousSibling;
          }
        return y;
    }

function FormatDate(dateObject){
  
  var dayString = '';
  var monthString = '';
  
  dayString = String(dateObject.getDate());
  
  if (dayString.length < 2){
    dayString = '0' + dayString;
  }
  
  monthString = String(dateObject.getMonth() + 1);
  
  if (monthString.length < 2){
    monthString = '0' + monthString;
  }
  
  return dayString + '/' + monthString  + '/' + dateObject.getFullYear();
}