function validateCurrency( strValue)
{
  var objRegExp = /(^\$\d{1,3}(,\d{3})*\.\d{2}$)|(^\(\$\d{1,3}(,\d{3})*\.\d{2}\)$)/;
  return objRegExp.test( strValue );
}

function validateTime ( strValue )
{
/************************************************
REMARKS: Returns True for time formats such as:
  HH:MM or HH:MM:SS or HH:MM:SS.mmm (where the
  .mmm is milliseconds as used in SQL Server 
  datetime datatype.  Also, the .mmm portion will 
  accept 1 to 3 digits after the period)
*************************************************/
  var objRegExp = /^([1-9]|1[0-2]):[0-5]\d(:[0-5]\d(\.\d{1,3})?)?$/;
  return objRegExp.test( strValue );
}

function validateState (strValue )
{
  var objRegExp = /^(AK|AL|AR|AZ|CA|CO|CT|DC|DE|FL|GA|HI|IA|ID|IL|IN|KS|KY|LA|MA|MD|ME|MI|MN|MO|MS|MT|NB|NC|ND|NH|NJ|NM|NV|NY|OH|OK|OR|PA|RI|SC|SD|TN|TX|UT|VA|VT|WA|WI|WV|WY)$/i; 
  return objRegExp.test(strValue);
}

function validateSSN( strValue )
{
  var objRegExp  = /^\d{3}\-\d{2}\-\d{4}$/;
  //check for valid SSN
  return objRegExp.test(strValue);
}


function validateEmail( strValue)
{
  var objRegExp  = /^[A-Za-z0-9]([A-Za-z0-9_\-\.]*)@([A-Za-z0-9_\-\.]*)(\.[A-Za-z]{2,3}(\.[A-Za-z]{2}){0,2})$/i;
  //check for valid email
  var val = objRegExp.test(strValue);
  if (val == true)
  {
	for (var i = 0; i < strValue.length; i++)
	{
		if (strValue.charAt(i) == "@")
		{
			if (strValue.charAt(i+1) == ".")
				val = false;
		}
		if (strValue.charAt(i) == ".")
		{
			if (strValue.charAt(i+1) == ".")
				val = false;
		}
	}
  }
  return val;
}
function validateUSPhone( strValue )
{
/************************************************
 Validates that a string contains valid
  US phone pattern. 
  Ex. (999) 999-9999 or (999)999-9999
*************************************************/
 //var objRegExp  = /^\([1-9]\d{2}\)\s?\d{3}\-\d{4}$/;
  var objRegExp  = /(^\([1-9]\d{2}\)\s?\d{3}\-\d{4}$)|(^\+((\d{1})|(\d{2})|(\d{3}))\([1-9]\d{2}\)\s?\d{3}\-\d{4}$)/;
  
  //check for valid us phone with or without space between 
  //area code
  return objRegExp.test(strValue); 
}

function  validateNumeric( strValue )
{
/*****************************************************************
DESCRIPTION: Validates that a string contains only valid numbers.
*****************************************************************/
  var objRegExp  =  /(^-?\d\d*\.\d*$)|(^-?\d\d*$)|(^-?\.\d\d*$)/; 
  //check for numeric characters 
  return objRegExp.test(strValue);
}

function validateInteger( strValue )
{
/************************************************
DESCRIPTION: Validates that a string contains only 
    valid integer number.
*************************************************/
  var objRegExp  = /(^-?\d\d*$)/;
  //check for integer characters
  return objRegExp.test(trim(strValue));
}

function validatePositiveInteger( strValue )
{
/************************************************
DESCRIPTION: Validates that a string contains only 
    valid positive integer or decimal.
*************************************************/
  var objRegExp  = /(^\d\d*$)/;
  //check for positive integers
  return objRegExp.test(trim(strValue));
}

function validateNotEmpty( strValue )
{
/************************************************
DESCRIPTION: Validates that a string is not all
  blank (whitespace) characters.
*************************************************/
   var strTemp = strValue;
   strTemp = trimAll1(strTemp);
   if(strTemp.length > 0){
     return true;
   }  
   return false;
}

function validateUSZip( strValue )
{
/************************************************
DESCRIPTION: Validates that a string a United
  States zip code in 5 digit format or zip+4
  format. 99999 or 99999-9999
*************************************************/
var objRegExp  = /(^\d{5}$)|(^\d{5}-\d{4}$)/;
 
  //check for valid US Zipcode
  return objRegExp.test(strValue);
}

function validateUSDate( strValue,flag )
{
/************************************************
DESCRIPTION: Validates that a string contains only 
    valid dates with 2 digit month, 2 digit day, 
    4 digit year. Date separator can be ., -, or /.
    Uses combination of regular expressions and 
    string parsing to validate date.
    Ex. mm/dd/yyyy or mm-dd-yyyy or mm.dd.yyyy
*************************************************/
  var objRegExp = /^\d{2}(\-|\/|\.)\d{2}\1\d{4}$/
 
  //check to see if in correct format
  if(!objRegExp.test(strValue))
  {
    return false; //doesn't match pattern, bad date
  }
  else
  {
    var arrayDate = strValue.split(RegExp.$1); //split date into month, day, year
	var intDay = parseInt(arrayDate[1],10); 
	var intYear = parseInt(arrayDate[2],10);
    var intMonth = parseInt(arrayDate[0],10);
	var today = new Date()
	var curYear = today.getFullYear();
	if (document.layers) 
	{
		curYear = curYear + 1900;
	}
	
	//check for valid month
	if((intMonth > 12) || (intMonth < 1) || (intYear < (curYear - 200)) || (intYear > (curYear + 200)))
	{	    
		return false;
	}
	
	//check if current year is greater then entered date
	if (flag != true) //gendral
	{
		var givenDate = new Date(intMonth + "/" + intDay + "/" + intYear);
		if (givenDate > today)
		{
			return false;
		}
	}
	
    //create a lookup for months not equal to Feb.
    var arrayLookup = { '01' : 31,'03' : 31, '04' : 30,'05' : 31,'06' : 30,'07' : 31,
                        '08' : 31,'09' : 30,'10' : 31,'11' : 30,'12' : 31}
  
    //check if month value and day value agree
    if(arrayLookup[arrayDate[0]] != null)
     {
      if(intDay <= arrayLookup[arrayDate[0]] && intDay != 0)
      {
        return true; //found in lookup table, good date
      }
    }
		
    //check for February
	var booLeapYear = (intYear % 4 == 0 && (intYear % 100 != 0 || intYear % 400 == 0));
    if( ((booLeapYear && intDay <= 29) || (!booLeapYear && intDay <=28)) && intDay !=0)
    {
      return true; //Feb. had valid number of days
    }
  }
  return false; //any other values, bad date
}

function validateString( strValue ) {

/********************************************
DESCRIPTION: Validates only for alphabets
*********************************************/
	//var objRegExp  =  /(^[\a-z]*$)|(^[\A-Z]*$)|(^[\A-Z][\a-z]*$)/;
	//return objRegExp.test(strValue); 

   if (!strValue) return false;
   var iChars = "*|,\":<>[]{}`\';()@&$#%1234567890";

   for (var i = 0; i < strValue.length; i++) {
      if (iChars.indexOf(strValue.charAt(i)) != -1)
         return false;
   }
   return true;
}


function RemoveBR(input) 
{
// Removes carriage returns 

var output = "";
for (var i = 0; i < input.length; i++) {
if ((input.charCodeAt(i) == 13) && (input.charCodeAt(i + 1) == 10)) {
i++;
output += "";
} else {
output += input.charAt(i);
   }
}
return output;
}


//Same as trimAll, diffrence is that this is used in validateNotEmpty()
function trimAll1( strValue )
{
/************************************************
DESCRIPTION: Removes leading and trailing spaces.
*************************************************/ 
 var objRegExp = /^(\s*)$/;

    strValue = RemoveBR(strValue);
    //check for all spaces
    if(objRegExp.test(strValue)) {
       strValue = strValue.replace(objRegExp, '');
       if( strValue.length == 0)
          return strValue;
    }
    
   //check for leading & trailing spaces
   objRegExp = /^(\s*)([\W\w]*)(\b\s*$)/;
   if(objRegExp.test(strValue)) {
       //remove leading and trailing whitespace characters
       strValue = strValue.replace(objRegExp,'$2');
    }
  
  return strValue;
}
/* To limit the length of text area 
pass the control name and maxlength */

function textCounter(field, maxlimit) 
{
	if (field.value.length > maxlimit) // if too long...trim it!
	field.value = field.value.substring(0, maxlimit);
	
}

/*****************************************************
DESCRIPTION: Validates Number datatypes with 2 decimals
*****************************************************/

// function to round the value to 2 decimal places       
function Rounder(val,decs) 
{
	var multiplier = 10    
	for (var i = 1;i<decs;++i)
		multiplier = (multiplier * 10) ;
	if (decs==0)
		return Math.round(val);
	else  
		return (Math.round(val *multiplier))/multiplier;  
}




//This function trims the given string and checks for unnecessary spaces

function IsValidFee(ctrl)
{
	ctrl.value=	trim(ctrl.value);
	if	(isNaN(ctrl.value )||(ctrl.value==""))
	{
		alert("Invalid Entry! Please enter a Valid Number.");
		//ctrl.value ="";
		ctrl.focus();
		ctrl.select();
		return false;
	}
	return true;
}

function trim( inputStringTrim ) 
{
//function to trims the given string and checks for unnecessary spaces
	fixedTrim = "";
	lastCh = " ";
	for (x=0; x < inputStringTrim.length; x++) 
	{
		ch = inputStringTrim.charAt(x);
		if ((ch != " ") || (lastCh != " ")) 
		{ 
			fixedTrim += ch; 
		}
		lastCh = ch;
	}
		if (fixedTrim.charAt(fixedTrim.length - 1) == " ") {
			fixedTrim = fixedTrim.substring(0, fixedTrim.length - 1); 
		}
		return fixedTrim
}

function validateFloat(ctrl,maxlen) 
{

/*
The following functions are used internally.
1. function Rounder(val,decs) 
2. function PadDecimal(val, decs)
3. function IsValidFee(ctrl)
4. function trim( inputStringTrim ) 

*/
	ctrl.value = trim(ctrl.value)

	for (x=0; x <ctrl.value.length; x++) 
	{
		ch = ctrl.value.charAt(x);
		//alert(ch);
		if (ch == ".") 
			break;
	}
	maxlen=maxlen - 3;
	if(x > maxlen)
	{
		alert("The number entered should be less than or \nequal to "+ maxlen + " digits with 2 decimal places.");
		ctrl.focus();
		return false;
	}	
	

	if (trim(ctrl.value) =="")
	{
		ctrl.value = 0;
	}
	else 
	{
		//if(!isNaN(ctrl.value))
		//	ctrl.value= Rounder(ctrl.value,2)
		if (! IsValidFee(ctrl)) 
		{
			return false;
		}
		ctrl.value= Rounder(ctrl.value,2)
	}
	
	return true;
}
/************************************************************/

function validatePositiveFloat(ctrl,maxlen) 
{
	ctrl.value = trim(ctrl.value)
	if(!validatePositiveInteger(ctrl.value))
	{
	    alert("Invalid Entry! Please enter a Positive Number");
	    ctrl.focus();    
	    return false;
	}
	return validateFloat(ctrl,maxlen) 
}
/*******************************************************
DESCRIPTION: Validates startdate is smaller then end date
*********************************************************/
function validateTwoDates(startDate, endDate) {

    var objStartDate = new parseDate(startDate);

    var objEndDate = new parseDate(endDate);
    var diff = (objEndDate.getTime() - objStartDate.getTime());
    //objDtStart = new Date(startDate.toString().replace("-","/"));
    //objDtEnd = new Date(endDate.toString().replace("-","/"));     
    //var browserName=navigator.userAgent;           
    if ((diff) >= 0) {
        return true;
    }
    else {
        return false;
    }

}

/***********************************************************/
//Modified By:mayuri shah
//Date:7/1/2010
//Description: open a popup window.
/***********************************************************/

function winOpen(targeturl) {
    window.open(targeturl, null, "height=400,width=400,status=yes,toolbar=no,menubar=no,location=no");
    return false;
}

/******************************************************/
//Modified By:mayuri shah
//Date:7/1/2010
//Description: Function counts the characters.
/*****************************************************/
function textCounter(field,cntfield,maxlimit) {

    if (field.value.length > maxlimit) {
        field.value = field.value.substring(0, maxlimit);
    }
    else {
        cntfield.value = maxlimit - field.value.length;
}
}

function validatePositiveIntegerEntry(e) {
    /************************************************
    DESCRIPTION: Validates that a keystroke entry contains only 
    valid positive integer.
    *************************************************/
    var keynum;
    var keychar;

    if (window.event) // IE
    {
        keynum = e.keyCode;
    }
    else if (e.which) // Netscape/Firefox/Opera
    {
        keynum = e.which;
    }
    keychar = String.fromCharCode(keynum);

    return validatePositiveInteger(keychar);
}
// ===================================================================
// 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
// ------------------------------------------------------------------
// May 17, 2003: Fixed bug in parseDate() for dates <1970
// 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 = now.getYear();
    var month = now.getMonth() + 1;
    var date = 1;
    var hh = now.getHours();
    var mm = now.getMinutes();
    var ss = now.getSeconds();
    var ampm = "";

    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 > 70) { 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 == 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; } }
    }
    if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) {
        if (date > 30) { return 0; }
    }
    // Correct hours value
    if (hh < 12 && ampm == "PM") { hh = hh - 0 + 12; }
    else if (hh > 11 && ampm == "AM") { hh -= 12; }
    var newdate = new Date(year, month - 1, date, hh, mm, ss);
    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 parseDate(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');
    dateFirst = new Array('d/M/y', 'd-M-y', 'd.M.y', 'd-MMM', 'd/M', 'd-M');
    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 != 0) { return new Date(d); }
        }
    }
    return null;
}