/*

 * jQuery validation plug-in 1.5.5

 *

 * http://bassistance.de/jquery-plugins/jquery-plugin-validation/

 * http://docs.jquery.com/Plugins/Validation

 *

 * Copyright (c) 2006 - 2008 Jörn Zaefferer

 *

 * $Id: jquery.validate.js 6403 2009-06-17 14:27:16Z joern.zaefferer $

 *

 * Dual licensed under the MIT and GPL licenses:

 *   http://www.opensource.org/licenses/mit-license.php

 *   http://www.gnu.org/licenses/gpl.html

 */

(function($) {

$.extend($.fn, {

	// http://docs.jquery.com/Plugins/Validation/validate

	validate: function( options ) {

		// if nothing is selected, return nothing; can't chain anyway

		if (!this.length) {

			options && options.debug && window.console && console.warn( "nothing selected, can't validate, returning nothing" );

			return;

		}

		// check if a validator for this form was already created

		var validator = $.data(this[0], 'validator');

		if ( validator ) {

			return validator;

		}

		validator = new $.validator( options, this[0] );

		$.data(this[0], 'validator', validator); 

		if ( validator.settings.onsubmit ) {

			// allow suppresing validation by adding a cancel class to the submit button

			this.find("input, button").filter(".cancel").click(function() {

				validator.cancelSubmit = true;

			});

			// when a submitHandler is used, capture the submitting button

			if (validator.settings.submitHandler) {

				this.find("input, button").filter(":submit").click(function() {

					validator.submitButton = this;

				});

			}

			// validate the form on submit

			this.submit( function( event ) {

				if ( validator.settings.debug )

					// prevent form submit to be able to see console output

					event.preventDefault();

				function handle() {

					if ( validator.settings.submitHandler ) {

						if (validator.submitButton) {

							// insert a hidden input as a replacement for the missing submit button

							var hidden = $("<input type='hidden'/>").attr("name", validator.submitButton.name).val(validator.submitButton.value).appendTo(validator.currentForm);

						}

						validator.settings.submitHandler.call( validator, validator.currentForm );

						if (validator.submitButton) {

							// and clean up afterwards; thanks to no-block-scope, hidden can be referenced

							hidden.remove();

						}

						return false;

					}

					return true;

				}

				// prevent submit for invalid forms or custom submit handlers

				if ( validator.cancelSubmit ) {

					validator.cancelSubmit = false;

					return handle();

				}

				if ( validator.form() ) {

					if ( validator.pendingRequest ) {

						validator.formSubmitted = true;

						return false;

					}

					return handle();

				} else {

					validator.focusInvalid();

					return false;

				}

			});

		}

		return validator;

	},

	// http://docs.jquery.com/Plugins/Validation/valid

	valid: function() {

        if ( $(this[0]).is('form')) {

            return this.validate().form();

        } else {

            var valid = true;

            var validator = $(this[0].form).validate();

            this.each(function() {

				valid &= validator.element(this);

            });

            return valid;

        }

    },

	// attributes: space seperated list of attributes to retrieve and remove

	removeAttrs: function(attributes) {

		var result = {},

			$element = this;

		$.each(attributes.split(/\s/), function(index, value) {

			result[value] = $element.attr(value);

			$element.removeAttr(value);

		});

		return result;

	},

	// http://docs.jquery.com/Plugins/Validation/rules

	rules: function(command, argument) {

		var element = this[0];

		if (command) {

			var settings = $.data(element.form, 'validator').settings;

			var staticRules = settings.rules;

			var existingRules = $.validator.staticRules(element);

			switch(command) {

			case "add":

				$.extend(existingRules, $.validator.normalizeRule(argument));

				staticRules[element.name] = existingRules;

				if (argument.messages)

					settings.messages[element.name] = $.extend( settings.messages[element.name], argument.messages );

				break;

			case "remove":

				if (!argument) {

					delete staticRules[element.name];

					return existingRules;

				}

				var filtered = {};

				$.each(argument.split(/\s/), function(index, method) {

					filtered[method] = existingRules[method];

					delete existingRules[method];

				});

				return filtered;

			}

		}

		var data = $.validator.normalizeRules(

		$.extend(

			{},

			$.validator.metadataRules(element),

			$.validator.classRules(element),

			$.validator.attributeRules(element),

			$.validator.staticRules(element)

		), element);

		// make sure required is at front

		if (data.required) {

			var param = data.required;

			delete data.required;

			data = $.extend({required: param}, data);

		}

		return data;

	}

});

// Custom selectors

$.extend($.expr[":"], {

	// http://docs.jquery.com/Plugins/Validation/blank

	blank: function(a) {return !$.trim(a.value);},

	// http://docs.jquery.com/Plugins/Validation/filled

	filled: function(a) {return !!$.trim(a.value);},

	// http://docs.jquery.com/Plugins/Validation/unchecked

	unchecked: function(a) {return !a.checked;}

});

// constructor for validator

$.validator = function( options, form ) {

	this.settings = $.extend( {}, $.validator.defaults, options );

	this.currentForm = form;

	this.init();

};

$.validator.format = function(source, params) {

	if ( arguments.length == 1 ) 

		return function() {

			var args = $.makeArray(arguments);

			args.unshift(source);

			return $.validator.format.apply( this, args );

		};

	if ( arguments.length > 2 && params.constructor != Array  ) {

		params = $.makeArray(arguments).slice(1);

	}

	if ( params.constructor != Array ) {

		params = [ params ];

	}

	$.each(params, function(i, n) {

		source = source.replace(new RegExp("\\{" + i + "\\}", "g"), n);

	});

	return source;

};

$.extend($.validator, {

	defaults: {

		messages: {},

		groups: {},

		rules: {},

		errorClass: "error",

		validClass: "valid",

		errorElement: "label",

		focusInvalid: true,

		errorContainer: $( [] ),

		errorLabelContainer: $( [] ),

		onsubmit: true,

		ignore: [],

		ignoreTitle: false,

		onfocusin: function(element) {

			this.lastActive = element;

			// hide error label and remove error class on focus if enabled

			if ( this.settings.focusCleanup && !this.blockFocusCleanup ) {

				this.settings.unhighlight && this.settings.unhighlight.call( this, element, this.settings.errorClass, this.settings.validClass );

				this.errorsFor(element).hide();

			}

		},

		onfocusout: function(element) {

			if ( !this.checkable(element) && (element.name in this.submitted || !this.optional(element)) ) {

				this.element(element);

			}

		},

		onkeyup: function(element) {

			if ( element.name in this.submitted || element == this.lastElement ) {

				this.element(element);

			}

		},

		onclick: function(element) {

			if ( element.name in this.submitted )

				this.element(element);

		},

		highlight: function( element, errorClass, validClass ) {

			$(element).addClass(errorClass).removeClass(validClass);

		},

		unhighlight: function( element, errorClass, validClass ) {

			$(element).removeClass(errorClass).addClass(validClass);

		}

	},

	// http://docs.jquery.com/Plugins/Validation/Validator/setDefaults

	setDefaults: function(settings) {

		$.extend( $.validator.defaults, settings );

	},

	messages: {

		required: "This field is required.",

		remote: "Please fix this field.",

		email: "Please enter a valid email address.",

		url: "Please enter a valid URL.",

		date: "Please enter a valid date.",

		dateISO: "Please enter a valid date (ISO).",

		dateDE: "Bitte geben Sie ein gültiges Datum ein.",

		number: "Please enter a valid number.",

		numberDE: "Bitte geben Sie eine Nummer ein.",

		digits: "Please enter only digits",

		creditcard: "Please enter a valid credit card number.",

		equalTo: "Please enter the same value again.",

		accept: "Please enter a value with a valid extension.",

		maxlength: $.validator.format("Please enter no more than {0} characters."),

		minlength: $.validator.format("Please enter at least {0} characters."),

		rangelength: $.validator.format("Please enter a value between {0} and {1} characters long."),

		range: $.validator.format("Please enter a value between {0} and {1}."),

		max: $.validator.format("Please enter a value less than or equal to {0}."),

		min: $.validator.format("Please enter a value greater than or equal to {0}.")

	},

	autoCreateRanges: false,

	prototype: {

		init: function() {

			this.labelContainer = $(this.settings.errorLabelContainer);

			this.errorContext = this.labelContainer.length && this.labelContainer || $(this.currentForm);

			this.containers = $(this.settings.errorContainer).add( this.settings.errorLabelContainer );

			this.submitted = {};

			this.valueCache = {};

			this.pendingRequest = 0;

			this.pending = {};

			this.invalid = {};

			this.reset();

			var groups = (this.groups = {});

			$.each(this.settings.groups, function(key, value) {

				$.each(value.split(/\s/), function(index, name) {

					groups[name] = key;

				});

			});

			var rules = this.settings.rules;

			$.each(rules, function(key, value) {

				rules[key] = $.validator.normalizeRule(value);

			});

			function delegate(event) {

				var validator = $.data(this[0].form, "validator");

				validator.settings["on" + event.type] && validator.settings["on" + event.type].call(validator, this[0] );

			}

			$(this.currentForm)

				.delegate("focusin focusout keyup", ":text, :password, :file, select, textarea", delegate)

				.delegate("click", ":radio, :checkbox", delegate);

			if (this.settings.invalidHandler)

				$(this.currentForm).bind("invalid-form.validate", this.settings.invalidHandler);

		},

		// http://docs.jquery.com/Plugins/Validation/Validator/form

		form: function() {

			this.checkForm();

			$.extend(this.submitted, this.errorMap);

			this.invalid = $.extend({}, this.errorMap);

			if (!this.valid())

				$(this.currentForm).triggerHandler("invalid-form", [this]);

			this.showErrors();

			return this.valid();

		},

		checkForm: function() {

			this.prepareForm();

			for ( var i = 0, elements = (this.currentElements = this.elements()); elements[i]; i++ ) {

				this.check( elements[i] );

			}

			return this.valid(); 

		},

		// http://docs.jquery.com/Plugins/Validation/Validator/element

		element: function( element ) {

			element = this.clean( element );

			this.lastElement = element;

			this.prepareElement( element );

			this.currentElements = $(element);

			var result = this.check( element );

			if ( result ) {

				delete this.invalid[element.name];

			} else {

				this.invalid[element.name] = true;

			}

			if ( !this.numberOfInvalids() ) {

				// Hide error containers on last error

				this.toHide = this.toHide.add( this.containers );

			}

			this.showErrors();

			return result;

		},