https://www.profumeriacauli.com/modules/pm_advancedsearch4/views/js/jquery.form.js

1/*!
2 * jQuery Form Plugin
3 * version: 2.73 (03-MAY-2011)
4 * @requires jQuery v1.3.2 or later
5 *
6 * Examples and documentation at: http://malsup.com/jquery/form/
7 * Dual licensed under the MIT and GPL licenses:
8 *   http://www.opensource.org/licenses/mit-license.php
9 *   http://www.gnu.org/licenses/gpl.html
10 */
11;(function($) {
12
13/*
14	Usage Note:
15	-----------
16	Do not use both ajaxSubmit and ajaxForm on the same form.  These
17	functions are intended to be exclusive.  Use ajaxSubmit if you want
18	to bind your own submit handler to the form.  For example,
19
20	$(document).ready(function() {
21		$('#myForm').bind('submit', function(e) {
22			e.preventDefault(); // <-- important
23			$(this).ajaxSubmit({
24				target: '#output'
25			});
26		});
27	});
28
29	Use ajaxForm when you want the plugin to manage all the event binding
30	for you.  For example,
31
32	$(document).ready(function() {
33		$('#myForm').ajaxForm({
34			target: '#output'
35		});
36	});
37
38	When using ajaxForm, the ajaxSubmit function will be invoked for you
39	at the appropriate time.
40*/
41
42/**
43 * ajaxSubmit() provides a mechanism for immediately submitting
44 * an HTML form using AJAX.
45 */
46$.fn.ajaxSubmit = function(options) {
47	// fast fail if nothing selected (http://dev.jquery.com/ticket/2752)
48	if (!this.length) {
49		log('ajaxSubmit: skipping submit process - no element selected');
50		return this;
51	}
52
53	if (typeof options == 'function') {
54		options = { success: options };
55	}
56
57	var action = this.attr('action');
58	var url = (typeof action === 'string') ? $.trim(action) : '';
59	if (url) {
60		// clean url (don't include hash vaue)
61		url = (url.match(/^([^#]+)/)||[])[1];
62	}
63	url = url || window.location.href || '';
64
65	options = $.extend(true, {
66		url:  url,
67		success: $.ajaxSettings.success,
68		type: this[0].getAttribute('method') || 'GET', // IE7 massage (see issue 57)
69		iframeSrc: /^https/i.test(window.location.href || '') ? 'javascript:false' : 'about:blank'
70	}, options);
71
72	// hook for manipulating the form data before it is extracted;
73	// convenient for use with rich editors like tinyMCE or FCKEditor
74	var veto = {};
75	this.trigger('form-pre-serialize', [this, options, veto]);
76	if (veto.veto) {
77		log('ajaxSubmit: submit vetoed via form-pre-serialize trigger');
78		return this;
79	}
80
81	// provide opportunity to alter form data before it is serialized
82	if (options.beforeSerialize && options.beforeSerialize(this, options) === false) {
83		log('ajaxSubmit: submit aborted via beforeSerialize callback');
84		return this;
85	}
86
87	var n,v,a = this.formToArray(options.semantic);
88	if (options.data) {
89		options.extraData = options.data;
90		for (n in options.data) {
91			if(options.data[n] instanceof Array) {
92				for (var k in options.data[n]) {
93					a.push( { name: n, value: options.data[n][k] } );
94				}
95			}
96			else {
97				v = options.data[n];
98				v = $.isFunction(v) ? v() : v; // if value is fn, invoke it
99				a.push( { name: n, value: v } );
100			}
101		}
102	}
103
104	// give pre-submit callback an opportunity to abort the submit
105	if (options.beforeSubmit && options.beforeSubmit(a, this, options) === false) {
106		log('ajaxSubmit: submit aborted via beforeSubmit callback');
107		return this;
108	}
109
110	// fire vetoable 'validate' event
111	this.trigger('form-submit-validate', [a, this, options, veto]);
112	if (veto.veto) {
113		log('ajaxSubmit: submit vetoed via form-submit-validate trigger');
114		return this;
115	}
116
117	var q = $.param(a);
118
119	if (options.type.toUpperCase() == 'GET') {
120		options.url += (options.url.indexOf('?') >= 0 ? '&' : '?') + q;
121		options.data = null;  // data is null for 'get'
122	}
123	else {
124		options.data = q; // data is the query string for 'post'
125	}
126
127	var $form = this, callbacks = [];
128	if (options.resetForm) {
129		callbacks.push(function() { $form.resetForm(); });
130	}
131	if (options.clearForm) {
132		callbacks.push(function() { $form.clearForm(); });
133	}
134
135	// perform a load on the target only if dataType is not provided
136	if (!options.dataType && options.target) {
137		var oldSuccess = options.success || function(){};
138		callbacks.push(function(data) {
139			var fn = options.replaceTarget ? 'replaceWith' : 'html';
140			$(options.target)[fn](data).each(oldSuccess, arguments);
141		});
142	}
143	else if (options.success) {
144		callbacks.push(options.success);
145	}
146
147	options.success = function(data, status, xhr) { // jQuery 1.4+ passes xhr as 3rd arg
148		var context = options.context || options;   // jQuery 1.4+ supports scope context
149		for (var i=0, max=callbacks.length; i < max; i++) {
150			callbacks[i].apply(context, [data, status, xhr || $form, $form]);
151		}
152	};
153
154	// are there files to upload?
155	var fileInputs = $('input:file', this).length > 0;
156	var mp = 'multipart/form-data';
157	var multipart = ($form.attr('enctype') == mp || $form.attr('encoding') == mp);
158
159	// options.iframe allows user to force iframe mode
160	// 06-NOV-09: now defaulting to iframe mode if file input is detected
161   if (options.iframe !== false && (fileInputs || options.iframe || multipart)) {
162	   // hack to fix Safari hang (thanks to Tim Molendijk for this)
163	   // see:  http://groups.google.com/group/jquery-dev/browse_thread/thread/36395b7ab510dd5d
164	   if (options.closeKeepAlive) {
165		   $.get(options.closeKeepAlive, fileUpload);
166		}
167	   else {
168		   fileUpload();
169		}
170   }
171   else {
172
173		$.ajax(options);
174   }
175
176	// fire 'notify' event
177	this.trigger('form-submit-notify', [this, options]);
178	return this;
179
180
181	// private function for handling file uploads (hat tip to YAHOO!)
182	function fileUpload() {
183		var form = $form[0];
184
185		if ($(':input[name=submit],:input[id=submit]', form).length) {
186			// if there is an input with a name or id of 'submit' then we won't be
187			// able to invoke the submit fn on the form (at least not x-browser)
188			alert('Error: Form elements must not have name or id of "submit".');
189			return;
190		}
191
192		var s = $.extend(true, {}, $.ajaxSettings, options);
193		s.context = s.context || s;
194		var id = 'jqFormIO' + (new Date().getTime()), fn = '_'+id;
195		var $io = $('<iframe id="' + id + '" name="' + id + '" src="'+ s.iframeSrc +'" />');
196		var io = $io[0];
197
198		$io.css({ position: 'absolute', top: '-1000px', left: '-1000px' });
199
200		var xhr = { // mock object
201			aborted: 0,
202			responseText: null,
203			responseXML: null,
204			status: 0,
205			statusText: 'n/a',
206			getAllResponseHeaders: function() {},
207			getResponseHeader: function() {},
208			setRequestHeader: function() {},
209			abort: function(status) {
210				var e = (status === 'timeout' ? 'timeout' : 'aborted');
211				log('aborting upload... ' + e);
212				this.aborted = 1;
213				$io.attr('src', s.iframeSrc); // abort op in progress
214				xhr.error = e;
215				s.error && s.error.call(s.context, xhr, e, e);
216				g && $.event.trigger("ajaxError", [xhr, s, e]);
217				s.complete && s.complete.call(s.context, xhr, e);
218			}
219		};
220
221		var g = s.global;

222		// trigger ajax global events so that activity/block indicators work like normal
223		if (g && ! $.active++) {
224			$.event.trigger("ajaxStart");
225		}
226		if (g) {
227			$.event.trigger("ajaxSend", [xhr, s]);
228		}
229
230		if (s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false) {
231			if (s.global) {
232				$.active--;
233			}
234			return;
235		}
236		if (xhr.aborted) {
237			return;
238		}
239
240		var timedOut = 0, timeoutHandle;
241
242		// add submitting element to data if we know it
243		var sub = form.clk;
244		if (sub) {
245			var n = sub.name;
246			if (n && !sub.disabled) {
247				s.extraData = s.extraData || {};
248				s.extraData[n] = sub.value;
249				if (sub.type == "image") {
250					s.extraData[n+'.x'] = form.clk_x;
251					s.extraData[n+'.y'] = form.clk_y;
252				}
253			}
254		}
255
256		// take a breath so that pending repaints get some cpu time before the upload starts
257		function doSubmit() {
258			// make sure form attrs are set
259			var t = $form.attr('target'), a = $form.attr('action');
260
261			// update form attrs in IE friendly way
262			form.setAttribute('target',id);
263			if (form.getAttribute('method') != 'POST') {
264				form.setAttribute('method', 'POST');
265			}
266			if (form.getAttribute('action') != s.url) {
267				form.setAttribute('action', s.url);
268			}
269
270			// ie borks in some cases when setting encoding
271			if (! s.skipEncodingOverride) {
272				$form.attr({
273					encoding: 'multipart/form-data',
274					enctype:  'multipart/form-data'
275				});
276			}
277
278			// support timout
279			if (s.timeout) {
280				timeoutHandle = setTimeout(function() { timedOut = true; cb(true); }, s.timeout);
281			}
282
283			// add "extra" data to form if provided in options
284			var extraInputs = [];
285			try {
286				if (s.extraData) {
287					for (var n in s.extraData) {
288						extraInputs.push(
289							$('<input type="hidden" name="'+n+'" value="'+s.extraData[n]+'" />')
290								.appendTo(form)[0]);
291					}
292				}
293
294				// add iframe to doc and submit the form
295				$io.appendTo('body');
296                io.attachEvent ? io.attachEvent('onload', cb) : io.addEventListener('load', cb, false);
297				form.submit();
298			}
299			finally {
300				// reset attrs and remove "extra" input elements
301				form.setAttribute('action',a);
302				if(t) {
303					form.setAttribute('target', t);
304				} else {
305					$form.removeAttr('target');
306				}
307				$(extraInputs).remove();
308			}
309		}
310
311		if (s.forceSync) {
312			doSubmit();
313		}
314		else {
315			setTimeout(doSubmit, 10); // this lets dom updates render
316		}
317
318		var data, doc, domCheckCount = 50, callbackProcessed;
319
320		function cb(e) {
321			if (xhr.aborted || callbackProcessed) {
322				return;
323			}
324			if (e === true && xhr) {
325				xhr.abort('timeout');
326				return;
327			}
328
329			var doc = io.contentWindow ? io.contentWindow.document : io.contentDocument ? io.contentDocument : io.document;
330			if (!doc || doc.location.href == s.iframeSrc) {
331				// response not received yet
332				if (!timedOut)
333					return;
334			}
335            io.detachEvent ? io.detachEvent('onload', cb) : io.removeEventListener('load', cb, false);
336
337			var ok = true;
338			try {
339				if (timedOut) {
340					throw 'timeout';
341				}
342
343				var isXml = s.dataType == 'xml' || doc.XMLDocument || $.isXMLDoc(doc);
344				log('isXml='+isXml);
345				if (!isXml && window.opera && (doc.body == null || doc.body.innerHTML == '')) {
346					if (--domCheckCount) {
347						// in some browsers (Opera) the iframe DOM is not always traversable when
348						// the onload callback fires, so we loop a bit to accommodate
349						log('requeing onLoad callback, DOM not available');
350						setTimeout(cb, 250);
351						return;
352					}
353					// let this fall through because server response could be an empty document
354					//log('Could not access iframe DOM after mutiple tries.');
355					//throw 'DOMException: not available';
356				}
357
358				//log('response detected');
359				xhr.responseText = doc.body ? doc.body.innerHTML : doc.documentElement ? doc.documentElement.innerHTML : null;
360				xhr.responseXML = doc.XMLDocument ? doc.XMLDocument : doc;
361				if (isXml)
362					s.dataType = 'xml';
363				xhr.getResponseHeader = function(header){
364					var headers = {'content-type': s.dataType};
365					return headers[header];
366				};
367				var scr = /(json|script|text)/.test(s.dataType);
368				if (scr || s.textarea) {
369					// see if user embedded response in textarea
370					var ta = doc.getElementsByTagName('textarea')[0];
371					if (ta) {
372						xhr.responseText = ta.value;
373					}
374					else if (scr) {
375						// account for browsers injecting pre around json response
376						var pre = doc.getElementsByTagName('pre')[0];
377						var b = doc.getElementsByTagName('body')[0];
378						if (pre) {
379							xhr.responseText = pre.textContent;
380						}
381						else if (b) {
382							xhr.responseText = b.innerHTML;
383						}
384					}
385				}
386				else if (s.dataType == 'xml' && !xhr.responseXML && xhr.responseText != null) {
387					xhr.responseXML = toXml(xhr.responseText);
388				}
389
390				data = httpData(xhr, s.dataType, s);
391			}
392			catch(e){
393				log('error caught:',e);
394				ok = false;

395				xhr.error = e;
396				s.error && s.error.call(s.context, xhr, 'error', e);
397				g && $.event.trigger("ajaxError", [xhr, s, e]);
398			}
399
400			if (xhr.aborted) {
401				log('upload aborted');
402				ok = false;
403			}
404
405			// ordering of these callbacks/triggers is odd, but that's how $.ajax does it
406			if (ok) {
407				s.success && s.success.call(s.context, data, 'success', xhr);
408				g && $.event.trigger("ajaxSuccess", [xhr, s]);
409			}
410
411			g && $.event.trigger("ajaxComplete", [xhr, s]);
412
413			if (g && ! --$.active) {
414				$.event.trigger("ajaxStop");
415			}
416
417			s.complete && s.complete.call(s.context, xhr, ok ? 'success' : 'error');
418
419			callbackProcessed = true;
420			if (s.timeout)
421				clearTimeout(timeoutHandle);
422
423			// clean up
424			setTimeout(function() {
425				$io.removeData('form-plugin-onload');
426				$io.remove();
427				xhr.responseXML = null;
428			}, 100);
429		}
430
431		var toXml = $.parseXML || function(s, doc) { // use parseXML if available (jQuery 1.5+)
432			if (window.ActiveXObject) {
433				doc = new ActiveXObject('Microsoft.XMLDOM');
434				doc.async = 'false';
435				doc.loadXML(s);
436			}
437			else {
438				doc = (new DOMParser()).parseFromString(s, 'text/xml');
439			}
440			return (doc && doc.documentElement && doc.documentElement.nodeName != 'parsererror') ? doc : null;
441		};
442		var parseJSON = $.parseJSON || function(s) {
443			return window['eval']('(' + s + ')');
444		};
445
446		var httpData = function( xhr, type, s ) { // mostly lifted from jq1.4.4
447
448			var ct = xhr.getResponseHeader('content-type') || '',
449				xml = type === 'xml' || !type && ct.indexOf('xml') >= 0,
450				data = xml ? xhr.responseXML : xhr.responseText;
451			if (xml && data.documentElement.nodeName === 'parsererror') {
452				$.error && $.error('parsererror');
453			}
454
455			if (s && s.dataFilter) {
456				data = s.dataFilter(data, type);
457			}
458			if (typeof data === 'string') {
459				if (type === 'json' || !type && ct.indexOf('json') >= 0) {
460					data = parseJSON(data);
461				} else if (type === "script" || !type && ct.indexOf("javascript") >= 0) {
462					$.globalEval(data);
463				}
464			}
465			return data;
466		};
467	}
468};
469
470/**
471 * ajaxForm() provides a mechanism for fully automating form submission.
472 *
473 * The advantages of using this method instead of ajaxSubmit() are:
474 *
475 * 1: This method will include coordinates for <input type="image" /> elements (if the element
476 *	is used to submit the form).
477 * 2. This method will include the submit element's name/value data (for the element that was
478 *	used to submit the form).
479 * 3. This method binds the submit() method to the form for you.
480 *
481 * The options argument for ajaxForm works exactly as it does for ajaxSubmit.  ajaxForm merely
482 * passes the options argument along after properly binding events for submit elements and
483 * the form itself.
484 */
485$.fn.ajaxForm = function(options) {
486	// in jQuery 1.3+ we can fix mistakes with the ready state
487	if (this.length === 0) {
488		var o = { s: this.selector, c: this.context };
489		if (!$.isReady && o.s) {
490			log('DOM not ready, queuing ajaxForm');
491			$(function() {
492				$(o.s,o.c).ajaxForm(options);
493			});
494			return this;
495		}
496		// is your DOM ready?  http://docs.jquery.com/Tutorials:Introducing_$(document).ready()
497		log('terminating; zero elements found by selector' + ($.isReady ? '' : ' (DOM not ready)'));
498		return this;
499	}
500
501	return this.ajaxFormUnbind().bind('submit.form-plugin', function(e) {
502		if (!e.isDefaultPrevented()) { // if event has been canceled, don't proceed
503			e.preventDefault();
504			$(this).ajaxSubmit(options);
505		}
506	}).bind('click.form-plugin', function(e) {
507		var target = e.target;
508		var $el = $(target);
509		if (!($el.is(":submit,input:image"))) {
510			// is this a child element of the submit el?  (ex: a span within a button)
511			var t = $el.closest(':submit');
512			if (t.length == 0) {
513				return;
514			}
515			target = t[0];
516		}
517		var form = this;
518		form.clk = target;
519		if (target.type == 'image') {
520			if (e.offsetX != undefined) {
521				form.clk_x = e.offsetX;
522				form.clk_y = e.offsetY;
523			} else if (typeof $.fn.offset == 'function') { // try to use dimensions plugin
524				var offset = $el.offset();
525				form.clk_x = e.pageX - offset.left;
526				form.clk_y = e.pageY - offset.top;
527			} else {
528				form.clk_x = e.pageX - target.offsetLeft;
529				form.clk_y = e.pageY - target.offsetTop;
530			}
531		}
532		// clear form vars
533		setTimeout(function() { form.clk = form.clk_x = form.clk_y = null; }, 100);
534	});
535};
536
537// ajaxFormUnbind unbinds the event handlers that were bound by ajaxForm
538$.fn.ajaxFormUnbind = function() {
539	return this.unbind('submit.form-plugin click.form-plugin');
540};
541
542/**
543 * formToArray() gathers form element data into an array of objects that can
544 * be passed to any of the following ajax functions: $.get, $.post, or load.
545 * Each object in the array has both a 'name' and 'value' property.  An example of
546 * an array for a simple login form might be:
547 *
548 * [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ]
549 *
550 * It is this array that is passed to pre-submit callback functions provided to the
551 * ajaxSubmit() and ajaxForm() methods.
552 */
553$.fn.formToArray = function(semantic) {
554	var a = [];
555	if (this.length === 0) {
556		return a;
557	}
558
559	var form = this[0];
560	var els = semantic ? form.getElementsByTagName('*') : form.elements;
561	if (!els) {
562		return a;
563	}
564
565	var i,j,n,v,el,max,jmax;
566	for(i=0, max=els.length; i < max; i++) {
567		el = els[i];
568		n = el.name;
569		if (!n) {
570			continue;
571		}
572
573		if (semantic && form.clk && el.type == "image") {
574			// handle image inputs on the fly when semantic == true
575			if(!el.disabled && form.clk == el) {
576				a.push({name: n, value: $(el).val()});
577				a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});
578			}
579			continue;
580		}
581
582		v = $.fieldValue(el, true);
583		if (v && v.constructor == Array) {
584			for(j=0, jmax=v.length; j < jmax; j++) {
585				a.push({name: n, value: v[j]});
586			}
587		}
588		else if (v !== null && typeof v != 'undefined') {
589			a.push({name: n, value: v});
590		}
591	}
592
593	if (!semantic && form.clk) {
594		// input type=='image' are not found in elements array! handle it here
595		var $input = $(form.clk), input = $input[0];
596		n = input.name;
597		if (n && !input.disabled && input.type == 'image') {
598			a.push({name: n, value: $input.val()});
599			a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});
600		}
601	}
602	return a;
603};
604
605/**
606 * Serializes form data into a 'submittable' string. This method will return a string
607 * in the format: name1=value1&amp;name2=value2
608 */

609$.fn.formSerialize = function(semantic) {
610	//hand off to jQuery.param for proper encoding
611	return $.param(this.formToArray(semantic));
612};
613
614/**
615 * Serializes all field elements in the jQuery object into a query string.
616 * This method will return a string in the format: name1=value1&name2=value2
617 */
618$.fn.fieldSerialize = function(successful) {
619	var a = [];
620	this.each(function() {
621		var n = this.name;
622		if (!n) {
623			return;
624		}
625		var v = $.fieldValue(this, ful);
626		if (v && v.constructor == Array) {
627			for (var i=0,max=v.length; i < max; i++) {
628				a.push({name: n, value: v[i]});
629			}
630		}
631		else if (v !== null && typeof v != 'undefined') {
632			a.push({name: this.name, value: v});
633		}
634	});
635	//hand off to jQuery.param for proper encoding
636	return $.param(a);
637};
638
639/**
640 * Returns the value(s) of the element in the matched set.  For example, consider the following form:
641 *
642 *  <form><fieldset>
643 *	  <input name="A" type="text" />
644 *	  <input name="A" type="text" />
645 *	  <input name="B" type="checkbox" value="B1" />
646 *	  <input name="B" type="checkbox" value="B2"/>
647 *	  <input name="C" type="radio" value="C1" />
648 *	  <input name="C" type="radio" value="C2" />
649 *  </fieldset></form>
650 *
651 *  var v = $(':text').fieldValue();
652 *  // if no values are entered into the text inputs
653 *  v == ['','']
654 *  // if values entered into the text inputs are 'foo' and 'bar'
655 *  v == ['foo','bar']
656 *
657 *  var v = $(':checkbox').fieldValue();
658 *  // if neither checkbox is checked
659 *  v === undefined
660 *  // if both checkboxes are checked
661 *  v == ['B1', 'B2']
662 *
663 *  var v = $(':radio').fieldValue();
664 *  // if neither radio is checked
665 *  v === undefined
666 *  // if first radio is checked
667 *  v == ['C1']
668 *
669 * The successful argument controls whether or not the field element must be 'successful'
670 * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
671 * The default value of the successful argument is true.  If this value is false the value(s)
672 * for each element is returned.
673 *
674 * Note: This method *always* returns an array.  If no valid value can be determined the
675 *	   array will be empty, otherwise it will contain one or more values.
676 */
677$.fn.fieldValue = function(successful) {
678	for (var val=[], i=0, max=this.length; i < max; i++) {
679		var el = this[i];
680		var v = $.fieldValue(el, successful);
681		if (v === null || typeof v == 'undefined' || (v.constructor == Array && !v.length)) {
682			continue;
683		}
684		v.constructor == Array ? $.merge(val, v) : val.push(v);
685	}
686	return val;
687};
688
689/**
690 * Returns the value of the field element.
691 */
692$.fieldValue = function(el, successful) {
693	var n = el.name, t = el.type, tag = el.tagName.toLowerCase();
694	if (successful === undefined) {
695		successful = true;
696	}
697
698	if (successful && (!n || el.disabled || t == 'reset' || t == 'button' ||
699		(t == 'checkbox' || t == 'radio') && !el.checked ||
700		(t == 'submit' || t == 'image') && el.form && el.form.clk != el ||
701		tag == 'select' && el.selectedIndex == -1)) {
702			return null;
703	}
704
705	if (tag == 'select') {
706		var index = el.selectedIndex;
707		if (index < 0) {
708			return null;
709		}
710		var a = [], ops = el.options;
711		var one = (t == 'select-one');
712		var max = (one ? index+1 : ops.length);
713		for(var i=(one ? index : 0); i < max; i++) {
714			var op = ops[i];
715			if (op.selected) {
716				var v = op.value;
717				if (!v) { // extra pain for IE...
718					v = (op.attributes && op.attributes['value'] && !(op.attributes['value'].specified)) ? op.text : op.value;
719				}
720				if (one) {
721					return v;
722				}
723				a.push(v);
724			}
725		}
726		return a;
727	}
728	return $(el).val();
729};
730
731/**
732 * Clears the form data.  Takes the following actions on the form's input fields:
733 *  - input text fields will have their 'value' property set to the empty string
734 *  - select elements will have their 'selectedIndex' property set to -1
735 *  - checkbox and radio inputs will have their 'checked' property set to false
736 *  - inputs of type submit, button, reset, and hidden will *not* be effected
737 *  - button elements will *not* be effected
738 */
739$.fn.clearForm = function() {
740	return this.each(function() {
741		$('input,select,textarea', this).clearFields();
742	});
743};
744
745/**
746 * Clears the selected form elements.
747 */
748$.fn.clearFields = $.fn.clearInputs = function() {
749	return this.each(function() {
750		var t = this.type, tag = this.tagName.toLowerCase();
751		if (t == 'text' || t == 'password' || tag == 'textarea') {
752			this.value = '';
753		}
754		else if (t == 'checkbox' || t == 'radio') {
755			this.checked = false;

756		}
757		else if (tag == 'select') {
758			this.selectedIndex = -1;
759		}
760	});
761};
762
763/**
764 * Resets the form data.  Causes all form elements to be reset to their original value.
765 */
766$.fn.resetForm = function() {
767	return this.each(function() {
768		// guard against an input with the name of 'reset'
769		// note that IE reports the reset function as an 'object'
770		if (typeof this.reset == 'function' || (typeof this.reset == 'object' && !this.reset.nodeType)) {
771			this.reset();
772		}
773	});
774};
775
776/**
777 * Enables or disables any matching elements.
778 */
779$.fn.enable = function(b) {
780	if (b === undefined) {
781		b = true;
782	}
783	return this.each(function() {
784		this.disabled = !b;
785	});
786};
787
788/**
789 * Checks/unchecks any matching checkboxes or radio buttons and
790 * selects/deselects and matching option elements.
791 */
792$.fn.selected = function(select) {
793	if (select === undefined) {
794		select = true;
795	}
796	return this.each(function() {
797		var t = this.type;
798		if (t == 'checkbox' || t == 'radio') {
799			this.checked = select;
800		}
801		else if (this.tagName.toLowerCase() == 'option') {
802			var $sel = $(this).parent('select');
803			if (select && $sel[0] && $sel[0].type == 'select-one') {
804				// deselect all other options
805				$sel.find('option').selected(false);
806			}
807			this.selected = select;
808		}
809	});
810};
811
812// helper fn for console logging
813// set $.fn.ajaxSubmit.debug to true to enable debug logging
814function log() {
815	if ($.fn.ajaxSubmit.debug) {
816		var msg = '[jquery.form] ' + Array.prototype.join.call(arguments,'');
817		if (window.console && window.console.log) {
818			window.console.log(msg);
819		}
820		else if (window.opera && window.opera.postError) {
821			window.opera.postError(msg);
822		}
823	}
824};
825
826})($);