<!--
/**************************************************************************************************
*                                                                                                 *
*                            MyValidator - Most Secure Form Validation                            *
*                                                                                                 *
**************************************************************************************************/
	
	function myValidator (config) {
		if (myValidator._checkSupportedBrowser()) {
			this.architect = "Matt Scalf, iZooX.com, copyright 2005";
			this.version = "1.2";
			
			this.forms = Array();
			this.active = true;
			this.config = (typeof config == "undefined") ? new myValidator._config() : config;
		}
		return false;
	};
	
	myValidator._config = function () {		
		this.validators = {
			alnum: "_validateAlphaNumeric", alphanum: "_validateAlphaNumeric", alnumeric: "_validateAlphaNumeric", alphanumeric: "_validateAlphaNumeric",
			char: "_validateCharacters", characters: "_validateCharacters",
			num: "_validateNumerical", number: "_validateNumerical",
			alpha: "_validateAlphabet", alphabet: "_validateAlphabet",
			empty: "_validateEmpty", req: "_validateEmpty", required: "_validateEmpty",
			credit: "_validateCredit", creditcard: "_validateCredit", creditcardnumber: "_validateCredit",
			zip: "_validateZip", zipcode: "_validateZip",
			phone: "_validatePhone", phonenumber: "_validatePhone",
			email: "_validateEmail", emailaddress: "_validateEmail",
			min: "_validateMinLength", minimum: "_validateMinLength", minlen: "_validateMinLength", minimumlen: "_validateMinLength", minlength: "_validateMinLength", minimumlength: "_validateMinLength",
			max: "_validateMaxLength", maximum: "_validateMaxLength", maxlen: "_validateMaxLength", maximumlen: "_validateMaxLength", maxlength: "_validateMaxLength", maximumlength: "_validateMaxLength",
			swear: "_validateWords", cuss: "_validateWords", badwords: "_validateWords", vulgar: "_validateWords"
		};
		
		this.tlds = ['com','edu','net','org','mil','gov','biz','info','cc','do','ad','ae','af','ag','ai','al','am','an','ao','aq','ar','as','at','au','aw','az','ba','bb','bd','be','bf','bg','bh','bi','bj','bm','bn','bo','br','bs','bt','bv','bw','by','bz','ca','cc','cd','cf','cg','ch','ci','ck','cl','cm','cn','co','cr','cs','cu','cv','cx','cy','cz','de','dj','dk','dm','dz','ec','ee','eg','eh','er','es','et','fi','fj','fk','fm','fo','fr','fx','ga','gb','gd','ge','gf','gh','gi','gl','gm','gn','gp','gq','gr','gs','gt','gu','gw','gy','hk','hm','hn','hr','ht','hu','id','ie','il','in','io','iq','ir','is','it','jm','jo','jp','ke','kg','kh','ki','km','kn','kp','kr','kw','ky','kz','la','lb','lc','li','lk','lr','ls','lt','lu','lv','ly','ma','mc','md','mg','mh','mk','ml','mm','mn','mo','mp','mq','mr','ms','mt','mu','mv','mw','mx','my','mz','na','nc','ne','nf','ng','ni','nl','no','np','nr','nt','nu','nz','om','pa','pe','pf','pg','ph','pk','pl','pm','pn','pr','pt','pw','py','qa','re','ro','ru','rw','sa','sb','sc','sd','se','sg','sh','si','sj','sk','sl','sm','sn','so','sr','st','sv','sy','sz','tc','td','tf','tg','th','tj','tk','tm','tn','to','tp','tr','tt','tv','tw','tz','ua','ug','uk','um','us','uy','uz','va','vc','ve','vg','vi','vn','vu','wf','ws','ye','yt','yu','za','zm','zr','zw'];
		this.badareacodes = ['900','976','500','700','809','758','664','710','533','456','911','811','711','611','511','411','311','211','204','250','289','306','403','416','418','450','506','514','519','604','613','647','705','709','778','780','807','819','867','902','905','242','246','264','268','284','441','473','664','758','767','784','868','869','876','371','372','373','374','375','376','377','378','379','370','961','962','963','964','965','966','967','968','969','960','291','292','293','294','295','296','297','298','299','290','391','392','393','394','395','396','397','398','399','390','491','492','493','494','495','496','497','498','499','490','591','592','593','594','595','596','597','598','599','590','691','692','693','694','695','696','697','698','699','690','791','792','793','794','795','796','797','798','799','790', '991','992','993','994','995','996','997','998','999','990'];
		this.badprefixes = ['111','222','333','444','555','666','777','888','999','411'];
		this.swearwords = [
			'badword','.*)(damn','.*)(dyke','.*)(fuck)(.*','.*)(shit)(.*','amcik','andskota','arschloch','arse)(.*','asshole','assrammer','ayir','b!+ch','b!tch','b17ch','b1tch','bastard','bi+ch','bi7ch','bitch)(.*','boiolas','bollock)(.*','breasts',
			'buceta','butt-pirate','c0ck','cabron','cawk','cazzo','chink','chraa','chuj','cipa','clits','Cock)(.*','cum','cunt)(.*','d4mn','daygo','dego','dick)(.*','dike)(.*','dildo','dirsa','dupa','dziwka','ejackulate','Ekrem)(.*','Ekto','enculer','faen','fag)(.*','fanculo','fanny','fatass','fcuk','feces','feg','Felcher',
			'ficken','fitt)(.*','Flikker','foreskin','Fotze','Fu)(.*','fuk)(.*','futkretzn','fux0r','gay','gook','guiena','h0r','h4x0r','hell','helvete','hoer)(.*','honkey','hore','Huevon','hui','injun','jism','jizz',
			'kanker)(.*','kawk','kike','klootzak','kraut','knulle','kuk','kuksuger','Kurac','kurwa','kusi)(.*','kyrpa)(.*','l3i+ch','l3itch','lesbian','lesbo',
			'mamhoon','masturbat)(.*','merd)(.*','mibun','monkleigh','motherfucker','mofo','mouliewop','muie','mulkku','muschi','nazis','nepesaurio','nigga','nigger)(.*','nutsack','orospu','paska)(.*',
			'perse','phuck','picka','pierdol)(.*','pillu)(.*','pimmel','pimpis','piss)(.*','pizda','poontsee','poop','porn','p0rn','pr0n','preteen','pula',
			'pule','pusse','pussy','puta','puto','qahbeh','queef)(.*','rautenberg','schaffer','scheiss)(.*','schlampe','schmuck','screw','scrotum','sh!t)(.*',
			'sharmuta','sharmute','shemale','shipal','shiz','skribz','skurwysyn','slut','smut','sphencter','spic','spierdalaj','splooge','suka',
			'teets','b00b)(.*','teez','testicle)(.*','titt)(.*','tits','twat','vittu','w00se','wank)(.*','wetback)(.*','whoar','wichser','wop)(.*','yed','zabourah'
		];
	};
	
	myValidator.prototype._about = function() {
		alert ('My Validator version: '+this.version+'/r/n/r/nDeveloped by: '+this.architect);
	}
	
	myValidator.prototype._activate = function() {
		this.active = true;
	}
	
	myValidator.prototype._deactivate = function() {
		this.active = false;
	}	
	
	myValidator.prototype._fireEvent = function (name, src, da) {
		if (da) {
			this._deactivate();
		}
		
		if (myValidator._inArray(src, this.forms)) {
			if (myValidator.is_ie) {
				var evt = document.createEventObject();
				src.fireEvent(name, evt);
				eval('src.'+name.slice(2)+'();');
			} else {
				var evt = document.createEvent("Events");
				evt.initEvent(name.slice(2), true, true);
				src.dispatchEvent(evt);
			}
		}
	};
	
	myValidator.prototype._addForm = function(obj) {
		if (typeof obj != "undefined") {
			if (!myValidator._inArray(obj, this.forms)) {				
				var validator = this;
				
				this.forms.push(obj);
				myValidator._addEvent(
					obj, 
					"keypress", 
					function (ev) {
						var key = (myValidator.is_ie)? window.event.charCode: ((ev.keyCode) ? ev.keyCode : ((ev.which) ? ev.which : 0));
						if (key == 13) {
							myValidator._stopEvent(myValidator.is_ie ? window.event : ev);
							return false;
						}
						return true;
					}
				);
				myValidator._addEvent(
					obj, 
					"submit", 
					function (ev) {
						var validity = true;
						if (validator.active) {
							validity = validator._validateForm (
								myValidator.is_ie ? window.event.srcElement.tagName.toLowerCase() == "form" ? window.event.srcElement : window.event.srcElement.form : ev.target ? ev.target.tagName.toLowerCase() == "form" ? ev.target : ev.target.form : ev.currentTarget.tagName.toLowerCase() == "form" ? ev.currentTarget : ev.currentTarget.form
							);
						}
						if (validity !== true) {
							myValidator._stopEvent(myValidator.is_ie ? window.event : ev);
							try {
								var fieldName = myValidator._getAttribute(validity.obj, 'description');
								if (fieldName === false) {
									alert (!validity.msg ? 'Error! Please seek the administrator.' : 'Field is invalid:\r\n\r\n\t\t' + validity.msg);
								} else {
									alert (!validity.msg ? 'Error! Please seek the administrator.' : fieldName + ' is invalid:\r\n\r\n\t\t' + validity.msg);
								}
								validity.obj.focus();
								if (myValidator._check4Basic(validity.obj) === true) {
									validity.obj.select();
								}
							} catch (err) { }
						}
					}
				);
				
				return true;
			}
		}
		return false;
	};
	
/**************************************************************************************************
*                                                                                                 *
*                                Special Integration Instructions                                 *
*                                                                                                 *
**************************************************************************************************/
	myValidator.prototype._runValidation = function (obj, fld, sbmt, evt) {
		if (evt) {
			myValidator._stopEvent(evt);
		}
		
		var validity = this._validateForm (obj, fld, sbmt);
		if (validity !== true) {
			try {
				var fieldName = myValidator._getAttribute(fld, 'description');
				if (fieldName === false) {
					alert (!validity.msg ? 'Error! Please seek the administrator.' : 'Field is invalid:\r\n\r\n' + validity.msg);
				} else {
					alert (!validity.msg ? 'Error! Please seek the administrator.' : fieldName + ' is invalid:\r\n\r\n' + validity.msg);
				}
				validity.obj.focus();
				if (myValidator._check4Basic(validity.obj) === true) {
					validity.obj.select();
				}
			} catch (err) { }
		}
	}
	
	myValidator.prototype._validateForm = function (obj, fld, sbmt) {
		if (myValidator._inArray(obj, this.forms) && obj.tagName.toLowerCase() == "form") {
			var validations = null; var validator = [];
			var valid = true; var data = false;
			var temp = null;
			
			for (var i = 0; i < obj.elements.length; i++) {
				if (myValidator._getAttribute(obj.elements[i], 'validate') !== false && myValidator._getAttribute(obj.elements[i], 'validate') != "false") {
					validations = myValidator._getAttribute(obj.elements[i], 'validate').split(",");
					for (var j = 0; j < validations.length; j++) {
						validator = validations[j].split("=");
						if (typeof this.config.validators[validator[0]] != "undefined") {
							data = myValidator._getData(obj.elements[i]);
							if (data !== false) { // Process basic data input fields.
								if (!fld || (fld && obj.elements[i] === fld)) {
									if (validator.length == 1) {
										eval ("valid = myValidator."+this.config.validators[validator[0].toLowerCase()]+"('"+data+"', this);");
									} else {
										eval ("valid = myValidator."+this.config.validators[validator[0].toLowerCase()]+"('"+data+"', "+validator[1]+", this);");
									}
									
									if (valid !== true) {
										return {
											msg: valid,
											obj: obj.elements[i]
										};
									}
								}
							} else { // Process advanced data input fields
								switch (obj.elements[i].type.toLowerCase()) {
									case "radio":
										if (!fld || (fld && obj.elements[i].name === fld)) {
											eval("var elm = obj."+obj.elements[i].name+";");
											eval ("valid = myValidator."+this.config.validators[validator[0].toLowerCase()]+"_Radio(elm, this);");									
										}
										break;
									case "checkbox":
										var group =  myValidator._getAttribute(obj.elements[i], 'group');
										if (group !== false) {
											if (!fld || (fld && group === fld)) {
												if (group != null) {
													eval ("valid = myValidator."+this.config.validators[validator[0].toLowerCase()]+"_Check(obj, '"+group+"', "+validator[1]+", this);");
												}
											}
										}
										break;
									default:
										break;
								}
								
								if (valid !== true) {
									return {
										msg: valid,
										obj: obj.elements[i]
									};
								}
							}
						}
					}
				}
			}
			
			if (sbmt) {
				this._fireEvent ('onsubmit', obj, true);
			}
			return true;
		}
		return {
			msg: "There was an error in the Validator Setup.\n Please check the configuration.",
			obj: null
		};
	}
	
/**************************************************************************************************
*                                                                                                 *
*                               Class Helper Functions v.1.0                                      *
*                               Class Helper Objects v.1.0                                        *
*                                                                                                 *
**************************************************************************************************/
	myValidator._checkSupportedBrowser = function() {
		this.agt = navigator.userAgent.toLowerCase();
		this.is_ie = ((this.agt.indexOf("msie") != -1) && (this.agt.indexOf("opera") == -1));
		this.is_opera = (this.agt.indexOf("opera") != -1);
		this.is_mac	= (this.agt.indexOf("mac") != -1);
		this.is_mac_ie = (this.is_ie && this.is_mac);
		this.is_win_ie = (this.is_ie && !this.is_mac);
		this.is_gecko = (navigator.product == "Gecko");
		
		return this.is_gecko || this.is_ie;
	};
	
	myValidator._inArray = function(obj, array) {
		for (var i = 0; i < array.length; i++) {
			if (array[i] === obj) {
				return true;	
			}	
		}
		return false;	
	}
	
	myValidator._getData = function(obj) {
		if (typeof obj !== "undefined") {
			if (myValidator._checkVisibility (obj)) {
				switch (obj.tagName.toLowerCase()) {
					case "input":
						if (obj.type.toLowerCase() == "checkbox" || obj.type.toLowerCase() == "radio")  return false;
					case "textarea":
						return obj.value;
						break;
					case "select":
						return obj.options[obj.selectedIndex].value;
						break;
					default:
						break;
				}
			}
		}
		return false;
	}
	
	myValidator._getAttribute = function(obj, attr) {
		eval("var exists = typeof obj.attributes['"+attr+"'] != 'undefined';");
		if (exists) {
			eval("var val = obj.attributes['"+attr+"'].value;");
			if (val != null) {
				return val;
			}
		}
		return false;
	}
	
	myValidator._check4Basic = function(obj) {
		if (typeof obj !== "undefined") {
			if (myValidator._checkVisibility (obj)) {
				switch (obj.tagName.toLowerCase()) {
					case "input":
						if (obj.type.toLowerCase() == "checkbox" || obj.type.toLowerCase() == "radio")  return false;
					case "textarea":
						return true;
						break;
					default:
						break;
				}
			}
		}
		return false;
	}
	
	myValidator._checkVisibility = function (obj) {
		try {
			tempObj = obj;
			do {
				if (tempObj.disabled == true || tempObj.style.visibility == "hidden" || tempObj.style.display == "none") {
					tempObj = null;
					return false;
				} else {
					tempObj = tempObj.parentNode;
				}
			} while (typeof tempObj.tagName != "undefined");
		} catch (err) {}
		return true;
	}
	
	myValidator._addEvent = function(el, evname, func) {
		if (this.is_ie) el.attachEvent("on" + evname, func);
		else el.addEventListener(evname, func, true);
	};
	
	myValidator._addEvents = function(el, evs, func) {
		for (var i in evs)
			myValidator._addEvent(el, evs[i], func);
	};
	
	myValidator._stopEvent = function(ev) {
		if (this.is_ie) {
			ev.cancelBubble = true;
			ev.returnValue = false;
		} else {
			ev.preventDefault();
			ev.stopPropagation();
		}
	};
	
/**************************************************************************************************
*                                                                                                 *
*                               Validation Functions v.1.0                                        *
*                                                                                                 *
**************************************************************************************************/
	myValidator._validateEmpty = function (data, v) {
		if (data.length <= 0 || data == "") {
			return "This field is required!";
		}
		return true;
	};
	
	myValidator._validateEmpty_Radio = function (obj, v) {
		for (var r = 0; r < obj.length; r++) {
			if (obj[r].checked === true) {
				return true;
			}
		}
		return "You must select one value from this radio group!";
	};
	
	myValidator._validateMaxLength_Check = function (obj, grp, len, v) {
		var count = 0;
		for (var i = 0; i < obj.elements.length; i++) {
			if (obj.elements[i].type.toLowerCase() == "checkbox") {
				if (typeof obj.elements[i].attributes['group'] != "undefined") {
					tgrp = obj.elements[i].attributes['group'].value;
					if (tgrp == grp && obj.elements[i].checked) {
						count++;
					}
				}
			}
		}
				
		
		if (count > len) {
			return "This group of check boxes is allowed a maximum of "+len+" boxes checked!";
		}
		return true;
	};
	
	myValidator._validateMinLength_Check = function (obj, grp, len, v) {
		var count = 0;
		for (var i = 0; i < obj.elements.length; i++) {
			if (obj.elements[i].type.toLowerCase() == "checkbox") {
				if (typeof obj.elements[i].attributes['group'] != "undefined") {
					tgrp = obj.elements[i].attributes['group'].value;
					if (tgrp == grp && obj.elements[i].checked) {
						count++;
					}
				}
			}
		}
		
		if (count < len) {
			return "This group of check boxes is required a minimum of "+len+" boxes checked!";
		}
		return true;
	};
	
	myValidator._validateMaxLength = function (data, len, v) {
		if (data.length > len) {
			return "This field is required to be "+len+" characters or under!";
		}
		return true;
	};
	
	myValidator._validateMinLength = function (data, len, v) {
		if (data.length < len) {
			return "This field is required to be "+len+" characters or over!";
		}
		return true;
	};
	
	myValidator._validateWords = function (data, v) {
		var words = data.split(" ");
		for (var j = 0; j < words.length; j++) {
			for (var i = 0; i < v.config.swearwords.length; i++) {
				if (words[j].toLowerCase().match("("+v.config.swearwords[i]+")") != null) {
					return "This fields contains blocked words!";
				}
			}
		}
		return true;
	};
	
	myValidator._validateWords = function (data, v) {
		var words = data.split(" ");
		for (var j = 0; j < words.length; j++) {
			for (var i = 0; i < v.config.swearwords.length; i++) {
				if (words[j].toLowerCase().match("("+v.config.swearwords[i]+")") != null) {
					return "This fields contains blocked words!";
				}
			}
		}
		return true;
	};
	
	myValidator._validateNumerical = function (data, v) {
		if (data.replace(/([0-9.\-]+)/, '') != "") {
			return "Invalid characters, this fields accepts only number representations.";
		}
		return true;
	};
	
	myValidator._validateAlphabet = function (data, v) {
		if (data.replace(/([a-zA-Z \'\".,:;?\/\-\(\)]+)/, '') != "") {
			return "Invalid characters, this fields accepts only letters.";
		}
		return true;
	};
	
	myValidator._validateCharacters = function (data, v) {
		if (data.replace(/([ -\/:-~]+)/, '') != "") {
			return "Invalid characters, this fields accepts only letters and characters.";
		}
		return true;
	};
	
	myValidator._validateAlphaNumeric = function (data, v) {
		if (data.replace(/([0-9a-zA-Z \'\".,:;?\/\-\(\)]+)/, '') != "") {
			return "Invalid characters, this fields accepts only letters and numbers.";
		}
		return true;
	};
	
	myValidator._validateZip = function (zip, v) {
		if (zip != "") {
			if (zip.length < 5 || zip.length > 5) {
				return "Zip Codes must be in starndard 5 digit format!";	
			}
			
			if (isNaN(zip) !== false) {
				return "Zip Code includes invalid characters!";
			}
		}
		return true;
	};
	
	myValidator._validateEmail = function (email, v) {
    		if (email != "") {
			if(email.indexOf('@') < 0){
				return "Email is invalid, no @ symbol included!";
			}
			var astring = email.split('@');
			var user = astring [0];
			var host = astring [1];
			
			if (user == "" || host == ""){
				return "Email missing some data, it must be in standard format!";
			}
			
			if(user.match(/[ 	]/) != null || host.match("[ 	]") != null){
				return "Email contains whitespace!";
			}
			
			var web = false;
			if (host.replace(/[-A-Z0-9\.]/, '') == "") {
				return "Email host includes invalid characters!"
			}
			if(host.match(/^www\./) != null){
				$web = true;
			}
			if(host.match(/\.\./) != null){
				return "Emails cannot include double dots!";
			}
			if(host.match(/^\./) != null){
				return "Email hostnames cannot have a leading dot!";
			}
			
			var host_chunks = host.split('.');
			if (host_chunks.length < 2) {
				return "Email hostname must include a dot separator!";
			}
			
			var count = host_chunks.length - 1;
			if(count < 1){
				return "Invalid email hostname!";
			}
			if(web && count < 2){
				return "Invalid email hostname!";
			}
			
			var tld = host_chunks[count];
			if(tld == ""){
				return "Email hostname is invalid, no tld found!";
			}
			
			if(!myValidator._inArray(tld, v.config.tlds)){
				return "Email does not include a recognized tld!";
			}
		}
		return true;
	};
	
	myValidator._validatePhone = function (phone, v) {
		if (phone != "") {
			var splitted = phone.match("^(.+)-(.+)-(.+)$");
	    
			if(splitted == null) return "Phone Numbers must be in standard format!";
			if(splitted[1] != null ) {
				if(myValidator._inArray(splitted[1], this.config.badareacodes)) {
					return "Phone Numbers cannot include invalid areacodes!";
				}
				if (splitted[1].length != 3){
					return "Phone Numbers areacode must be 3 digits long!";
				}			
			} else {
				return "Phone Numbers must include an areacode!";
			}
			
			if(splitted[2] != null) {
				if(myValidator._inArray(splitted[2], this.config.badprefixes)) {
					return "Phone Numbers cannot include invalid prefixes!";
				}
				if (splitted[2].length != 3){
					return "Phone Numbers prefixes must be 3 digits long!";
				}
			} else {
				return "Phone Numbers must include a prefix!";
			}
			
			if(splitted[3] != null) {
				if (splitted[3].length != 4){
					return "Phone Numbers suffixes must be 4 digits long!";
				}
			} else {
				return "Phone Numbers must include a suffix!";
			}
			
			if (isNaN(splitted[1]) || isNaN(splitted[2]) || isNaN(splitted[3])) {
				return "Phone Numbers includes invalid characters!";
			}
			
			return true;
		}
		return true;
	};
	
	myValidator._validateCredit = function (number, v) {
	  	if (number != "") {
			if (number.length > 4) {
				var i, n, c, r, t;
				
				r = "";
				for (i = 0; i < number.length; i++) {
					c = parseInt(number.charAt(i), 10);
					if (c >= 0 && c <= 9)
						r = c + r;
				}
				
				t = "";
				for (i = 0; i < r.length; i++) {
					c = parseInt(r.charAt(i), 10);
					if (i % 2 != 0)
						c *= 2;
					t = t + c;
				}
				
				n = 0;
				for (i = 0; i < t.length; i++) {
					c = parseInt(t.charAt(i), 10);
					n = n + c;
				}
				
				if (n != 0 && n % 10 == 0) {
					return true;
				}else{
					return "Invalid Credit Card Number!";
				}
			}
			return "Credit Card Numbers must be in standard format!";
		}
		return true;
	};
// -->