/*******************************************************************************
 * YAV - Yet Another Validator v2.0 * Copyright (C) 2005-2008 * Author: Federico
 * Crivellaro <f.crivellaro@gmail.com> * WWW: http://yav.sourceforge.net * *
 * This library is free software; you can redistribute it and/or * modify it
 * under the terms of the GNU Lesser General Public * License as published by
 * the Free Software Foundation; either * version 2.1 of the License, or (at
 * your option) any later version. * * This library is distributed in the hope
 * that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied
 * warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU * Lesser General Public License for more details. * * You should have
 * received a copy of the GNU Lesser General Public * License along with this
 * library; if not, write to the Free Software * Foundation, Inc.,59 Temple
 * Place,Suite 330,Boston,MA 02111-1307 USA * * last revision: 2 MAR 2008 *
 ******************************************************************************/

var yav = {

	// ------------------------------------------------------------ PUBLIC
	// FUNCTIONS
	undef : undefined,
	isFocusSet : undefined,
	internalRules : undefined,
	f : undefined,
	formEvt : undefined,
	fieldsEvt : new Array(),
	rulesEvt : new Array(),
	helpEvt : new Array(),
	mask : new Array(),
	onOKEvt : new Array(),
	onErrorEvt : new Array(),
	preValidationEvt : new Array(),
	filterByName : null,

	performCheck : function(formName, strRules, alertType, filterErrorsByName) {
		yav.filterByName = (filterErrorsByName) ? filterErrorsByName : null;
		for ( var j = 0; j < yav.preValidationEvt.length; j++) {
			if (yav.filterByName == yav.preValidationEvt[j].name) {
				var preValidationResult = eval(yav.preValidationEvt[j].fn);
				yav.preValidationEvt[j].executedWithSuccess = preValidationResult;
				if (!preValidationResult) {
					return preValidationResult;
				}
				break;
			}
		}
		yav.isFocusSet = false;
		var rules = yav.makeRules(strRules);
		yav.internalRules = yav.makeRules(strRules);
		yav.f = document.forms[formName];
		if (!yav.f) {
			yav.debug('DEBUG: could not find form object ' + formName);
			return null;
		}
		var errors = new Array();
		var ix = 0;
		if (rules.length) {
			for ( var i = 0; i < rules.length; i++) {
				var aRule = rules[i];
				if (aRule != null) {
					yav.highlight(yav.getField(yav.f, aRule.el),
							yav_config.inputclassnormal);
				}
			}
		} else {
			if (rules != null) {
				yav.highlight(yav.getField(yav.f, rules.el),
						yav_config.inputclassnormal);
			}
		}
		if (rules.length) {
			for ( var i = 0; i < rules.length; i++) {
				var aRule = rules[i];
				var anErr = null;
				if (aRule == null) {
					// do nothing
				} else if (aRule.ruleType == 'pre-condition'
						|| aRule.ruleType == 'post-condition'
						|| aRule.ruleType == 'andor-operator') {
					// do nothing
				} else if (aRule.ruleName == 'implies') {
					pre = aRule.el;
					post = aRule.comparisonValue;
					var oldClassName = yav.getField(yav.f, rules[pre].el).className;
					if (yav.filterByName != null) {
						if (rules[pre].el == yav.filterByName
								|| rules[post].el == yav.filterByName) {
							yav.clearInlineSpans(rules[pre].el, rules[post].el);
						}
					}
					if (yav.checkRule(yav.f, rules[pre]) == null
							&& yav.checkRule(yav.f, rules[post]) != null) {
						anErr = yav.deleteInline(aRule.alertMsg) + '__inline__'
								+ rules[post].el;
					} else if (yav.checkRule(yav.f, rules[pre]) != null) {
						yav.getField(yav.f, rules[pre].el).className = oldClassName;
					}
				} else if (aRule.ruleName == 'date_lt'
						|| aRule.ruleName == 'date_le') {
					if (yav.filterByName != null) {
						if (aRule.comparisonValue
								&& aRule.comparisonValue
										.indexOf('$' + yav.filterByName) == 0) {
							yav.clearInlineSpans(aRule.el, yav.filterByName);
						}
					}
					anErr = yav.checkRule(yav.f, aRule);
				} else {
					anErr = yav.checkRule(yav.f, aRule);
				}
				if (anErr != null) {
					if (yav.filterByName && yav.filterByName != null) {
						if (aRule.ruleName == 'implies') {
							if (rules[pre].el == yav.filterByName
									|| rules[post].el == yav.filterByName) {
								yav.clearInlineSpans(rules[pre].el,
										rules[post].el);
							}
							aRule = rules[aRule.comparisonValue];
						}
						// todo
						if (aRule.ruleName == 'or') {
							var tmp = aRule.comparisonValue.split('-');
							for ( var t = 0; t < tmp.length; t++) {
								yav.clearInlineSpans(rules[tmp[t]].el);
							}
							if (rules[aRule.el].el == yav.filterByName) {
								yav.clearInlineSpans(rules[aRule.el].el);
							}
							aRule = rules[aRule.el];
						}
						//
						if (aRule.el == yav.filterByName
								|| (aRule.comparisonValue && aRule.comparisonValue
										.indexOf('$' + yav.filterByName) == 0)) {
							for ( var z = 0; z < rules.length; z++) {
								if (rules[z].ruleName == 'implies'
										&& rules[rules[z].el].el == aRule.el) {
									yav
											.clearInlineSpans(rules[rules[z].comparisonValue].el);
								}
							}
							errors[ix] = anErr;
							ix++;
							break;
						}
					} else {
						errors[ix] = anErr;
						ix++;
					}
				}
			}// for
		} else {
			var myRule = rules;
			err = yav.checkRule(yav.f, myRule);
			if (err != null) {
				if (yav.filterByName && yav.filterByName != null) {
					if (myRule.el == yav.filterByName) {
						errors[0] = err;
					}
				} else {
					errors[0] = err;
				}
			}
		}
		var retval = yav.displayAlert(errors, alertType);
		yav.filterByName = null;
		return retval;
	},

	checkKeyPress : function(ev, obj, strRules) {
		var keyCode = null;
		keyCode = (typeof (ev.which)) != 'undefined' ? ev.which
				: window.event.keyCode;
		var rules = yav.makeRules(strRules);
		var keyAllowed = true;
		if (rules.length) {
			for ( var i = 0; i < rules.length; i++) {
				var aRule = rules[i];
				if (aRule.ruleName == 'keypress' && aRule.el == obj.name) {
					keyAllowed = yav.isKeyAllowed(keyCode,
							aRule.comparisonValue);
					break;
				}
			}
		} else {
			var aRule = rules;
			if (aRule.ruleName == 'keypress' && aRule.el == obj.name) {
				keyAllowed = yav.isKeyAllowed(keyCode, aRule.comparisonValue);
			}
		}
		if (!keyAllowed) {
			if (typeof (ev.which) == 'undefined') {
				window.event.keyCode = 0;
			} else {
				ev.preventDefault();
				ev.stopPropagation();
				ev.returnValue = false;
			}
		}
		return keyAllowed;
	},

	init : function(formName, strRules) {
		yav.addMask('alphabetic', null, null, yav_config.alphabetic_regex);
		yav.addMask('alphanumeric', null, null, yav_config.alphanumeric_regex);
		yav.addMask('alnumhyphen', null, null, yav_config.alnumhyphen_regex);
		yav
				.addMask('alnumhyphenat', null, null,
						yav_config.alnumhyphenat_regex);
		yav.addMask('alphaspace', null, null, yav_config.alphaspace_regex);
		yav.formEvt = formName;
		yav.rulesEvt = strRules;
		if (strRules.length) {
			for ( var i = 0; i < strRules.length; i++) {
				var aRule = yav.splitRule(strRules[i]);
				var elm = yav.getField(document.forms[formName], aRule.el);
				if (elm && aRule.ruleName == 'mask') {
					yav.addEvent(elm, 'keypress', yav.maskEvt
							.bindAsEventListener(elm));
				} else if (elm && !yav.inArray(yav.fieldsEvt, aRule.el)) {
					var eventAdded = false;
					for ( var j = 0; j < yav.onOKEvt.length; j++) {
						if (elm.name == yav.onOKEvt[j].name) {
							yav
									.addEvent(
											elm,
											yav.onOKEvt[j].evType,
											function() {
												if (yav.performEvt(this.name)) {
													yav
															.performOnOKEvt(this.name);
												} else {
													for ( var k = 0; k < yav.preValidationEvt.length; k++) {
														if (this.name == yav.preValidationEvt[k].name) {
															if (yav.preValidationEvt[k].executedWithSuccess == false) {
																yav.preValidationEvt[k].executedWithSuccess = null;
																return;
															}
															yav.preValidationEvt[k].executedWithSuccess = null;
															break;
														}
													}
													yav
															.performOnErrorEvt(this.name);
												}
											});
							eventAdded = true;
							break;
						}
					}
					if (!eventAdded) {
						for ( var j = 0; j < yav.onErrorEvt.length; j++) {
							if (elm.name == yav.onErrorEvt[j].name) {
								yav
										.addEvent(
												elm,
												yav.onErrorEvt[j].evType,
												function() {
													if (!yav
															.performEvt(this.name)) {
														for ( var k = 0; k < yav.preValidationEvt.length; k++) {
															if (this.name == yav.preValidationEvt[k].name) {
																if (yav.preValidationEvt[k].executedWithSuccess == false) {
																	yav.preValidationEvt[k].executedWithSuccess = null;
																	return;
																}
																yav.preValidationEvt[k].executedWithSuccess = null;
																break;
															}
														}
														yav
																.performOnErrorEvt(this.name);
													}
												});
								eventAdded = true;
								break;
							}
						}
					}
					yav.fieldsEvt.push(aRule.el);
					if (!eventAdded) {
						yav.addEvent(elm, 'blur', function() {
							yav.performEvt(this.name);
						});
					}
				}
			}
		} else {
			var rule = yav.splitRule(strRules);
			var elm = yav.getField(document.forms[formName], rule.el);
			if (elm && rule.ruleName == 'mask') {
				yav.addEvent(elm, 'keypress', yav.maskEvt
						.bindAsEventListener(elm));
			} else if (elm) {
				var eventAdded = false;
				for ( var j = 0; i < yav.onOKEvt.length; j++) {
					if (elm.name == yav.onOKEvt[i].name) {
						yav.addEvent(elm, yav.onOKEvt[j].evType, function() {
							if (yav.performEvt(this.name)) {
								yav.performOnOKEvt(this.name);
							}
						});
						eventAdded = true;
						break;
					}
				}
				for ( var j = 0; j < yav.onErrorEvt.length; j++) {
					if (elm.name == yav.onErrorEvt[j].name) {
						yav
								.addEvent(
										elm,
										yav.onErrorEvt[j].evType,
										function() {
											if (!yav.performEvt(this.name)) {
												for ( var k = 0; k < yav.preValidationEvt.length; k++) {
													if (this.name == yav.preValidationEvt[k].name) {
														if (yav.preValidationEvt[k].executedWithSuccess == false) {
															yav.preValidationEvt[k].executedWithSuccess = null;
															return;
														}
														yav.preValidationEvt[k].executedWithSuccess = null;
														break;
													}
												}
												yav
														.performOnErrorEvt(this.name);
											}
										});
						eventAdded = true;
						break;
					}
				}
				if (!eventAdded) {
					yav.addEvent(elm, 'blur', function() {
						yav.performEvt(this.name);
					});
				}
			}
		}
		if (yav.helpEvt.length > 0) {
			for ( var i = 0; i < yav.helpEvt.length; i++) {
				var elm = yav.getField(document.forms[formName],
						yav.helpEvt[i].name);
				if (elm) {
					if (elm.focus) {
						yav.addEvent(elm, 'focus', function() {
							yav.showHelpEvt(this.name);
						});
					} else {
						yav.addEvent(elm, 'click', function() {
							yav.showHelpEvt(this.name);
						});
					}
					if (!yav.inArray(yav.fieldsEvt, yav.helpEvt[i].name)) {
						yav.addEvent(elm, 'blur', function() {
							yav.cleanInline(this.name);
						});
					}
				}
			}
		}
	},

	displayMsg : function(name, msg, clazz) {
		var elm = yav.get(yav_config.errorsdiv + '_' + name);
		if (elm) {
			elm.innerHTML = msg;
			elm.className = clazz;
			elm.style.display = '';
		} else {
			elm = yav.get(yav_config.errorsdiv);
			if (elm) {
				elm.innerHTML = msg;
				elm.className = clazz;
				elm.style.display = '';
			} else {
				alert(msg);
			}
		}
	},

	cleanInline : function(name) {
		yav.get(yav_config.errorsdiv + '_' + name).innerHTML = '';
		yav.get(yav_config.errorsdiv + '_' + name).className = '';
		yav.get(yav_config.errorsdiv + '_' + name).style.display = 'none';
	},

	addHelp : function(name, helpMsg) {
		var elem = new Object();
		elem.name = name;
		elem.help = helpMsg;
		yav.helpEvt.push(elem);
	},

	addMask : function(name, format, charsAllowed, regex) {
		var elem = new Object();
		elem.name = name;
		elem.format = format;
		elem.charsAllowed = charsAllowed;
		elem.regex = regex ? regex : null;
		yav.mask.push(elem);
	},

	postValidation_OnOK : function(name, evType, fn) {
		var elem = new Object();
		elem.name = name;
		elem.evType = evType;
		elem.fn = fn;
		yav.onOKEvt.push(elem);
	},

	postValidation_OnError : function(name, evType, fn) {
		var elem = new Object();
		elem.name = name;
		elem.evType = evType;
		elem.fn = fn;
		yav.onErrorEvt.push(elem);
	},

	preValidation : function(fn, name) {
		var elem = new Object();
		elem.name = (name && name != null) ? name : null;
		elem.fn = fn;
		elem.executedWithSuccess = null;
		yav.preValidationEvt.push(elem);
	},

	// ------------------------------------------------------------ PRIVATE
	// FUNCTIONS

	inArray : function(arr, value) {
		var found = false;
		for ( var i = 0; i < arr.length; i++) {
			if (arr[i] == value) {
				found = true;
				break;
			}
		}
		return found;
	},

	performEvt : function(name) {
		var elm = yav.get(yav_config.errorsdiv);
		if (elm) {
			elm.innerHTML = '';
			elm.className = '';
			elm.style.display = 'none';
		}
		return yav.performCheck(yav.formEvt, yav.rulesEvt, 'inline', name);
	},

	performOnOKEvt : function(name) {
		for ( var j = 0; j < yav.onOKEvt.length; j++) {
			if (name == yav.onOKEvt[j].name) {
				eval(yav.onOKEvt[j].fn);
				break;
			}
		}
	},

	performOnErrorEvt : function(name) {
		for ( var j = 0; j < yav.onErrorEvt.length; j++) {
			if (name == yav.onErrorEvt[j].name) {
				eval(yav.onErrorEvt[j].fn);
				break;
			}
		}
	},

	showHelpEvt : function(name) {
		for ( var i = 0; i < yav.helpEvt.length; i++) {
			if (yav.helpEvt[i].name == name) {
				yav.get(yav_config.errorsdiv + '_' + name).innerHTML = yav.helpEvt[i].help;
				yav.get(yav_config.errorsdiv + '_' + name).className = yav_config.innerhelp;
				yav.get(yav_config.errorsdiv + '_' + name).style.display = '';
				break;
			}
		}
	},

	maskEvt : function(ev) {
		var mask = null;
		var myRule = null;
		for ( var i = 0; i < yav.rulesEvt.length; i++) {
			var aRule = yav.splitRule(yav.rulesEvt[i]);
			var elm = yav.getField(document.forms[yav.formEvt], aRule.el);
			if (elm && aRule.ruleName == 'mask' && elm.name == this.name) {
				for ( var j = 0; j < yav.mask.length; j++) {
					if (yav.mask[j].name == aRule.comparisonValue) {
						mask = yav.mask[j];
						break;
					}
				}
				myRule = aRule;
				break;
			}
		}
		var key = (typeof (ev.which)) != 'undefined' ? ev.which
				: window.event.keyCode;
		var ch = String.fromCharCode(key);
		var str = this.value + ch;
		var pos = str.length;
		if (key == 8 || key == 0) {
			return true;
		}
		var keyAllowed = false;
		if (mask == null) {
			if (yav.isKeyAllowed(key, myRule.comparisonValue)) {
				keyAllowed = true;
			} else {
				if (typeof (ev.which) == 'undefined') {
					window.event.keyCode = 0;
				} else {
					ev.preventDefault();
					ev.stopPropagation();
					ev.returnValue = false;
				}
			}
			return keyAllowed;
		} else if (mask.format == null) {
			reg = new RegExp(mask.regex);
			if (reg.test(ch)) {
				keyAllowed = true;
			} else {
				if (typeof (ev.which) == 'undefined') {
					window.event.keyCode = 0;
				} else {
					ev.preventDefault();
					ev.stopPropagation();
					ev.returnValue = false;
				}
			}
			return keyAllowed;
		} else if (yav.isKeyAllowed(key, mask.charsAllowed)
				&& pos <= mask.format.length) {
			if (mask.format.charAt(pos - 1) != ' ') {
				str = this.value + mask.format.charAt(pos - 1) + ch;
			}
			this.value = str;
			keyAllowed = true;
		}
		if (typeof (ev.which) == 'undefined') {
			window.event.keyCode = 0;
		} else {
			ev.preventDefault();
			ev.stopPropagation();
			ev.returnValue = false;
		}
		return keyAllowed;
	},

	displayAlert : function(messages, alertType) {
		var retval = null;
		yav.clearAllInlineSpans();
		if (alertType == 'classic') {
			retval = yav.displayClassic(messages);
		} else if (alertType == 'innerHtml') {
			retval = yav.displayInnerHtml(messages);
		} else if (alertType == 'inline') {
			retval = yav.displayInline(messages);
		} else if (alertType == 'jsVar') {
			retval = yav.displayJsVar(messages);
		} else {
			yav.debug('DEBUG: alert type ' + alertType + ' not supported');
		}
		return retval;
	},

	displayClassic : function(messages) {
		var str = '';
		if (messages != null && messages.length > 0) {
			if (yav.strTrim(yav_config.HEADER_MSG).length > 0) {
				str += yav_config.HEADER_MSG + '\n\n';
			}
			for ( var i = 0; i < messages.length; i++) {
				str += ' ' + yav.deleteInline(messages[i]) + '\n';
			}
			if (yav.strTrim(yav_config.FOOTER_MSG).length > 0) {
				str += '\n' + yav_config.FOOTER_MSG;
			}
			alert(str);
			return false;
		} else {
			return true;
		}
	},

	displayInnerHtml : function(messages) {
		if (messages != null && messages.length > 0) {
			var str = '';
			if (yav.strTrim(yav_config.HEADER_MSG).length > 0) {
				str += yav_config.HEADER_MSG;
			}
			str += '<ul>';
			for ( var i = 0; i < messages.length; i++) {
				str += '<li>' + yav.deleteInline(messages[i]) + '</li>';
			}
			str += '</ul>';
			if (yav.strTrim(yav_config.FOOTER_MSG).length > 0) {
				str += yav_config.FOOTER_MSG;
			}
			yav.get(yav_config.errorsdiv).innerHTML = str;
			yav.get(yav_config.errorsdiv).className = yav_config.innererror;
			yav.get(yav_config.errorsdiv).style.display = 'block';
			return false;
		} else {
			yav.get(yav_config.errorsdiv).innerHTML = '';
			yav.get(yav_config.errorsdiv).className = '';
			yav.get(yav_config.errorsdiv).style.display = 'none';
			return true;
		}
	},

	displayInline : function(messages) {
		if (messages != null && messages.length > 0) {
			var genericErrors = new Array();
			var genericErrIndex = 0;
			for ( var i = 0; i < messages.length; i++) {
				var elName = messages[i].substring(messages[i]
						.indexOf('__inline__') + 10);
				if (yav.get(yav_config.errorsdiv + '_' + elName)) {
					yav.get(yav_config.errorsdiv + '_' + elName).innerHTML = yav
							.deleteInline(messages[i]);
					yav.get(yav_config.errorsdiv + '_' + elName).className = yav_config.innererror;
					yav.get(yav_config.errorsdiv + '_' + elName).style.display = '';
				} else {
					genericErrors[genericErrIndex] = messages[i];
					genericErrIndex++;
				}
			}
			if (genericErrIndex > 0) {
				yav.displayInnerHtml(genericErrors);
			}
			return false;
		} else {
			return true;
		}
	},

	clearAllInlineSpans : function() {
		var allDivs = document.getElementsByTagName("span");
		for ( var j = 0; j < allDivs.length; j++) {
			var idName = allDivs[j].id;
			if (idName.indexOf(yav_config.errorsdiv + '_') == 0) {
				if (yav.filterByName != null) {
					if (idName == yav_config.errorsdiv + '_' + yav.filterByName) {
						yav.get(idName).innerHTML = '';
						yav.get(idName).className = '';
						yav.get(idName).style.display = 'none';
					}
				} else {
					yav.get(idName).innerHTML = '';
					yav.get(idName).className = '';
					yav.get(idName).style.display = 'none';
				}
			}
		}
	},

	clearInlineSpans : function() {
		var allDivs = document.getElementsByTagName("span");
		for ( var j = 0; j < allDivs.length; j++) {
			var idName = allDivs[j].id;
			if (idName.indexOf(yav_config.errorsdiv + '_') == 0) {
				for ( var k = 0; k < arguments.length; k++) {
					if (idName == yav_config.errorsdiv + '_' + arguments[k]) {
						yav.get(idName).innerHTML = '';
						yav.get(idName).className = '';
						yav.get(idName).style.display = 'none';
					}
				}
			}
		}
	},

	displayJsVar : function(messages) {
		yav.get(yav_config.errorsdiv).className = '';
		yav.get(yav_config.errorsdiv).style.display = 'none';
		if (messages != null && messages.length > 0) {
			for ( var i = 0; i < messages.length; i++) {
				messages[i] = yav.deleteInline(messages[i]);
			}
			var str = '';
			str += '<script>var jsErrors;</script>';
			yav.get(yav_config.errorsdiv).innerHTML = str;
			jsErrors = messages;
			return false;
		} else {
			yav.get(yav_config.errorsdiv).innerHTML = '<script>var jsErrors;</script>';
			return true;
		}
	},

	rule : function(el, ruleName, comparisonValue, alertMsg, ruleType) {
		var checkArguments = arguments.length >= 4 && arguments[0] != null
				&& arguments[1] != null;
		if (!checkArguments) {
			return false;
		}
		tmp = el.split(':');
		nameDisplayed = '';
		if (tmp.length == 2) {
			nameDisplayed = tmp[1];
			el = tmp[0];
		}
		this.el = el;
		this.nameDisplayed = nameDisplayed;
		this.ruleName = ruleName;
		this.comparisonValue = comparisonValue;
		this.ruleType = ruleType;
		if (alertMsg == yav.undef || alertMsg == null) {
			this.alertMsg = yav.getDefaultMessage(el, nameDisplayed, ruleName,
					comparisonValue)
					+ '__inline__' + this.el;
		} else {
			this.alertMsg = alertMsg + '__inline__' + this.el;
		}
	},

	checkRule : function(f, myRule) {
		retVal = null;
		if (myRule != null) {
			if (myRule.ruleName == 'custom') {
				var customFunction = null;
				if (myRule.comparisonValue != null) {
					customFunction = ' retVal = ' + myRule.comparisonValue;
				} else { // deprecated, maintained for back compatibility
					customFunction = ' retVal = ' + myRule.el;
				}
				retVal = eval(customFunction);
				if (myRule.comparisonValue != null && retVal != this.undef
						&& retVal != null) {
					retVal += '__inline__' + myRule.el;
				}
				if (retVal != null && myRule.comparisonValue != null) {
					yav.highlight(yav.getField(yav.f, myRule.el),
							yav_config.inputclasserror);
				}
			} else if (myRule.ruleName == 'and') {
				var op_1 = myRule.el;
				var op_next = myRule.comparisonValue;
				if (yav.checkRule(f, yav.internalRules[op_1]) != null) {
					retVal = myRule.alertMsg;
					if (myRule.ruleType == 'pre-condition'
							|| myRule.ruleType == 'andor-operator') {
						// yav.highlight(yav.getField(f,
						// yav.internalRules[op_1].el),
						// yav_config.inputclasserror);
					}
				} else {
					var op_k = op_next.split('-');
					for ( var k = 0; k < op_k.length; k++) {
						if (yav.checkRule(f, yav.internalRules[op_k[k]]) != null) {
							retVal = myRule.alertMsg;
							if (myRule.ruleType == 'pre-condition'
									|| myRule.ruleType == 'andor-operator') {
								// yav.highlight(yav.getField(f,
								// yav.internalRules[op_k[k]].el),
								// yav_config.inputclasserror);
							}
							break;
						}
					}
				}
			} else if (myRule.ruleName == 'or') {
				var op_1 = myRule.el;
				var op_next = myRule.comparisonValue;
				var success = false;
				if (yav.checkRule(f, yav.internalRules[op_1]) == null) {
					success = true;
				} else {
					if (myRule.ruleType == 'pre-condition'
							|| myRule.ruleType == 'andor-operator') {
						// yav.highlight(yav.getField(f,
						// yav.internalRules[op_1].el),
						// yav_config.inputclasserror);
					}
					var op_k = op_next.split('-');
					for ( var k = 0; k < op_k.length; k++) {
						if (yav.checkRule(f, yav.internalRules[op_k[k]]) == null) {
							success = true;
							break;
						} else {
							if (myRule.ruleType == 'pre-condition'
									|| myRule.ruleType == 'andor-operator') {
								// yav.highlight(yav.getField(f,
								// yav.internalRules[op_k[k]].el),
								// yav_config.inputclasserror);
							}
						}
					}
				}
				if (success) {
					yav.highlight(yav.getField(f, yav.internalRules[op_1].el),
							yav_config.inputclassnormal);
					var op_k = op_next.split('-');
					for ( var k = 0; k < op_k.length; k++) {
						yav.highlight(yav.getField(f,
								yav.internalRules[op_k[k]].el),
								yav_config.inputclassnormal);
					}
				} else {
					retVal = myRule.alertMsg;
				}
			} else {
				el = yav.getField(f, myRule.el);
				if (el == null) {
					yav.debug('DEBUG: could not find element ' + myRule.el);
					return null;
				}
				var err = null;
				if (el.type) {
					if (el.type == 'hidden' || el.type == 'text'
							|| el.type == 'password' || el.type == 'textarea') {
						err = yav.checkText(el, myRule);
					} else if (el.type == 'checkbox') {
						err = yav.checkCheckbox(el, myRule);
					} else if (el.type == 'select-one') {
						err = yav.checkSelOne(el, myRule);
					} else if (el.type == 'select-multiple') {
						err = yav.checkSelMul(el, myRule);
					} else if (el.type == 'radio') {
						err = yav.checkRadio(el, myRule);
					} else {
						yav.debug('DEBUG: type ' + el.type + ' not supported');
					}
				} else {
					err = yav.checkRadio(el, myRule);
				}
				retVal = err;
			}
		}
		return retVal;
	},

	checkRadio : function(el, myRule) {
		var err = null;
		if (myRule.ruleName == 'required') {
			var radios = el;
			var found = false;
			if (isNaN(radios.length) && radios.checked) {
				found = true;
			} else {
				for ( var j = 0; j < radios.length; j++) {
					if (radios[j].checked) {
						found = true;
						break;
					}
				}
			}
			if (!found) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'equal') {
			var radios = el;
			var found = false;
			if (isNaN(radios.length) && radios.checked) {
				if (radios.value == myRule.comparisonValue) {
					found = true;
				}
			} else {
				for ( var j = 0; j < radios.length; j++) {
					if (radios[j].checked) {
						if (radios[j].value == myRule.comparisonValue) {
							found = true;
							break;
						}
					}
				}
			}
			if (!found) {
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'notequal') {
			var radios = el;
			var found = false;
			if (isNaN(radios.length) && radios.checked) {
				if (radios.value != myRule.comparisonValue) {
					found = true;
				}
			} else {
				for ( var j = 0; j < radios.length; j++) {
					if (radios[j].checked) {
						if (radios[j].value != myRule.comparisonValue) {
							found = true;
							break;
						}
					}
				}
			}
			if (!found) {
				err = myRule.alertMsg;
			}
		} else {
			yav
					.debug('DEBUG: rule ' + myRule.ruleName + ' not supported for radio');
		}
		return err;
	},

	checkText : function(el, myRule) {
		err = null;
		if (yav_config.trimenabled) {
			el.value = yav.strTrim(el.value);
		}
		if (myRule.ruleName == 'required') {
			if (el.value == null || el.value == '') {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'equal') {
			err = yav.checkEqual(el, myRule);
		} else if (myRule.ruleName == 'notequal') {
			err = yav.checkNotEqual(el, myRule);
		} else if (myRule.ruleName == 'numeric') {
			reg = new RegExp("^[0-9]*$");
			if (!reg.test(el.value)) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'alphabetic') {
			reg = new RegExp(yav_config.alphabetic_regex);
			if (!reg.test(el.value)) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'alphanumeric') {
			reg = new RegExp(yav_config.alphanumeric_regex);
			if (!reg.test(el.value)) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'alnumhyphen') {
			reg = new RegExp(yav_config.alnumhyphen_regex);
			if (!reg.test(el.value)) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'alnumhyphenat') {
			reg = new RegExp(yav_config.alnumhyphenat_regex);
			if (!reg.test(el.value)) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'alphaspace') {
			reg = new RegExp(yav_config.alphaspace_regex);
			if (!reg.test(el.value)) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'email') {
			reg = new RegExp(yav_config.email_regex);
			if (!reg.test(el.value)) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'maxlength') {
			if (isNaN(myRule.comparisonValue)) {
				yav
						.debug('DEBUG: comparisonValue for rule ' + myRule.ruleName + ' not a number');
			} else if (el.value.length > myRule.comparisonValue) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'minlength') {
			if (isNaN(myRule.comparisonValue)) {
				yav
						.debug('DEBUG: comparisonValue for rule ' + myRule.ruleName + ' not a number');
			} else if (el.value.length < myRule.comparisonValue) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'numrange') {
			reg = new RegExp("^[-+]{0,1}[0-9]*[.]{0,1}[0-9]*$");
			if (!reg.test(yav.unformatNumber(el.value))) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			} else {
				regRange = new RegExp("^[0-9]+-[0-9]+$");
				if (!regRange.test(myRule.comparisonValue)) {
					yav
							.debug('DEBUG: comparisonValue for rule ' + myRule.ruleName + ' not in format number1-number2');
				} else {
					rangeVal = myRule.comparisonValue.split('-');
					if (eval(yav.unformatNumber(el.value)) < eval(rangeVal[0])
							|| eval(yav.unformatNumber(el.value)) > eval(rangeVal[1])) {
						yav.highlight(el, yav_config.inputclasserror);
						err = myRule.alertMsg;
					}
				}
			}
		} else if (myRule.ruleName == 'regexp') {
			reg = new RegExp(myRule.comparisonValue);
			if (!reg.test(el.value)) {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'integer') {
			err = yav.checkInteger(el, myRule);
		} else if (myRule.ruleName == 'double') {
			err = yav.checkDouble(el, myRule);
		} else if (myRule.ruleName == 'date') {
			err = yav.checkDate(el, myRule);
		} else if (myRule.ruleName == 'date_lt') {
			err = yav.checkDateLessThan(el, myRule, false);
		} else if (myRule.ruleName == 'date_le') {
			err = yav.checkDateLessThan(el, myRule, true);
		} else if (myRule.ruleName == 'keypress') {
			// do nothing
		} else if (myRule.ruleName == 'empty') {
			if (el.value != null && el.value != '') {
				yav.highlight(el, yav_config.inputclasserror);
				err = myRule.alertMsg;
			}
		} else {
			yav.debug('DEBUG: rule ' + myRule.ruleName + ' not supported for '
					+ el.type);
		}
		return err;
	},

	checkInteger : function(el, myRule) {
		reg = new RegExp("^[-+]{0,1}[0-9]*$");
		if (!reg.test(el.value)) {
			yav.highlight(el, yav_config.inputclasserror);
			return myRule.alertMsg;
		}
	},

	checkDouble : function(el, myRule) {
		var sep = yav_config.DECIMAL_SEP;
		reg = new RegExp("^[-+]{0,1}[0-9]*[" + sep + "]{0,1}[0-9]*$");
		if (!reg.test(el.value)) {
			yav.highlight(el, yav_config.inputclasserror);
			return myRule.alertMsg;
		}
	},

	checkDate : function(el, myRule) {
		error = null;
		if (el.value != '') {
			var dateFormat = yav_config.DATE_FORMAT;
			ddReg = new RegExp("dd");
			MMReg = new RegExp("MM");
			yyyyReg = new RegExp("yyyy");
			if (!ddReg.test(dateFormat) || !MMReg.test(dateFormat)
					|| !yyyyReg.test(dateFormat)) {
				yav
						.debug('DEBUG: locale format ' + dateFormat + ' not supported');
			} else {
				ddStart = dateFormat.indexOf('dd');
				MMStart = dateFormat.indexOf('MM');
				yyyyStart = dateFormat.indexOf('yyyy');
			}
			strReg = dateFormat.replace('dd', '[0-9]{2}').replace('MM',
					'[0-9]{2}').replace('yyyy', '[0-9]{4}');
			reg = new RegExp("^" + strReg + "$");
			if (!reg.test(el.value)) {
				yav.highlight(el, yav_config.inputclasserror);
				error = myRule.alertMsg;
			} else {
				dd = el.value.substring(ddStart, ddStart + 2);
				MM = el.value.substring(MMStart, MMStart + 2);
				yyyy = el.value.substring(yyyyStart, yyyyStart + 4);
				if (!yav.checkddMMyyyy(dd, MM, yyyy)) {
					yav.highlight(el, yav_config.inputclasserror);
					error = myRule.alertMsg;
				}
			}
		}
		return error;
	},

	checkDateLessThan : function(el, myRule, isEqualAllowed) {
		error = null;
		var isDate = yav.checkDate(el, myRule) == null ? true : false;
		if (isDate && el.value != '') {
			var dateFormat = yav_config.DATE_FORMAT;
			ddStart = dateFormat.indexOf('dd');
			MMStart = dateFormat.indexOf('MM');
			yyyyStart = dateFormat.indexOf('yyyy');
			dd = el.value.substring(ddStart, ddStart + 2);
			MM = el.value.substring(MMStart, MMStart + 2);
			yyyy = el.value.substring(yyyyStart, yyyyStart + 4);
			myDate = "" + yyyy + MM + dd;
			strReg = dateFormat.replace('dd', '[0-9]{2}').replace('MM',
					'[0-9]{2}').replace('yyyy', '[0-9]{4}');
			reg = new RegExp("^" + strReg + "$");
			var isMeta = myRule.comparisonValue.indexOf('$') == 0 ? true
					: false;
			var comparisonDate = '';
			if (isMeta) {
				toSplit = myRule.comparisonValue.substr(1);
				tmp = toSplit.split(':');
				if (tmp.length == 2) {
					comparisonDate = yav.getField(yav.f, tmp[0]).value;
				} else {
					comparisonDate = yav.getField(yav.f, myRule.comparisonValue
							.substr(1)).value;
				}
			} else {
				comparisonDate = myRule.comparisonValue;
			}
			if (!reg.test(comparisonDate)) {
				yav.highlight(el, yav_config.inputclasserror);
				error = myRule.alertMsg;
			} else {
				cdd = comparisonDate.substring(ddStart, ddStart + 2);
				cMM = comparisonDate.substring(MMStart, MMStart + 2);
				cyyyy = comparisonDate.substring(yyyyStart, yyyyStart + 4);
				cDate = "" + cyyyy + cMM + cdd;
				if (isEqualAllowed) {
					if (!yav.checkddMMyyyy(cdd, cMM, cyyyy) || myDate > cDate) {
						yav.highlight(el, yav_config.inputclasserror);
						error = myRule.alertMsg;
					}
				} else {
					if (!yav.checkddMMyyyy(cdd, cMM, cyyyy) || myDate >= cDate) {
						yav.highlight(el, yav_config.inputclasserror);
						error = myRule.alertMsg;
					}
				}
			}
		} else {
			if (el.value != '') {
				yav.highlight(el, yav_config.inputclasserror);
				error = myRule.alertMsg;
			}
		}
		return error;
	},

	checkEqual : function(el, myRule) {
		error = null;
		var isMeta = myRule.comparisonValue.indexOf('$') == 0 ? true : false;
		var comparisonVal = '';
		if (isMeta) {
			toSplit = myRule.comparisonValue.substr(1);
			tmp = toSplit.split(':');
			if (tmp.length == 2) {
				comparisonVal = yav.getField(yav.f, tmp[0]).value;
			} else {
				comparisonVal = yav.getField(yav.f, myRule.comparisonValue
						.substr(1)).value;
			}
		} else {
			comparisonVal = myRule.comparisonValue;
		}
		if (el.value != comparisonVal) {
			yav.highlight(el, yav_config.inputclasserror);
			error = myRule.alertMsg;
		}
		return error;
	},

	checkNotEqual : function(el, myRule) {
		error = null;
		var isMeta = myRule.comparisonValue.indexOf('$') == 0 ? true : false;
		var comparisonVal = '';
		if (isMeta) {
			toSplit = myRule.comparisonValue.substr(1);
			tmp = toSplit.split(':');
			if (tmp.length == 2) {
				comparisonVal = yav.getField(yav.f, tmp[0]).value;
			} else {
				comparisonVal = yav.getField(yav.f, myRule.comparisonValue
						.substr(1)).value;
			}
		} else {
			comparisonVal = myRule.comparisonValue;
		}
		if (el.value == comparisonVal) {
			yav.highlight(el, yav_config.inputclasserror);
			error = myRule.alertMsg;
		}
		return error;
	},

	checkddMMyyyy : function(dd, MM, yyyy) {
		retVal = true;
		if ((dd < 1)
				|| (dd > 31)
				|| (MM < 1)
				|| (MM > 12)
				|| (dd == 31 && (MM == 2 || MM == 4 || MM == 6 || MM == 9 || MM == 11))
				|| (dd > 29 && MM == 2)
				|| (dd == 29 && (MM == 2) && ((yyyy % 4 > 0) || (yyyy % 4 == 0
						&& yyyy % 100 == 0 && yyyy % 400 > 0)))) {
			retVal = false;
		}
		return retVal;
	},

	checkCheckbox : function(el, myRule) {
		if (myRule.ruleName == 'required') {
			if (!el.checked) {
				yav.highlight(el, yav_config.inputclasserror);
				return myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'equal') {
			if (!el.checked || el.value != myRule.comparisonValue) {
				yav.highlight(el, yav_config.inputclasserror);
				return myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'notequal') {
			if (el.checked && el.value == myRule.comparisonValue) {
				yav.highlight(el, yav_config.inputclasserror);
				return myRule.alertMsg;
			}
		} else {
			yav.debug('DEBUG: rule ' + myRule.ruleName + ' not supported for '
					+ el.type);
		}
	},

	checkSelOne : function(el, myRule) {
		if (myRule.ruleName == 'required') {
			var found = false;
			var inx = el.selectedIndex;
			if (inx >= 0 && el.options[inx].value) {
				found = true;
			}
			if (!found) {
				yav.highlight(el, yav_config.inputclasserror);
				return myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'equal') {
			var found = false;
			var inx = el.selectedIndex;
			if (inx >= 0 && el.options[inx].value == myRule.comparisonValue) {
				found = true;
			}
			if (!found) {
				yav.highlight(el, yav_config.inputclasserror);
				return myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'notequal') {
			var found = false;
			var inx = el.selectedIndex;
			if (inx >= 0 && el.options[inx].value != myRule.comparisonValue) {
				found = true;
			}
			if (!found) {
				yav.highlight(el, yav_config.inputclasserror);
				return myRule.alertMsg;
			}
		} else {
			yav.debug('DEBUG: rule ' + myRule.ruleName + ' not supported for '
					+ el.type);
		}
	},

	checkSelMul : function(el, myRule) {
		if (myRule.ruleName == 'required') {
			var found = false;
			opts = el.options;
			for ( var i = 0; i < opts.length; i++) {
				if (opts[i].selected && opts[i].value) {
					found = true;
					break;
				}
			}
			if (!found) {
				yav.highlight(el, yav_config.inputclasserror);
				return myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'equal') {
			var found = false;
			opts = el.options;
			for ( var i = 0; i < opts.length; i++) {
				if (opts[i].selected && opts[i].value == myRule.comparisonValue) {
					found = true;
					break;
				}
			}
			if (!found) {
				yav.highlight(el, yav_config.inputclasserror);
				return myRule.alertMsg;
			}
		} else if (myRule.ruleName == 'notequal') {
			var found = false;
			opts = el.options;
			for ( var i = 0; i < opts.length; i++) {
				if (opts[i].selected && opts[i].value != myRule.comparisonValue) {
					found = true;
					break;
				}
			}
			if (!found) {
				yav.highlight(el, yav_config.inputclasserror);
				return myRule.alertMsg;
			}
		} else {
			yav.debug('DEBUG: rule ' + myRule.ruleName + ' not supported for '
					+ el.type);
		}
	},

	debug : function(msg) {
		if (yav_config.debugmode) {
			alert(msg);
		}
	},

	strTrim : function(str) {
		return str.replace(/^\s+/, '').replace(/\s+$/, '');
	},

	makeRules : function(strRules) {
		var rules = new Array();
		if (strRules.length) {
			for ( var i = 0; i < strRules.length; i++) {
				rules[i] = yav.splitRule(strRules[i]);
			}
		} else {
			rules[0] = yav.splitRule(strRules);
		}
		return rules;
	},

	splitRule : function(strRule) {
		var retval = null;
		if (strRule != yav.undef) {
			params = strRule.split(yav_config.RULE_SEP);
			switch (params.length) {
			case 2:
				retval = new yav.rule(params[0], params[1], null, null, null);
				break;
			case 3:
				if (yav.threeParamRule(params[1])) {
					retval = new yav.rule(params[0], params[1], params[2],
							null, null);
				} else if (params[2] == 'pre-condition'
						|| params[2] == 'post-condition'
						|| params[2] == 'andor-operator') {
					retval = new yav.rule(params[0], params[1], null, 'foo',
							params[2]);
				} else {
					retval = new yav.rule(params[0], params[1], null,
							params[2], null);
				}
				break;
			case 4:
				if (yav.threeParamRule(params[1])
						&& (params[3] == 'pre-condition'
								|| params[3] == 'post-condition' || params[3] == 'andor-operator')) {
					retval = new yav.rule(params[0], params[1], params[2],
							'foo', params[3]);
				} else {
					retval = new yav.rule(params[0], params[1], params[2],
							params[3], null);
				}
				break;
			default:
				yav.debug('DEBUG: wrong definition of rule');
			}
		}
		return retval;
	},

	threeParamRule : function(ruleName) {
		return (ruleName == 'equal' || ruleName == 'notequal'
				|| ruleName == 'minlength' || ruleName == 'maxlength'
				|| ruleName == 'date_lt' || ruleName == 'date_le'
				|| ruleName == 'implies' || ruleName == 'regexp'
				|| ruleName == 'numrange' || ruleName == 'keypress'
				|| ruleName == 'and' || ruleName == 'or'
				|| ruleName == 'custom' || ruleName == 'mask') ? true : false;
	},

	highlight : function(el, clazz) {
		if (yav.rulesEvt.length > 0 && clazz == yav_config.inputclasserror) {
			return;
		}
		if (!yav.isFocusSet && clazz == yav_config.inputclasserror) {
			if ((!el.type) && (el.length > 0) && (el.item(0).type == 'radio')) {
				el.item(0).focus();
			} else {
				el.focus();
			}
			yav.isFocusSet = true;
		}
		if (el != yav.undef && yav_config.inputhighlight) {
			if (yav_config.multipleclassname) {
				yav.highlightMultipleClassName(el, clazz);
			} else {
				el.className = clazz;
			}
		}
	},

	highlightMultipleClassName : function(el, clazz) {
		re = new RegExp("(^|\\s)(" + yav_config.inputclassnormal + "|"
				+ yav_config.inputclasserror + ")($|\\s)");
		el.className = yav
				.strTrim(((typeof el.className != "undefined") ? el.className
						.replace(re, "") : "")
						+ " " + clazz);
	},

	getDefaultMessage : function(el, nameDisplayed, ruleName, comparisonValue) {
		if (nameDisplayed.length == 0) {
			nameDisplayed = el;
		}
		var msg = yav_config.DEFAULT_MSG;
		if (ruleName == 'required') {
			msg = yav_config.REQUIRED_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'minlength') {
			msg = yav_config.MINLENGTH_MSG.replace('{1}', nameDisplayed)
					.replace('{2}', comparisonValue);
		} else if (ruleName == 'maxlength') {
			msg = yav_config.MAXLENGTH_MSG.replace('{1}', nameDisplayed)
					.replace('{2}', comparisonValue);
		} else if (ruleName == 'numrange') {
			msg = yav_config.NUMRANGE_MSG.replace('{1}', nameDisplayed)
					.replace('{2}', comparisonValue);
		} else if (ruleName == 'date') {
			msg = yav_config.DATE_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'numeric') {
			msg = yav_config.NUMERIC_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'integer') {
			msg = yav_config.INTEGER_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'double') {
			msg = yav_config.DOUBLE_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'equal') {
			msg = yav_config.EQUAL_MSG.replace('{1}', nameDisplayed).replace(
					'{2}', yav.getComparisonDisplayed(comparisonValue));
		} else if (ruleName == 'notequal') {
			msg = yav_config.NOTEQUAL_MSG
					.replace('{1}', nameDisplayed)
					.replace('{2}', yav.getComparisonDisplayed(comparisonValue));
		} else if (ruleName == 'alphabetic') {
			msg = yav_config.ALPHABETIC_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'alphanumeric') {
			msg = yav_config.ALPHANUMERIC_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'alnumhyphen') {
			msg = yav_config.ALNUMHYPHEN_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'alnumhyphenat') {
			msg = yav_config.ALNUMHYPHENAT_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'alphaspace') {
			msg = yav_config.ALPHASPACE_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'email') {
			msg = yav_config.EMAIL_MSG.replace('{1}', nameDisplayed);
		} else if (ruleName == 'regexp') {
			msg = yav_config.REGEXP_MSG.replace('{1}', nameDisplayed).replace(
					'{2}', comparisonValue);
		} else if (ruleName == 'date_lt') {
			msg = yav_config.DATE_LT_MSG.replace('{1}', nameDisplayed).replace(
					'{2}', yav.getComparisonDisplayed(comparisonValue));
		} else if (ruleName == 'date_le') {
			msg = yav_config.DATE_LE_MSG.replace('{1}', nameDisplayed).replace(
					'{2}', yav.getComparisonDisplayed(comparisonValue));
		} else if (ruleName == 'empty') {
			msg = yav_config.EMPTY_MSG.replace('{1}', nameDisplayed);
		}
		return msg;
	},

	getComparisonDisplayed : function(comparisonValue) {
		comparisonDisplayed = comparisonValue;
		if (comparisonValue.substring(0, 1) == '$') {
			comparisonValue = comparisonValue.substring(1,
					comparisonValue.length);
			tmp = comparisonValue.split(':');
			if (tmp.length == 2) {
				comparisonDisplayed = tmp[1];
			} else {
				comparisonDisplayed = comparisonValue;
			}
		}
		return comparisonDisplayed;
	},

	isKeyAllowed : function(keyCode, charsAllowed) {
		retval = false;
		var aCharCode;
		if (keyCode == 8 || keyCode == 0) {
			retval = true;
		} else {
			for ( var i = 0; i < charsAllowed.length; i++) {
				aCharCode = charsAllowed.charCodeAt(i);
				if (aCharCode == keyCode) {
					retval = true;
					break;
				}
			}
		}
		return retval;
	},

	getField : function(formObj, fieldName) {
		var retval = null;
		if (formObj.elements[fieldName]) {
			retval = formObj.elements[fieldName];
		} else if (yav.get(fieldName)) {
			retval = yav.get(fieldName);
		}
		return retval;
	},

	get : function(id) {
		return document.getElementById(id);
	},

	unformatNumber : function(viewValue) {
		var retval = viewValue.replace(yav_config.THOUSAND_SEP, "");
		retval = retval.replace(yav_config.DECIMAL_SEP, ".");
		return retval;
	},

	deleteInline : function(msg) {
		if (msg.indexOf('__inline__') == -1) {
			return msg;
		} else {
			return msg.substring(0, msg.indexOf('__inline__'));
		}
	},

	addEvent : function(elm, evType, fn) {
		if (elm.addEventListener) {
			elm.addEventListener(evType, fn, false);
			return true;
		} else if (elm.attachEvent) {
			// The main drawback of the Microsoft event registration model is
			// that
	// attachEvent() creates a reference to the function and does not copy it.
	// so these lines (commented out) don't work in some circumstances.
	// var r = elm.attachEvent('on'+evType, fn);
	// return r;
	elm['on' + evType] = fn;
} else {
	elm['on' + evType] = fn;
}
},

call : function(elmName, evType, fn) {
var elm = document.forms[yav.formEvt].elements[elmName];
addEvent(elm, evType, fn);
}

}
// end namespace 'yav'

Function.prototype.bindAsEventListener = function(object) {
	var __method = this;
	return function(event) {
		return __method.call(object, event || window.event);
	}
}