<!--
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
	Utility javascript functions.
	Author: Sandeep Kulkarni
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  var whitespace = " \t\n\r";

  // added on 09/02/2003
  function isDefined(o) {
	 return ( !( o == undefined || typeof(o) == undefined ) )
  }
  
  function isEmpty(s) {   
	return ((s == null) || (s.length == 0))
  }

  function isWhiteSpace (s) {
      var i;

      // Is s empty?
      if (isEmpty(s)) return true;
      s = s.toString() ;

      // Search through string's characters one by one
      // until we find a non-whitespace character.
      // When we do, return false; if we don't, return true.

      for (i = 0; i < s.length; i++)
      {   
        // Check that current character isn't whitespace.
        var c = s.charAt(i);

        if (whitespace.indexOf(c) == -1) return false;
      }

      // All characters are whitespace.
      return true;
  }
 
function subString(s, sPos, sLen) {
	sPos-- ;
	var retStr = "" ;
	var intLen = parseInt(sPos) + parseInt(sLen) ;

	// alert("s.len = " + s.length + " intLen = " + intLen ) ;
	if (s.length >= sPos)
		for (i=sPos; i<intLen; i++ ) 
			retStr += s.charAt(i) ;

	return retStr ;
}

function rTrim(s)
{
	var sRegExp = /[ |\t|\n|\r]*$/g ;
	return s.replace(sRegExp, '') ;
}

function lTrim(s)
{
	var sRegExp = /^[ |\t|\n|\r]*/g ;
	return s.replace(sRegExp, '') ;
}

function trim(s)
{
	var sRegExp = /[ |\t|\n|\r]*/g ;
	return s.replace(sRegExp, '') ;
}

function stripCommas(s){
	var sRegExp = /[,]*/g ;
    s = s.toString() ;
	if ( s.indexOf(',') >= 0 )
		return s.replace(sRegExp, '') ;
	else
		return s ;
}

function rPad(s, ch, len) {
	if ( isEmpty(ch) || len <= 0 || s.length > len )
		return s ;
	
	var strToPad = "" ;
	for( i = 0 ; i < (len - s.length); i++ ) 
		strToPad = strToPad + ch ;
	
	return s + strToPad ;
}

function lPad(s, ch, len) {
	if ( isEmpty(ch) || len <= 0 || s.length > len )
		return s ;
	
	var strToPad = "" ;
	for( i = 0 ; i < (len - s.length); i++ ) 
		strToPad = strToPad + ch ;
	
	return strToPad + s ;
}

function hasWhiteSpaces(s)
{
	var i;
    if (isEmpty(s)) return true;
    
	//s = rTrim(s) ;
    for (i = 0; i < s.length; i++)
    {   
      // Check that current character isn't whitespace.
      var c = s.charAt(i);
       //alert("whitespace = " + whitespace + " c = " + c + " whitespace.indexOf(c) = " + whitespace.indexOf(c) ) ;
       if (whitespace.indexOf(c) >= 0) return true;
    }
    // All characters are not whitespace.
    return false;
}

function compareDates(fDate, tDate) {
	// expects fDate & tDate strings explicitly in mm/dd/yyyy format
	if ( isWhiteSpace(fDate) || isWhiteSpace(tDate) )
		return null ;
	var d1 = new Date(fDate) ;
	var d2 = new Date(tDate) ;
	// alert("d1 = " + d1 + " d2 = " + d2) ;
	// does not evaluate ( d1 == d2 ) condition

	if ( d1 > d2 ) 
		return 1 ;
	else if ( d1 < d2 )
		return -1 ;
	else if ( d1.toDateString() == d2.toDateString() )
		return 0 ;
 }

function isDecimal(e) {
	//alert("keyCode = " + e.keyCode + " Value = " + ( ((e.keyCode >= 48) && (e.keyCode <= 57)) || (e.keyCode ==45) || (e.keyCode ==46)) ) ;
	// allows any of [0123456789-.]
	return ( ((e.keyCode >= 48) && (e.keyCode <= 57)) || (e.keyCode ==45) || (e.keyCode ==46)) ;
}

function isPositiveDecimal(pStr) {
	var re = /^[0-9]{1,10}((.[0-9]{1,2})?)$/ ;
	return re.test(pStr) ;
}

function isNumber(e) {
	//alert("keyCode = " + e.keyCode + " Value = " + ( ((e.keyCode >= 48) && (e.keyCode <= 57)) || (e.keyCode ==45) || (e.keyCode ==46)) ) ;
	// allows [0123456789]
	return ( ((e.keyCode >= 48) && (e.keyCode <= 57)) ) ;
}

function toCurrency(s) {
	var retStr = "";
	var tmpAry  ;
	var strLeft ;
	var strRight ;
	var boolNegative = false ;
	var sRegExp = /[,|+|-]*/g ;

	if ( parseFloat(s) < 0 )
		boolNegative = true ;

	s = s.toString().replace(sRegExp, '') ;
	if ( isWhiteSpace(s) )
		return s ;
	
	// Check if . is there
	if ( s.indexOf('.') >= 0 ) {
		tmpAry = s.split('.') ;
		strLeft = tmpAry[0] ;
		strRight = "." + rPad(tmpAry[1].substr(0,2),'0', 2) ;
	} else {
		strLeft = s ;
		strRight = ".00" ;
	}

	var dCnt = 0 ;
	for ( i=(strLeft.length-1) ; i>=0; i--) {
		retStr = strLeft.charAt(i) + retStr ;
		dCnt++ ;
		if ( dCnt % 3 == 0 ) {
			retStr = "," + retStr ;
			dCnt = 0 ;
		} 
	}
	// remove leading , if it is there
	if ( retStr.indexOf(',') == 0 )
		retStr = retStr.substr(1) ;
		
	retStr = ( boolNegative )? retStr="-"+retStr : retStr;

	retStr = retStr + strRight ;
//	alert("Left = " + strLeft + " Right = " + strRight + " RetStr = " + retStr ) ;
	return retStr ;
}

// Added on 02/18/2003
function nvlf(pNbr, pRepl) {
	if ( isEmpty(pNbr) )
		return pRepl ;
		
	pNbr = stripCommas(pNbr) ;
	
	// alert("pNbr = " + pNbr + " pRepl = " + pRepl + " parseFloat(pNbr) = " + parseFloat(pNbr) + " isNaN(parseFloat(pNbr)) = " + isNaN(parseFloat(pNbr)) ) ;
	if ( isNaN(parseFloat(pNbr)) )
		return pRepl ;
	else
		return parseFloat(pNbr) ;
}

// Added on 04/30/2003
function nvl(pNbr, pRepl) {
	/* * *
		parseInt(numberString, radix)
		Always supply the "radix" parameter (value 2..36) to parseInt method as
		results of parseInt(08) are returned as 0 not 8
		It treates any number preceeded with 0 as octal.
	* * */
	if ( isEmpty(pNbr) )
		return pRepl ;
		
	pNbr = stripCommas(pNbr) ;
	
	if ( isNaN(parseInt(pNbr,10)) )
		return pRepl ;
	else
		return parseInt(pNbr,10) ;
}

// Added on 05/01/2003
function isValidEmail(pStr) {
	var re = /^[\w-]+(?:\.[\w-]+)*@(?:[\w-]+\.)+[a-zA-Z]{2,7}$/
	return re.test(pStr) ;
}

function isValidPhoneNbr(pStr) {
	// ?: previous match is optional
	// var re = /((\(\d{3}\) ?)|(\d{3}[-| ]?))?\d{3}[-| ]?\d{4}/
	//var re = /^([\(]{1}[0-9]{3}[\)]{1}[ |\-]{0,1}|^[0-9]{3}([\-| ]?))?[0-9]{3}((\-| )?){1}[0-9]{4}(([x|X][0-9]{1,7})?)$/ ;
	var re = /^([\(]{1}[0-9]{3}[\)]{1}[ |\-]{0,1}|^[0-9]{3}([\-| ]?))[0-9]{3}((\-| )?){1}[0-9]{4}(([x|X][0-9]{1,7})?)$/ ;
	return re.test(pStr) ;
}

// Added on 05/12/2003
function formatPhone(pStr){
	if (isWhiteSpace(pStr))
		return pStr;
	
	var s = pStr.toLowerCase() ;
	var arToks = pStr.toLowerCase().split("x") ;
	var sPhnNbr = arToks[0] ;
	var sXtnsn = arToks[1] ;

// 	alert("arToks[0] = " + arToks[0] + " arToks[1] = " + arToks[1] ) ;
	var sNbr = getOnlyDigits(sPhnNbr) ;
	var retStr ;
	if ( sNbr.length == 10 )
		retStr = "(" + sNbr.substr(0,3) + ")" + sNbr.substr(3,3) + "-" + sNbr.substr(6,4) ;
	else if ( sNbr.length == 7 )
		retStr = sNbr.substr(0,3) + "-" + sNbr.substr(3,4) ;
	else
		retStr = pStr ;

	retStr += ( (arToks.length == 2) ? "x" + sXtnsn : "" ) ;

	return retStr ;		
}

function getOnlyDigits(s) {
	var sDigits = "0123456789" ;
	if ( isWhiteSpace(s) ) return s ;
	s = trim(s) ;
	var sDig = "" ;
	for (i=0; i<s.length; i++) {
		var c = s.charAt(i) ;
		if ( sDigits.indexOf(c) >= 0 )
			sDig += c ;
	}
	
	return sDig ;
}

// Function to check mandatory fields: pass the HTML Form object and and array containing field names, to be checked
function checkRequiredFields(oForm, arFields) {
	for (i=0;i<arFields.length;i++){
		var oFld = arFields[i] ;
		// alert("oForm(oFld).value = " + oForm(oFld).value + " oForm(oFld).type = " + oForm(oFld).type ) ;
		if ( oForm(oFld).type.indexOf("select") >= 0 ) {	// select field
			if ( oForm(oFld).value == "-1" || isWhiteSpace(oForm(oFld).value) ) {
				alert("Please select value for " + nvls(oForm(oFld).title, oForm(oFld).name) ) ;
				oForm(oFld).focus() ;
				return false ;
			}
		} else if ( oForm(oFld).type.indexOf("text") >= 0 ) {	// Text Field
			if ( isWhiteSpace(oForm(oFld).value) ) {
				alert("Please enter " + nvls(oForm(oFld).title, oForm(oFld).name) ) ;
				oForm(oFld).focus() ;
				return false ;
			}
		}
	}
	
	return true ;
}

function nvls(pStr, pRepl) {

	var retStr = ( isWhiteSpace(pStr) ? pRepl : pStr ) ;
	return retStr ;
}

// Function to initCap    Added:06/26/2003
function toInitCap(s) {
	var re = new RegExp("[ |\t|\n|\r]") ;
	s = s.toLowerCase() ;
	arToks = s.split(re) ;
	for(i=0; i<arToks.length; i++) {
		arToks[i] = arToks[i].charAt(0).toUpperCase() + arToks[i].substr(1) ;
	}
	return arToks.join(" ") ;
}

/* Function to validate Date Added:11/05/2003
DateTime Validator. This RE validates both dates and/or times patterns. 
Days in Feb. are also validated for Leap years. 
Dates: in the US mm/dd/yyyy or m/d/yy format between 1/1/1600 - 12/31/9999. 
Leading zeroes are optional. 
Date separators can be either matching dashes(-), slashes(/) or periods(.) 
All 4 digit year and all two digit years except 00, which might not be a leap year. 
*/
function isValidDate(pStr) {
	/* Author:Michael Ash downloaded from: www.regexlib.com */
	var re = /^(?:(?:(?:0?[13578]|1[02])(\/|-|\.)31)\1|(?:(?:0?[1,3-9]|1[0-2])(\/|-|\.)(?:29|30)\2))(?:(?:1[6-9]|[2-9]\d)?\d{2})$|^(?:0?2(\/|-|\.)29\3(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00))))$|^(?:(?:0?[1-9])|(?:1[0-2]))(\/|-|\.)(?:0?[1-9]|1\d|2[0-8])\4(?:(?:1[6-9]|[2-9]\d)?\d{2})$/ ; 
	return re.test(pStr) ;
}

function isValidSSN(pStr) {
	var re = /^\d{3}[-| ]\d{2}[-| ]\d{4}$/ ;
	return re.test(pStr) ;
}

function isValidZip(pStr) {
	var re = /^[0-9]{5}(([-| ][0-9]{4})?)$/ ;
	return re.test(pStr) ;
}

function hasOnlyAlphabets(pStr) {
	var re = /^[a-z|A-Z| |.|-|']*$/ ;
	return re.test(pStr) ;
}


-->