var daysInMonth = new Array();
  daysInMonth[1] = 31;
  daysInMonth[2] = 29;
  daysInMonth[3] = 31;
  daysInMonth[4] = 30;
  daysInMonth[5] = 31;
  daysInMonth[6] = 30;
  daysInMonth[7] = 31;
  daysInMonth[8] = 31;
  daysInMonth[9] = 30;
  daysInMonth[10] = 31;
  daysInMonth[11] = 30;
  daysInMonth[12] = 31;

//-------------------------------------------------
function trim(text){
  text = text.replace(/^\s+/g, "");
  return text.replace(/\s+$/g, "");
}
//-------------------------------------------------
function isEmpty(text) {
  return ((text == null) || (text.length == 0));
}
//-------------------------------------------------
function isInteger(text) {
  var reInteger = /^\d+$/;
  
  return reInteger.test(text)
}
//-------------------------------------------------
function stringToDate(dateAsString) {
  // Converts a string date to a javascript date object
  // Allows date comparisons to be performed.
  // Assumes string date has been validated using the validateDate function
  var dateParts = dateAsString.split("/");
  var year = parseInt(dateParts[2], 10);
  var month = parseInt(dateParts[1], 10);
  var day = parseInt(dateParts[0], 10);
  return new Date(year, month - 1, day);
}
//-------------------------------------------------
function daysInFebruary (year) {
  return ( ((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0) ) ) ? 29 : 28 );
}
//-------------------------------------------------
function validateDate(objInput, allowEmpty, alertError, error) {
  
  if (validateDate.arguments.length < 4) {
    error = "";
  }
  else {
    error += "\n";
  }
  
  if (validateDate.arguments.length < 3) {
      alertError = true;
  }
  
  if (validateDate.arguments.length < 2) {
    allowEmpty = false;
  }

  try {
    if (isEmpty(objInput.value) && allowEmpty) {
      return true;
    }
    else {
      if (isEmpty(objInput.value)) {
        throw error + "A date is required for this field.";
      }
      
      var dateParts = objInput.value.split("/");

      if (!((isInteger(dateParts[0])) && (isInteger(dateParts[1])) && (isInteger(dateParts[2])))) {
        throw error + "Date must be of the format 31/12/1999";
      }

      var year = parseInt(dateParts[2], 10);
      var month = parseInt(dateParts[1], 10);
      var day = parseInt(dateParts[0], 10);

      if (isNaN(year) || isNaN(month) || isNaN(day)) {
        throw error + "Date must be of the format 31/12/1999";
      }

      if ((month < 1) || (month > 12)) {
        throw error + "Month must be between 1 and 12";
      }

      if ((day < 1) || (day > daysInMonth[month]) || ((month == 2) && (day > daysInFebruary(year)))){
        throw error + "Invalid number of days for this month"
      }

      if ((year < 1900) || (year > 2100)) {
        throw error + "Year must be specified using four digits and between 1900 and 2100";
      }
      return true;
    }
  }
  catch(error) {
    if (alertError) {
      alert(error);
      objInput.select();
    }
    return false;
  }
}
//-------------------------------------------------

// Validates that a given input control contains a valid number
function validateNumber(objInput,cMsg,allowEmpty, minValue, maxValue) {  
  if (validateNumber.arguments.length < 2) {
    cMsg = "";
  }

  if (validateNumber.arguments.length < 3) {
    allowEmpty = false;
  }

  if ((validateNumber.arguments.length < 4) || isNaN(minValue) || isEmpty(minValue)) {
    minValue = Number.NEGATIVE_INFINITY;
  }

  if ((validateNumber.arguments.length < 5) || isNaN(maxValue) || isEmpty(maxValue)) {    
    maxValue = Number.POSITIVE_INFINITY;
  }
  
  if (maxValue == "" || isNaN(maxValue) || isEmpty(maxValue)|| maxValue == NaN) {
    alert("null found");
  }

  if  (cMsg != "") {
    cMsg = cMsg + ".  ";
  }
    
  try {
    if (isEmpty(objInput.value) && allowEmpty) {
      return true;
    }
    else {
      if (isNaN(objInput.value) || isEmpty(objInput.value)) {
        throw cMsg+"Please enter a valid number.";
    }    
    
    if ((Number(objInput.value) < Number(minValue)) || (Number(objInput.value) > Number(maxValue))) {
      if ((minValue != Number.NEGATIVE_INFINITY) && (maxValue != Number.POSITIVE_INFINITY)) {
        throw cMsg + "Value must be between " + minValue + " and " + maxValue;
      }
      else {
        if (maxValue == Number.POSITIVE_INFINITY) {
          throw cMsg + "Value must be greater than " + minValue;
        }
        else {
          throw cMsg + "Value must be less than " + maxValue;
        }
      }
    }

      return true;
    }
  }
  catch(error) {
    alert(error);
    objInput.select();
    objInput.focus();
    return false;
  }
}
//-------------------------------------------------
function upperCaseKeyPress() {
  var key = String.fromCharCode(window.event.keyCode).toUpperCase();
  window.event.keyCode = key.charCodeAt(0);
}
//-------------------------------------------------
//Ensures only keypresses that would allow valid numbers are allowed
// allowReal and allowSigned default to false

function numericKeyPress(allowReal, allowSigned) {
  var chars = "1234567890";

  if (numericKeyPress.arguments.length < 1) {
    allowReal = false;
  }

  if (numericKeyPress.arguments.length < 2) {
    allowSigned = false;
  }

  if (allowReal) {
    chars += ".";
  }

  if ((chars.indexOf(String.fromCharCode(window.event.keyCode)) == -1) ||
    ((String.fromCharCode(window.event.keyCode) == ".") &&
    ((window.event.srcElement.value.indexOf(".") != -1)))) {
    window.event.returnValue = false;
  }

  if ( (chars.indexOf(String.fromCharCode(window.event.keyCode)) != -1) &&
    (String.fromCharCode(window.event.keyCode) == ".") &&
    (window.event.srcElement.value.length == 0) ) {
    window.event.srcElement.value = "0";
  }

  if (allowSigned && (String.fromCharCode(window.event.keyCode) == "-")) {
    if (window.event.srcElement.value.indexOf("-") == 0) {
      window.event.srcElement.value = window.event.srcElement.value.substr(1);
    }
    else {
      window.event.srcElement.value = "-" + window.event.srcElement.value;
    }
  }

}
//----------------------------------------------------------------
//function formats text numbers to the number of decimal places specified.
//It defaults to 2 decimal places if it is not specified.

function formatNumber(num, decimals, allowNull, midPointRoundsUp) {
  if (arguments.length < 4) {
    midPointRoundsUp = true;
  }

  if (arguments.length < 3) {
    allowNull = false;
  }

  if ( (allowNull) && (num == "") ) {
    return "";
  }

  if ( (arguments.length < 2) || (decimals == null) ) {
     decimals = 2;
  }

  if (decimals == 0)  {
    if (midPointRoundsUp) {
      return Math.round(Number(num));
    }
    else {
      return -Math.round(-Number(num));
    }
  }
  
  if (decimals > 0)  {
    var intPart;
    var fracPart = "";
    var nextDigit = "";
    
    num = Number(num);

    if (isNaN(num) || (num > 9999999999999) || (num < -9999999999999) ) {
      return "n/a";
    }

    var isNegative = (num < 0);

    num = Math.abs(num);

    var numAsString = num + "";

    var decimalPos = numAsString.indexOf('.');

    if (decimalPos > -1) {
      intPart = numAsString.substr(0, decimalPos);
      fracPart = numAsString.substr(decimalPos + 1, decimals);
      nextDigit = numAsString.substr(decimalPos + 1 + decimals, 1);
    }
    else {
      intPart = numAsString;
    }

    // pad fracPart with zeros until it's of length decimals
    while (fracPart.length < decimals) {
      fracPart += "0";
    }

    nextDigit = Number(nextDigit); 

    var newNum = Number(intPart + fracPart);

    if (nextDigit > (midPointRoundsUp ? 4 : 5) ) {
      newNum += 1;
    }

    newNum += "";

    while (newNum.length < decimals) {
      newNum = "0" + newNum;
    }

    fracPart = newNum.substr(newNum.length - decimals);
    intPart = Number(newNum.substring(0, newNum.length - decimals));

    newNum = Number(intPart + "." + fracPart);

    return ((isNegative && (newNum != 0)) ? "-" : "") + intPart + "." + fracPart;
  }
}
//----------------------------------------------------------------
function formatEdit(Control, decimals, allowNull){
  if (formatEdit.arguments.length < 2) {
    decimals = 2;
  }

  if (formatEdit.arguments.length < 3) {
    allowNull = false;
  }
  formatEditControl(document.all(Control), decimals, allowNull);
}
//-------------------------------------------------
//function formats edit control numbers to the number of decimal places specified.
//It defaults to 2 decimal places if it is not specified.

function formatEditControl(control, decimals, allowNull){
  if (control) {
    if (formatEditControl.arguments.length < 2) {
      decimals = 2;
    }
    if (formatEditControl.arguments.length < 3) {
      allowNull = false;
    }
    control.value = formatNumber(control.value, decimals, allowNull);
  }
}
//-------------------------------------------------
// function will only accept letters and will convert them to uppercase
function upperCaseKeyPressOnly(){

  var key = String.fromCharCode(window.event.keyCode).toUpperCase();
  var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  
  if (chars.indexOf(key) == -1){
  window.event.keyCode = "";
  }else{
  window.event.keyCode = key.charCodeAt(0);
  };

  
  
}