<!--//<%

var MANDATORY_MESSAGE = "This field is required.";

var nbsp = 160;    // non-breaking space char
var node_text = 3; // DOM text node-type
emptyString = /^\s*$/

function prepareJSArgument(str)
{
	var result;
	if (!isNull(str))
		result=(str+"").replace(/([^\\])(["'])/g,"$1\\$2").replace(/\r\n|\n|\r/g,"\\n");
	else 
		result="";
	return result;
}
//formats a string depending on the type of quotes used...
//stringQuoteChar can be " or ' 
function escapeQuotes(stringQuoteChar, str)
{
	if(isNull(str))
		return "";
	str = str+"";
	if(stringQuoteChar == '"')
	{
		return str.replace(/(?![\\])"/g, '\\"'); 
	}
	
	if(stringQuoteChar == "'")
	{
		return str.replace(/(?![\\])'/g, "\\'"); 
	}
}

function toHTMLQuotes(stringQuoteChar, str)
{
	if(isNull(str))
		return "";
	str = str+"";
	if(stringQuoteChar == '"')
	{
		return str.replace(/(?![\\])"/g, '&quot;'); 
	}
	
	if(stringQuoteChar == "'")
	{
		return str.replace(/(?![\\])'/g, "&#039;"); 
	}
}

function trim(str)
{
  return str.replace(/(^\s+)|(\s+$)/g, '')
}

function msg(fld,     // id of element to display message in
             msgtype, // class to give element ("warn" or "error")
             message) // string to display
{

  // setting an empty string can give problems if later set to a 
  // non-empty string, so ensure a space present. (For Mozilla and Opera one could 
  // simply use a space, but IE demands something more, like a non-breaking space.)
  var dispmessage;
  
  if (emptyString.test(message)) 
    dispmessage = null;//String.fromCharCode(nbsp);    
  else  
    dispmessage = message;

  var elem = document.getElementById(fld);
  
  elem.innerHTML = dispmessage ? dispmessage : "<span></span>";  
  elem.className = dispmessage ? msgtype : null;
}

function isDisabled(vfld)
{
   var isDisabled = vfld && ((vfld.disabled === true) || (vfld.readOnly === true));
   return isDisabled;
}

function checkNumber(vfld,ifld,mandatory,maxLength,min,max,minWarn,maxWarn)	{ 
	var tfld = Number(trim(vfld.value.replace(/,/g,"")));
	
	if (isDisabled(vfld))
	{
	   msg (ifld, "red", (mandatory)?"*":"");
	   return true;
	}
	   
	if(mandatory && isNull(trim(vfld.value))){
		msg (ifld, "red", MANDATORY_MESSAGE);
    	vfld.focus();
   	return false;
	}
	
	///// dont check anything if the field is empty
	if(!isNull(trim(vfld.value))){	
		if(tfld+"" == 'NaN'){
		  	msg (ifld, "red", "Not a valid number.");
	    	vfld.focus();
	   	return false;
		}
		
	////////////////////////////////////////////////////////////////////
	///// check if the min and max thresholds are correct
			
		if(!isNull(min)){
			min = Number(min);
			if(min+"" == 'NaN'){
				msg (ifld, "red", "ERROR: Coding Error: not a valid Min Value");
	    		vfld.focus();
				return false;
			}
		}
		
		if(!isNull(max)){
			max = Number(max);
			if(max+"" == 'NaN'){
				msg (ifld, "red", "ERROR: Coding Error: not a valid Max Value");
	    		vfld.focus();
				return false;
			}
			if(!isNull(min) && (min > max)){
				msg (ifld, "red", "ERROR: Coding Error: Min value cannot be greater than Max Value");
	    		vfld.focus();
				return false;
			}
		}
		
		if(!isNull(minWarn)){
			minWarn = Number(minWarn);
			if(minWarn+"" == 'NaN'){
				msg (ifld, "red", "ERROR: Coding Error: not a valid minWarn Value");
	    		vfld.focus();
				return false;
			}
			if(!isNull(min) && (minWarn < min)){
				msg (ifld, "red", "ERROR: Coding Error: Min warning value cannot be less than min Value");
	    		vfld.focus();
				return false;
			}
		}
		
		if(!isNull(maxWarn)){
			maxWarn = Number(maxWarn);
			if(maxWarn+"" == 'NaN'){
				msg (ifld, "red", "ERROR: Coding Error: not a valid maxWarn Value");
	    		vfld.focus();
				return false;
			}
			
			if(!isNull(max) && (maxWarn > max)){
				msg (ifld, "red", "ERROR: Coding Error: Max warning value cannot be greater than Max Value");
	    		vfld.focus();
				return false;
			}
			
			if(!isNull(minWarn) && (minWarn > maxWarn)){
				msg (ifld, "red", "ERROR: Coding Error: Min Warn value cannot be greater than Max warn Value");
	    		vfld.focus();
				return false;
			}
		}
		
	////////////////////////////////////////////////	
	////now check if the input is within the acceptable ranges
	
		if(!isNull(min) && tfld < min){
			msg (ifld, "red", "Value cannot be less than '"+min+"'");
	    	vfld.focus();
	   	return false;
		}
		
		if(!isNull(max) && tfld > max ){
			msg (ifld, "red", "Value cannot be greater than '"+max+"'");
	    	vfld.focus();
	   	return false;
		}
	
	
		if(!isNull(minWarn) && tfld < minWarn ){
			msg (ifld, "red", "WARNING: Check correct");
	    	return true;
		}
		
		if(!isNull(maxWarn) && tfld > maxWarn ){
			msg (ifld, "red", "WARNING: Check correct");
	   	return true;
		}
	}
	msg (ifld, "red", (mandatory)?"*":"");
  	return true;
}



function checkString(vfld,ifld,mandatory,maxLength,min,max,minWarn,maxWarn)	{ 

   if (isDisabled(vfld))
	{
	   msg (ifld, "red", (mandatory)?"*":"");
	   return true;
	}
	
	var tfld = trim(vfld.value);

	if(mandatory && isNull(tfld)){
		msg (ifld, "red", MANDATORY_MESSAGE);
    	vfld.focus();
   	return false;
	}

	///// dont check anything if the field is empty
	if(!isNull(trim(vfld.value))){	
		if(!isNull(maxLength) && (Number(maxLength)+"" == 'NaN')){
			msg (ifld, "red", "ERROR: Coding Error:The maxLength is not a number");
	    	vfld.focus();
	   	return false;
		}
		
		if(!isNull(maxLength) && tfld.length > maxLength){
			msg (ifld, "red", "Maximum Field Size ( "+maxLength+" ).  You entered "+tfld.length);
	    	vfld.focus();
	   	return false;
		}
	}
	msg (ifld, "red", (mandatory)?"*":"");
  	return true;
}


function checkDate(vfld,ifld,mandatory,maxLength,min,max,minWarn,maxWarn)	{ 

   if (isDisabled(vfld))
	{
	   msg (ifld, "red", (mandatory)?"*":"");
	   return true;
	}
	
	//validate input date
	try{
		var tfld = parseDate(trim(vfld.value));
	}
	catch(e){
		msg (ifld, "red", "The date entered is not correct.");
    	vfld.focus();
   	return false;
	}
	
	//check if mandatory
	if(mandatory && trim(vfld.value) == ""){
		msg (ifld, "red", MANDATORY_MESSAGE);
    	vfld.focus();
   	return false;
	}

///// dont check anything if the field is empty
	if(!isNull(trim(vfld.value))){	
	////////////////////////////////////////////////////////////////////////
	/// make sure the min and max date thresholds are in the correct format
		
		if(!isNull(min)){
			//make sure the min date is a valid date
			try{
				min = parseDate(min);
			}
			catch(e){
				msg (ifld, "red", "ERROR: Coding Error: not a valid minValue date");
	   	 	vfld.focus();
	   		return false;
				
			}
		}	
	
		if(!isNull(max)){
			//make sure the max date is a valid date
			try{
				max = parseDate(max);
			}
			catch(e){
				msg (ifld, "red", "ERROR: Coding Error: not a valid maxValue date");
	   	 	vfld.focus();
	   		return false;
			}
			//check if the minimum is greater than the maximum
			if(!isNull(min) && (max.getDateInteger() < min.getDateInteger())){
				msg (ifld, "red", "ERROR: Coding Error: Maximum Value must be greater than the Minimum Value");
	   	 	vfld.focus();
	   		return false;
	   	}
		}
		
		if(!isNull(minWarn)){
			try{
				minWarn = parseDate(minWarn);
			}
			catch(e){
				msg (ifld, "red", "ERROR: Coding Error: not a valid minWarn date");
	   	 	vfld.focus();
	   		return false;
			}
	
			if(!isNull(min) && (minWarn.getDateInteger() < min.getDateInteger())){
				msg (ifld, "red", "ERROR: Coding Error: minWarn date must be greater than the minimum date");
	   	 	vfld.focus();
	   		return false;
			}
		}
		
		if(!isNull(maxWarn)){
			try{
				maxWarn = parseDate(maxWarn);
			}
			catch(e){
				msg (ifld, "red", "ERROR: Coding Error: not a valid maxWarn date");
	   	 	vfld.focus();
	   		return false;
			}
			if(!isNull(max) && (maxWarn.getDateInteger() < max.getDateInteger())){
				msg (ifld, "red", "ERROR: Coding Error: maxWarn date must be greater than the maximum date");
	   	 	vfld.focus();
	   		return false;
			}
			
			if(!isNull(minWarn) && (maxWarn.getDateInteger() < minWarn.getDateInteger())){
				msg (ifld, "red", "ERROR: Coding Error: Maximum Warn Value must be greater than the Minimum Warn Value");
	   	 	vfld.focus();
	   		return false;
	   	}
		}
		
		
	//done checking correctness
	//////////////////////////////////////////////////////////////////////////
	/// now check if the input is within the acceptable ranges
	if(!isNull(min)){
			//make sure the input date is not less than the minimum
			if(tfld.getDateInteger() < min.getDateInteger()){
				msg (ifld, "red", "Value cannot be less than '"+dateToString(min)+"'");
	   	 	vfld.focus();
	   		return false;
	   	}
		}
		
		if(!isNull(max)){
			//make sure the input date is not greater than the maximum  
			if( tfld.getDateInteger() > max.getDateInteger() ){
	   		msg (ifld, "red", "Value cannot be greater than '"+dateToString(max)+"'");
	   	 	vfld.focus();
	   		return false;
			}
		}
		
		if(!isNull(minWarn)){
			//warning if the input date is less than the minimum warning value  
			if( tfld.getDateInteger() < minWarn.getDateInteger()  ){
				msg (ifld, "red", "WARNING: Check correct");
	    		return true;
			}
		}
		
		if(!isNull(maxWarn)){
			//warning if the input date is greater than the maximum warning value  
			if( tfld.getDateInteger() > maxWarn.getDateInteger()  ){
				msg (ifld, "red", "WARNING: Check correct");
	    		return true;
			}
		}
	}
	// must be ok to get this far
	msg (ifld, "red", (mandatory)?"*":"");
	vfld.value = dateToString(tfld);
  return true;
}


function checkTime(vfld,ifld,mandatory,maxLength,min,max,minWarn,maxWarn)	{ 

   if (isDisabled(vfld))
	{
	   msg (ifld, "red", (mandatory)?"*":"");
	   return true;
	}
	
	//validate input date
	try{
		var tfld = parseTime(trim(vfld.value),true,true);
	}
	catch(e){
		msg (ifld, "red", "The time entered is not correct.");
    	vfld.focus();
   	return false;
	}
	
	//check if mandatory
	if(mandatory && trim(vfld.value) == ""){
		msg (ifld, "red", MANDATORY_MESSAGE);
    	vfld.focus();
   	return false;
	}

///// dont check anything if the field is empty
	if(!isNull(trim(vfld.value))){	
	////////////////////////////////////////////////////////////////////////
	/// make sure the min and max date thresholds are in the correct format
		
		if(!isNull(min)){
			//make sure the min date is a valid date
			try{
				min = parseTime(min,true,true);
			}
			catch(e){
				msg (ifld, "red", "ERROR: Coding Error: not a valid minValue date");
	   	 	vfld.focus();
	   		return false;
				
			}
		}	
	
		if(!isNull(max)){
			//make sure the max date is a valid date
			try{
				max = parseTime(max,true,true);
			}
			catch(e){
				msg (ifld, "red", "ERROR: Coding Error: not a valid maxValue date");
	   	 	vfld.focus();
	   		return false;
			}
			//check if the minimum is greater than the maximum
			if(!isNull(min) && (max.getTime() < min.getTime())){
				msg (ifld, "red", "ERROR: Coding Error: Maximum Value must be greater than the Minimum Value");
	   	 	vfld.focus();
	   		return false;
	   	}
		}
		
		if(!isNull(minWarn)){
			try{
				minWarn = parseTime(minWarn,true,true);
			}
			catch(e){
				msg (ifld, "red", "ERROR: Coding Error: not a valid minWarn date");
	   	 	vfld.focus();
	   		return false;
			}
	
			if(!isNull(min) && (minWarn.getTime() < min.getTime())){
				msg (ifld, "red", "ERROR: Coding Error: minWarn date must be greater than the minimum date");
	   	 	vfld.focus();
	   		return false;
			}
		}
		
		if(!isNull(maxWarn)){
			try{
				maxWarn = parseTime(maxWarn,true,true);
			}
			catch(e){
				msg (ifld, "red", "ERROR: Coding Error: not a valid maxWarn date");
	   	 	vfld.focus();
	   		return false;
			}
			if(!isNull(max) && (maxWarn.getTime() < max.getTime())){
				msg (ifld, "red", "ERROR: Coding Error: maxWarn date must be greater than the maximum date");
	   	 	vfld.focus();
	   		return false;
			}
			
			if(!isNull(minWarn) && (maxWarn.getTime() < minWarn.getTime())){
				msg (ifld, "red", "ERROR: Coding Error: Maximum Warn Value must be greater than the Minimum Warn Value");
	   	 	vfld.focus();
	   		return false;
	   	}
		}
		
		
	//done checking correctness
	//////////////////////////////////////////////////////////////////////////
	/// now check if the input is within the acceptable ranges
		
		if(!isNull(min)){
			//make sure the input date is not less than the minimum
		 	if(tfld.getTime() < min.getTime()){
	   		msg (ifld, "red", "Value cannot be less than '"+dateToString(min)+"'");
	   	 	vfld.focus();
	   		return false;
	   	}
		}
		
		if(!isNull(max)){
			//make sure the input date is not greater than the maximum  
			if( tfld.getTime() > max.getTime() ){
	   		msg (ifld, "red", "Value cannot be greater than '"+dateToString(max)+"'");
	   	 	vfld.focus();
	   		return false;
			}
		}
		
		if(!isNull(minWarn)){
			//warning if the input date is less than the minimum warning value  
			if( tfld.getTime() < minWarn.getTime()  ){
				msg (ifld, "red", "WARNING: Check correct");
	    		return true;
			}
		}
		
		if(!isNull(maxWarn)){
			//warning if the input date is greater than the maximum warning value  
			if( tfld.getTime() > maxWarn.getTime()  ){
				msg (ifld, "red", "WARNING: Check correct");
	    		return true;
			}
		}
	}
	// must be ok to get this far
	msg (ifld, "red", (mandatory)?"*":"");
  	return true;
}






function checkEmail(vfld,ifld,mandatory,maxLength,min,max,minWarn,maxWarn){
   
   if (isDisabled(vfld))
	{
	   msg (ifld, "red", (mandatory)?"*":"");
	   return true;
	}
	
  	var tfld = trim(vfld.value);  // value of field with whitespace trimmed off
	
	//check if mandatory
	if(mandatory && isNull(tfld)){
		msg (ifld, "red", MANDATORY_MESSAGE);
    	vfld.focus();
   	return false;
	}
	
	if(!isNull(tfld)){
		var email = /^[^@]+@[^@.]+\.[^@]*\w\w$/
	  	if (!email.test(tfld)) {
	   	msg (ifld, "red", "Not a valid e-mail address.");
	    	vfld.focus();
	    	return false;
	  	}
	  	if(!checkString(vfld,ifld,mandatory,maxLength,min,max,minWarn,maxWarn))
			return false;
	  	//var email2 = /^[A-Za-z][\w.-]+@\w[\w.-]+\.[\w.-]*[A-Za-z][A-Za-z]$/
	  	//if (!email2.test(tfld)) {
	   	//msg (ifld, "red", "WARNING: Unusual e-mail address - check if correct");
	  	//}
	}else{
		msg (ifld, "red", "");
	}
	
  	return true;
}

function checkPhoneNumber(vfld,ifld,mandatory,maxLength,min,max,minWarn,maxWarn)
{
   if (isDisabled(vfld))
	{
	   msg (ifld, "red", (mandatory)?"*":"");
	   return true;
	}
	
  	var tfld = trim(vfld.value);  // value of field with whitespace trimmed off
	
	//check if mandatory
	if(mandatory && isNull(tfld))
	{
		msg (ifld, "red", MANDATORY_MESSAGE);
    	vfld.focus();
   	return false;
	}
	
	if(!isNull(tfld))
	{
		var phone = /[a-z]+/ig;
		
	  	if (phone.test(tfld)) 
	  	{
	   	msg (ifld, "red", "Not a valid phone number.");
	    	vfld.focus();
	    	return false;
	  	}
	  	
	  	if (!checkString(vfld,ifld,mandatory,maxLength,min,max,minWarn,maxWarn))
			return false;
	}
	else
	{
		msg (ifld, "red", "");
	}
	
  	return true;
}

function showCharCount(vfld, ifld, maxLength)
{
   if (isDisabled(vfld))
	{
	   msg (ifld, "red", "");
	   return true;
	}
	
	if(!vfld)
		return;
		
	var cnt = vfld.value.length;
	var maxNum = !isNaN(Number(maxLength)) ? Number(maxLength) : 0;
	var ml = maxNum > 0 ? '/' + maxLength + ' Characters Used': "";
	var msgStr = (cnt > 0 ? '<span class="charCountMessage">' + cnt + ml + '</span>' : ""); 
	var classStr = "";
	if(maxNum > 0 && cnt > maxNum)
		classStr = "red";
	
	msg(ifld, classStr, msgStr);	
}

function isNull(obj)	{
	/*
	switch (true){
		case (arguments.length != 1) 	:debug("arguments 0"			); break;
		case (obj+"" == "") 				:debug("obj is '' "			); break;
		case (obj == null) 				:debug("obj is null"			); break;
		case (obj == NaN) 				:debug("NaN"					); break;
		case (obj == undefined) 		:debug("undefined"			); break;
		case (obj=="null") 				:debug("'null'"				); break;
	}
	*/
	return  (arguments.length != 1) || (obj == null) || (obj == undefined) || (obj +"" == "") || (obj == NaN) || (obj=="null");
}


function nullValue( iInput, iNullValue ) {
	if (isNull(iInput)) 
		return iNullValue;
	else
		return iInput;
}

/*
date formatting functions:
	
	dateToTimeString(inputDate,showHrs,showMin,showSec);
	dateToString(inputDate);
	isLeapYear(year);
	isAlpha(test_char);
	parseDate(date_string, month_before_day);
	parseTime(time_string, showHrs, showMin, showSec);
*/
///////////////////////////////////////////////////////////////////////////////////



var todayDateString = dateToString(new Date());

function dateToTimeString(inputDate,showHrs,showMin,showSec)	{
	
	if(isNull(inputDate))
		return "";
	
	time_string = "";

	if(isNull(showHrs)&& isNull(showMin) && isNull(showSec)){
			var showHrs = true;
			var showMin = true;
			var showSec = true;
	}	
	else {
		if(isNull(showHrs))
			var showHrs = false;
		
		if(isNull(showMin))
			var showMin = false;
		
		if(isNull(showSec))
			var showSec = false;
	}
	
	var hrs = inputDate.getHours();
	
	var mins  = inputDate.getMinutes();
	if(Number(mins) < 10)
		mins = "0"+mins;
	
	var secs  = inputDate.getSeconds();
	if(Number(secs)< 10)	
			secs = "0"+secs;
	if(isNull(hrs)||isNull(mins)||isNull(secs))
		return "";
	switch(true){
		case showHrs && showMin && showSec : time_string += hrs+":"+mins+":"+secs; 	break; 
		case showHrs && showMin 			  : time_string += hrs+":"+mins; 				break; 
		case showHrs && showSec 			  : time_string += hrs+":"+secs;				break; 
		case showMin && showSec 			  : time_string += mins+":"+secs; 				break; 
		case showHrs							  : time_string += ""+hrs;                    	break;
		case showMin							  : time_string += ""+mins;                   	break;
		case showSec							  : time_string += ""+secs;                   	break;
		default : 
	}
	
	return time_string;
	
}


function dateToString(inputDate)	{


		if(isNull(inputDate))
			return "";
		var months = new Array('JAN','FEB','MAR','APR','MAY','JUN','JUL','AUG','SEP','OCT','NOV','DEC');

		var day_of_month = inputDate.getDate();
		var month = inputDate.getMonth();
		var year = inputDate.getFullYear();
		
		var date_string = new String("");

		if (day_of_month < 10) {
			date_string = '0' + day_of_month;
		} else {
			date_string = '' + day_of_month;
		}


		for (var i=0; i<12; i++)
		{
			if (month == i) {
				date_string+='-' + months[i];
				break;
			}
		}

		if (year < 1000) {
			date_string += '-0' + year;
		} else {
			date_string += '-' + year;
		}
		
		return date_string;

}



function isLeapYear(year)
{
	if ((year%100)==0) {
		if ((year%400)==0) {
			return true;
		} else {
			return false;
		}
	} else {
		if ((year%4)==0) {
			return true;
		} else {
			return false;
		}
	}
}



function isDigit(test_char)
{
	var test_digit = parseInt(test_char);

	if (isNaN(test_digit)) return false;

	for (var i=0;i<10;i++)
	{
		if (test_digit == i)
			return true;
	}
	return false;

}

function isAlpha(test_char)
{
	var alphas = new Array("A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z");

	for (var i=0; i<alphas.length; i++)
	{
		if (test_char.toUpperCase() == alphas[i])
			return true;
	}
	return false;
}



function parseTime(time_string,showHrs,showMin,showSec)	{
	
	if (isNull(time_string)) {
		return "";
	}

	var timeREX = new Array();

	timeREX[0] = /^([0-1]{0,1}[0-9]{1}){1}$/; 															//0 - 19 hh 		eg: 07
	timeREX[1] = /^(2[0-3]){1}$/; 																			//20 - 23 hh      eg: 22
	timeREX[2] = /^([0-1]{0,1}[0-9]{1}){1}\W{0,1}[0-5]{1}[0-9]{1}$/;								//0-19:00         eg: 10:07
	timeREX[3] = /^((2[0-3]){1})\W{0,1}[0-5]{1}[0-9]{1}$/;											//20-23:mm        eg: 23:00
	                                                                                                      
	timeREX[4] = /^((0{0,1}[1-9]{1}){1})\s*((am|pm)|(AM|PM))*?\b$/; 							//1-9am/pm        eg: 7am 7 pm
	timeREX[5] = /^((1[0-2]{1}){1})\s*((am|pm)|(AM|PM))*?\b$/;									//10-12am/pm      eg: 11pm 11 PM
	timeREX[6] = /^((0{0,1}[1-9]{1}){1})\W{0,1}[0-5]{1}[0-9]{1}\s*((am|pm)|(AM|PM))*?\b$/; 	//1-9:mm am/pm    eg: 1:06 pm 01:10 am
	timeREX[7] = /^((1[0-2]{1}){1})\W{0,1}[0-5]{1}[0-9]{1}\s*((am|pm)|(AM|PM))*?\b$/;		//10-12:mm am/pm  eg: 11:17 am 12:09PM

	var timeOk = 0;
	var is24Hr = true;
	var isPM = false;
	for(var iTime = 0; iTime < timeREX.length; iTime++){
		if(timeREX[iTime].test(time_string)){
			if(iTime >= 0 && iTime <= 3){ //inside 24hr time range
				//do nothing
			}else if(iTime >= 4 && iTime <= 7) {//inside am pm time range
				is24Hr = false;	
				if(time_string.toLowerCase().charAt(time_string.length-2) == 'p'){
					isPM = true;
				}
				
				time_string = time_string.replace(/\s*(am|pm)*?\b$/,"");
			}
			timeOk = 1;
			break; //time is ok
		}
	}
	if(timeOk == 0){
		throw timeOk;
	}
	
	parsedTime = new Date();

	if(isNull(showHrs)&& isNull(showMin) && isNull(showSec)){
			var showHrs = true;
			var showMin = true;
			var showSec = true;
	}	
	else {
		if(isNull(showHrs))
			var showHrs = false;
		
		if(isNull(showMin))
			var showMin = false;
		
		if(isNull(showSec))
			var showSec = false;
	}
	
	var tmp = "";
	var hours = "";
	var minutes = "";
	var seconds = "";
	var tmpIndex;

	var iTime = time_string.length - 1; //start from the last digit
	
	if(time_string.length > 2){
		
		//traverse along the string until the time separator is found or two digits are satisfied then move next time measure
		if(showSec){
			tmpIndex = 0;
			while( (iTime > -1) && (tmpIndex < 2) ){
				if(Number(tmp = time_string.charAt(iTime))+"" != 'NaN' ){
					seconds = tmp + seconds;
					tmpIndex++;
				}
				else {
					if(tmpIndex !=0){
						tmpIndex = 3;
						iTime--;
					}

				}
				iTime--;
			}
		}
		
			
		if(showMin){
			tmpIndex = 0;
			while( (iTime > -1) && (tmpIndex < 2)){
				if(Number(tmp = time_string.charAt(iTime))+"" != 'NaN'){
					minutes = tmp + minutes;
					tmpIndex++;
				}
				else {
					if(tmpIndex !=0){
						tmpIndex = 3;
						iTime--;
					}
				}
				iTime--;
			}

		}
		
		
	if(showHrs){
			tmpIndex = 0;
			while( (iTime > -1) && (tmpIndex < 2)){
				if(Number(tmp = time_string.charAt(iTime))+"" != 'NaN' ){
					hours = tmp + hours;
					tmpIndex++;
				}
				else {
					if(tmpIndex !=0){
						tmpIndex = 3;
						iTime--;
					}

				}
				iTime--;
			}

		}
	}
	else{
		if(showHrs){
			hours = Number(time_string.charAt(iTime-1)) +""+ Number(time_string.charAt(iTime));	 
		} else if(showMin){
			minutes = Number(time_string.charAt(iTime-1)) +""+ Number(time_string.charAt(iTime));	 
		} else if(showSec){
			seconds = Number(time_string.charAt(iTime-1)) +""+ Number(time_string.charAt(iTime));	 
		}
	}
	
	if(!is24Hr){
		if(isPM)
			hours = ((Number(hours)+12)==24?12:(Number(hours)+12));
		else
			hours = ((Number(hours)==12)?0:hours);
	}

	parsedTime.setHours(hours,minutes,seconds);
	return parsedTime;
}

function parseDate(date_string, month_before_day)
{
	if (isNull(date_string)) {
		return "";
	}
	
	if (date_string.constructor == Date) {
		return date_string;
	}

	var months = new Array("January","February","March","April","May","June","July","August","September","October","November","December");
	// var months = new Array("Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec");
	var month_days = new Array(31,29,31,30,31,30,31,31,30,31,30,31);
	var state=0;
	var sub = new String("");
	var numcount = 0;
	var lastnumlen = 0;
	var alphacount = 0;
	var nums = new Array(0,0,0);
	var currentChar;
	var day = 0; var month = 0; var year= 0;
	var date_err=0;

	// Add a space to the end of the string to simplify this routine
	date_string += " ";

	for (var i=0;i<date_string.length;i++)
	{
		currentChar = date_string.charAt(i);

		switch (state) {
			case 0:
				if (isDigit(currentChar))  {sub = currentChar; state=1;}
				if (isAlpha(currentChar))  {sub = currentChar; state=2;}
				break;
			case 1:
				if (isDigit(currentChar)) 	{sub += currentChar;}
				else {

					// have found the end of the number
					if (sub.length<6) {
						// a day or month or year
						if (numcount<3) {

							// Find the first occurence of a non-zero number in the string sub
							// Have to remove all of the leading zeros due to a bug in the javascript parseInt function
							for (var j=0; j<sub.length; j++)
							{
								if (sub.charAt(j) != '0')
								{
									sub = sub.substr(j);
									break;
								}

							}
							nums[numcount] = parseInt(sub);

							lastnumlen=sub.length;
							numcount++;
							if (isAlpha(currentChar)) {
								sub=currentChar; state=2;
							} else {
								state=0;
							}
						} else {
							date_err=1;
						}
					} else if ((sub.length >= 6) && (sub.length<=8)) {
						if (numcount<1) {
							var sub1=sub.substr(0,2);
							for (var j=0; j<sub1.length; j++)
							{
								if (sub1.charAt(j) != '0')
								{
									sub1 = sub1.substr(j);
									break;
								}

							}
							nums[numcount++] = parseInt(sub1);
							sub1 = sub.substr(2,2);
							for (var j=0; j<sub1.length; j++)
							{
								if (sub1.charAt(j) != '0')
								{
									sub1 = sub1.substr(j);
									break;
								}

							}
							nums[numcount++] = parseInt(sub1);
							sub1 = sub.substr(4);
							for (var j=0; j<sub1.length; j++)
							{
								if (sub1.charAt(j) != '0')
								{
									sub1 = sub1.substr(j);
									break;
								}

							}
							nums[numcount++] = parseInt(sub1);
							lastnumlen = sub1.length;
						} else {
							date_err=1;
						}
					} else {
						// definitely an error
						date_err=1;
					}
				}
				break;
			case 2:
				if (isAlpha(currentChar)) {sub+= currentChar;}
				else {
					// have found a complete alpha string

					if (alphacount<1 && sub.length >= 3) {

						// convert sub to a month
						for (month=1; month<=12; month++) {
							if (sub.length > months[month-1].length) {
								continue;
							}
							if (sub.toUpperCase() == months[month-1].substr(0,sub.length).toUpperCase()) {
								break;
							}
						}
						if (month <= 12) {
							alphacount++;
							if (isDigit(currentChar)) {
								sub = currentChar; state=1;
							} else {
								state=0;
							}
						} else {
							date_err=1;
						}
					} else {
						date_err=1;
					}
				}
				break;


		} // end of switch
		
		if (date_err > 0) {
			throw "The date you have entered is not in the correct format.";	
		}

	} // end of for




	if (((numcount==2) && (month > 0)) || ((numcount==3) && (month==0))) {
		if (month > 0) {
			day=nums[0];
			year=nums[1];

		} else {
			if (month_before_day)
			{
				month=nums[0];
				day=nums[1];
			} else {
				day=nums[0];
				month=nums[1];
			}
			year=nums[2];
		}




		if (lastnumlen<=2) {
			// empty constructor gives the current date
			var today = new Date();

			var thisYear = today.getFullYear();
			var baseYear = ((thisYear-(thisYear%100))/100) * 100;

			if (thisYear%100 > 50) baseYear += 100;

			var offset = thisYear - baseYear;
			var resultYear = baseYear + year;

			if (year > (50 + offset)) resultYear -= 100;
			year = resultYear;
		}


		if ((month>=1) && (month<=12)) {
			if ((day >= 1) && (day<=month_days[month-1])) {
				if (month == 2) {
					if ((isLeapYear(year)==false) && (day>28))
						date_err=1;
				}
			} else {
				date_err=1;
			}
		} else {
			date_err=1;
		}
	} else {
		date_err=1;
	}

	var returnDate;
	if (date_err > 0) {
		throw "The date you have entered is not in the correct format.";	
	} else {

		returnDate = new Date();
		returnDate.setMonth(0);
		returnDate.setFullYear(year);
		returnDate.setDate(day);
		returnDate.setMonth(month-1);
		//set time to 0:0:0 as it is unknown
		returnDate.setHours(0);	
		returnDate.setMinutes(0);
		returnDate.setSeconds(0);
		return returnDate;
	}


} // end of parseDate function

function getDaysInMonth(month, year)
{
	monthdays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
	if (month != 1) {
		return monthdays[month];
	} else {
		return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ? 29 : 28);
	}
}

Date.prototype.toFormattedString = function(format)
{
	
// Format , Code  Meaning ,    Example

// s			,	Second
// ss			,
// m			,	Minute
// mm     ,
// h			,	Hour
// hh     ,
// am			,12 hour clock with "a" or "p" suffix
// A			,	12 hour clock with "A" or "P" suffix
// AM			,12 hour clock with "AM" or "PM" suffix
 
// date formats
// d			, 	day (one digit)	 												,	3
// dx			,day with "st", "rd", "th" etc (e.g. 1st, 2nd, 23rd)	, 1st, 2nd, 23rd
// dd			,day spelled out (two digits, 0 pad)			,	 03, 15
// ddd		,	weekday (three character, upper case)	,	 Sun, Mon
// dddd		,weekday (three character, lower case)	,	 Sunday, Monday
// M			,	month (one digit)		 									,			1
// MM			,month (two digits, zero pad)		 				,		 01, 10
// MMM		,	month (three character name, proper case)	,	 Jan, Feb
// MMMM		,month (full name, proper case) ,e.g. January, February 
// y			,	year (two digits)									,				 99, 03
// yy			,year (two digits)										,			 99, 03
// yyyy		,year (two digits)


	if(isNull(format))
		return this.toDateString();
		
	var weekdays = new Array("Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday");
	var months	 = new Array("January","February","March","April", "May","June","July","August","September","October","November","December");
	var dateExt  = new Array("th", "st", "nd", "rd");
	
	var dateStr = format;
	var Reps = new Array();
	var Regs = new Array();
	var day  = this.getDay();
	var d    = this.getDate();
	var y    = this.getFullYear();
	var m    = this.getMonth();
	var h    = this.getHours();
	var mins = this.getMinutes();
	var s    = this.getSeconds(); 
	
	Regs.push( {r:new RegExp().compile("yyyy", "g") , v: y   } );
	Regs.push( {r:new RegExp().compile("yy|y", "g") , v: (y+"").substring(2,4) } );
	Regs.push( {r:new RegExp().compile("dddd", "g") , v: weekdays[day]                } );
	Regs.push( {r:new RegExp().compile("ddd", "g")  , v: weekdays[day].substring(0,3) } );
	Regs.push( {r:new RegExp().compile("dd", "g")   , v: d < 10? "0"+d : d	} );
	Regs.push( {r:new RegExp().compile("dx", "g")   , v: (d < 4)  || (d > 20 && d < 24) || (d > 30 )? (d+dateExt[Number((String(d)).charAt(String(d).length-1))]) : d+dateExt[0] } );
	Regs.push( {r:new RegExp().compile("d", "g")    , v: d 	} );
	Regs.push( {r:new RegExp().compile("MMMM", "g") , v: months[ m ]  } );
	Regs.push( {r:new RegExp().compile("MMM", "g")  , v: months[ m ].substring(0,3)} );
	Regs.push( {r:new RegExp().compile("MM", "g")   , v: m   } );
	Regs.push( {r:new RegExp().compile("hh", "g")   , v: h < 10		? "0"+h		: h } );
	Regs.push( {r:new RegExp().compile("mm", "g")   , v: mins < 10 ? "0"+mins	: mins} );
	Regs.push( {r:new RegExp().compile("ss", "g")   , v: s < 10		? "0"+s		: s} );
	//Regs.push( {r:new RegExp().compile("h", "g")   , v: h   } );
	//Regs.push( {r:new RegExp().compile("m", "g")   , v: mins} );
	//Regs.push( {r:new RegExp().compile("s", "g")   , v: s} );
	var iRep = 0;
	
	for(var i=0; i < Regs.length; i++)
	{
		var t = 0;
		if((Regs[i].r).test(dateStr))
		{
			dateStr = dateStr.replace((Regs[i].r), '`'+iRep);
			Reps.push(Regs[i].v);
			t++;
		}
		if(t>0)
			iRep++;
	}
	
	for(var j=0; j<Reps.length; j++)
		dateStr = dateStr.replace(new RegExp("`"+j, "g"), Reps[j]);
		
	//dateStr = 
	return dateStr;
}

Date.prototype.toFormattedTimeSpan = function(toDate, dateFormatString, separator)
{
	dateFormatString = dateFormatString ? dateFormatString : "";
	separator = separator ? " "+separator+" " : " ";
	
	if(isNull(toDate))
		return this.toFormattedString(dateFormatString);

	if(!(toDate instanceof Date))
		throw "Date Error: Not A Date";
	
	if(this.getFullYear() == toDate.getFullYear() 
		&& this.getMonth()  == toDate.getMonth()
		&& this.getDate() == toDate.getDate())
		return this.toFormattedString(dateFormatString);
	
	var fromFormat = dateFormatString+"";
	var toFormat   = dateFormatString+"";
	
		
	if(this.getFullYear() == toDate.getFullYear())
	{
		if(dateFormatString.indexOf("y") > dateFormatString.indexOf("M"))
			fromFormat = fromFormat.replace(/yyyy|yy|y/g,"");
		else
			toFormat = toFormat.replace(/yyyy|yy|y/g,"");
	}
	
	if(this.getMonth() == toDate.getMonth() && dateFormatString.indexOf("ddd") < 0)
	{
		if(dateFormatString.indexOf("M") > dateFormatString.indexOf("d"))
			fromFormat = fromFormat.replace(/MMMM|MMM|MM/g,"");
		else
			toFormat = toFormat.replace(/MMMM|MMM|MM/g,"");
	}
		
	return (this.toFormattedString(fromFormat) + separator + toDate.toFormattedString(toFormat));	
}

// new getDateInteger function
Date.prototype.getDateInteger = function() {
	var dateString = this.getFullYear() + "" + ((this.getMonth() + "").length < 2 ? "0" + this.getMonth() : this.getMonth() ) + "" + ( (this.getDate() + "").length < 2 ? "0" + this.getDate() : this.getDate() ) ;
	return parseInt(dateString);
}
////////////////////////////////////////////////////////////////////
		function dpn(n,precision) { // returns text for a number rounded to 2dp
			var isNeg=0
			if (n<0) {n*=-1; isNeg=true;}

			var precision_denominator = Math.pow(10,precision);

			var intpart=Math.floor(n);
			var fracpart='0000000000000000'+Math.round((n-intpart)*precision_denominator); // pad with zero's
			if (Math.round((n-intpart)*precision_denominator) >= precision_denominator) {
				intpart+=1;
			}
			var part=(intpart%1000).toString();
			var intstring=''
			var remainder=Math.floor(intpart/1000.0);
			while (remainder>0) {
				part='00'+part; part=part.substr(part.length-3);
				intstring=part+intstring;

				//intstring=','+intstring;
				var part= (remainder%1000).toString();
				remainder=Math.floor(remainder/1000);
			}
			intstring=part+intstring;

			return  (isNeg ? '-' : '') + intstring+'.'+fracpart.substr(fracpart.length-precision);
		}

		function dp2(n) { // returns text for a number rounded to 2dp
			return dpn(n,2);
		}
		
		function EnterDnIsTab(event) {
			
			if (event && (event.keyCode==13 || (event.keyCode==40 && event.srcElement.type!='select-one')) && (event.srcElement.type != 'textarea') && (event.srcElement.type != 'button') && (event.srcElement.type != 'submit')) {event.keyCode=9; return true;};
		}

		
//%>-->