var defaultEmptyOK = false;
var whitespace = " \t\n\r";
var jsBackspace = String.fromCharCode(8);		// backspace		\b
var jsTab = String.fromCharCode(9);				// tab				\t
var jsLinefeed = String.fromCharCode(10);		// linefeed			\n
//var jsFormfeed = String.fromCharCode(12);		// formfeed			\f
var jsCarriageReturn = String.fromCharCode(13);	// carriage return	\r
var jsDoubleQuote = String.fromCharCode(34);	// double quote		\"
var jsSingleQuote = String.fromCharCode(39);	// single quote		\'
var jsBackslash = String.fromCharCode(92);		// backslash		\\

//------------------------------------------------------------------------------

 function lTrim(sString, sChar) {
  var iCount = 0;
  var iLength = sString.length;

  if (sChar.indexOf(sString.charAt(0)) != -1) {
   while (iCount < iLength && sChar.indexOf(sString.charAt(iCount)) != -1) iCount++;

   sString = sString.substring(iCount, iLength);
  }

  return sString;
 }

//------------------------------------------------------------------------------

 function rTrim(sString, sChar) {
  var iCount = sString.length - 1;

  if (sChar.indexOf(sString.charAt(sString.length - 1)) != false) {
   while (iCount >= 0 && sChar.indexOf(sString.charAt(iCount)) != -1) iCount--;

   sString = sString.substring(0, iCount + 1);
  }

  return sString;
 }

//------------------------------------------------------------------------------

 function trim(sString, sChar) {
    return lTrim(rTrim(sString, sChar), sChar);
 }

//------------------------------------------------------------------------------

 function isWhitespace (sString) {
  var iCount;
  var sChar = "";

  if (isEmpty(sString)) return true;

  for (iCount = 0; iCount < sString.length; iCount++) {   
   sChar = sString.charAt(iCount);

   if (whitespace.indexOf(sChar) == -1) return false;
  }

  return true;                                  // all characters are whitespace
 }

//------------------------------------------------------------------------------

 function isEmpty(s) {
  return ((s == null) || (s.length == 0))
 }

//------------------------------------------------------------------------------
	function isEmailAddress(EmailAddress) {
		return (EmailAddress.search(/^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/) != -1);
	}

	function match(Source, Destination) {
		return Source == Destination;
	}

 function isEMail(s) {
  if (isEmpty(s)) 
   if (isEMail.arguments.length == 1) return defaultEmptyOK;
   else return (isEmail.arguments[1] == true);
   
  if (isWhitespace(s)) return false;                         // is s whitespace?
    
  // there must be >= 1 character before @, so we
  // start looking at character position 1 
  // (i.e. second character)
  var i = 1;
  var sLength = s.length;

  // look for @
  while ((i < sLength) && (s.charAt(i) != "@")) {
   i++
  }

  if ((i >= sLength) || (s.charAt(i) != "@")) return false;
  else i += 2;

  // look for .
  while ((i < sLength) && (s.charAt(i) != ".")) {
   i++
  }

  // there must be at least one character after the .
  if ((i >= sLength - 1) || (s.charAt(i) != ".")) return false;
  else return true;
 }

//------------------------------------------------------------------------------

	function contains(Text, Valid) {
		var sChar = '';
		var bResult = true;

		if (Text.length == 0) return false;

		for (iCount = 0; iCount < Text.length && bResult == true; iCount++) {
			sChar = Text.charAt(iCount);

			if (Valid.indexOf(sChar) == -1) {
				bResult = false;
			}
		}

		return bResult;
	}

	function isNumeric(NumberString) {
		return(contains(NumberString, '0123456789'));
	}

	function isAlpha(AlphaString) {
		return(contains(AlphaString, 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'));
	}

	function containsIllegal(Text, Illegal) {
		var sChar = '';
		var bResult = false;

		if (Text.length == 0) return false;

		for (iCount = 0; iCount < Text.length && bResult == false; iCount++) {
			sChar = Text.charAt(iCount);

			if (Illegal.indexOf(sChar) > 0) {
				bResult = true;
			}
		}

		return bResult;
	}

function stripCharacter(string, character) {
	var spaces = string.length;

	for(var iCount = 1; iCount<spaces; ++iCount){
		string = string.replace(character, "");   
	}

	return string;
}

//------------------------------------------------------------------------------

 function validDate(iDayIn, iMonthIn, iYearIn) {
  var iDay = parseInt(iDayIn);
  var iMonth = parseInt(iMonthIn);
  var iYear = parseInt(iYearIn);
  var iFeb = 28;
  var iReturn = 0;

  if (iMonth == 2 && isLeapYear(iYear) == true) iFeb = 29;

  switch (iMonth) {
   case 2:
    if (iDay > iFeb) iReturn = iFeb;
    break;

   case 4:
    if (iDay > 30) iReturn = iMonth;
    break;

   case 6:
    if (iDay > 30) iReturn = iMonth;
    break;

   case 9:
    if (iDay > 30) iReturn = iMonth;
    break;

   case 11:
    if (iDay > 30) iReturn = iMonth;
    break;
  }

  return iReturn;
 }

//------------------------------------------------------------------------------

 function falseDate(iValue) {
  var sError = "";

  switch(iValue) {
   case 4:
    sError = numberToMonth(iValue) + " has 30 days\n";
    break;

   case 6:
    sError = numberToMonth(iValue) + " has 30 days\n";
    break;

   case 9:
    sError = numberToMonth(iValue) + " has 30 days\n";
    break;

   case 11:
    sError = numberToMonth(iValue) + " has 30 days\n";
    break;

   case 28:
    sError = "February has 28 days\n";
    break;

   case 29:
    sError = "February has 29 days (leap year)\n";
    break;
  }

  return sError;
 }

function countOccurrences(Input, CharString) {
	var iStart = 0;
	var iFound = 0;
	var iInputLength = Input.length;

	while (Input.indexOf(CharString, iStart) > -1) {
		if (Input.indexOf(CharString, iStart) > -1) iFound++;

		iStart = Input.indexOf(CharString, iStart) + 1;
	}

	return iFound;
}

function getOccurrence(Input, CharString, Occurrence) {
	var iStart = 0;
	var iFound = 0;
	var iInputLength = Input.length;
	var iOccurrence = -1;

	while (Input.indexOf(CharString, iStart) > -1 && Occurrence != iFound) {
		if (Input.indexOf(CharString, iStart) > -1) {
			iFound++;
			iOccurrence = Input.indexOf(CharString, iStart);
		}

		iStart = Input.indexOf(CharString, iStart) + 1;
	}

	return iOccurrence;
}

function _fix(digits) {
	// digits specifies how many digits
	// Invalid values default to 0.
	if ((digits < 0) || (digits == null) || (isNaN(digits))) digits = 0;

	var power = Math.pow(10, digits);

	return Math.round(this.valueOf() * power) / power;
}
Number.prototype.fix = _fix;

function formatNumber(Expression, NumDigitsAfterDecimal, IncludeLeadingDigit, UseParensForNegativeNumbers, GroupDigits) { 
	if (isNaN(parseInt(Expression))) return Expression;

	var iExpressionTemp = Expression;
	var iSign = Expression < 0 ? -1 : 1;		// Get sign of number

	// Adjust number so only the specified number of numbers after
	// the decimal point are shown.
	iExpressionTemp *= Math.pow(10,NumDigitsAfterDecimal);
	iExpressionTemp = Math.round(Math.abs(iExpressionTemp))
	iExpressionTemp /= Math.pow(10,NumDigitsAfterDecimal);
	iExpressionTemp *= iSign;					// Readjust for sign


	// Create a string object to do our formatting on
	var iExpressionTempStr = new String(iExpressionTemp);

	// See if we need to strip out the leading zero or not.
	if (!IncludeLeadingDigit && Expression < 1 && Expression > -1 && Expression != 0)
		if (Expression > 0)
			iExpressionTempStr = iExpressionTempStr.substring(1,iExpressionTempStr.length);
		else
			iExpressionTempStr = "-" + iExpressionTempStr.substring(2,iExpressionTempStr.length);

	// See if we need to put in the commas
	if (GroupDigits && (Expression >= 1000 || Expression <= -1000)) {
		var iStart = iExpressionTempStr.indexOf(".");
		if (iStart < 0) iStart = iExpressionTempStr.length;

		iStart -= 3;
		while (iStart >= 1) {
			iExpressionTempStr = iExpressionTempStr.substring(0,iStart) + "," + iExpressionTempStr.substring(iStart,iExpressionTempStr.length)
			iStart -= 3;
		}		
	}

	// See if we need to use parenthesis
	if (UseParensForNegativeNumbers && Expression < 0) iExpressionTempStr = "(" + iExpressionTempStr.substring(1,iExpressionTempStr.length) + ")";

	return iExpressionTempStr;		// Return our formatted string!
}

function InStr(InputString, SearchFor) {
	for (var iCount = 0; iCount < len(InputString); iCount++) {
		if (SearchFor == Mid(InputString, iCount, SearchFor.length)) {
			return iCount;
		}
	}

	return -1;
}

function len(InputString) {
	return String(InputString).length;
}

function Mid(InputString, Start, Length) {
	if (Start < 0 || Length < 0) return "";

	var iEnd = 0;
	var iLength = String(InputString).length;

	if (Start + Length > iLength) {
		iEnd = iLength;
	} else {
		iEnd = Start + Length;
	}

	return String(InputString).substring(Start, iEnd);
}

function valueExists(Value) {
	return !(typeof(Value) == "undefined");
}

function stripHTML(HTML) {
	return HTML.replace(/(<([^>]+)>)/ig,"");
}

function toJS(input) {
	var sTemporary = "";

	sTemporary = input.replace(jsBackslash, "\\");
	sTemporary = sTemporary.replace(jsBackspace, "\b");
	sTemporary = sTemporary.replace(jsTab, "\t");
	sTemporary = sTemporary.replace(jsLinefeed, "\n");
	sTemporary = sTemporary.replace(jsCarriageReturn, "\r");
	sTemporary = sTemporary.replace(jsDoubleQuote, jsBackslash + jsDoubleQuote);
	sTemporary = sTemporary.replace(jsSingleQuote, "\'");
	sTemporary = sTemporary.replace(jsBackspace, "\b");

	return sTemporary;
}