// LiveValidation 1.3 (standalone version)
// Copyright (c) 2007-2008 Alec Hill (www.livevalidation.com)
// LiveValidation is licensed under the terms of the MIT License
var j = 0;

var LiveValidation=function(B,A){
	this.initialize(B,A);
};

LiveValidation.VERSION="1.3 standalone";
LiveValidation.TEXTAREA=1;
LiveValidation.TEXT=2;
LiveValidation.PASSWORD=3;
LiveValidation.CHECKBOX=4;
LiveValidation.SELECT=5;
LiveValidation.FILE=6;
LiveValidation.massValidate=function(C){
	var D=true;
	for(var B=0,A=C.length;B<A;++B){
		var E=C[B].validate();
		if(D){
			D=E;
		}
	}
	return D;
};

LiveValidation.prototype={
	validClass:"LV_valid",
	invalidClass:"LV_invalid",
	messageClass:"LV_validation_message",
	validFieldClass:"LV_valid_field",
	invalidFieldClass:"LV_invalid_field",
	initialize:function(D,C){
		var A=this;
		if(!D){
			throw new Error("LiveValidation::initialize - No element reference or element id has been provided!");
		}
		this.element=D.nodeName?D:document.getElementById(D);
		if(!this.element){
			throw new Error("LiveValidation::initialize - No element with reference or id of '"+D+"' exists!");
		}
		this.validations=[];
		this.elementType=this.getElementType();
		this.form=this.element.form;
		var B=C||{};

		this.validMessage=B.validMessage||"";
		var E=B.insertAfterWhatNode||this.element;
		this.insertAfterWhatNode=E.nodeType?E:document.getElementById(E);
		this.onValid=B.onValid||function(){
			this.insertMessage(this.createMessageSpan());
			this.addFieldClass();
		};

		this.onInvalid=B.onInvalid||function(){
			this.insertMessage(this.createMessageSpan());
			this.addFieldClass();
		};

		this.onlyOnBlur=B.onlyOnBlur||false;
		this.wait=B.wait||0;
		this.onlyOnSubmit=B.onlyOnSubmit||false;
		if(this.form){
			this.formObj=LiveValidationForm.getInstance(this.form);
			this.formObj.addField(this);
		}
		this.oldOnFocus=this.element.onfocus||function(){};

		this.oldOnBlur=this.element.onblur||function(){};

		this.oldOnClick=this.element.onclick||function(){};

		this.oldOnChange=this.element.onchange||function(){};

		this.oldOnKeyup=this.element.onkeyup||function(){};

		this.element.onfocus=function(F){
			A.doOnFocus(F);
			return A.oldOnFocus.call(this,F);
		};

		if(!this.onlyOnSubmit){
			switch(this.elementType){
				case LiveValidation.CHECKBOX:
					this.element.onclick=function(F){
					A.validate();
					return A.oldOnClick.call(this,F);
				};

				case LiveValidation.SELECT:case LiveValidation.FILE:
					this.element.onchange=function(F){
					A.validate();
					return A.oldOnChange.call(this,F);
				};

				break;
				default:
					if(!this.onlyOnBlur){
					this.element.onkeyup=function(F){
						A.deferValidation();
						return A.oldOnKeyup.call(this,F);
					};
				}
				this.element.onblur=function(F){
					A.doOnBlur(F);
					return A.oldOnBlur.call(this,F);
				};
			}
		}
	},
	destroy:function(){
		if(this.formObj){
			this.formObj.removeField(this);
			this.formObj.destroy();
		}
		this.element.onfocus=this.oldOnFocus;
		if(!this.onlyOnSubmit){
			switch(this.elementType){
				case LiveValidation.CHECKBOX:
					this.element.onclick=this.oldOnClick;
				case LiveValidation.SELECT:case LiveValidation.FILE:
					this.element.onchange=this.oldOnChange;
					break;
				default:
					if(!this.onlyOnBlur){
					this.element.onkeyup=this.oldOnKeyup;
				}
				this.element.onblur=this.oldOnBlur;
			}
		}
		this.validations=[];
		this.removeMessageAndFieldClass();
	},
	add:function(A,B){
		this.validations.push({
			type:A,
			params:B||{}
		});
		return this;
	},
	remove:function(B,D){
		var E=false;
		for(var C=0,A=this.validations.length;C<A;C++){
			if(this.validations[C].type==B){
				if(this.validations[C].params==D){
					E=true;
					break;
				}
			}
		}
		if(E){
			this.validations.splice(C,1);
		}
		return this;
	},
	deferValidation:function(B){
		if(this.wait>=300){
			this.removeMessageAndFieldClass();
		}
		var A=this;
		if(this.timeout){
			clearTimeout(A.timeout);
		}
		this.timeout=setTimeout(function(){
			A.validate();
		},A.wait);
	},
	doOnBlur:function(A){
		this.focused=false;
		this.validate(A);
	},
	doOnFocus:function(A){
		this.focused=true;
		this.removeMessageAndFieldClass();
	},
	getElementType:function(){
		switch(true){
			case (this.element.nodeName.toUpperCase()=="TEXTAREA"):
				return LiveValidation.TEXTAREA;
			case (this.element.nodeName.toUpperCase()=="INPUT"&&this.element.type.toUpperCase()=="TEXT"):
				return LiveValidation.TEXT;
			case (this.element.nodeName.toUpperCase()=="INPUT"&&this.element.type.toUpperCase()=="PASSWORD"):
				return LiveValidation.PASSWORD;
			case (this.element.nodeName.toUpperCase()=="INPUT"&&this.element.type.toUpperCase()=="CHECKBOX"):
				return LiveValidation.CHECKBOX;
			case (this.element.nodeName.toUpperCase()=="INPUT"&&this.element.type.toUpperCase()=="FILE"):
				return LiveValidation.FILE;
			case (this.element.nodeName.toUpperCase()=="SELECT"):
				return LiveValidation.SELECT;
			case (this.element.nodeName.toUpperCase()=="INPUT"):
				throw new Error("LiveValidation::getElementType - Cannot use LiveValidation on an "+this.element.type+" input!");
			default:
				throw new Error("LiveValidation::getElementType - Element must be an input, select, or textarea!");
		}
	},
	doValidations:function(){
		this.validationFailed=false;
		for(var C=0,A=this.validations.length;C<A;++C){
			var B=this.validations[C];
			switch(B.type){
				case Validate.Presence:case Validate.Confirmation:case Validate.Acceptance:
					this.displayMessageWhenEmpty=true;
					this.validationFailed=!this.validateElement(B.type,B.params);
					break;
				default:
					this.validationFailed=!this.validateElement(B.type,B.params);
					break;
			}
			if(this.validationFailed){
				return false;
			}
		}
		this.message=this.validMessage;
		return true;
	},
	validateElement:function(A,C){
		var D=(this.elementType==LiveValidation.SELECT)?this.element.options[this.element.selectedIndex].value:this.element.value;
		if(A==Validate.Acceptance){
			if(this.elementType!=LiveValidation.CHECKBOX){
				throw new Error("LiveValidation::validateElement - Element to validate acceptance must be a checkbox!");
			}
			D=this.element.checked;
		}
		var E=true;
		try{
			A(D,C);
		}catch(B){
			if(B instanceof Validate.Error){
				if(D!==""||(D===""&&this.displayMessageWhenEmpty)){
					this.validationFailed=true;
					this.message=B.message;
					E=false;
				}
			}else{
				throw B;
			}
		}finally{
			return E;
		}
	},
	validate:function(){
		if(!this.element.disabled){
			var A=this.doValidations();
			if(A){
				this.onValid();
				return true;
			}else{
				this.onInvalid();
				return false;
			}
		}else{
			return true;
		}
	},
	enable:function(){
		this.element.disabled=false;
		return this;
	},
	disable:function(){
		this.element.disabled=true;
		this.removeMessageAndFieldClass();
		return this;
	},
	createMessageSpan:function(){
		var A=document.createElement("span");
		var B=document.createTextNode(this.message);
		A.appendChild(B);
		return A;
	},
	insertMessage:function(B){
		this.removeMessage();
		if((this.displayMessageWhenEmpty&&(this.elementType==LiveValidation.CHECKBOX||this.element.value==""))||this.element.value!=""){
			var A=this.validationFailed?this.invalidClass:this.validClass;
			B.className+=" "+this.messageClass+" "+A;
			if(this.insertAfterWhatNode.nextSibling){
				this.insertAfterWhatNode.parentNode.insertBefore(B,this.insertAfterWhatNode.nextSibling);
			}else{
				this.insertAfterWhatNode.parentNode.appendChild(B);
			}
		}
	},
	addFieldClass:function(){
		this.removeFieldClass();
		if(!this.validationFailed){
			if(this.displayMessageWhenEmpty||this.element.value!=""){
				if(this.element.className.indexOf(this.validFieldClass)==-1){
					this.element.className+=" "+this.validFieldClass;
				}
			}
		}else{
			if(this.element.className.indexOf(this.invalidFieldClass)==-1){
				this.element.className+=" "+this.invalidFieldClass;
			}
		}
	},
	removeMessage:function(){
		var A;
		var B=this.insertAfterWhatNode;
		while(B.nextSibling){
			if(B.nextSibling.nodeType===1){
				A=B.nextSibling;
				break;
			}
			B=B.nextSibling;
		}
		if(A&&A.className.indexOf(this.messageClass)!=-1){
			this.insertAfterWhatNode.parentNode.removeChild(A);
		}
	},
	removeFieldClass:function(){
		if(this.element.className.indexOf(this.invalidFieldClass)!=-1){
			this.element.className=this.element.className.split(this.invalidFieldClass).join("");
		}
		if(this.element.className.indexOf(this.validFieldClass)!=-1){
			this.element.className=this.element.className.split(this.validFieldClass).join(" ");
		}
	},
	removeMessageAndFieldClass:function(){
		this.removeMessage();
		this.removeFieldClass();
	}
};

var LiveValidationForm=function(A){
	this.initialize(A);
};

LiveValidationForm.instances={};

LiveValidationForm.getInstance=function(A){
	var B=Math.random()*Math.random();
	if(!A.id){
		A.id="formId_"+B.toString().replace(/\./,"")+new Date().valueOf();
	}
	if(!LiveValidationForm.instances[A.id]){
		LiveValidationForm.instances[A.id]=new LiveValidationForm(A);
	}
	return LiveValidationForm.instances[A.id];
};

LiveValidationForm.prototype={
	initialize:function(B){
		this.name=B.id;
		this.element=B;
		this.fields=[];
		this.oldOnSubmit=this.element.onsubmit||function(){};

		var A=this;
		this.element.onsubmit=function(C){
			return(LiveValidation.massValidate(A.fields))?A.oldOnSubmit.call(this,C||window.event)!==false:false;
		};
	},
	addField:function(A){
		this.fields.push(A);
	},
	removeField:function(C){
		var D=[];
		for(var B=0,A=this.fields.length;B<A;B++){
			if(this.fields[B]!==C){
				D.push(this.fields[B]);
			}
		}
		this.fields=D;
	},
	destroy:function(A){
		if(this.fields.length!=0&&!A){
			return false;
		}
		this.element.onsubmit=this.oldOnSubmit;
		LiveValidationForm.instances[this.name]=null;
		return true;
	}
};

var Validate={
	Presence:function(B,C){//alert(B);
		var C=C||{};
		var A=C.failureMessage||"Please enter the field !";

		// var D = B.substring(Math.max(B.search(/\S/), 0));
		var D = B.replace(/^\s+|\s+$/, '')

		if(B===""||B===null||B===undefined||D==''){
			Validate.fail(A);
		}
		return true;
	},
	CheckSpaces:function(B,C){//alert(B);
		var C=C||{};
		var A=C.failureMessage||"Please enter the field !";

		var D = B.replace(/^\s+|\s+$/, '')
		if(D == ''){
			Validate.fail(A);
		}
		return true;
	},
	IsSame:function(C,D){//alert(C);alert(D);
		if(!D.match){
			throw new Error("Validate::Confirmation - Error validating confirmation: Id of element to match must be provided!");
		}
		var D=D||{};

		var B=D.failureMessage||"Does not match!";
		var A=D.match.nodeName?D.match:document.getElementById(D.match);
		if(!A){
			throw new Error("Validate::Confirmation - There is no reference with name of, or element with id of '"+D.match+"'!");
		}
		if(C ==A.value){
			Validate.fail(B);
		}
		return true;
	},
	Numericality:function(J,E){
		var A=J;
		var J=Number(J);
		var E=E||{};

		var F=((E.minimum)||(E.minimum==0))?E.minimum:null;
		var C=((E.maximum)||(E.maximum==0))?E.maximum:null;
		var D=((E.is)||(E.is==0))?E.is:null;
		var G=E.notANumberMessage||"Must be a number!";
		var H=E.notAnIntegerMessage||"Must be an integer!";
		var I=E.wrongNumberMessage||"Must be "+D+"!";
		var B=E.tooLowMessage||"Must not be less than "+F+"!";
		var K=E.tooHighMessage||"Must not be more than "+C+"!";
		if(!isFinite(J)){
			Validate.fail(G);
		}
		if(E.onlyInteger&&(/\.0+$|\.$/.test(String(A))||J!=parseInt(J))){
			Validate.fail(H);
		}
		switch(true){
			case (D!==null):
				if(J!=Number(D)){
				Validate.fail(I);
			}
			break;
			case (F!==null&&C!==null):
				Validate.Numericality(J,{
				tooLowMessage:B,
				minimum:F
			});
			Validate.Numericality(J,{
				tooHighMessage:K,
				maximum:C
			});
			break;
			case (F!==null):
				if(J<Number(F)){
				Validate.fail(B);
			}
			break;
			case (C!==null):
				if(J>Number(C)){
				Validate.fail(K);
			}
			break;
		}
		return true;
	},
	Format:function(C,E){
		var C=String(C);
		var E=E||{};

		var A=E.failureMessage||"Not valid!";
		var B=E.pattern||/./;
		var D=E.negate||false;
		if(!D&&!B.test(C)){
			Validate.fail(A);
		}
		if(D&&B.test(C)){
			Validate.fail(A);
		}
		return true;
	},
	Email:function(B,C){
		var C=C||{};

		var A=C.failureMessage||"Please enter valid email address.";
		Validate.Format(B,{
			failureMessage:A,
			pattern:/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
		});
		return true;
	},
	Length:function(F,G){
		var F=String(F);
		var G=G||{};

		var E=((G.minimum)||(G.minimum==0))?G.minimum:null;
		var H=((G.maximum)||(G.maximum==0))?G.maximum:null;
		var C=((G.is)||(G.is==0))?G.is:null;
		var A=G.wrongLengthMessage||"Must be "+C+" characters long!";
		var B=G.tooShortMessage||"Please enter more than "+E+" characters.";
		var D=G.tooLongMessage||"Must not be more than "+H+" characters long!";
		switch(true){
			case (C!==null):
				if(F.length!=Number(C)){
				Validate.fail(A);
			}
			break;
			case (E!==null&&H!==null):
				Validate.Length(F,{
				tooShortMessage:B,
				minimum:E
			});
			Validate.Length(F,{
				tooLongMessage:D,
				maximum:H
			});
			break;
			case (E!==null):
				if(F.length<Number(E)){
				Validate.fail(B);
			}
			break;
			case (H!==null):
				if(F.length>Number(H)){
				Validate.fail(D);
			}
			break;
			default:
				throw new Error("Validate::Length - Length(s) to validate against must be provided!");
		}
		return true;
	},
	Inclusion:function(H,F){
		var F=F||{};

		var K=F.failureMessage||"Must be included in the list!";
		var G=(F.caseSensitive===false)?false:true;
		if(F.allowNull&&H==null){
			return true;
		}
		if(!F.allowNull&&H==null){
			Validate.fail(K);
		}
		var D=F.within||[];
		if(!G){
			var A=[];
			for(var C=0,B=D.length;C<B;++C){
				var I=D[C];
				if(typeof I=="string"){
					I=I.toLowerCase();
				}
				A.push(I);
			}
			D=A;
			if(typeof H=="string"){
				H=H.toLowerCase();
			}
		}
		var J=false;
		for(var E=0,B=D.length;E<B;++E){
			if(D[E]==H){
				J=true;
			}
			if(F.partialMatch){
				if(H.indexOf(D[E])!=-1){
					J=true;
				}
			}
		}
		if((!F.negate&&!J)||(F.negate&&J)){
			Validate.fail(K);
		}
		return true;
	},
	Exclusion:function(A,B){
		var B=B||{};

		B.failureMessage=B.failureMessage||"Must not be included in the list!";
		B.negate=true;
		Validate.Inclusion(A,B);
		return true;
	},
	Confirmation:function(C,D){
		if(!D.match){
			throw new Error("Validate::Confirmation - Error validating confirmation: Id of element to match must be provided!");
		}
		var D=D||{};

		var B=D.failureMessage||"Does not match!";
		var A=D.match.nodeName?D.match:document.getElementById(D.match);
		if(!A){
			throw new Error("Validate::Confirmation - There is no reference with name of, or element with id of '"+D.match+"'!");
		}
		if(C!=A.value){
			Validate.fail(B);
		}
		return true;
	},
	Acceptance:function(B,C){
		var C=C||{};

		var A=C.failureMessage||"Must be accepted!";
		if(!B){
			Validate.fail(A);
		}
		return true;
	},
	Custom:function(D,E){
		var E=E||{};

		var B=E.against||function(){
			return true;
		};

		var A=E.args||{};

		var C=E.failureMessage||"Not valid!";
		if(!B(D,A)){
			Validate.fail(C);
		}
		return true;
	},
	now:function(A,D,C){
		if(!A){
			throw new Error("Validate::now - Validation function must be provided!");
		}
		var E=true;
		try{
			A(D,C||{});
		}catch(B){
			if(B instanceof Validate.Error){
				E=false;
			}else{
				throw B;
			}
		}finally{
			return E;
		}
	},
	Phonenumber:function(B,C){
		var C=C||{};

		var A=C.failureMessage||"Please enter valid phone number.";
		Validate.Format(B,{
			failureMessage:A,
			pattern:/^((\+\d{1,3}(-| )?\(?\d\)?(-| )?\d{1,5})|(\(?\d{2,6}\)?))(-| )?(\d{3,4})(-| )?(\d{4})(( x| ext)\d{1,5}){0,1}$/
		});
		return true;
	},
	AlphaNumeric:function(B,C){
		var C=C||{};

		var A=C.failureMessage||"Please enter numbers & characters only.";
		Validate.Format(B,{
			failureMessage:A,
			pattern:/^[a-zA-Z0-9_]*$/
		});
		return true;
	},
	Alphabetic:function(B,C){
		var C=C||{};

		var A=C.failureMessage||"Please enter characters only.";
		Validate.Format(B,{
			failureMessage:A,
			pattern:/^[A-Z]+[a-zA-Z]*$/
		});
		return true;
	},
	Url:function(B,C){
		var C=C||{};

		var A=C.failureMessage||"Please enter valid url.";
		Validate.Format(B,{
			failureMessage:A,
			pattern:/(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?/
		});
		return true;
	},
	//^(http[s]?://|ftp://)?(www\.)?[a-zA-Z0-9-\.]+\.(com|org|net|mil|edu|ca|co.uk|com.au|gov)$
	//
	//url reg exp : /(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?/
	//^[a-zA-Z0-9_]*$
	/*phoneRe = /^((\+\d{1,3}(-| )?\(?\d\)?(-| )?\d{1,5})|(\(?\d{2,6}\)?))(-| )?(\d{3,4})(-| )?(\d{4})(( x| ext)\d{1,5}){0,1}$*/
	//^[A-Z]+[a-zA-Z]*$
	fail:function(A){
		throw new Validate.Error(A);
	},
	Error:function(A){
		this.message=A;
		this.name="ValidationError";
	}
};