//Counterpoint Software Inc. Common JavaScript File - V1.0 - 03/08/2004

function formFocus()
{ // convenient way to start the form onLoad
  if(!document.forms.length) return;
  var els= document.forms[0].elements;
  for(var i= 0; i < els.length; i++)
    if(els[i].type != 'hidden') { els[i].focus(); return; }
}

function requireValue(fld)
{ // disallow a blank field
  if(fld.disabled) return true;
  if(!fld.value.length)
  { status= 'The '+fld.name+' field cannot be left blank.'; return false; }
  return true;
}

function requireChecked(fld)
{ // require a checkbox to be checked
  if(fld.disabled) return true;
  if(!fld.checked)
  { status= 'The '+fld.name+' checkbox must be checked.'; return false; }
  return true;
}

function requireRadio(radios)
{ // require at least one radio in this group to be checked
  if(!radios.length) return true; // invalid parameter
  var visible= false, enabled= false;
  for(var i= 0; i < radios.length; i++)
  {
    if(!enabled) enabled= !radios[i].disabled;
    if(radios[i].checked) return true;
    else if(radios[i].offsetWidth == undefined || radios[i].offsetWidth > 0) visible= true;
  }
  if(!visible||!enabled) return true; // no visible/enabled options in this group
  status= 'You must select one of the '+radios[0].name+' options.';
  return false;
}

function requireLength(fld,min,max)
{ // set minimum and/or maximum field lengths
  if(fld.disabled) return true;
  var len= fld.value.length;
  if(min > -1 && len < min)
  { status= 'The '+fld.name+' field must be at least '+min+
    ' characters long; it is currently '+len+' characters long.'; return false; }
  if(max > -1 && len > max)
  { status= 'The '+fld.name+' field must be no more than '+max+
    ' characters long; it is currently '+len+' characters long.'; return false; }
  return true;
}

function dependants(enabled,elements)
{ // convenience function to enable/disable dependant fields, passed in as an array 
  if(!elements.length) return true;
  for(var i= 0; i < elements.length; i++)
    elements[i].disabled= !enabled;
}

function allowChars(fld,chars)
{ // provide a string of acceptable chars for a field
  if(fld.disabled) return true;
  for(var i= 0; i < fld.value.length; i++)
  {
    if(chars.indexOf(fld.value.charAt(i)) == -1)
    { status= 'The '+fld.name+' field may not contain "'+fld.value.charAt(i)+'" characters.'; return false; }
  }
  return true;
}

function disallowChars(fld,chars)
{ // provide a string of unacceptable chars for a field
  if(fld.disabled) return true;
  for(var i= 0; i < fld.value.length; i++)
  {
    if(chars.indexOf(fld.value.charAt(i)) != -1)
    { status= 'The '+fld.name+' field may not contain "'+fld.value.charAt(i)+'" characters.'; return false; }
  }
  return true;
}

function checkEmail(fld)
{ // simple email check
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  var emailfmt= /^\w+([.-]\w+)*@\w+([.-]\w+)*\.\w{2,8}$/;
  if(!emailfmt.test(fld.value))
  { status= 'The '+fld.name+' field must contain a valid email address.'; return false; }
  return true;
}

function checkIntRange(fld,minVal,maxVal,sep)
{
  if(!fixInt(fld)) return false;
  var val= parseInt(fld.value);
  if(val < minVal) { status= 'The '+fld.name+' field must be no less than '+minVal+'.'; return false; }
  if(val > maxVal) { status= 'The '+fld.name+' field must be no greater than than '+maxVal+'.'; return false; }
  return true;
}

function checkFloatRange(fld,minVal,maxVal,sep)
{
  if(!fixFloat(fld)) return false;
  var val= parseFloat(fld.value);
  if(val < minVal) { status= 'The '+fld.name+' field must be no less than '+minVal+'.'; return false; }
  if(val > maxVal) { status= 'The '+fld.name+' field must be no greater than than '+maxVal+'.'; return false; }
  return true;
}

function fixInt(fld,sep)
{ // integer check/complainer 
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  var val= fld.value;
  if(typeof(sep)!='undefined') val= val.replace(sep,'');
  val= parseInt(val);
  if(isNaN(val))
  { // parse error 
    status= 'The '+fld.name+' field must contain a whole number.';
    return false;
  }
  fld.value= val;
  return true;
}

function fixFloat(fld,sep)
{ // decimal number check/complainer 
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  var val= fld.value;
  if(typeof(sep)!='undefined') val= val.replace(sep,'');
  val= parseFloat(fld.value);
  if(isNaN(val))
  { // parse error 
    status= 'The '+fld.name+' field must contain a number.';
    return false;
  }
  fld.value= val;
  return true;
}

function fixMoney(fld,sep)
{ // monetary field check
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  var val= fld.value;
  if(typeof(sep)!='undefined') val= val.replace(sep,'');
  if(val.indexOf('$') == 0)
    val= parseFloat(val.substring(1,40));
  else
    val= parseFloat(val);
  if(isNaN(val))
  { // parse error 
    status= 'The '+fld.name+' field must contain a dollar amount.';
    return false;
  }
  var sign= ( val < 0 ? '-': '' );
  val= Number(Math.round(Math.abs(val)*100)).toString();
  while(val.length < 2) val= '0'+val;
  var len= val.length;
  val= sign + ( len == 2 ? '0' : val.substring(0,len-2) ) + '.' + val.substring(len-2,len+1);
  fld.value= val;
  return true;
}

function fixFixed(fld,dec,sep)
{ // fixed decimal fields 
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  var val= fld.value;
  if(typeof(sep)!='undefined') val= val.replace(sep,'');
  val= parseFloat(fld.value);
  if(isNaN(val))
  { // parse error 
    status= 'The '+fld.name+' field must contain a number.';
    return false;
  }
  var sign= ( val < 0 ? '-': '' );
  val= Number(Math.round(Math.abs(val)*Math.pow(10,dec))).toString();
  while(val.length < dec) val= '0'+val;
  var len= val.length;
  val= sign + ( len == dec ? '0' : val.substring(0,len-dec) ) + '.' + val.substring(len-dec,len+1);
  fld.value= val;
  return true;
}

function fixDate(fld)
{ // tenacious date correction 
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  var val= fld.value;
  var dt= new Date(val.replace(/\D/g,'/'));
  if(!dt.valueOf())
  { // the date was unparseable 
    status= 'The '+fld.name+' field has the wrong date.';
    return false;
  }
  fld.value= (dt.getMonth()+1)+'/'+dt.getDate()+'/'+dt.getFullYear();
  return true;
}

function fixRecentDate(fld,minyear)
{ // tenacious date correction 
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  var val= fld.value;
  var dt= new Date(val.replace(/\D/g,'/'));
  if(!dt.valueOf())
  { // the date was unparseable 
    status= 'The '+fld.name+' field has the wrong date.';
    return false;
  }
  while(dt.getFullYear() < minyear) { dt.setFullYear(dt.getFullYear()+100); }
  fld.value= (dt.getMonth()+1)+'/'+dt.getDate()+'/'+dt.getFullYear();
  return true;
}

function fixTime(fld,starthour) 
{ // tenacious time correction 
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  var hour= 0; 
  var mins= 0;
  var ampm= 'am';
  val= fld.value;
  var dt= new Date('1/1/2000 ' + val);
  if(('9'+val) == parseInt('9'+val))
  { hour= val; }
  else if(dt.valueOf())
  { hour= dt.getHours(); mins= dt.getMinutes(); }
  else
  {
    val= val.replace(/\D+/g,':');
    hour= parseInt(val);
    mins= parseInt(val.substring(val.indexOf(':')+1,20));
    if(val.indexOf('pm') > -1) ampm= 'pm';
    if(isNaN(hour)) hour= 0;
    if(isNaN(mins)) mins= 0;
  }
  if(hour < starthour) { ampm= 'pm'; }
  while(hour > 12) { hour-= 12; ampm= 'pm'; }
  while(mins > 60) { mins-= 60; hour++; }
  if(mins < 10) mins= '0' + mins;
  if(!hour)
  { // the date was unparseable 
    status= 'The '+fld.name+' field has the wrong time.';
    return false;
  }
  fld.value= hour + ':' + mins + ampm;
  return true;
}

function fixTime24(fld) 
{ // tenacious time correction 
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  var hour= 0; 
  var mins= 0;
  val= fld.value;
  var dt= new Date('1/1/2000 ' + val);
  if(('9'+val) == parseInt('9'+val))
  { hour= val; }
  else if(dt.valueOf())
  { hour= dt.getHours(); mins= dt.getMinutes(); }
  else
  {
    val= val.replace(/\D+/g,':');
    hour= parseInt(val);
    mins= parseInt(val.substring(val.indexOf(':')+1,20));
    if(isNaN(hour)) hour= 0;
    if(isNaN(mins)) mins= 0;
    if(val.indexOf('pm') > -1) hour+= 12;
  }
  hour%= 24;
  mins%= 60;
  if(mins < 10) mins= '0' + mins;
  fld.value= hour + ':' + mins;
  return true;
}

function fixPhone(fld,defaultAreaCode,sep,noext)
{ // tenacious phone # correction 
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  if(typeof(sep)=='undefined') sep= '-';
  if(typeof(defaultAreaCode)!='undefined') defaultAreaCode= defaultAreaCode + sep;
  var ext= '', val= fld.value.toLowerCase();
  if(val.indexOf('x') > 0)
  {
    if(!noext) ext= ' x'+val.substr(val.indexOf('x')).replace(/\D/g,'');
    val= val.substr(0,val.indexOf('x'));
  }
  val= val.replace(/\D/g,'');
  if(val.length == 7)
  {
    fld.value= defaultAreaCode + val.substring(0,3) + sep + val.substring(3,20) + ext;
    return true;
  }
  if(val.length == 10)
  {
    fld.value= val.substring(0,3) + sep + val.substring(3,6) + sep + val.substring(6,20) + ext;
    return true;
  }
  if(val.length < 7)
  {
    status= 'The phone number you supplied for the '+fld.name+' field was too short.';
    return false;
  }
  if(val.length > 10)
  {
    status= 'The phone number you supplied for the '+fld.name+' field was too long.';
    return false;
  }
  status= 'The phone number you supplied for the '+fld.name+' field was wrong.';
  return false;
}

function fixSSN(fld)
{ // tenacious SSN correction; fieldname isn't a big consideration, probably only one SSN per form 
  if(!fld.value.length||fld.disabled) return true; // blank fields are the domain of requireValue 
  var val= fld.value;
  val= val.replace(/\D/g,'');
  if( val.length < 9 )
  {
    status= 'The Social Security Number you provided is not long enough.';
    return false;
  }
  if( val.length > 9 )
  {
    status= 'The Social Security Number you provided is too long.';
    return false;
  }
  fld.value= val.substring(0,3)+'-'+val.substring(3,5)+'-'+val.substring(5,12);
  return true;
}



function nameContains(name,str)
{ // Check for nontrivial inclusion 
  // OK, *some* trivial cases must be handled...
  if(name == str || name.toLowerCase() == str.toLowerCase()) return true;
  var nlen= name.length;
  var slen= str.length;
  var endat= nlen - slen;
  // too small to fit?
  if(nlen > str) return false;
  if(name.toLowerCase() == name || name.toUpperCase() == name)
  { // all lower/upper case name? underscores separate
    if(name.indexOf('_') == -1) return false;
    str= str.toLowerCase();
    if( name.indexOf(str+'_') == 0 ||
      name.indexOf('_'+str+'_') > -1 ||
      name.substring(endat-1,nlen+1) == ('_'+str) )
      return true;
  }
  else
  { // proper case name? uppercase starts new words 
    var sep= name.substring(slen,slen+1);
    if( name.indexOf(str) == 0 && sep == sep.toUpperCase() ) return true;
    if( name.indexOf(str.toLowerCase()) == 0 && sep == sep.toUpperCase() ) return true;
    var sep= name.substring(endat-1,endat);
    if( name.substring(endat,nlen+1) == str ) return true;
    for(var index= name.indexOf(str); index > -1; index= name.indexOf(str,index+1))
    { // for each occurence of the word, is it followed by a non-lowercase char? 
      endat= index+slen;
      sep= name.substring(endat,endat+1);
      if(sep == sep.toUpperCase()) return true;
    }
  }
  return false;
}

var dFilterStep

function dFilter (key, textbox, dFilterMask)
{
	dFilterNum = dFilterStrip(textbox.value, dFilterMask);
    if (key==8 || key==9 || key==46) //backspace, tab, delete
    {
        return true;
    }
    else if ((key>47&&key<58) && dFilterNum.length<dFilterMax(dFilterMask) )
    {
		dFilterNum=dFilterNum+String.fromCharCode(key); //numbers only
    }
	else if ((key>95&&key<106) && dFilterNum.length<dFilterMax(dFilterMask) )
    {
		dFilterNum=dFilterNum+String.fromCharCode(key - 48); //numbers fron the keypad
    }
    var dFilterFinal='';
	for (dFilterStep = 0; dFilterStep < dFilterMask.length; dFilterStep++) {
		if (dFilterMask.charAt(dFilterStep)=='#') {
			if (dFilterNum.length!=0) {
				dFilterFinal = dFilterFinal + dFilterNum.charAt(0);
				dFilterNum = dFilterNum.substring(1,dFilterNum.length);
			} else {
				dFilterFinal = dFilterFinal + "";
			}
		} else if (dFilterMask.charAt(dFilterStep)!='#') {
			dFilterFinal = dFilterFinal + dFilterMask.charAt(dFilterStep);                
		}
    }
	textbox.value = dFilterFinal;
	return false;
}

function dFilterStrip (dFilterTemp, dFilterMask)
{
	dFilterMask = replace(dFilterMask,'#','');
	for (dFilterStep = 0; dFilterStep < dFilterMask.length++; dFilterStep++) {
		dFilterTemp = replace(dFilterTemp,dFilterMask.substring(dFilterStep,dFilterStep+1),'');
    }
	return dFilterTemp;
}

function dFilterMax (dFilterMask)
{
	dFilterTemp = dFilterMask;
	for (dFilterStep = 0; dFilterStep < (dFilterMask.length+1); dFilterStep++){
		if (dFilterMask.charAt(dFilterStep)!='#') {
			dFilterTemp = replace(dFilterTemp,dFilterMask.charAt(dFilterStep),'');
        }
	}
    return dFilterTemp.length;
}

function replace(fullString,text,by)
{
//Replaces text with by in string
	var strLength = fullString.length, txtLength = text.length;
	if ((strLength == 0) || (txtLength == 0)) return fullString;
		var i = fullString.indexOf(text);
	if ((!i) && (text != fullString.substring(0,txtLength))) return fullString;
	if (i == -1) return fullString;
	var newstr = fullString.substring(0,i) + by;
	if (i+txtLength < strLength)
		newstr += replace(fullString.substring(i+txtLength,strLength),text,by);
	return newstr;
}

function isDate(dateField, dateStr)
{
	if (dateStr.length < 1) return true; 

	var datePat = /^(\d{1,2})(\/|-)(\d{1,2})(\/|-)(\d{4})$/;
	var matchArray = dateStr.match(datePat); // is the format ok?

	if (matchArray == null) {
		alert("Please enter date as either mm/dd/yyyy or mm-dd-yyyy.");
		dateField.value = "";
		dateField.focus();
		return false;
	}

	month = matchArray[1]; // parse date into variables
	day = matchArray[3];
	year = matchArray[5];

	if (month < 1 || month > 12) { // check month range
		alert("Month must be between 1 and 12.");
		dateField.value = "";
		dateField.focus();
		return false;
	}

	if (day < 1 || day > 31) {
		alert("Day must be between 1 and 31.");
		dateField.value = "";
		dateField.focus();
		return false;
	}

	if (year < 1754 || year > 9999) {
		alert("Year must be between 1754 and 9999.");
		dateField.value = "";
		dateField.focus();
		return false;
	}

	if ((month==4 || month==6 || month==9 || month==11) && day==31) {
		alert("Month "+month+" doesn`t have 31 days!")
		dateField.value = "";
		dateField.focus();
		return false;
	}

	if (month == 2) { // check for february 29th
		var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
		if (day > 29 || (day==29 && !isleap)) {
			alert("February " + year + " doesn`t have " + day + " days!");
		    dateField.value = "";
		    dateField.focus();
			return false;
		}
	}
	return true; // date is valid
}

function validateCurrency( strValue)  {
/************************************************
DESCRIPTION: Validates that a string contains a 
  valid currency format. 
  
 PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
*************************************************/
  var objRegExp = /(^\$\d{1,3}(,\d{3})*\.\d{2}$)|(^\(\$\d{1,3}(,\d{3})*\.\d{2}\)$)/;

  return objRegExp.test( strValue );
}

function validateTime ( strValue ) {
/************************************************
DESCRIPTION: Validates that a string contains a 
  valid 12 hour time format. Seconds are optional.
  
 PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.

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 ) {
/************************************************
DESCRIPTION: Validates that a string contains a 
  valid state abbreviation. 
  
 PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
*************************************************/

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 ) {
/************************************************
DESCRIPTION: Validates that a string contains a 
  valid social security number. 
  
 PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
*************************************************/
var objRegExp  = /^\d{3}\-\d{2}\-\d{4}$/;
 
  //check for valid SSN
  return objRegExp.test(strValue);

}


function validateEmail( strValue) {
/************************************************
DESCRIPTION: Validates that a string contains a 
  valid email pattern. 
  
 PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
   
REMARKS: Accounts for email with country appended
  does not validate that email contains valid URL
  type (.com, .gov, etc.) and optionally,
  a valid country suffix.  Since email has many
  forms this expression only tests for near valid
  address.  Some additional validation may be
  required.
*************************************************/
var objRegExp  = /^[a-z0-9]([a-z0-9_\-\.]*)@([a-z0-9_\-\.]*)(\.[a-z]{2,3}(\.[a-z]{2}){0,2})$/i;
  //check for valid email
  return objRegExp.test(strValue);
}

function validateUSPhone( strValue ) {
/************************************************
DESCRIPTION: Validates that a string contains valid
  US phone pattern. 
  Ex. (999) 999-9999 or (999)999-9999
  
PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
*************************************************/
  var objRegExp  = /^\([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.

PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
******************************************************************************/
  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.
    
PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
******************************************************************************/
  var objRegExp  = /(^-?\d\d*$)/;
 
  //check for integer characters
  return objRegExp.test(strValue);
}

function validateNotEmpty( strValue ) {
/************************************************
DESCRIPTION: Validates that a string is not all
  blank (whitespace) characters.
    
PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
*************************************************/
   var strTemp = strValue;
   strTemp = trimAll(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
    
PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.

*************************************************/
var objRegExp  = /(^\d{5}$)|(^\d{5}-\d{4}$)/;
 
  //check for valid US Zipcode
  return objRegExp.test(strValue);
}

function validateUSDate( strValue ) {
/************************************************
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
    
PARAMETERS:
   strValue - String to be tested for validity
   
RETURNS:
   True if valid, otherwise false.
   
REMARKS:
   Avoids some of the limitations of the Date.parse()
   method such as the date separator character.
*************************************************/
  var objRegExp = /^\d{1,2}(\-|\/|\.)\d{1,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);
	
	//check for valid month
	if(intMonth > 12 || intMonth < 1) {
		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 validateValue( strValue, strMatchPattern ) {
/************************************************
DESCRIPTION: Validates that a string a matches
  a valid regular expression value.
    
PARAMETERS:
   strValue - String to be tested for validity
   strMatchPattern - String containing a valid
      regular expression match pattern.
      
RETURNS:
   True if valid, otherwise false.
*************************************************/
var objRegExp = new RegExp( strMatchPattern);
 
 //check if string matches pattern
 return objRegExp.test(strValue);
}


function rightTrim( strValue ) {
/************************************************
DESCRIPTION: Trims trailing whitespace chars.
    
PARAMETERS:
   strValue - String to be trimmed.  
      
RETURNS:
   Source string with right whitespaces removed.
*************************************************/
var objRegExp = /^([\w\W]*)(\b\s*)$/;
 
      if(objRegExp.test(strValue)) {
       //remove trailing a whitespace characters
       strValue = strValue.replace(objRegExp, '$1');
    }
  return strValue;
}

function leftTrim( strValue ) {
/************************************************
DESCRIPTION: Trims leading whitespace chars.
    
PARAMETERS:
   strValue - String to be trimmed
   
RETURNS:
   Source string with left whitespaces removed.
*************************************************/
var objRegExp = /^(\s*)(\b[\w\W]*)$/;
 
      if(objRegExp.test(strValue)) {
       //remove leading a whitespace characters
       strValue = strValue.replace(objRegExp, '$2');
    }
  return strValue;
}

function trimAll( strValue ) {
/************************************************
DESCRIPTION: Removes leading and trailing spaces.

PARAMETERS: Source string from which spaces will
  be removed;

RETURNS: Source string with whitespaces removed.
*************************************************/ 
 var objRegExp = /^(\s*)$/;

    //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;
}

function removeCurrency( strValue ) {
/************************************************
DESCRIPTION: Removes currency formatting from 
  source string.
  
PARAMETERS: 
  strValue - Source string from which currency formatting
     will be removed;

RETURNS: Source string with commas removed.
*************************************************/
  var objRegExp = /\(/;
  var strMinus = '';
 
  //check if negative
  if(objRegExp.test(strValue)){
    strMinus = '-';
  }
  
  objRegExp = /\)|\(|[,]/g;
  strValue = strValue.replace(objRegExp,'');
  if(strValue.indexOf('$') >= 0){
    strValue = strValue.substring(1, strValue.length);
  }
  return strMinus + strValue;
}

function addCurrency( strValue ) {
/************************************************
DESCRIPTION: Formats a number as currency.

PARAMETERS: 
  strValue - Source string to be formatted

REMARKS: Assumes number passed is a valid 
  numeric value in the rounded to 2 decimal 
  places.  If not, returns original value.
*************************************************/
  var objRegExp = /-?[0-9]+\.[0-9]{2}$/;
   
    if( objRegExp.test(strValue)) {
      objRegExp.compile('^-');
      strValue = addCommas(strValue);
      if (objRegExp.test(strValue)){
        strValue = '($' + strValue.replace(objRegExp,'') + ')';
      }
      else {
        strValue = '$' + strValue;
      }
      return  strValue;
    }
    else
      return strValue;
}

function removeCommas( strValue ) {
/************************************************
DESCRIPTION: Removes commas from source string.

PARAMETERS: 
  strValue - Source string from which commas will 
    be removed;

RETURNS: Source string with commas removed.
*************************************************/
  var objRegExp = /,/g; //search for commas globally
 
  //replace all matches with empty strings
  return strValue.replace(objRegExp,'');
}

function addCommas( strValue ) {
/************************************************
DESCRIPTION: Inserts commas into numeric string.

PARAMETERS: 
  strValue - source string containing commas.
  
RETURNS: String modified with comma grouping if
  source was all numeric, otherwise source is 
  returned.
  
REMARKS: Used with integers or numbers with
  2 or less decimal places.
*************************************************/
  var objRegExp  = new RegExp('(-?[0-9]+)([0-9]{3})'); 

    //check for match to search criteria
    while(objRegExp.test(strValue)) {
       //replace original string with first group match, 
       //a comma, then second group match
       strValue = strValue.replace(objRegExp, '$1,$2');
    }
  return strValue;
}

function removeCharacters( strValue, strMatchPattern ) {
/************************************************
DESCRIPTION: Removes characters from a source string
  based upon matches of the supplied pattern.

PARAMETERS: 
  strValue - source string containing number.
  
RETURNS: String modified with characters
  matching search pattern removed
  
USAGE:  strNoSpaces = removeCharacters( ' sfdf  dfd', 
                                '\s*')
*************************************************/
 var objRegExp =  new RegExp( strMatchPattern, 'gi' );
 
 //replace passed pattern matches with blanks
  return strValue.replace(objRegExp,'');
}

function currencyFilter(fld, milSep, decSep, e) {
/**********************************************************************
Function: currencyFilter
Purpose:  Applies input mask to control for currency
Parameters: fld - name of object having mask applied to it
			milSep - "," for digit separation
			decSep - "." for decimal point
			e - event (keyPress)
**********************************************************************/
		var sep = 0;
		var key = '';
		var i = j = 0;
		var len = len2 = 0;
		var strCheck = '0123456789';
		var aux = aux2 = '';
		var whichCode = (window.Event) ? e.which : e.keyCode;
		if (whichCode == 13) return true;  // Enter
		key = String.fromCharCode(whichCode);  // Get key value from key code
		if (strCheck.indexOf(key) == -1) return false;  // Not a valid key
		len = fld.value.length;
		for(i = 0; i < len; i++)
		if ((fld.value.charAt(i) != '0') && (fld.value.charAt(i) != decSep)) break;
		aux = '';
		for(; i < len; i++)
		if (strCheck.indexOf(fld.value.charAt(i))!=-1) aux += fld.value.charAt(i);
		aux += key;
		len = aux.length;
		if (len == 0) fld.value = '';
		if (len == 1) fld.value = '0'+ decSep + '0' + aux;
		if (len == 2) fld.value = '0'+ decSep + aux;
		if (len > 2) {
		aux2 = '';
		for (j = 0, i = len - 3; i >= 0; i--) {
		if (j == 3) {
		aux2 += milSep;
		j = 0;
		}
		aux2 += aux.charAt(i);
		j++;
		}
		fld.value = '';
		len2 = aux2.length;
		for (i = len2 - 1; i >= 0; i--)
		fld.value += aux2.charAt(i);
		fld.value += decSep + aux.substr(len - 2, len);
		}
		return false;
}


function validatorEnabled(val, enable) {
/**********************************************************************
Function: ValidatorEnabled
Purpose:  Toggles form validation controls on/off
Parameters: val - name of the object (validator control)
			enable – Boolean value (true/false for on/off)
**********************************************************************/
		val.enabled = (enable != false);
}

function SetDropDownBox(ddnBox, val){
// sets the selected value of the drop down box 

	for (var x = 0 ; x < (ddnBox.length)  ; x++) {
		
		
		if (ddnBox.options[x].value == val) {
			ddnBox.options[x].selected = true ;
			}
	}
}