function  validateString( strValue ) {
 var objRegExp  =  /(^[a-zA-Z]+$)/; 
  return objRegExp.test(strValue);
}
function validateNumeric( field ) {
/******************************************************************************
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);
	if(!objRegExp.test(field) || parseFloat(field) <= 0 || trimAll(field) == ""){
		   return 0;
	 }else{
			return 1;
	}
}
function parseCurrency(field){
	  var currency = /^\d*(?:\.\d{0,2})?$/;
	  
	  if(!currency.test(field) || parseInt(field) <= 0)
	  {
		   return 0;
	  }else{
	return 1;
  }
 }
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*$)/;

	if(parseInt(strValue) <= 0){
		return false;
	}
  //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 popUp(URL,WIDTH,HEIGHT) {
day = new Date();
id = day.getTime();
eval("page" + id + " = window.open(URL, '" + id + "', 'toolbar=0,scrollbars=1,location=0,statusbar=0,menubar=0,resizable=0,"+WIDTH+","+HEIGHT+"');");
}
function validateEmail( strValue) {
  var objRegExp  = /^([a-z0-9])([a-z0-9_\-]*)([\.]{0,1}([a-z0-9_\-]*))@([a-z0-9_\-]+)([\.]{1})([a-z]{2,3}(\.[a-z]{2}){0,2})$/i;
    //check for valid email
    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  validatename(strValue) {
 var objRegExp  =  /(^[a-zA-Z\ ]+$)/; 
  return objRegExp.test(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 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 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 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 validateUrl(strValue){ 
	var objRegExp;
	var returnvalue;

	objRegExp = /^([a-z0-9_\-\.]*)([a-z0-9_\-])$/;

	if(objRegExp.test(strValue) == true){

		var StringValue = strValue.substring(0,4);
		var strArr = strValue.split(".");
		var ArrLen = strArr.length;
		if((StringValue == "www." || StringValue == "WWW.") && ArrLen == 2){
		returnvalue = false;
		}else if(ArrLen < 2){
		objRegExp=/^(http:\/\/www.|https:\/\/www.|ftp:\/\/www.|www.|http:\/\/|https:\/\/){1}([\w]+)(.[\w]+){1,2}$/;

		returnvalue = objRegExp.test(strValue);
		}else{
		returnvalue = true;
		}
	}else{
		objRegExp=/^(http:\/\/www.|https:\/\/www.|ftp:\/\/www.|www.|http:\/\/|https:\/\/){1}([\w]+)(.[\w]+){1,2}$/;

		returnvalue = objRegExp.test(strValue);
		
	}

	return returnvalue;
} 
function replace(argvalue, x, y) {

  if ((x == y) || (parseInt(y.indexOf(x)) > -1)) {
    errmessage = "replace function error: \n";
    errmessage += "Second argument and third argument could be the same ";
    errmessage += "or third argument contains second argument.\n";
    errmessage += "This will create an infinite loop as it's replaced globally.";
    alert(errmessage);
    return false;
  }
    
  while (argvalue.indexOf(x) != -1) {
    var leading = argvalue.substring(0, argvalue.indexOf(x));
    var trailing = argvalue.substring(argvalue.indexOf(x) + x.length, 
	argvalue.length);
    argvalue = leading + y + trailing;
  }

  return argvalue;

}
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 IsvalidURL(imageURL)
{
		

		lengthValue = trimAll(imageURL);
		lengthValue = lengthValue.length;
		if(lengthValue != 0)
		{
		var j = new RegExp();
		j.compile("^[A-Za-z]+://[A-Za-z0-9-]+\.[A-Za-z0-9]+");             
		lengthValue = trimAll(imageURL);
	
		if (!j.test(lengthValue))
		{
			return false;
		}
		else
		{
			return true;
		}
		}
	
}

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 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 is_valid_credit_card_number(cardNumber, cardType)//sample card type visa no 4992739871642 
{
	//alert(cardType);
	//alert(cardNumber);
  var isValid = false;
  var ccCheckRegExp = /[^\d ]/;
  isValid = !ccCheckRegExp.test(cardNumber);
  if (isValid)
  {
    var cardNumbersOnly = cardNumber.replace(/ /g,"");
    var cardNumberLength = cardNumbersOnly.length;
    var lengthIsValid = false;
    var prefixIsValid = false;
    var prefixRegExp;
    switch(cardType.toLowerCase())
    {
      case "mastercard":
        lengthIsValid = (cardNumberLength == 16);
        prefixRegExp = /^5[1-5]/;
        break;

      case "visa":
        lengthIsValid = (cardNumberLength == 16 || cardNumberLength == 13);
        prefixRegExp = /^4/;
        break;

      case "amex":
        lengthIsValid = (cardNumberLength == 15);
        prefixRegExp = /^3(4|7)/;
        break;
	  case "discover":
		lengthIsValid = (cardNumberLength == 16);
        prefixRegExp = /^6011/;
        break;  
      default:
        lengthIsValid = (cardNumberLength == 16 || cardNumberLength == 13);
        prefixRegExp = /^4/;
        break;
    }

    prefixIsValid = prefixRegExp.test(cardNumbersOnly);
    isValid = prefixIsValid && lengthIsValid;
  }

  if (isValid)
  {
    var numberProduct;
    var numberProductDigitIndex;
    var checkSumTotal = 0;

    for (digitCounter = cardNumberLength - 1; 
      digitCounter >= 0; 
      digitCounter--)
    {
      checkSumTotal += parseInt (cardNumbersOnly.charAt(digitCounter));
      digitCounter--;
      numberProduct = String((cardNumbersOnly.charAt(digitCounter) * 2));
      for (var productDigitCounter = 0;
        productDigitCounter < numberProduct.length; 
        productDigitCounter++)
		{
        checkSumTotal += 
          parseInt(numberProduct.charAt(productDigitCounter));
      }
    }

    isValid = (checkSumTotal % 10 == 0);
  }
  //isValid=true;
  return isValid;
}
this.isValidCardNumber = function(cardNumber, cardType) {
		  var isValid = false;
		  var ccCheckRegExp = /[^\d ]/;
		  isValid = !ccCheckRegExp.test(cardNumber);

		  if (isValid)
		  {
			var cardNumbersOnly = cardNumber.replace(/ /g,"");
			var cardNumberLength = cardNumbersOnly.length;
			var lengthIsValid = false;
			var prefixIsValid = false;
			var prefixRegExp;

			switch(cardType)
			{
			  case "mastercard","MasterCard":
				lengthIsValid = (cardNumberLength == 16);
				prefixRegExp = /^5[1-5]/;
				break;

			  case "visa","Visa":
				lengthIsValid = (cardNumberLength == 16 || cardNumberLength == 13);
				prefixRegExp = /^4/;
				break;

			  case "amex","Amex":
				lengthIsValid = (cardNumberLength == 15);
				prefixRegExp = /^3(4|7)/;
				break;
			  case "discover","Discover":
				lengthIsValid = (cardNumberLength == 16);
				prefixRegExp = /^6011/;
				break;  
			  default:
				prefixRegExp = /^$/;
				//alert("Card type not found");
			}

			prefixIsValid = prefixRegExp.test(cardNumbersOnly);
			isValid = prefixIsValid && lengthIsValid;
		  }

		  if (isValid)
		  {
			var numberProduct;
			var numberProductDigitIndex;
			var checkSumTotal = 0;

			for (digitCounter = cardNumberLength - 1; 
			  digitCounter >= 0; 
			  digitCounter--)
			{
			  checkSumTotal += parseInt (cardNumbersOnly.charAt(digitCounter));
			  digitCounter--;
			  numberProduct = String((cardNumbersOnly.charAt(digitCounter) * 2));
			  for (var productDigitCounter = 0;
				productDigitCounter < numberProduct.length; 
				productDigitCounter++)
				{
				checkSumTotal += 
				  parseInt(numberProduct.charAt(productDigitCounter));
			  }
			}

			isValid = (checkSumTotal % 10 == 0);
		  }
		  //isValid=true;
		  return isValid;
	}
//function for validating credit card number

function is_valid_credit_card(cardNumber, cardType)//sample card type visa no 4992739871642 
{
	alert(cardType);
	alert(cardNumber);
  var isValid = false;
  var ccCheckRegExp = /[^\d ]/;
  isValid = !ccCheckRegExp.test(cardNumber);

  if (isValid)
  {
    var cardNumbersOnly = cardNumber.replace(/ /g,"");
    var cardNumberLength = cardNumbersOnly.length;
    var lengthIsValid = false;
    var prefixIsValid = false;
    var prefixRegExp;

    switch(cardType)
    {
      case "mastercard","MasterCard":
        lengthIsValid = (cardNumberLength == 16);
        prefixRegExp = /^5[1-5]/;
        break;

      case "visa","Visa":
        lengthIsValid = (cardNumberLength == 16 || cardNumberLength == 13);
        prefixRegExp = /^4/;
        break;

      case "amex","Amex":
        lengthIsValid = (cardNumberLength == 15);
        prefixRegExp = /^3(4|7)/;
        break;
	  case "discover","Discover":
		lengthIsValid = (cardNumberLength == 16);
        prefixRegExp = /^6011/;
        break;  
      default:
        prefixRegExp = /^$/;
        alert("Card type not found");
    }

    prefixIsValid = prefixRegExp.test(cardNumbersOnly);
    isValid = prefixIsValid && lengthIsValid;
  }

  if (isValid)
  {
    var numberProduct;
    var numberProductDigitIndex;
    var checkSumTotal = 0;

    for (digitCounter = cardNumberLength - 1; 
      digitCounter >= 0; 
      digitCounter--)
    {
      checkSumTotal += parseInt (cardNumbersOnly.charAt(digitCounter));
      digitCounter--;
      numberProduct = String((cardNumbersOnly.charAt(digitCounter) * 2));
      for (var productDigitCounter = 0;
        productDigitCounter < numberProduct.length; 
        productDigitCounter++)
		{
        checkSumTotal += 
          parseInt(numberProduct.charAt(productDigitCounter));
      }
    }

    isValid = (checkSumTotal % 10 == 0);
  }
  //isValid=true;
   alert(isValid);
  return isValid;
}

//to check for numeric
function IsNumeric(sText)
{
   var ValidChars = "0123456789.,";
   var IsNumber=true;
   var Char;
 
   for (i = 0; i < sText.length && IsNumber == true; i++) 
      { 
		  Char = sText.charAt(i); 
		  if (ValidChars.indexOf(Char) == -1) 
		 {
			IsNumber = false;
		 }
      }
   return IsNumber;
}

function isValidDate(currentDate,controlDate)
{
	//alert(currentDate);
	var date1 = currentDate;
    var date2 = controlDate;
     
    var date3 = new Date();
    var date4 = date3.getMonth() + "/" + date3.getDay() + "/" + date3.getYear();
    var currentDate = new Date(date4);
   // alert(date2);
       if(date1 > date2)
       {
           //alert("fromdate should be less than todate");
           return false; 
       }
       else if(date1 > currentDate)
       {
          // alert("From Date should be less than current date");
           return false; 
       }
	  else if(date2 > currentDate) 
	  {
		 // alert("To Date should be less than current date");
			return false; 
	  }

		return true;
}

function funcValidateCreditCardNum(CreditCardNum)
{
	var ccNumb=CreditCardNum;
	var valid = "0123456789";
	var len = ccNumb.length;  
	var iCCN = parseInt(ccNumb);  
	var sCCN = ccNumb.toString();  
	sCCN = sCCN.replace (/^\s+|\s+$/g,'');  
	var iTotal = 0;  
	var bNum = true;  
	var bResult = false;  
	var temp;  // temp variable for parsing string
	var calc;  // used for calculation of each digit


	// ccNumb is a number and the proper length - let's see if it is a valid card number
	if(len >= 13 && len <=16)
	{  // 15 or 16 for Amex or V/MC					
			for(var i=len;i>0;i--)
				{  // LOOP throught the digits of the card
					  calc = parseInt(iCCN) % 10;  // right most digit
					  calc = parseInt(calc);  // assure it is an integer
					  iTotal += calc;  // running total of the card number as we loop - Do Nothing to first digit
					  i--;  // decrement the count - move to the next digit in the card
					  iCCN = iCCN / 10;                               // subtracts right most digit from ccNumb
					  calc = parseInt(iCCN) % 10 ;    // NEXT right most digit
					  calc = calc *2;                                 // multiply the digit by two
					  // Instead of some screwy method of converting 16 to a string and then parsing 1 and 6 and then adding them to make 7,
					  // I use a simple switch statement to change the value of calc2 to 7 if 16 is the multiple.
					  switch(calc)
					  {
						case 10: calc = 1; break;       //5*2=10 & 1+0 = 1
						case 12: calc = 3; break;       //6*2=12 & 1+2 = 3
						case 14: calc = 5; break;       //7*2=14 & 1+4 = 5
						case 16: calc = 7; break;       //8*2=16 & 1+6 = 7
						case 18: calc = 9; break;       //9*2=18 & 1+8 = 9
						default: calc = calc;           //4*2= 8 &   8 = 8  -same for all lower numbers
					  }                                               
					iCCN = iCCN / 10;  // subtracts right most digit from ccNum
					iTotal += calc;  // running total of the card number as we loop
				}  // END OF LOOP
		  if(! ((iTotal%10)==0))
			{
				return false;
			}	
	}	
	else
	{
		return false;
	}
}
function isCreditCard(textval) {
 /*
  *  This function validates a credit card entry.
  *  If the checksum is ok, the function returns true.
  */
   var ccNum;
   var odd = 1;
   var even = 2;
   var calcCard = 0;
   var calcs = 0;
   var ccNum2 = "";
   var aChar = '';
   var cc;
   var r;
   ccNum	=	textval;
   for(var i = 0; i != ccNum.length; i++) {
      aChar = ccNum.substring(i,i+1);
      if(aChar == '-') {
         continue;
      }

      ccNum2 = ccNum2 + aChar;
   }
   
   cc = parseInt(ccNum2);
   if(cc == 0) {
      return false;
   }
   r = ccNum.length / 2;
   if(ccNum.length - (parseInt(r)*2) == 0) {
      odd = 2;
      even = 1;
   }
   
   for(var x = ccNum.length - 1; x > 0; x--) {
      r = x / 2;
      if(r < 1) {
         r++;
      }
      if(x - (parseInt(r) * 2) != 0) {
         calcs = (parseInt(ccNum.charAt(x - 1))) * odd;
      }
      else {
         calcs = (parseInt(ccNum.charAt(x - 1))) * even;
      }
      if(calcs >= 10) {
         calcs = calcs - 10 + 1;
      }
      calcCard = calcCard + calcs;
   }
   
   calcs = 10 - (calcCard % 10);
   if(calcs == 10) {
      calcs = 0;
   }
   
   if(calcs == (parseInt(ccNum.charAt(ccNum.length - 1)))) {
      return true;
   }
   else {
      return false;
   }
}
function  containsURLCharacters( strValue ) {
	  var objRegExp  =  /(^[a-zA-Z0-9]+$)/; 
	  return objRegExp.test(strValue);
}
function  containssubCharacters( strValue ) {
	 var objRegExp  =  /(^[a-zA-Z0-9\:\/\ ]+$)/;   
	 return objRegExp.test(strValue);
}
function  containshtmlCharacters( strValue ) {
	 var objRegExp  =   /(^[a-zA-Z0-9\:\/\,\;\'\"\ \|\!\(\)\ ]+$)/; 
	 return objRegExp.test(strValue);
}
function  validate_urlcharacters( strValue ) {
 var objRegExp  =  /(^[a-zA-Z0-9\_\ ]+$)/; 
  return objRegExp.test(strValue);
}
function add_to_cart(productid){
	
	if(trimAll(document.getElementById('product_qty_'+productid).value) == ""){
		alert("Please enter product quantity.");
		document.getElementById('product_qty_'+productid).focus();
	}else if(!(validateInteger(document.getElementById('product_qty_'+productid).value))){
		alert("Please enter valid product quantity.");
		document.getElementById('product_qty_'+productid).focus();
	}else{
		document.getElementById('cart_'+productid).innerHTML = "<img src=images/loading.gif border=0>";
		document.productForm.cartproductID.value = productid;
		
		url = "ajax/cart.php?productID="+productid+"&qty="+document.getElementById('product_qty_'+productid).value+"&From=products";

		http_req = null;

		if (window.XMLHttpRequest)     http_req = new XMLHttpRequest();
		else if (window.ActiveXObject) http_req = new ActiveXObject("Microsoft.XMLHTTP");

		if (http_req)
		{
			http_req.onreadystatechange = processcart;
			http_req.open("GET", url, true);
			http_req.send("");
		}
	}
}
function processcart(){
	if(http_req.readyState == 4){
		var txt,DisplayText;			
		txt = http_req.responseText;
		
		var sValues = txt.split("||")
		document.getElementById('cart_'+sValues[0]).innerHTML   = "<img src=images/update_cart_bt.jpg border=0 style=cursor:pointer; OnClick=add_to_cart('"+sValues[0]+"')>";
		
		var productcaption;
		if(sValues[2] == "1"){
			productcaption = "product";
		}else{
			productcaption = "products";
		}
		document.getElementById('message').innerHTML = "<a href=shopping-cart.php class=siteblink>View Cart&nbsp;("+sValues[2]+")</a>";

	}	
}

//paging function
var nav4 = window.Event ? true : false;
function pagetransfer(pagenumber,Formname)
{
	with(document.forms[Formname])
	{
		hdn_page.value	= pagenumber;
		hdn_mode.value	= "paging";
		target="";
		action="";
		submit();
	}
}

function enter_paging(e,Formname,TotalPages)
{	if(nav4) 	
		{		var whichCode = e.which; 	 
		}
	 else
		 { 		
		 var whichCode = event.keyCode;	
		 }		
	if(whichCode == 13) 	
		{		
		if(valid_paging(Formname,TotalPages) == false)		
			{			
			return false;		
			}	
		}
}

function submit_form(FormName){
		document.forms[FormName].submit();
}

function valid_paging(Formname,TotalPages){			
	var Err_Message = "";
		with(document.forms[Formname]){	
				
			if(!(validateNotEmpty(page_Go.value))){
				alert('Enter page number');
				page_Go.focus();
				return false;
			}
			else if(!(parseCurrency(trimAll(page_Go.value))))
			{
				alert('Enter valid page number');
				page_Go.focus();
				return false;
			}
			else if(page_Go.value > TotalPages)
			{
				alert('Page does not exists');
				page_Go.focus();
				return false;
			}

			else if(!(validateNumeric(page_Go.value)))
			{
				alert('Enter valid page number');
				page_Go.focus();
				return false;
			}
			else
				{			
				pagetransfer(page_Go.value,Formname);	
				}
			return true;
		}
	}

function enter_key_for_login_page(e)
{
	if(e.keyCode==13)
	{
	 if (navigator.appName=="Netscape")
	 {
	  e.preventDefault();
	 }
	else
	  e.keyCode=0;
	  fun_login();
	}
}

function fun_login(){
	 with(document.loginfrm)
	 {
		 if(trimAll(user.value)=="")
		 {
			 alert("Please enter username!");
			 user.focus();
			 return false;
		 }
		 else if(trimAll(pass.value)=="")
		 {
			 alert("Please enter password!");
			 pass.focus();
			 return false;
		 }
         submit();
         return true;
	 }
 }

function enter_key_for_institution_page(e)
{
	if(e.keyCode==13)
	{
	 if (navigator.appName=="Netscape")
	 {
	  e.preventDefault();
	 }
	else
	  e.keyCode=0;
	  institution_validation();
	}
}

function institution_validation(){
	 with(document.FrmNewInstitution)
	 {
		 if(trimAll(txt_school_name.value)=="")
		 {
			 alert("Please enter school name!");
			 txt_school_name.focus();
			 return false;
		 }
		 else if(trimAll(txt_email.value)=="")
		 {
			 alert("Please enter email!");
			 txt_email.focus();
			 return false;
		 }
		 else if(!(validateEmail(txt_email.value)))
		 {
			 alert("Please enter valid email!");
			 txt_email.focus();
			 return false;
		 }
		else if(trimAll(txt_password.value)=="")
		 {
			 alert("Please enter password!");
			 txt_password.focus();
			 return false;
		 }
         submit();
         return true;
	 }
 }

 function enter_key_for_institution_change_password_page(e)
{
	if(e.keyCode==13)
	{
	 if (navigator.appName=="Netscape")
	 {
	  e.preventDefault();
	 }
	else
	  e.keyCode=0;
	  institution_change_password();
	}
}

function institution_change_password(){
	 with(document.FrmChangePassword)
	 {
		 if(trimAll(old_password.value)=="")
		 {
			 alert("Please enter old password!");
			 old_password.focus();
			 return false;
		 }
		 else if(trimAll(new_password.value)=="")
		 {
			 alert("Please enter new password!");
			 new_password.focus();
			 return false;
		 }
		else if(trimAll(retype_password.value)=="")
		 {
			 alert("Please enter Retype new password!");
			 retype_password.focus();
			 return false;
		 }
		else if(trimAll(new_password.value)!=trimAll(retype_password.value))
		 {
			 alert("Passwords don't match!");
			 retype_password.focus();
			 return false;
		 }
         submit();
         return true;
	 }
 }

 function getScreenLeft(width){
    var left = parseInt((screen.availWidth/2) - (width/2));
	return left;
 }

 function getScreenTop(height){
    var top = parseInt((screen.availHeight/2) - (height/2));
	return top;
 }

 function showPopUp(url,width,height){
	var windowFeatures = "width=" + width + ",height=" + height + ",status,scrollbars,resizable,left=" + getScreenLeft(width) + ",top=" + getScreenTop(height) + "screenX=" + getScreenLeft(width) + ",screenY=" + getScreenTop(height);

	myWindow = window.open(url, "subWind", windowFeatures);
 }

 function find_browser(){
	var browser;
	if (checkIt('konqueror'))
	{
		browser = "Konqueror";
		OS = "Linux";
	}
	else if (checkIt('safari')) browser = "Safari"
	else if (checkIt('omniweb')) browser = "OmniWeb"
	else if (checkIt('opera')) browser = "Opera"
	else if (checkIt('webtv')) browser = "WebTV";
	else if (checkIt('icab')) browser = "iCab"
	else if (checkIt('msie')) browser = "IE"
	else if (!checkIt('compatible'))
	{
		browser = "Netscape Navigator"
	}
	else browser = "An unknown browser";

	if(browser == "Safari"){
		var b = navigator.userAgent.toLowerCase().split("/");
		var n =  b[2].split(" ");
		if(n[4] == 'chrome')
			browser = "chrome";
		else
			browser = "Safari";
	}
	return browser;
}

function checkIt(string){
	var detect = navigator.userAgent.toLowerCase();
	place = detect.indexOf(string) + 1;
	thestring = string;
	return place;
}