//----------------------------------------------------------------
//  Author:			Sally Xu
//  Procedure Name:	Number_Format
//  Description:	Formats a number value to a given numeric format
//  Arguments:		input   	- the number value to be formatted
//					format		- the format to be used
//  Return Value:	A formatted numeric value
//  Comments:		(none)
//----------------------------------------------------------------
function Number_Format(input, format, applyprecision) {
	var formatArray = new Array;
	var userdecimal = "";
	var serverdecimal = "";
	var sReturn = "";
	var precision = 0;
	var thousandseparator = "";
	
	//If one of the input arguments is blank, return the input value
	if ((input == "") || (format == "")) {
		return input;
	} else if (input + "" == "undefined") {
		return input;	
	}	

	//Assign the format value and decimal separator to be used
	formatArray = format.split("|");
	if (formatArray.length > 1) 
	{
		format = formatArray[0];
		serverdecimal = formatArray[1];
		if(formatArray.length > 2)
			thousandseparator = formatArray[2];
	}
	
	//Identify the format's decimal character
	for (i=0; i < format.length; i++) {
		if ((format.charAt(i) != "-") && 
			(format.charAt(i) != "+") && 
			(isNaN(format.charAt(i)))) {
				userdecimal = format.charAt(i);
				precision = format.substring(i+1);
		}
	}
	//Replace the current decimal character with the format's decimal character and return the result (Tack on empty string to convert to string)
	var sTemp = Replace(input, serverdecimal, userdecimal) + "";
	if(serverdecimal == userdecimal && userdecimal == ","){		// 296519
		if(sTemp.indexOf(userdecimal) == -1)
			sTemp = Replace(input, ".", userdecimal);	
	}
	
	var sDigit;
	var pos = 0;
	var sDecimal = "";
	var sSign = "";
	var sTail = "";
	if(sTemp.charAt(0) == "-")
	{
		sSign = "-"
		sTemp = sTemp.substring(1);
	}
	pos = sTemp.indexOf(userdecimal);
	if (pos >=0)
	{
		sDigit = sTemp.substring(0, pos);
		sDecimal = sTemp.substring(pos);
	}
	else
		sDigit = sTemp;
	if(thousandseparator!="")
	{
		while(sDigit.length > 3)
		{
			pos = sDigit.length - 3		
			sTail = thousandseparator + sDigit.substring(pos) + sTail;		
			sDigit = sDigit.substring(0, pos);		
		}
		sDigit = sDigit + sTail;
	}
	if(precision == 0) //remove any decimal point if precision is 0
		sReturn = sSign + sDigit;
	else
	{
		if (applyprecision)
		{		
		    if(sDecimal.indexOf(userdecimal) == -1)            
                sDecimal += userdecimal;  
		    while(sDecimal.length <= precision)                        
                sDecimal += "0";                      
			sReturn = sSign + sDigit + sDecimal.substring(0, Number(precision) + 1);
	    }
		else
			sReturn = sSign + sDigit + sDecimal;			
	}
	return sReturn;
}


//----------------------------------------------------------------
//  Author:			Sally Xu
//  Procedure Name:	Number_onInput
//  Description:	Examines a character entered into a number field and determines
//					whether or not to allow the character to be appended to the 
//					existing numeric value
//  Arguments:		field - the name of the HTML form field containing the number 
//  Return Value:	Boolean - True if the entered character is allowed
//							  False if the entered character is invalid
//  Comments:		This function assumes that the form field in question has a
//					populated format attribute
//----------------------------------------------------------------
function Number_onKeyPress(field) {
	var inputChar = 0;
	var sInput = "";
	var format = "";
	var formatArray = new Array;
	var separator = "";
	var decimal = "";
	var precision = "";
	var sign = "";
	var numdigits = "";
	var digitsLeft = 0;
	var digitsRight = 0;
	var digitsArray = new Array;
	var valueDigitsLeft = 0;
	var valueDigitsRight = 0;
	
	//Identify the character that was entered by the user
	inputChar = window.event.keyCode;
	if(IsMac())//Allow Tab for MAC
	{
	if (inputChar == 9) {
		return true;
	}
		
	}
	//Allow the backspace character
	if (inputChar == 8) {
		return true;
	}

	//Read in the field value and format strings
	sInput = field.value;
	format = field.getAttribute("NumberFormat");
	//Assign the format value and decimal separator to be used
	formatArray = format.split("|");
	if (formatArray.length > 1) {
		format = formatArray[0];
		separator = formatArray[1];
	}

	//Identify the format's decimal character
	for (i=0; i < format.length; i++) {
		if ((format.charAt(i) != "-") && 
			(format.charAt(i) != "+") && 
			(isNaN(format.charAt(i)))) {
				decimal = format.charAt(i);
		}
	}

	// Figure out the number of digits to the left and to the right of the decimal
	var numFormat = format;
	if (numFormat.charAt(0) == "-" || numFormat.charAt(0) == "+")
		numFormat = numFormat.substring(1);
		
	
	if (decimal != "") {
		var digitsArray = numFormat.split(decimal);
		digitsLeft = parseInt(digitsArray[0]);
		digitsRight = parseInt(digitsArray[1]);
	} else {
		digitsLeft = parseInt(numFormat);
		digitsRight = 0;
	}		
	
	//Determine the format's precision, sign and total number of digits allowed
	if (decimal != "") {
		formatArray = format.split(decimal);
		if (formatArray.length > 1) {
			precision = formatArray[1];
			format = formatArray[0];
		}
		if (format.charAt(0) == "-" || format.charAt(0) == "+") {
			sign = format.charAt(0);
			numdigits = format.substring(1, format.length);
		}
		else {
			numdigits = format;
		}
	}

	//Only the negative sign, the decimal character and number values are allowed to be input 
	if ((String.fromCharCode(inputChar) != decimal) && (String.fromCharCode(inputChar) != "-") && (inputChar < 48 || inputChar > 57)) {
		return false;
	}

	//The decimal character is not allowed for number values with no precision
	if ((String.fromCharCode(inputChar) == decimal) && (precision == "0")) {
		return false;
	}

	// Only allow one negative sign
	if (String.fromCharCode(inputChar) == "-") {
		if (sInput.indexOf("-") >= 0) {
			return false;	
		}		
	}	
	
	// Only allow one positive sign
	if (String.fromCharCode(inputChar) == "+") {
		if (sInput.indexOf("+") >= 0) {
			return false;	
		}		
	}	
	
	//The negative sign is only allowed at the beginning of the numeric value
	if (sign == "-" && String.fromCharCode(inputChar) == sign && !IsMac()) {
		if (document.selection.type.toLowerCase() == "text") {
			// If they first selected some text, then don't allow the negative sign.
			return false;
		} else {
			var caretPos = document.selection.createRange().duplicate();
			
     		// Create textrange for the text of the textbox
     		var textAreaRange = field.createTextRange();	
     		// Make sure they are trying to put the negative sign as the first character.
     		if (textAreaRange.boundingLeft != caretPos.boundingLeft) {
				return false;	
			}				
		}		
	}

	//A negative sign is not allowed in positive values
	if ((sign == "+") && (String.fromCharCode(inputChar) == "-")) {
		return false;
	}

	//Sequential decimal characters are not allowed, but a single leading decimal is
	if ((String.fromCharCode(inputChar) == decimal) && (sInput.lastIndexOf(decimal) == sInput.length-1) && (sInput.length != 0)) {
		return false;
	}

	// Check and see if we can add more numbers (ONLY DO THIS FOR IE AND FOR ENTERING NUMBERS)
	if (!IsMac() && sInput != "" && inputChar >= 48 && inputChar <= 57) {
		var fieldValue = sInput;
		if (fieldValue.charAt(0) == "-" || fieldValue.charAt(0) == "+")
			fieldValue = fieldValue.substring(1);
		
		var decimalLocation = fieldValue.indexOf(decimal);
		if (decimalLocation >= 0) {
			digitsArray = fieldValue.split(decimal);
			valueDigitsLeft = digitsArray[0].length;
			if (digitsArray.length > 1) {
				valueDigitsRight = digitsArray[1].length;
			} else {
				valueDigitsRight = 0;
			}		
		} else {	
			valueDigitsLeft = fieldValue.length
			valueDigitsRight = 0;
		}
	
		// Check document.selection to make sure they haven't selected any text that they're attempting to overwrite
		if (document.selection.type.toLowerCase() == "text") {
			// They have selected some text, allow the input
		} else {
			// Nothing selected	
			var caretPos = document.selection.createRange().duplicate();
			
     		// Create textrange for the text of the textbox
     		var decimalRange = field.createTextRange();
     		
			if (decimalLocation >= 0) {
				decimalRange.findText(decimal);
				
				if (decimalRange.boundingLeft >= caretPos.boundingLeft) {
					if (valueDigitsLeft >= digitsLeft) {
						return false;	
					}	
				} else {
					if (valueDigitsRight >= digitsRight) {
						return false;	
					}
				}		
			} else {
				if (valueDigitsLeft >= digitsLeft) {
					return false;	
				}	
			}		
		}		
	}
	
	
	//If no errors are found, return true to allow the input character
	return true;

}

//----------------------------------------------------------------
//  Author:			Travis Harlow
//  Procedure Name:	Number_JSFormat
//  Description:	Formats a number to the user format, but always applies "." as the decimal
//                      for utilization in JS functions.
//  Arguments:		sInput	 - the number value to be reformatted
//					format	 - the old format that was used
//					unformat - the new format to be used
//  Return Value:	A reformatted numeric string
//	Comments:		(none)
//----------------------------------------------------------------
function Number_JSFormat(sInput, format)
{
	var formatArray = format.split("|");
	var tmpFormat = "";
	
	if (formatArray.length > 1) 
	{
		format = formatArray[0];
		formatArray[1] = ".";
		if(formatArray.length > 2)
			thousandseparator = formatArray[2];
	
		//Identify the format's decimal character
		for (i=0; i < format.length; i++) 
		{
			if ((format.charAt(i) != "-") && 
				(format.charAt(i) != "+") && 
				(isNaN(format.charAt(i)))) 
			{
					tmpFormat += ",";				
			}
			else
				tmpFormat += format.charAt(i);
		}
		formatArray[0] = tmpFormat;
		return Number_Unformat(sInput, formatArray.join("|"));
	}
	else
		return sInput;
}


//----------------------------------------------------------------
//  Author:			Sally Xu
//  Procedure Name:	Number_Unformat
//  Description:	Formats an already formatted number into a new numeric format
//  Arguments:		sInput	 - the number value to be reformatted
//					format	 - the old format that was used
//					unformat - the new format to be used
//  Return Value:	A reformatted numeric string
//	Comments:		(none)
//----------------------------------------------------------------
function Number_Unformat(sInput, format) {
	var formatArray = new Array;
	var userdecimal = "";
	var serverdecimal = "";
	var sReturn = "";
	var precision = 0;
	var thousandseparator = "";
	var sTemp = "";
	var strTempSeparator = "@";
	
	//If one of the input arguments is blank, return the input value
	if ((sInput == "") || (format == "")) {
		return sInput;
	}

	//Assign the format value and decimal separator to be used
	formatArray = format.split("|");
	if (formatArray.length > 1) 
	{
		format = formatArray[0];
		serverdecimal = formatArray[1];
		if(formatArray.length > 2)
			thousandseparator = formatArray[2];
	}
	//Identify the format's decimal character
	for (i=0; i < format.length; i++) {
		if ((format.charAt(i) != "-") && 
			(format.charAt(i) != "+") && 
			(isNaN(format.charAt(i)))) {
				userdecimal = format.charAt(i);				
		}
	}
	
	sTemp = sInput;
	
	//Replace the user decimal character with the server decimal character and return the result
	if(userdecimal!= serverdecimal)
		sTemp = Replace(sTemp, userdecimal, strTempSeparator);
	if(thousandseparator!="" && !(serverdecimal == "," && userdecimal == ",") && (sTemp.toString().indexOf(strTempSeparator) > -1)) // 296519
		sTemp = Replace(sTemp, thousandseparator, "");
	if(serverdecimal == "," && userdecimal == ",")	// Euro decimal formats need to be converted to use "." to save correctly: 296805
		sTemp = Replace(sTemp, serverdecimal, ".");
	if(userdecimal!="," && serverdecimal!= ",") //If only the userdecimal is a , then we should have already replaced it with @
		sTemp = Replace(sTemp, ",", "");
	sTemp = Replace(sTemp, " ", "");
	
	if(userdecimal!= serverdecimal)
		sTemp = Replace(sTemp, strTempSeparator, serverdecimal);
		
	return sTemp;
}


//----------------------------------------------------------------
//  Author:			Sally Xu
//  Procedure Name:	Number_Validate
//  Description:	Verifies that a given HTML form field contains a valid number
//  Arguments:		field - the name of the HTML form field containing the number 
//  Return Value:	True if the field contains an empty string
//					False if the field contains an invalid numeric value
//					A numeric variable if the field contains a valid number
//  Comments:		This function assumes that the form field in question has a
//					populated format attribute
//----------------------------------------------------------------

//DO NOT DELETE USED FOR INBOUND FORM FIELDS
function Number_Validate(field) {
	var sInput = "";
	var format = "";
	var formatArray = new Array;
	var separator = "";
	var decimal = "";
	var precision = "";
	var sign = "";
	var numdigits = "";
	var signed = false;
	var numberArray = new Array;
	var digitsLeft = 0;
	var digitsRight = 0;

	//If the input value is blank, return true
	sInput = field.value;
	if (sInput == "")
		return true;
		
	//Read in the field value and format strings
	if (field.getAttribute("NumberFormat")) {	
		format = field.getAttribute("NumberFormat")
	} else {
		format = field.getAttribute("format")
	}		
	
	//Assign the format value and decimal separator to be used
	formatArray = format.split("|");
	if (formatArray.length > 1) {
		format = formatArray[0];
		separator = formatArray[1];
	}
	
	//Identify the format's decimal character
	for (i=0; i < format.length; i++) {
		if ((format.charAt(i) != "-") && 
			(format.charAt(i) != "+") && 
			(isNaN(format.charAt(i)))) {
				decimal = format.charAt(i);
		}
	}
	
	//Determine the format's precision, sign and total number of digits allowed
	if (decimal != "") {
		formatArray = format.split(decimal);
		if (formatArray.length > 1) {
			precision = formatArray[1];
			format = formatArray[0];
		}
		if (format.charAt(0) == "-" || format.charAt(0) == "+") {
			sign = format.charAt(0);
			numdigits = format.substring(1, format.length);
		}
		else {
			numdigits = format;
		}
	}
	var sTemp = Number_Unformat(sInput, format);
	if(isNaN(sTemp)) // not a number
	{
		popMessage(ResourceID512 + " " + sign + numdigits + decimal + precision, field);
		return false;
	}
	//The number may not violate the format's sign restriction
	if ((decimal != "") && ((sInput.charAt(0) == "-") && (sign == "+"))) 
	{
		popMessage(ResourceID512 + " " + sign + numdigits + decimal + precision, field);
		return false;
	}
	if ((decimal != "") && ((sInput.charAt(0) != "-") && (sign == "-"))) 
	{
		popMessage(ResourceID512 + " " + sign + numdigits + decimal + precision, field);
		return false;
	}

	//Determine the number of input digits on each side of the decimal character
	numberArray = sInput.split(decimal);
	if (numberArray.length > 1) 
	{
		digitsLeft = numberArray[0].length;
		digitsRight = numberArray[1].length;
	}
	else 
	{
		digitsLeft = numberArray[0].length;
		digitsRight = 0;
	}

	//Compensate for a possible leading sign character
	if ((sInput.charAt(0) == "-") || (sInput.charAt(0) == "+")) 
	{
		digitsLeft = eval(digitsLeft - 1);
	}

	//The number may not have more digits than are specified in the format
	if ((digitsLeft > numdigits) || (digitsRight > precision)) {
		popMessage(ResourceID512 + " " + sign + numdigits + decimal + precision, field);
		return false;
	}
	return true;
}

//----------------------------------------------------------------
//  Author:			Sally Xu / Modified and added by Mike Young
//  Procedure Name:	Number_Validate_No_Alert
//  Description:	Verifies that a given HTML form field contains a valid number
//  Arguments:		field - the name of the HTML form field containing the number 
//  Return Value:	True if the field contains an empty string
//					False if the field contains an invalid numeric value
//					A numeric variable if the field contains a valid number
//  Comments:		This function assumes that the form field in question has a
//					populated format attribute
//----------------------------------------------------------------

function Number_Validate_No_Alert(field) {
	var sInput = "";
	var format = "";
	var formatArray = new Array;
	var separator = "";
	var decimal = "";
	var precision = "";
	var sign = "";
	var numdigits = "";
	var signed = false;
	var numberArray = new Array;
	var digitsLeft = 0;
	var digitsRight = 0;

	//If the input value is blank, return true
	sInput = field.value;
	if (sInput == "")
		return true;
	
	//Read in the field value and format strings
	if (field.getAttribute("NumberFormat")) {	
		format = field.getAttribute("NumberFormat")
	} else {
		format = field.getAttribute("format")
	}		
	
	//Assign the format value and decimal separator to be used
	formatArray = format.split("|");
	if (formatArray.length > 1) {
		format = formatArray[0];
		separator = formatArray[1];
	}
	
	//Identify the format's decimal character
	for (i=0; i < format.length; i++) {
		if ((format.charAt(i) != "-") && 
			(format.charAt(i) != "+") && 
			(isNaN(format.charAt(i)))) {
				decimal = format.charAt(i);
		}
	}
	
	//Determine the format's precision, sign and total number of digits allowed
	if (decimal != "") {
		formatArray = format.split(decimal);
		if (formatArray.length > 1) {
			precision = formatArray[1];
			format = formatArray[0];
		}
		if (format.charAt(0) == "-" || format.charAt(0) == "+") {
			sign = format.charAt(0);
			numdigits = format.substring(1, format.length);
		}
		else {
			numdigits = format;
		}
	}
	var sTemp = Number_Unformat(sInput, format);
	if(isNaN(sTemp)) // not a number
	{
		return false;
	}
	//The number may not violate the format's sign restriction
	if ((decimal != "") && ((sInput.charAt(0) == "-") && (sign == "+"))) 
	{
		return false;
	}
	if ((decimal != "") && ((sInput.charAt(0) != "-") && (sign == "-"))) 
	{
		return false;
	}

	//Determine the number of input digits on each side of the decimal character
	numberArray = sInput.split(decimal);
	if (numberArray.length > 1) 
	{
		digitsLeft = numberArray[0].length;
		digitsRight = numberArray[1].length;
	}
	else 
	{
		digitsLeft = numberArray[0].length;
		digitsRight = 0;
	}

	//Compensate for a possible leading sign character
	if ((sInput.charAt(0) == "-") || (sInput.charAt(0) == "+")) 
	{
		digitsLeft = eval(digitsLeft - 1);
	}

	//The number may not have more digits than are specified in the format
	if ((digitsLeft > numdigits) || (digitsRight > precision)) {
		return false;
	}
	return true;
}

function TruncateNumber(input, precision, roundValue)
{
	if(roundValue == null || roundValue == undefined)
		roundValue = true;
		
    //Round
    var y = input * Math.pow(10, precision);
    
    var x = Math.floor(y);
    
    var diff = y - x;
    
	if(roundValue)
	{
		if(diff >= 0.00000001)
			x += 1.0;
    }
	
	//javascript does not like multiplying out by the 1/1xxxx value
    x = x / (1 / Math.pow(10, -1 * precision));
	
	return x;
}

function RoundFinancialNumber(input, precision, numberFormat, formatted)
{
	// TJH Case #49630, Defect #302204
	var x;
	
	if (formatted == null || formatted == undefined)
		formatted = true;
	
	if (!formatted)
	{
		// Truncate the number
		x = TruncateNumber(input, precision, true);
	}
	
	else 
	{
		// Unformat the number, then truncate it
		x = TruncateNumber(Number_JSFormat(input, numberFormat), precision, true);
	}
	
    //Set value
	if (numberFormat)
		x = Number_Format(x, numberFormat);

    var userdecimal = "";
	
	for (i=0; i < numberFormat.length; i++) 
	{
		if ((numberFormat.charAt(i) != "-") && 
			(numberFormat.charAt(i) != "+") && 
			(isNaN(numberFormat.charAt(i)))) 
		{
		    userdecimal = numberFormat.charAt(i);
		    break;
		}
    }
    
    if(userdecimal != "" && precision > 0)
    {
        x = x + "";

		if(x.indexOf(userdecimal) == -1) // check for whole numbers
        {
            x += userdecimal;
            for(var i = 1; i <= precision; i++)
                x += "0";
        }
        else
        {
            var wholePart = x.substring(0, x.indexOf(userdecimal));
            var decPart = x.substring(x.indexOf(userdecimal));
            
            x = wholePart + userdecimal;
            for(var i = 1; i <= precision; i++)
                x += decPart.charAt(i);
                
            if(decPart.length < precision + 1)
            {
                for(var i = decPart.length; i <= precision; i++)
                    x += "0";
            }
        }
    }
    
    return x;
}

function Number_Padding(val, precision, numberFormat)
{
	var userdecimal = "";
    var x = val + "";
	
	userdecimal = IdentifyUserDecimalChar(numberFormat); // 296805
	if(userdecimal == "," && x.indexOf(",") == -1 && x.indexOf(".") > -1) 
		x = Replace(x, ".", userdecimal); 
		
    if(userdecimal != "" && precision > 0)
    {              
        if(x.indexOf(userdecimal) == -1)
        {
            x += userdecimal;
            for(var i = 1; i <= precision; i++)
                x += "0";
        }
        else
        {
            var wholePart = x.substring(0, x.indexOf(userdecimal));
            var decPart = x.substring(x.indexOf(userdecimal) + 1);   
            while(decPart.length < precision)                           
                decPart += "0";         
			if(decPart.length > precision)
				decPart = decPart.substring(0, precision);			                                                       
            x = wholePart + userdecimal + decPart;            
        }
    }	
	return x;
}

function FormatCurrency(roundedValue, symbol, symbolLocation)
{
	var s = "";
    var val = roundedValue;
	var stringValue = roundedValue + "";
	
	if(stringValue.indexOf("-") == 0)
	{
		s += "(";
		val = stringValue.substring(1);
	}
	
    switch(symbolLocation)
    {
        case "0":
            s += symbol + val;
            break;
            
        case "1":
            s += val + symbol;
            break;
            
        case "2":
            s += symbol + " " + val;
            break;

        case "3":
            s += val + " " + symbol;
            break;
    }
	
	if(stringValue.indexOf("-") == 0)
		s += ")";
    
    return s;
}

function FormatCurrencyString(val, precision, numberFormat, symbol, symbolLocation)
{
	//Rounded value
	var roundedValue = RoundFinancialNumber(val, precision, numberFormat);
	
	var s = FormatAltHoverNumber(val);
	
	//Format currency
	var html = "<span title=\"" + s + "\">" + FormatCurrency(roundedValue, symbol, symbolLocation) + "</span>";
	
	return html;
}

function FormatAltHover(ctl)
{
	var x = 0;
	var controlName = ctl.name;

    if(controlName.indexOf("field") > -1)
        controlName = controlName.substring(5);

	var s = "";
	
    var currObj = ObjectManager.GetObject(controlName.substring(8));
	if(currObj != null)
		s = FormatAltHoverNumber(currObj.GetValue());
	else
		s = FormatAltHoverNumber(0);
	
	var spanTag = document.getElementById(ctl.id.substring(13));
	if(spanTag)
		spanTag.title = s;
}

function FormatAltHoverNumber(val)
{
	var x = TruncateNumber(val, 9, false);
	if(val < 0)
		x = Math.abs(x);
		
	var s = "";
	if(val < 0)
		s += "(";
	
	var tempNumFormat = "10" + userDecSep + "9|" + serverDecSep + "|" + userThdSep;
	x = Number_Format(x, tempNumFormat);
	s += Number_Padding(x, 9, tempNumFormat);
	
	if(val < 0)
		s += ")";
		
	return s;
}

function IdentifyUserDecimalChar(format) // SLS 09 Mar 09 defect 290602
{
	//Assign the format value and decimal separator to be used
	var formatArray = new Array;
	formatArray = format.split("|");
	if (formatArray.length > 1) {
		format = formatArray[0];
	}
	//Identify the format's user decimal character
	var decimal = "";
	for (i=0; i < format.length; i++) {
		if ((format.charAt(i) != "-") && 
			(format.charAt(i) != "+") && 
			(isNaN(format.charAt(i)))) {
				decimal = format.charAt(i);
		}
	}
	return decimal;
}

function IdentifyServerDecimalChar(format) // SLS 09 Mar 09 defect 290602
{
	//Assign the format value and decimal separator to be used
	var formatArray = new Array;
	formatArray = format.split("|");
	if (formatArray.length > 1) {
		format = formatArray[1];
	}
	//Identify the format's server decimal character
	var decimal = "";
	for (i=0; i < format.length; i++) {
		if ((format.charAt(i) != "-") && 
			(format.charAt(i) != "+") && 
			(isNaN(format.charAt(i)))) {
				decimal = format.charAt(i);
		}
	}
	return decimal;
}

//---------------------------------------------------------------------------------------
//  Author:			Sarah Stone 13 Mar 09
//  Procedure Name:	FormatNumericRegEx
//  Description:	Returns the RegEx validation expression based on a numeric format
//  Arguments:		format - numeric format, blnAllowNegatives, blnAllowPositives
//  Return Value:	Returns the RegEx string
//  Comments:		defect: 296805
//----------------------------------------------------------------------------------------
function FormatNumericRegEx(format, blnAllowNegatives, blnAllowPositives)
{
	var numberArray = new Array;
	var numDigitsLeft = 0;
	var numDigitsRight = 0;
	var serverdecimal = "";
	var userdecimal = "";
	var regEx = "";
	
	//Assign the format value and decimal separator to be used
	formatArray = format.split("|");
	if (formatArray.length > 1) 
	{
		format = formatArray[0];
		serverdecimal = formatArray[1];
	}
	
	//Identify the format's decimal precision
	for (i=0; i < format.length; i++) {
		if ((format.charAt(i) != "-") && 
			(format.charAt(i) != "+") && 
			(isNaN(format.charAt(i)))) {
				numDigitsRight = format.substring(i+1);
		}
	}
	//Identify the format's decimal character
	userdecimal = IdentifyUserDecimalChar(format);
	
	//Identify the format's precision to the left of the decimal
	formatArray = format.split(userdecimal);
	if (formatArray.length > 1) 
	{
		numDigitsLeft = formatArray[0];
		if(numDigitsLeft.indexOf("+") > -1) // remove sign char
			numDigitsLeft = Replace(numDigitsLeft, "+", "");
		if(numDigitsLeft.indexOf("-") > -1)
			numDigitsLeft = Replace(numDigitsLeft, "-", "");
	}
	
	// For Euro servers - Euro formats converted to US before save so validate against US format
	if(serverdecimal == "," && userdecimal == ",") 
		userdecimal = ".";

	// Build the RegEx
	if (blnAllowNegatives && blnAllowPositives)
	{
		// Sign doesn't matter
		regEx = "(-)?";
	}
	else if (blnAllowNegatives)
	{
		// Negative Only
		regEx = "(-)";
	}
	else
	{
		// Positive only
		regEx = "";
	}
		
	regEx += "(\\d{0," + numDigitsLeft + "})";
	if (numDigitsRight > 0)
		regEx += "(\\" + userdecimal + "\\d{1," + numDigitsRight + "})?";
	
	return regEx;
}