https://www.thisandroidlife.com/wp-content/plugins/contact-form-7/jquery.form_ver-2.52.js

1/*!
2 * jQuery Form Plugin
3 * version: 2.52 (07-DEC-2010)
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		type: this.attr('method') || 'GET',
68		iframeSrc: /^https/i.test(window.location.href || '') ? 'javascript:false' : 'about:blank'
69	}, options);
70
71	// hook for manipulating the form data before it is extracted;
72	// convenient for use with rich editors like tinyMCE or FCKEditor
73	var veto = {};
74	this.trigger('form-pre-serialize', [this, options, veto]);
75	if (veto.veto) {
76		log('ajaxSubmit: submit vetoed via form-pre-serialize trigger');
77		return this;
78	}
79
80	// provide opportunity to alter form data before it is serialized
81	if (options.beforeSerialize && options.beforeSerialize(this, options) === false) {
82		log('ajaxSubmit: submit aborted via beforeSerialize callback');
83		return this;
84	}
85
86	var n,v,a = this.formToArray(options.semantic);
87	if (options.data) {
88		options.extraData = options.data;
89		for (n in options.data) {
90			if(options.data[n] instanceof Array) {
91				for (var k in options.data[n]) {
92					a.push( { name: n, value: options.data[n][k] } );
93				}
94			}
95			else {
96				v = options.data[n];
97				v = $.isFunction(v) ? v() : v; // if value is fn, invoke it
98				a.push( { name: n, value: v } );
99			}
100		}
101	}
102
103	// give pre-submit callback an opportunity to abort the submit
104	if (options.beforeSubmit && options.beforeSubmit(a, this, options) === false) {
105		log('ajaxSubmit: submit aborted via beforeSubmit callback');
106		return this;
107	}
108
109	// fire vetoable 'validate' event
110	this.trigger('form-submit-validate', [a, this, options, veto]);
111	if (veto.veto) {
112		log('ajaxSubmit: submit vetoed via form-submit-validate trigger');
113		return this;
114	}
115
116	var q = $.param(a);
117
118	if (options.type.toUpperCase() == 'GET') {
119		options.url += (options.url.indexOf('?') >= 0 ? '&' : '?') + q;
120		options.data = null;  // data is null for 'get'
121	}
122	else {
123		options.data = q; // data is the query string for 'post'
124	}
125
126	var $form = this, callbacks = [];
127	if (options.resetForm) {
128		callbacks.push(function() { $form.resetForm(); });
129	}
130	if (options.clearForm) {
131		callbacks.push(function() { $form.clearForm(); });
132	}
133
134	// perform a load on the target only if dataType is not provided
135	if (!options.dataType && options.target) {
136		var oldSuccess = options.success || function(){};
137		callbacks.push(function(data) {
138			var fn = options.replaceTarget ? 'replaceWith' : 'html';
139			$(options.target)[fn](data).each(oldSuccess, arguments);
140		});
141	}
142	else if (options.success) {
143		callbacks.push(options.success);
144	}
145
146	options.success = function(data, status, xhr) { // jQuery 1.4+ passes xhr as 3rd arg
147		var context = options.context || options;   // jQuery 1.4+ supports scope context 
148		for (var i=0, max=callbacks.length; i < max; i++) {
149			callbacks[i].apply(context, [data, status, xhr || $form, $form]);
150		}
151	};
152
153	// are there files to upload?
154	var fileInputs = $('input:file', this).length > 0;
155	var mp = 'multipart/form-data';
156	var multipart = ($form.attr('enctype') == mp || $form.attr('encoding') == mp);
157
158	// options.iframe allows user to force iframe mode
159	// 06-NOV-09: now defaulting to iframe mode if file input is detected
160   if (options.iframe !== false && (fileInputs || options.iframe || multipart)) {
161	   // hack to fix Safari hang (thanks to Tim Molendijk for this)
162	   // see:  http://groups.google.com/group/jquery-dev/browse_thread/thread/36395b7ab510dd5d
163	   if (options.closeKeepAlive) {
164		   $.get(options.closeKeepAlive, fileUpload);
165		}
166	   else {
167		   fileUpload();
168		}
169   }
170   else {
171	   $.ajax(options);
172   }
173
174	// fire 'notify' event
175	this.trigger('form-submit-notify', [this, options]);
176	return this;
177
178
179	// private function for handling file uploads (hat tip to YAHOO!)
180	function fileUpload() {
181		var form = $form[0];
182
183		if ($(':input[name=submit],:input[id=submit]', form).length) {
184			// if there is an input with a name or id of 'submit' then we won't be
185			// able to invoke the submit fn on the form (at least not x-browser)
186			alert('Error: Form elements must not have name or id of "submit".');
187			return;
188		}
189		
190		var s = $.extend(true, {}, $.ajaxSettings, options);
191		s.context = s.context || s;
192		var id = 'jqFormIO' + (new Date().getTime()), fn = '_'+id;
193		window[fn] = function() {
194			var f = $io.data('form-plugin-onload');
195			if (f) {
196				f();
197				window[fn] = undefined;

198				try { delete window[fn]; } catch(e){}
199			}
200		}
201		var $io = $('<iframe id="' + id + '" name="' + id + '" src="'+ s.iframeSrc +'" onload="window[\'_\'+this.id]()" />');
202		var io = $io[0];
203
204		$io.css({ position: 'absolute', top: '-1000px', left: '-1000px' });
205
206		var xhr = { // mock object
207			aborted: 0,
208			responseText: null,
209			responseXML: null,
210			status: 0,
211			statusText: 'n/a',
212			getAllResponseHeaders: function() {},
213			getResponseHeader: function() {},
214			setRequestHeader: function() {},
215			abort: function() {
216				this.aborted = 1;
217				$io.attr('src', s.iframeSrc); // abort op in progress
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 cbInvoked = false;
241		var timedOut = 0;
242
243		// add submitting element to data if we know it
244		var sub = form.clk;
245		if (sub) {
246			var n = sub.name;
247			if (n && !sub.disabled) {
248				s.extraData = s.extraData || {};
249				s.extraData[n] = sub.value;
250				if (sub.type == "image") {
251					s.extraData[n+'.x'] = form.clk_x;
252					s.extraData[n+'.y'] = form.clk_y;
253				}
254			}
255		}
256
257		// take a breath so that pending repaints get some cpu time before the upload starts
258		function doSubmit() {
259			// make sure form attrs are set
260			var t = $form.attr('target'), a = $form.attr('action');
261
262			// update form attrs in IE friendly way
263			form.setAttribute('target',id);
264			if (form.getAttribute('method') != 'POST') {
265				form.setAttribute('method', 'POST');
266			}
267			if (form.getAttribute('action') != s.url) {
268				form.setAttribute('action', s.url);
269			}
270
271			// ie borks in some cases when setting encoding
272			if (! s.skipEncodingOverride) {
273				$form.attr({
274					encoding: 'multipart/form-data',
275					enctype:  'multipart/form-data'
276				});
277			}
278
279			// support timout
280			if (s.timeout) {
281				setTimeout(function() { timedOut = true; cb(); }, s.timeout);
282			}
283
284			// add "extra" data to form if provided in options
285			var extraInputs = [];
286			try {
287				if (s.extraData) {
288					for (var n in s.extraData) {
289						extraInputs.push(
290							$('<input type="hidden" name="'+n+'" value="'+s.extraData[n]+'" />')
291								.appendTo(form)[0]);
292					}
293				}
294
295				// add iframe to doc and submit the form
296				$io.appendTo('body');
297				$io.data('form-plugin-onload', cb);
298				form.submit();
299			}
300			finally {
301				// reset attrs and remove "extra" input elements
302				form.setAttribute('action',a);
303				if(t) {
304					form.setAttribute('target', t);
305				} else {
306					$form.removeAttr('target');
307				}
308				$(extraInputs).remove();
309			}
310		}
311
312		if (s.forceSync) {
313			doSubmit();
314		}
315		else {
316			setTimeout(doSubmit, 10); // this lets dom updates render
317		}
318	
319		var data, doc, domCheckCount = 50;
320
321		function cb() {
322			if (cbInvoked) {
323				return;
324			}
325
326			$io.removeData('form-plugin-onload');
327			
328			var ok = true;
329			try {
330				if (timedOut) {
331					throw 'timeout';
332				}
333				// extract the server response from the iframe
334				doc = io.contentWindow ? io.contentWindow.document : io.contentDocument ? io.contentDocument : io.document;
335				
336				var isXml = s.dataType == 'xml' || doc.XMLDocument || $.isXMLDoc(doc);
337				log('isXml='+isXml);
338				if (!isXml && window.opera && (doc.body == null || doc.body.innerHTML == '')) {
339					if (--domCheckCount) {
340						// in some browsers (Opera) the iframe DOM is not always traversable when
341						// the onload callback fires, so we loop a bit to accommodate
342						log('requeing onLoad callback, DOM not available');
343						setTimeout(cb, 250);
344						return;
345					}
346					// let this fall through because server response could be an empty document
347					//log('Could not access iframe DOM after mutiple tries.');
348					//throw 'DOMException: not available';
349				}
350
351				//log('response detected');
352				cbInvoked = true;
353				xhr.responseText = doc.documentElement ? doc.documentElement.innerHTML : null; 
354				xhr.responseXML = doc.XMLDocument ? doc.XMLDocument : doc;
355				xhr.getResponseHeader = function(header){
356					var headers = {'content-type': s.dataType};
357					return headers[header];
358				};
359
360				var scr = /(json|script)/.test(s.dataType);
361				if (scr || s.textarea) {
362					// see if user embedded response in textarea
363					var ta = doc.getElementsByTagName('textarea')[0];
364					if (ta) {
365						xhr.responseText = ta.value;
366					}
367					else if (scr) {
368						// account for browsers injecting pre around json response
369						var pre = doc.getElementsByTagName('pre')[0];
370						var b = doc.getElementsByTagName('body')[0];
371						if (pre) {
372							xhr.responseText = pre.textContent;
373						}
374						else if (b) {
375							xhr.responseText = b.innerHTML;
376						}
377					}			  
378				}
379				else if (s.dataType == 'xml' && !xhr.responseXML && xhr.responseText != null) {
380					xhr.responseXML = toXml(xhr.responseText);
381				}
382				data = $.httpData(xhr, s.dataType);
383			}
384			catch(e){
385				log('error caught:',e);
386				ok = false;

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

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

721		}
722		else if (tag == 'select') {
723			this.selectedIndex = -1;
724		}
725	});
726};
727
728/**
729 * Resets the form data.  Causes all form elements to be reset to their original value.
730 */
731$.fn.resetForm = function() {
732	return this.each(function() {
733		// guard against an input with the name of 'reset'
734		// note that IE reports the reset function as an 'object'
735		if (typeof this.reset == 'function' || (typeof this.reset == 'object' && !this.reset.nodeType)) {
736			this.reset();
737		}
738	});
739};
740
741/**
742 * Enables or disables any matching elements.
743 */
744$.fn.enable = function(b) {
745	if (b === undefined) {
746		b = true;
747	}
748	return this.each(function() {
749		this.disabled = !b;
750	});
751};
752
753/**
754 * Checks/unchecks any matching checkboxes or radio buttons and
755 * selects/deselects and matching option elements.
756 */
757$.fn.selected = function(select) {
758	if (select === undefined) {
759		select = true;
760	}
761	return this.each(function() {
762		var t = this.type;
763		if (t == 'checkbox' || t == 'radio') {
764			this.checked = select;
765		}
766		else if (this.tagName.toLowerCase() == 'option') {
767			var $sel = $(this).parent('select');
768			if (select && $sel[0] && $sel[0].type == 'select-one') {
769				// deselect all other options
770				$sel.find('option').selected(false);
771			}
772			this.selected = select;
773		}
774	});
775};
776
777// helper fn for console logging
778// set $.fn.ajaxSubmit.debug to true to enable debug logging
779function log() {
780	if ($.fn.ajaxSubmit.debug) {
781		var msg = '[jquery.form] ' + Array.prototype.join.call(arguments,'');
782		if (window.console && window.console.log) {
783			window.console.log(msg);
784		}
785		else if (window.opera && window.opera.postError) {
786			window.opera.postError(msg);
787		}
788	}
789};
790
791})(jQuery);