if (!FieldManager) {

var FieldManager = {
	adminTypes: {},
	publicTypes: {},
	
	RegisterAdminFieldType: function(typeName, typeObject) {
		this.adminTypes[typeName] = Class.create(typeObject);
	},
	
	RegisterAdminFieldProperties: function(typeName, propertiesArray) {
		var fieldType = this.adminTypes[typeName];
		if (fieldType)
		{
			if (!propertiesArray)
			{
				propertiesArray = [];
			}
			
			var propertiesClasses = [];
			for (var i = 0, length = propertiesArray.length; i < length; i++)
			{
				propertiesClasses.push(Class.create(propertiesArray[i]));
			}
			
			fieldType.prototype.DefaultProperties = propertiesClasses;
			fieldType.prototype.GetPropertiesInstance = function() {
				var properties = [];
				
				for (var i = 0, length = this.DefaultProperties.length; i < length; i++)
				{
					properties.push(new this.DefaultProperties[i]());
				}
				
				return properties;
			}
		}
	},
	
	RegisterPublicFieldType: function(typeName, typeObject) {
		this.publicTypes[typeName] = Class.create(typeObject);
	},
	
	GetAdminFieldType: function(typeName) {
		var adminType = this.adminTypes[typeName];
		if (adminType)
		{
			return new adminType();
		}
		return null;
	},
	
	GetPublicFieldType: function(typeName) {
		var publicType = this.publicTypes[typeName];
		if (publicType)
		{
			return new publicType();
		}
		return null;
	}
};

}

FieldManager.RegisterPublicFieldType("BaseFields.TouchPointCalculation", {
    GetCalculationValue: function(fieldContainer) {
        var textBox = fieldContainer.getElementsByTagName("input");
        if (textBox.length == 1)
        {
            return (+textBox[0].value);
        }
        else
        {
            var label = fieldContainer.getElementsByTagName("span");
            if (span.length == 1)
            {
                return (+span[0].value);
            }
        }
        return 0;
    },
    
    GetValue: function(fieldContainer) {
		var textBox = fieldContainer.getElementsByTagName("input");
		return textBox[0].value;
		
		var textBox = fieldContainer.getElementsByTagName("input");
        if (textBox.length == 1)
        {
            return textBox[0].value;
        }
        else
        {
            var label = fieldContainer.getElementsByTagName("span");
            if (span.length == 1)
            {
                return span[0].value;
            }
        }
        return null;
    },
    
    DependencyTests: [
		{
			name: "equals...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = textBox[0].value;
				return currentValue.toLowerCase() == value.toLowerCase();
			}
		},
		{
			name: "does not equal...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = textBox[0].value;
				return currentValue.toLowerCase() != value.toLowerCase();
			}
		},
		{
			name: "is greater than...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = (+textBox[0].value);
				var value = (+value);
				if (isNaN(value) || isNaN(currentValue))
					return false
				else
					return currentValue > value;
			}
		},
		{
			name: "is less than...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = (+textBox[0].value);
				var value = (+value);
				if (isNaN(value) || isNaN(currentValue))
					return false
				else
					return currentValue < value;
			}
		}
    ]
});


TouchPointCalculationManager = Class.create({   
	initialize: function() {
	      // Create GetCalculationValue lookups	      
	      this.FormValuesField = $('Calculation_FormValues');
	      if (this.FormValuesField.value != '' && this.FormValuesField.value != null)
	      {
	        this.FormValues = this.FormValuesField.value.evalJSON();
	      }
	      else
	      {
	        this.FormValues = {};
	      }
	},
	
	Update: function(calculationFieldID, equation) {
	    var calcField = $(calculationFieldID);
	    var equationResult = '';
	    if (equation != null && equation != '')
	    {
	        equationResult = eval(equation);
	    }
	    
	    if (calcField)
	    {
	        if (calcField.tagName.toLowerCase() == 'input')
	        {
	            $(calculationFieldID).value = equationResult;
	        }
	        else
	        {
	            $(calculationFieldID).previous().value = equationResult;
	            $(calculationFieldID).innerHTML = equationResult;
	        }
	        
	        if (calcField.onkeyup)
	        {
	            calcField.onkeyup();
	        }
	    }
	},
	
	GetValue: function(containerID, fieldType) {
	    // Find the appropriate FieldType
	    var fieldType = FieldManager.GetPublicFieldType(fieldType);	             
	    if (fieldType && fieldType.GetCalculationValue)
	    {
	        var container = $(containerID);
	        if (container)
	        {
	            var value = fieldType.GetCalculationValue(container);
	            this.FormValues[containerID] = value;
	            this.FormValuesField.value = Sys.Serialization.JavaScriptSerializer.serialize(this.FormValues);
	            return value;
	        }
	        else if (this.FormValues[containerID] != null)
	        {
	            return this.FormValues[containerID];
	        }
	    }
	    
	    return 0;
	}
});


FieldManager.RegisterPublicFieldType("BaseFields.TouchPointCheckBoxList", {
    GetCalculationValue: function(fieldContainer) {
        var sum = 0;
        var checkboxes = fieldContainer.getElementsByTagName("input");
		for (var i = 0; i < checkboxes.length; i++)
		{
		    if (checkboxes[i].type.toLowerCase() != "checkbox") continue;
		    
			if (checkboxes[i].checked && !isNaN(+checkboxes[i].value))
			{
				sum += (+checkboxes[i].value);
			}
		}
		return sum;
    },
    
    GetValue: function(fieldContainer) {
		var selectedValues = [];
        var checkboxes = fieldContainer.getElementsByTagName("input");
		for (var i = 0; i < checkboxes.length; i++)
		{
		    if (checkboxes[i].type.toLowerCase() != "checkbox") continue;
		    
			if (checkboxes[i].checked)
			{
				selectedValues.push(checkboxes[i].value);
			}
		}
		return selectedValues;
    },
    
    DependencyTests: [
		{
			name: "equals...",
			valueselectiontype: "dropdown",
			Test: function(fieldContainer, value) {
				var checkboxes = fieldContainer.getElementsByTagName("input");
				for (var i = 0; i < checkboxes.length; i++)
				{
					if (checkboxes[i].type.toLowerCase() != "checkbox") continue;
	    		    
					if (checkboxes[i].checked && checkboxes[i].value == value)
					{
						return true;				
					}
				}
				return false;
			},
			GetPossibleValues: function(properties) {
				var values = [];
				if (!properties.Choices) return values;
				for (var i = 0; i < properties.Choices.length; i++)
				{
					values.push(properties.Choices[i].Value);
				}
				return values;
			}
		},
		{
			name: "does not equal...",
			valueselectiontype: "dropdown",
			Test: function(fieldContainer, value) {
				var checkboxes = fieldContainer.getElementsByTagName("input");
				for (var i = 0; i < checkboxes.length; i++)
				{
					if (checkboxes[i].type.toLowerCase() != "checkbox") continue;
	    		    
					if (checkboxes[i].checked && checkboxes[i].value == value)
					{
						return false;				
					}
				}
				return true;
			},
			GetPossibleValues: function(properties) {
				var values = [];
				if (!properties.Choices) return values;
				for (var i = 0; i < properties.Choices.length; i++)
				{
					values.push(properties.Choices[i].Value);
				}
				return values;
			}
		},
		{
			name: "has an option selected",
			valueselectiontype: "none",
			Test: function(fieldContainer) {
				var checkboxes = fieldContainer.getElementsByTagName("input");
				for (var i = 0; i < checkboxes.length; i++)
				{
					if (checkboxes[i].type.toLowerCase() != "checkbox") continue;
	    		    
					if (checkboxes[i].checked)
					{
						return true;				
					}
				}
				return false;
			}
		},
		{
			name: "has no option selected",
			valueselectiontype: "none",
			Test: function(fieldContainer) {
				var checkboxes = fieldContainer.getElementsByTagName("input");
				for (var i = 0; i < checkboxes.length; i++)
				{
					if (checkboxes[i].type.toLowerCase() != "checkbox") continue;
	    		    
					if (checkboxes[i].checked)
					{
						return false;				
					}
				}
				return true;
			}
		}
    ]
});





FieldManager.RegisterPublicFieldType("BaseFields.TouchPointDropDown", {
    GetCalculationValue: function(fieldContainer) {
        var dropdown = fieldContainer.getElementsByTagName("select");
        var value = (+dropdown[0].value);
        return isNaN(value) ? 0 : value;
    },
    
    GetValue: function(fieldContainer) {
		var dropdown = fieldContainer.getElementsByTagName("select");
        return dropdown[0].value;
    },
    
    DependencyTests: [
		{
			name: "equals...",
			valueselectiontype: "dropdown",
			Test: function(fieldContainer, value) {
				var dropdown = fieldContainer.getElementsByTagName("select");
				var currentValue = dropdown[0].value;
				return currentValue == value;
			},
			GetPossibleValues: function(properties) {
				var values = [];
				if (!properties.Choices) return values;
				for (var i = 0; i < properties.Choices.length; i++)
				{
					values.push(properties.Choices[i].Value);
				}
				return values;
			}
		},
		{
			name: "does not equal...",
			valueselectiontype: "dropdown",
			Test: function(fieldContainer, value) {
				var dropdown = fieldContainer.getElementsByTagName("select");
				var currentValue = dropdown[0].value;
				return currentValue != value;
			},
			GetPossibleValues: function(properties) {
				var values = [];
				if (!properties.Choices) return values;
				for (var i = 0; i < properties.Choices.length; i++)
				{
					values.push(properties.Choices[i].Value);
				}
				return values;
			}
		}
    ]
});








FieldManager.RegisterPublicFieldType("BaseFields.TouchPointListBox", {
    GetCalculationValue: function(fieldContainer) {
        var sum = 0;
        var listbox = fieldContainer.getElementsByTagName("select")[0];
		for (var i = 0; i < listbox.options.length; i++)
		{
		    var option = listbox.options[i];
		    if (option.selected && !isNaN(+option.value))
			{
				sum += (+option.value);				
			}
		}
		return sum;
    },
    
    GetValue: function(fieldContainer) {
		var selectedValues = [];
        var listbox = fieldContainer.getElementsByTagName("select")[0];
		for (var i = 0; i < listbox.options.length; i++)
		{
		    var option = listbox.options[i];
		    if (option.selected)
			{
				selectedValues.push(option.value);				
			}
		}
		return selectedValues;
    },
    
    DependencyTests: [
		{
        name: "equals...",
			valueselectiontype: "dropdown",
			Test: function(fieldContainer, value) {
				var listbox = fieldContainer.getElementsByTagName("select")[0];
				for (var i = 0; i < listbox.options.length; i++)
				{
					var option = listbox.options[i];
					if (option.selected && option.value == value)
					{
						return true;				
					}
				}
				return false;
			},
			GetPossibleValues: function(properties) {
				var values = [];
				if (!properties.Choices) return values;
				for (var i = 0; i < properties.Choices.length; i++)
				{
					values.push(properties.Choices[i].Value);
				}
				return values;
			}
		},
		{
			name: "does not equal...",
			valueselectiontype: "dropdown",
			Test: function(fieldContainer, value) {
				var listbox = fieldContainer.getElementsByTagName("select")[0];
				for (var i = 0; i < listbox.options.length; i++)
				{
					var option = listbox.options[i];
					if (option.selected && option.value == value)
					{
						return false;				
					}
				}
				return true;
			},
			GetPossibleValues: function(properties) {
				var values = [];
				if (!properties.Choices) return values;
				for (var i = 0; i < properties.Choices.length; i++)
				{
					values.push(properties.Choices[i].Value);
				}
				return values;
			}
		},
		{
			name: "has an option selected",
			valueselectiontype: "none",
			Test: function(fieldContainer) {
				var listbox = fieldContainer.getElementsByTagName("select")[0];
				for (var i = 0; i < listbox.options.length; i++)
				{
					var option = listbox.options[i];
					if (option.selected)
					{
						return true;				
					}
				}
				return false;
			}
		},
		{
			name: "has no option selected",
			valueselectiontype: "none",
			Test: function(fieldContainer) {
				var listbox = fieldContainer.getElementsByTagName("select")[0];
				for (var i = 0; i < listbox.options.length; i++)
				{
					var option = listbox.options[i];
					if (option.selected)
					{
						return false;				
					}
				}
				return true;
			}
		}
    ]
});


FieldManager.RegisterPublicFieldType("BaseFields.TouchPointRadioButtonList", {
    GetCalculationValue: function(fieldContainer) {
        var radios = fieldContainer.getElementsByTagName("input");
		for (var i = 0; i < radios.length; i++)
		{
		    if (radios[i].type.toLowerCase() != "radio") continue;
		    
			if (radios[i].checked && !isNaN(+radios[i].value))
				return (+radios[i].value);
		}
		return 0;
    },
    
    GetValue: function(fieldContainer) {
		var radios = fieldContainer.getElementsByTagName("input");
		for (var i = 0; i < radios.length; i++)
		{
		    if (radios[i].type.toLowerCase() != "radio") continue;
		    
			if (radios[i].checked)
				return radios[i].value;
		}
		return null;
    },
    
    DependencyTests: [
		{
			name: "equals...",
			valueselectiontype: "dropdown",
			Test: function(fieldContainer, value) {
				var radios = fieldContainer.getElementsByTagName("input");
				for (var i = 0; i < radios.length; i++)
				{
					if (radios[i].type.toLowerCase() != "radio") continue;
	    		    
					if (radios[i].checked && radios[i].value == value)
						return true;
				}
				return false;
			},
			GetPossibleValues: function(properties) {
				var values = [];
				if (!properties.Choices) return values;
				for (var i = 0; i < properties.Choices.length; i++)
				{
					values.push(properties.Choices[i].Value);
				}
				return values;
			}
		},
		{
			name: "does not equal...",
			valueselectiontype: "dropdown",
			Test: function(fieldContainer, value) {
				var radios = fieldContainer.getElementsByTagName("input");
				for (var i = 0; i < radios.length; i++)
				{
					if (radios[i].type.toLowerCase() != "radio") continue;
	    		    
					if (radios[i].checked && radios[i].value == value)
						return false;
				}
				return true;
			},
			GetPossibleValues: function(properties) {
				var values = [];
				if (!properties.Choices) return values;
				for (var i = 0; i < properties.Choices.length; i++)
				{
					values.push(properties.Choices[i].Value);
				}
				return values;
			}
		}
    ]
});


FieldManager.RegisterPublicFieldType("BaseFields.TouchPointTextArea", {
    GetCalculationValue: function(fieldContainer) {
        var textArea = fieldContainer.getElementsByTagName("textarea");
        var value = (+textArea[0].value);
        return isNaN(value) ? 0 : value;
    },
    
    DependencyActions: {
		Require: function(fieldContainer, conditionResult) {
			var validator = fieldContainer.getElementsByTagName("span")[0];
			if (conditionResult)
			{
				if (!validator.enabled || validator.enabled == "False")
				{
					validator.enabled = true;
					validator.enabledbyaction = true;
				}
			}
			else
			{
				if (validator.enabledbyaction)
				{
					ValidatorEnable(validator, false);
				}
			}
		}
    },
    
    DependencyTests: [
		{
			name: "is empty",
			valueselectiontype: "none",
			Test: function(fieldContainer, value) {
				var textArea = fieldContainer.getElementsByTagName("textarea");
				var currentValue = textArea[0].value;
				return currentValue == "";
			}
		},
		{
			name: "is not empty",
			valueselectiontype: "none",
			Test: function(fieldContainer, value) {
				var textArea = fieldContainer.getElementsByTagName("textarea");
				var currentValue = textArea[0].value;
				return currentValue != "";
			}
		},
		{
			name: "equals...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textArea = fieldContainer.getElementsByTagName("textarea");
				var currentValue = textArea[0].value;
				return currentValue.toLowerCase() == value.toLowerCase();
			}
		},
		{
			name: "does not equal...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textArea = fieldContainer.getElementsByTagName("textarea");
				var currentValue = textArea[0].value;
				return currentValue.toLowerCase() != value.toLowerCase();
			}
		},
		{
			name: "contains...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textArea = fieldContainer.getElementsByTagName("textarea");
				var currentValue = textArea[0].value;
				return (currentValue.match(new RegExp(value, "i")) != null);
			}
		},
		{
			name: "does not contain...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textArea = fieldContainer.getElementsByTagName("textarea");
				var currentValue = textArea[0].value;
				return (currentValue.match(new RegExp(value, "i")) == null);
			}
		}
    ]
});


// Attaches character counters to each textarea on the form
function SetTextAreaMaxLength(textarea) 
{
    textarea = $(textarea);
    
    if (!textarea) return;
    
	if (textarea.getAttribute("maxlength")) 
	{
	    var counter = document.createElement("div");
		counter.relatedElement = textarea;
		counter.innerHTML = "<span>0</span>/" + textarea.getAttribute("maxlength");
		textarea.parentNode.insertBefore(counter, textarea.nextSibling);
		textarea.relatedElement = counter.getElementsByTagName("span")[0];
        
		textarea.onkeyup = textarea.onchange = CheckTextAreaMaxLength;
		textarea.onkeyup();
		
		var floatClear = document.createElement("div");
		floatClear.style.float = "none";
		floatClear.style.clear = "both";
		textarea.parentNode.insertBefore(floatClear, counter.nextSibling);
	}
}

// Compares the current length of a textarea to the maximum
// allowed length and sets a class to inform the user if
// they go over
function CheckTextAreaMaxLength() 
{
	var maxLength = this.getAttribute("maxlength");
	var currentLength = this.value.length;
	if (currentLength > maxLength)
	{
		this.relatedElement.className = "error_text";
	}
	else
    {
		this.relatedElement.className = "";
	}
	this.relatedElement.firstChild.nodeValue = currentLength;
}

// Validates that the textarea's value length is below the
// maximum allowed
function ValidateTextAreaLength(src, args)
{
    var textArea = $(src.getAttribute("controltovalidate"));
	var numCharsAllowed = textArea.getAttribute("maxlength");
	if (textArea.value.length > numCharsAllowed)
		args.IsValid = false;
	else
		args.IsValid = true;
}


FieldManager.RegisterPublicFieldType("TouchPoint.Domain.Fields.Payment.TouchPointPayment", {

});

function SetRecurringPayment(container)
{
	if (container)
	{
		var box = container.getElementsByTagName('input')[0];
		var associatedControl = $(container.getAttribute('associatedcontrol'));
		if(box.checked)
		{
			associatedControl.show();
		}
		else
		{
			associatedControl.hide();
			associatedControl.getElementsByTagName('input')[0].value = '';
		}
	}
}

function LaunchPopup(url, width, height)
{
	window.open(url, null, 'width=' + width + ', height=' + height);
}

function ValidateCCExpiration(src, args)
{
	var ddlMonth = $(src.getAttribute('controltovalidate'));
	var ddlYear = $(src.getAttribute('expirationyearcontrol'));
	
	var now = new Date();
	var currentYear = now.getFullYear();
	var currentMonth = now.getMonth() + 1;
	
	if ((+ddlYear.value) > currentYear)
	{
		args.IsValid = true;
		return;
	}
	
	if ((+ddlMonth.value) >= currentMonth)
	{
		args.IsValid = true;
		return;
	}
	
	args.IsValid = false;
}

// Define the cards we support.
//	Name:		As in the selection box of the form - must be same as user's
//	Length:		List of possible valid lengths of the card number for the card
//	prefixes:	List of possible prefixes for the card
//	checkdigit: Boolean to say whether there is a check digit
var CreditCards = [
	{	name: "Visa", 
		length: "13,16", 
		prefixes: "4",
		checkdigit: true
	},
	{	
		name: "MasterCard", 
		length: "16", 
		prefixes: "51,52,53,54,55",
		checkdigit: true
	},
	{
		name: "Amex", 
		length: "15", 
		prefixes: "34,37",
		checkdigit: true
	},
	{
		name: "Discover", 
		length: "16", 
		prefixes: "6011,650",
		checkdigit: true
	}
];

function ValidateCreditCardNumber(src, args) 
{
	var cardnumber = $(src.getAttribute('controltovalidate')).value;
	var cardtype = $(src.getAttribute('cardtypecontrol')).value;
	  
	// Establish card type
	var cardTypeIndex = -1;
	for (var i = 0, length = CreditCards.length; i < length; i++) 
	{
		// See if it is this card (ignoring the case of the string)
		if (cardtype.toLowerCase() == CreditCards[i].name.toLowerCase()) 
		{
			cardTypeIndex = i;
			break;
		}
	}
  
	// If card type not found, report an error
	if (cardTypeIndex == -1) 
	{
		args.IsValid = false;
		return; 
	}
	
	var currentCardType = CreditCards[cardTypeIndex];
    
	// Remove any spaces from the credit card number
	cardnumber = cardnumber.replace (/\s/g, '');
  
	// Check that the number is numeric
	var cardNo = cardnumber
	var cardexp = /^[0-9]{13,19}$/;
	if (!cardexp.exec(cardNo))  
	{
		args.IsValid = false;
		return; 
	}
       
	// Now check the modulus 10 check digit - if required
	if (currentCardType.checkdigit) 
	{
		var checksum = 0;   // running checksum total
		var mychar = '';	// next char to process
		var j = 1;          // takes value of 1 or 2

		// Process each digit one by one starting at the right
		var calc;
		for (i = cardNo.length - 1; i >= 0; i--) 
		{
			// Extract the next digit and multiply by 1 or 2 on alternative digits.
			calc = Number(cardNo.charAt(i)) * j;

			// If the result is in two digits add 1 to the checksum total
			if (calc > 9) 
			{
				checksum = checksum + 1;
				calc = calc - 10;
			}

			// Add the units element to the checksum total
			checksum = checksum + calc;

			// Switch the value of j
			if (j == 1) {j = 2} else {j = 1};
		} 

		// All done - if checksum is divisible by 10, it is a valid modulus 10.
		// If not, report an error.
		if (checksum % 10 != 0)  
		{
			args.IsValid = false;
			return; 
		}
	}  

	// Make sure the prefix is valid
	var PrefixValid = false;
	var prefixes = currentCardType.prefixes.split(',');
	for (i = 0, length = prefixes.length; i < length; i++) 
	{
		var exp = new RegExp ('^' + prefixes[i]);
		if (exp.test (cardNo)) PrefixValid = true;
	}

	if (!PrefixValid) 
	{
		args.IsValid = false;
		return; 
	}
    
	// See if the length is valid for this card
	var LengthValid = false;
	var lengths = CreditCards[cardTypeIndex].length.split(',');
	for (j = 0, length = lengths.length; j < length; j++) 
	{
		if (cardNo.length == lengths[j]) LengthValid = true;
	}

	if (!LengthValid) 
	{
		args.IsValid = false;
		return; 
	};   
  
	// The credit card is in the required format.
	args.IsValid = true;
}


TouchPointPaymentManager = Class.create({   
	initialize: function() {
	      // Create GetCalculationValue lookups	      
	      this.FormValuesField = $('Payment_FormValues');
	      if (this.FormValuesField.value != '' && this.FormValuesField.value != null)
	      {
	        this.FormValues = this.FormValuesField.value.evalJSON();
	      }
	      else
	      {
	        this.FormValues = {};
	      }
	},
	
	Update: function(paymentLabelID, equation) {
	    var paymentAmountLabel = $(paymentLabelID);
	    var equationResult = '';
	    if (equation != null && equation != '')
	    {
	        equationResult = eval(equation);
	    }
	    
	    if (paymentAmountLabel)
	    {
	        paymentAmountLabel.innerHTML = this.FormatCurrency(equationResult);
	    }
	},
	
	GetValue: function(containerID, fieldType) {
	    // Find the appropriate FieldType
	    var fieldType = FieldManager.GetPublicFieldType(fieldType);
	    if (fieldType && fieldType.GetValue)
	    {
	        var container = $(containerID);
	        if (container)
	        {
				var numericValue = 0;
	            var value = fieldType.GetValue(container);
				var mapping = window[containerID + '_paymentmapping'];
				if (mapping)
				{
					if (Object.isArray(value))
					{
						for (var i = 0, length = value.length; i < length; i++)
						{
							var price = (+mapping[value[i]]);
							numericValue += isNaN(price) ? 0 : price;
						}
					}
					else
					{
						var price = (+mapping[value]);
						numericValue = isNaN(price) ? 0 : price;
					}
				}
	            else
	            {
					var numeric = (+value);
					numericValue = isNaN(numeric) ? 0 : numeric;
	            }
	            this.FormValues[containerID] = numericValue;
	            this.FormValuesField.value = Sys.Serialization.JavaScriptSerializer.serialize(this.FormValues);
	            return numericValue;
	        }
	        else if (this.FormValues[containerID] != null)
	        {
	            return this.FormValues[containerID];
	        }
	    }
	    
	    return 0;
	},
	
	FormatCurrency: function(num) {
		num = num.toString().replace(/\$|\,/g,'');
		
		if(isNaN(num))
		{
			num = "0";
		}
		
		sign = (num == (num = Math.abs(num)));
		num = Math.floor(num*100+0.50000000001);
		cents = num%100;
		num = Math.floor(num/100).toString();
		
		if(cents<10)
		{
			cents = "0" + cents;
		}
		
		for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++)
		{
			num = num.substring(0,num.length-(4*i+3)) + ',' + num.substring(num.length-(4*i+3));
		}
		
		return (((sign)?'':'-') + '$' + num + '.' + cents);
	}
});


FieldManager.RegisterPublicFieldType("BaseFields.TouchPointTextBox", {
    GetCalculationValue: function(fieldContainer) {
        var textBox = fieldContainer.getElementsByTagName("input");
        var value = (+textBox[0].value);
        return isNaN(value) ? 0 : value;
    },
    
    GetValue: function(fieldContainer) {
		var textBox = fieldContainer.getElementsByTagName("input");
		return textBox[0].value;
    },
    
    DependencyActions: {
		Require: function(fieldContainer, conditionResult) {
			var validator = fieldContainer.getElementsByTagName('span')[0];
			if (conditionResult)
			{
				if (!validator.enabled || validator.enabled == 'False')
				{
					validator.enabled = true;
					validator.enabledbyaction = true;
				}
			}
			else
			{
				if (validator.enabledbyaction)
				{
					ValidatorEnable(validator, false);
				}
			}
		},
	    
		Set: {
			RenderParameters: function(container, parameter) {
				var text = Builder.node('span', ' to ');
				var txtValue = Builder.node('input', {type:'text', value:parameter ? parameter : ''});
				var space = Builder.node('span', ' ');
				container.appendChild(text);
				container.appendChild(txtValue);
				container.appendChild(space);
			},
			
			GetParameter: function(container) {
				var txtValue = container.getElementsByTagName('input')[0];
				return txtValue.value;
			},
			
			Action: function(fieldContainer, conditionResult, parameter) {
				//textbox
				var textbox = fieldContainer.getElementsByTagName("input")[0];
				if (conditionResult)
				{
					textbox.value = parameter;
				}
				else
				{
					textbox.value = '';
				}
			}
		}
    },
    
    DependencyTests: [
        {
			name: "is empty",
			valueselectiontype: "none",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = textBox[0].value;
				return currentValue == "";
			}
		},
		{
			name: "is not empty",
			valueselectiontype: "none",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = textBox[0].value;
				return currentValue != "";
			}
		},
		{
			name: "equals...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = textBox[0].value;
				return currentValue.toLowerCase() == value.toLowerCase();
			}
		},
		{
			name: "does not equal...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = textBox[0].value;
				return currentValue.toLowerCase() != value.toLowerCase();
			}
		},
		{
			name: "contains...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = textBox[0].value;
				return (currentValue.match(new RegExp(value, "i")) != null);
			}
		},
		{
			name: "does not contain...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = textBox[0].value;
				return (currentValue.match(new RegExp(value, "i")) == null);
			}
		},
		{
			name: "is greater than...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = (+textBox[0].value);
				var value = (+value);
				if (isNaN(value) || isNaN(currentValue))
					return false
				else
					return currentValue > value;
			}
		},
		{
			name: "is less than...",
			valueselectiontype: "text",
			Test: function(fieldContainer, value) {
				var textBox = fieldContainer.getElementsByTagName("input");
				var currentValue = (+textBox[0].value);
				var value = (+value);
				if (isNaN(value) || isNaN(currentValue))
					return false
				else
					return currentValue < value;
			}
		}
    ]
});



// 9/8/2010 10:48:41 PM