wp-includes/js/jquery/jquery.form.dev.js

   1 /*
   2  * jQuery Form Plugin
   3  * version: 2.02 (12/16/2007)
   4  * @requires jQuery v1.1 or later
   5  *
   6  * Examples 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  * Revision: $Id$
  12  */
  13  (function($) {
  14 /**
  15  * ajaxSubmit() provides a mechanism for submitting an HTML form using AJAX.
  16  *
  17  * ajaxSubmit accepts a single argument which can be either a success callback function
  18  * or an options Object.  If a function is provided it will be invoked upon successful
  19  * completion of the submit and will be passed the response from the server.
  20  * If an options Object is provided, the following attributes are supported:
  21  *
  22  *  target:   Identifies the element(s) in the page to be updated with the server response.
  23  *            This value may be specified as a jQuery selection string, a jQuery object,
  24  *            or a DOM element.
  25  *            default value: null
  26  *
  27  *  url:      URL to which the form data will be submitted.
  28  *            default value: value of form's 'action' attribute
  29  *
  30  *  type:     The method in which the form data should be submitted, 'GET' or 'POST'.
  31  *            default value: value of form's 'method' attribute (or 'GET' if none found)
  32  *
  33  *  data:     Additional data to add to the request, specified as key/value pairs (see $.ajax).
  34  *
  35  *  beforeSubmit:  Callback method to be invoked before the form is submitted.
  36  *            default value: null
  37  *
  38  *  success:  Callback method to be invoked after the form has been successfully submitted
  39  *            and the response has been returned from the server
  40  *            default value: null
  41  *
  42  *  dataType: Expected dataType of the response.  One of: null, 'xml', 'script', or 'json'
  43  *            default value: null
  44  *
  45  *  semantic: Boolean flag indicating whether data must be submitted in semantic order (slower).
  46  *            default value: false
  47  *
  48  *  resetForm: Boolean flag indicating whether the form should be reset if the submit is successful
  49  *
  50  *  clearForm: Boolean flag indicating whether the form should be cleared if the submit is successful
  51  *
  52  *
  53  * The 'beforeSubmit' callback can be provided as a hook for running pre-submit logic or for
  54  * validating the form data.  If the 'beforeSubmit' callback returns false then the form will
  55  * not be submitted. The 'beforeSubmit' callback is invoked with three arguments: the form data
  56  * in array format, the jQuery object, and the options object passed into ajaxSubmit.
  57  * The form data array takes the following form:
  58  *
  59  *     [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ]
  60  *
  61  * If a 'success' callback method is provided it is invoked after the response has been returned
  62  * from the server.  It is passed the responseText or responseXML value (depending on dataType).
  63  * See jQuery.ajax for further details.
  64  *
  65  *
  66  * The dataType option provides a means for specifying how the server response should be handled.
  67  * This maps directly to the jQuery.httpData method.  The following values are supported:
  68  *
  69  *      'xml':    if dataType == 'xml' the server response is treated as XML and the 'success'
  70  *                   callback method, if specified, will be passed the responseXML value
  71  *      'json':   if dataType == 'json' the server response will be evaluted and passed to
  72  *                   the 'success' callback, if specified
  73  *      'script': if dataType == 'script' the server response is evaluated in the global context
  74  *
  75  *
  76  * Note that it does not make sense to use both the 'target' and 'dataType' options.  If both
  77  * are provided the target will be ignored.
  78  *
  79  * The semantic argument can be used to force form serialization in semantic order.
  80  * This is normally true anyway, unless the form contains input elements of type='image'.
  81  * If your form must be submitted with name/value pairs in semantic order and your form
  82  * contains an input of type='image" then pass true for this arg, otherwise pass false
  83  * (or nothing) to avoid the overhead for this logic.
  84  *
  85  *
  86  * When used on its own, ajaxSubmit() is typically bound to a form's submit event like this:
  87  *
  88  * $("#form-id").submit(function() {
  89  *     $(this).ajaxSubmit(options);
  90  *     return false; // cancel conventional submit
  91  * });
  92  *
  93  * When using ajaxForm(), however, this is done for you.
  94  *
  95  * @example
  96  * $('#myForm').ajaxSubmit(function(data) {
  97  *     alert('Form submit succeeded! Server returned: ' + data);
  98  * });
  99  * @desc Submit form and alert server response
 100  *
 101  *
 102  * @example
 103  * var options = {
 104  *     target: '#myTargetDiv'
 105  * };
 106  * $('#myForm').ajaxSubmit(options);
 107  * @desc Submit form and update page element with server response
 108  *
 109  *
 110  * @example
 111  * var options = {
 112  *     success: function(responseText) {
 113  *         alert(responseText);
 114  *     }
 115  * };
 116  * $('#myForm').ajaxSubmit(options);
 117  * @desc Submit form and alert the server response
 118  *
 119  *
 120  * @example
 121  * var options = {
 122  *     beforeSubmit: function(formArray, jqForm) {
 123  *         if (formArray.length == 0) {
 124  *             alert('Please enter data.');
 125  *             return false;
 126  *         }
 127  *     }
 128  * };
 129  * $('#myForm').ajaxSubmit(options);
 130  * @desc Pre-submit validation which aborts the submit operation if form data is empty
 131  *
 132  *
 133  * @example
 134  * var options = {
 135  *     url: myJsonUrl.php,
 136  *     dataType: 'json',
 137  *     success: function(data) {
 138  *        // 'data' is an object representing the the evaluated json data
 139  *     }
 140  * };
 141  * $('#myForm').ajaxSubmit(options);
 142  * @desc json data returned and evaluated
 143  *
 144  *
 145  * @example
 146  * var options = {
 147  *     url: myXmlUrl.php,
 148  *     dataType: 'xml',
 149  *     success: function(responseXML) {
 150  *        // responseXML is XML document object
 151  *        var data = $('myElement', responseXML).text();
 152  *     }
 153  * };
 154  * $('#myForm').ajaxSubmit(options);
 155  * @desc XML data returned from server
 156  *
 157  *
 158  * @example
 159  * var options = {
 160  *     resetForm: true
 161  * };
 162  * $('#myForm').ajaxSubmit(options);
 163  * @desc submit form and reset it if successful
 164  *
 165  * @example
 166  * $('#myForm).submit(function() {
 167  *    $(this).ajaxSubmit();
 168  *    return false;
 169  * });
 170  * @desc Bind form's submit event to use ajaxSubmit
 171  *
 172  *
 173  * @name ajaxSubmit
 174  * @type jQuery
 175  * @param options  object literal containing options which control the form submission process
 176  * @cat Plugins/Form
 177  * @return jQuery
 178  */
 179 $.fn.ajaxSubmit = function(options) {
 180     if (typeof options == 'function')
 181         options = { success: options };
 182
 183     options = $.extend({
 184         url:  this.attr('action') || window.location.toString(),
 185         type: this.attr('method') || 'GET'
 186     }, options || {});
 187
 188     // hook for manipulating the form data before it is extracted;
 189     // convenient for use with rich editors like tinyMCE or FCKEditor
 190     var veto = {};
 191     $.event.trigger('form.pre.serialize', [this, options, veto]);
 192     if (veto.veto) return this;
 193
 194     var a = this.formToArray(options.semantic);
 195         if (options.data) {
 196             for (var n in options.data)
 197                 a.push( { name: n, value: options.data[n] } );
 198         }
 199
 200     // give pre-submit callback an opportunity to abort the submit
 201     if (options.beforeSubmit && options.beforeSubmit(a, this, options) === false) return this;
 202
 203     // fire vetoable 'validate' event
 204     $.event.trigger('form.submit.validate', [a, this, options, veto]);
 205     if (veto.veto) return this;
 206
 207     var q = $.param(a);//.replace(/%20/g,'+');
 208
 209     if (options.type.toUpperCase() == 'GET') {
 210         options.url += (options.url.indexOf('?') >= 0 ? '&' : '?') + q;
 211         options.data = null;  // data is null for 'get'
 212     }
 213     else
 214         options.data = q; // data is the query string for 'post'
 215
 216     var $form = this, callbacks = [];
 217     if (options.resetForm) callbacks.push(function() { $form.resetForm(); });
 218     if (options.clearForm) callbacks.push(function() { $form.clearForm(); });
 219
 220     // perform a load on the target only if dataType is not provided
 221     if (!options.dataType && options.target) {
 222         var oldSuccess = options.success || function(){};
 223         callbacks.push(function(data) {
 224             if (this.evalScripts)
 225                 $(options.target).attr("innerHTML", data).evalScripts().each(oldSuccess, arguments);
 226             else // jQuery v1.1.4
 227                 $(options.target).html(data).each(oldSuccess, arguments);
 228         });
 229     }
 230     else if (options.success)
 231         callbacks.push(options.success);
 232
 233     options.success = function(data, status) {
 234         for (var i=0, max=callbacks.length; i < max; i++)
 235             callbacks[i](data, status, $form);
 236     };
 237
 238     // are there files to upload?
 239     var files = $('input:file', this).fieldValue();
 240     var found = false;
 241     for (var j=0; j < files.length; j++)
 242         if (files[j])
 243             found = true;
 244
 245     // options.iframe allows user to force iframe mode
 246    if (options.iframe || found) {
 247        // hack to fix Safari hang (thanks to Tim Molendijk for this)
 248        // see:  http://groups.google.com/group/jquery-dev/browse_thread/thread/36395b7ab510dd5d
 249        if ($.browser.safari && options.closeKeepAlive)
 250            $.get(options.closeKeepAlive, fileUpload);
 251        else
 252            fileUpload();
 253        }
 254    else
 255        $.ajax(options);
 256
 257     // fire 'notify' event
 258     $.event.trigger('form.submit.notify', [this, options]);
 259     return this;
 260
 261
 262     // private function for handling file uploads (hat tip to YAHOO!)
 263     function fileUpload() {
 264         var form = $form[0];
 265         var opts = $.extend({}, $.ajaxSettings, options);
 266
 267         var id = 'jqFormIO' + $.fn.ajaxSubmit.counter++;
 268         var $io = $('<iframe id="' + id + '" name="' + id + '" />');
 269         var io = $io[0];
 270         var op8 = $.browser.opera && window.opera.version() < 9;
 271         if ($.browser.msie || op8) io.src = 'javascript:false;document.write("");';
 272         $io.css({ position: 'absolute', top: '-1000px', left: '-1000px' });
 273
 274         var xhr = { // mock object
 275             responseText: null,
 276             responseXML: null,
 277             status: 0,
 278             statusText: 'n/a',
 279             getAllResponseHeaders: function() {},
 280             getResponseHeader: function() {},
 281             setRequestHeader: function() {}
 282         };
 283
 284         var g = opts.global;
 285         // trigger ajax global events so that activity/block indicators work like normal
 286         if (g && ! $.active++) $.event.trigger("ajaxStart");
 287         if (g) $.event.trigger("ajaxSend", [xhr, opts]);
 288
 289         var cbInvoked = 0;
 290         var timedOut = 0;
 291
 292         // take a breath so that pending repaints get some cpu time before the upload starts
 293         setTimeout(function() {
 294             // make sure form attrs are set
 295             var encAttr = form.encoding ? 'encoding' : 'enctype';
 296             var t = $form.attr('target');
 297             $form.attr({
 298                 target:   id,
 299                 method:  'POST',
 300                 action:   opts.url
 301             });
 302             form[encAttr] = 'multipart/form-data';
 303
 304             // support timout
 305             if (opts.timeout)
 306                 setTimeout(function() { timedOut = true; cb(); }, opts.timeout);
 307
 308             // add iframe to doc and submit the form
 309             $io.appendTo('body');
 310             io.attachEvent ? io.attachEvent('onload', cb) : io.addEventListener('load', cb, false);
 311             form.submit();
 312             $form.attr('target', t); // reset target
 313         }, 10);
 314
 315         function cb() {
 316             if (cbInvoked++) return;
 317
 318             io.detachEvent ? io.detachEvent('onload', cb) : io.removeEventListener('load', cb, false);
 319
 320             var ok = true;
 321             try {
 322                 if (timedOut) throw 'timeout';
 323                 // extract the server response from the iframe
 324                 var data, doc;
 325                 doc = io.contentWindow ? io.contentWindow.document : io.contentDocument ? io.contentDocument : io.document;
 326                 xhr.responseText = doc.body ? doc.body.innerHTML : null;
 327                 xhr.responseXML = doc.XMLDocument ? doc.XMLDocument : doc;
 328
 329                 if (opts.dataType == 'json' || opts.dataType == 'script') {
 330                     var ta = doc.getElementsByTagName('textarea')[0];
 331                     data = ta ? ta.value : xhr.responseText;
 332                     if (opts.dataType == 'json')
 333                         eval("data = " + data);
 334                     else
 335                         $.globalEval(data);
 336                 }
 337                 else if (opts.dataType == 'xml') {
 338                     data = xhr.responseXML;
 339                     if (!data && xhr.responseText != null)
 340                         data = toXml(xhr.responseText);
 341                 }
 342                 else {
 343                     data = xhr.responseText;
 344                 }
 345             }
 346             catch(e){
 347                 ok = false;
 348                 $.handleError(opts, xhr, 'error', e);
 349             }
 350
 351             // ordering of these callbacks/triggers is odd, but that's how $.ajax does it
 352             if (ok) {
 353                 opts.success(data, 'success');
 354                 if (g) $.event.trigger("ajaxSuccess", [xhr, opts]);
 355             }
 356             if (g) $.event.trigger("ajaxComplete", [xhr, opts]);
 357             if (g && ! --$.active) $.event.trigger("ajaxStop");
 358             if (opts.complete) opts.complete(xhr, ok ? 'success' : 'error');
 359
 360             // clean up
 361             setTimeout(function() {
 362                 $io.remove();
 363                 xhr.responseXML = null;
 364             }, 100);
 365         };
 366
 367         function toXml(s, doc) {
 368             if (window.ActiveXObject) {
 369                 doc = new ActiveXObject('Microsoft.XMLDOM');
 370                 doc.async = 'false';
 371                 doc.loadXML(s);
 372             }
 373             else
 374                 doc = (new DOMParser()).parseFromString(s, 'text/xml');
 375             return (doc && doc.documentElement && doc.documentElement.tagName != 'parsererror') ? doc : null;
 376         };
 377     };
 378 };
 379 $.fn.ajaxSubmit.counter = 0; // used to create unique iframe ids
 380
 381 /**
 382  * ajaxForm() provides a mechanism for fully automating form submission.
 383  *
 384  * The advantages of using this method instead of ajaxSubmit() are:
 385  *
 386  * 1: This method will include coordinates for <input type="image" /> elements (if the element
 387  *    is used to submit the form).
 388  * 2. This method will include the submit element's name/value data (for the element that was
 389  *    used to submit the form).
 390  * 3. This method binds the submit() method to the form for you.
 391  *
 392  * Note that for accurate x/y coordinates of image submit elements in all browsers
 393  * you need to also use the "dimensions" plugin (this method will auto-detect its presence).
 394  *
 395  * The options argument for ajaxForm works exactly as it does for ajaxSubmit.  ajaxForm merely
 396  * passes the options argument along after properly binding events for submit elements and
 397  * the form itself.  See ajaxSubmit for a full description of the options argument.
 398  *
 399  *
 400  * @example
 401  * var options = {
 402  *     target: '#myTargetDiv'
 403  * };
 404  * $('#myForm').ajaxSForm(options);
 405  * @desc Bind form's submit event so that 'myTargetDiv' is updated with the server response
 406  *       when the form is submitted.
 407  *
 408  *
 409  * @example
 410  * var options = {
 411  *     success: function(responseText) {
 412  *         alert(responseText);
 413  *     }
 414  * };
 415  * $('#myForm').ajaxSubmit(options);
 416  * @desc Bind form's submit event so that server response is alerted after the form is submitted.
 417  *
 418  *
 419  * @example
 420  * var options = {
 421  *     beforeSubmit: function(formArray, jqForm) {
 422  *         if (formArray.length == 0) {
 423  *             alert('Please enter data.');
 424  *             return false;
 425  *         }
 426  *     }
 427  * };
 428  * $('#myForm').ajaxSubmit(options);
 429  * @desc Bind form's submit event so that pre-submit callback is invoked before the form
 430  *       is submitted.
 431  *
 432  *
 433  * @name   ajaxForm
 434  * @param  options  object literal containing options which control the form submission process
 435  * @return jQuery
 436  * @cat    Plugins/Form
 437  * @type   jQuery
 438  */
 439 $.fn.ajaxForm = function(options) {
 440     return this.ajaxFormUnbind().submit(submitHandler).each(function() {
 441         // store options in hash
 442         this.formPluginId = $.fn.ajaxForm.counter++;
 443         $.fn.ajaxForm.optionHash[this.formPluginId] = options;
 444         $(":submit,input:image", this).click(clickHandler);
 445     });
 446 };
 447
 448 $.fn.ajaxForm.counter = 1;
 449 $.fn.ajaxForm.optionHash = {};
 450
 451 function clickHandler(e) {
 452     var $form = this.form;
 453     $form.clk = this;
 454     if (this.type == 'image') {
 455         if (e.offsetX != undefined) {
 456             $form.clk_x = e.offsetX;
 457             $form.clk_y = e.offsetY;
 458         } else if (typeof $.fn.offset == 'function') { // try to use dimensions plugin
 459             var offset = $(this).offset();
 460             $form.clk_x = e.pageX - offset.left;
 461             $form.clk_y = e.pageY - offset.top;
 462         } else {
 463             $form.clk_x = e.pageX - this.offsetLeft;
 464             $form.clk_y = e.pageY - this.offsetTop;
 465         }
 466     }
 467     // clear form vars
 468     setTimeout(function() { $form.clk = $form.clk_x = $form.clk_y = null; }, 10);
 469 };
 470
 471 function submitHandler() {
 472     // retrieve options from hash
 473     var id = this.formPluginId;
 474     var options = $.fn.ajaxForm.optionHash[id];
 475     $(this).ajaxSubmit(options);
 476     return false;
 477 };
 478
 479 /**
 480  * ajaxFormUnbind unbinds the event handlers that were bound by ajaxForm
 481  *
 482  * @name   ajaxFormUnbind
 483  * @return jQuery
 484  * @cat    Plugins/Form
 485  * @type   jQuery
 486  */
 487 $.fn.ajaxFormUnbind = function() {
 488     this.unbind('submit', submitHandler);
 489     return this.each(function() {
 490         $(":submit,input:image", this).unbind('click', clickHandler);
 491     });
 492
 493 };
 494
 495 /**
 496  * formToArray() gathers form element data into an array of objects that can
 497  * be passed to any of the following ajax functions: $.get, $.post, or load.
 498  * Each object in the array has both a 'name' and 'value' property.  An example of
 499  * an array for a simple login form might be:
 500  *
 501  * [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ]
 502  *
 503  * It is this array that is passed to pre-submit callback functions provided to the
 504  * ajaxSubmit() and ajaxForm() methods.
 505  *
 506  * The semantic argument can be used to force form serialization in semantic order.
 507  * This is normally true anyway, unless the form contains input elements of type='image'.
 508  * If your form must be submitted with name/value pairs in semantic order and your form
 509  * contains an input of type='image" then pass true for this arg, otherwise pass false
 510  * (or nothing) to avoid the overhead for this logic.
 511  *
 512  * @example var data = $("#myForm").formToArray();
 513  * $.post( "myscript.cgi", data );
 514  * @desc Collect all the data from a form and submit it to the server.
 515  *
 516  * @name formToArray
 517  * @param semantic true if serialization must maintain strict semantic ordering of elements (slower)
 518  * @type Array<Object>
 519  * @cat Plugins/Form
 520  */
 521 $.fn.formToArray = function(semantic) {
 522     var a = [];
 523     if (this.length == 0) return a;
 524
 525     var form = this[0];
 526     var els = semantic ? form.getElementsByTagName('*') : form.elements;
 527     if (!els) return a;
 528     for(var i=0, max=els.length; i < max; i++) {
 529         var el = els[i];
 530         var n = el.name;
 531         if (!n) continue;
 532
 533         if (semantic && form.clk && el.type == "image") {
 534             // handle image inputs on the fly when semantic == true
 535             if(!el.disabled && form.clk == el)
 536                 a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});
 537             continue;
 538         }
 539
 540         var v = $.fieldValue(el, true);
 541         if (v && v.constructor == Array) {
 542             for(var j=0, jmax=v.length; j < jmax; j++)
 543                 a.push({name: n, value: v[j]});
 544         }
 545         else if (v !== null && typeof v != 'undefined')
 546             a.push({name: n, value: v});
 547     }
 548
 549     if (!semantic && form.clk) {
 550         // input type=='image' are not found in elements array! handle them here
 551         var inputs = form.getElementsByTagName("input");
 552         for(var i=0, max=inputs.length; i < max; i++) {
 553             var input = inputs[i];
 554             var n = input.name;
 555             if(n && !input.disabled && input.type == "image" && form.clk == input)
 556                 a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});
 557         }
 558     }
 559     return a;
 560 };
 561
 562
 563 /**
 564  * Serializes form data into a 'submittable' string. This method will return a string
 565  * in the format: name1=value1&amp;name2=value2
 566  *
 567  * The semantic argument can be used to force form serialization in semantic order.
 568  * If your form must be submitted with name/value pairs in semantic order then pass
 569  * true for this arg, otherwise pass false (or nothing) to avoid the overhead for
 570  * this logic (which can be significant for very large forms).
 571  *
 572  * @example var data = $("#myForm").formSerialize();
 573  * $.ajax('POST', "myscript.cgi", data);
 574  * @desc Collect all the data from a form into a single string
 575  *
 576  * @name formSerialize
 577  * @param semantic true if serialization must maintain strict semantic ordering of elements (slower)
 578  * @type String
 579  * @cat Plugins/Form
 580  */
 581 $.fn.formSerialize = function(semantic) {
 582     //hand off to jQuery.param for proper encoding
 583     return $.param(this.formToArray(semantic));
 584 };
 585
 586
 587 /**
 588  * Serializes all field elements in the jQuery object into a query string.
 589  * This method will return a string in the format: name1=value1&amp;name2=value2
 590  *
 591  * The successful argument controls whether or not serialization is limited to
 592  * 'successful' controls (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
 593  * The default value of the successful argument is true.
 594  *
 595  * @example var data = $("input").formSerialize();
 596  * @desc Collect the data from all successful input elements into a query string
 597  *
 598  * @example var data = $(":radio").formSerialize();
 599  * @desc Collect the data from all successful radio input elements into a query string
 600  *
 601  * @example var data = $("#myForm :checkbox").formSerialize();
 602  * @desc Collect the data from all successful checkbox input elements in myForm into a query string
 603  *
 604  * @example var data = $("#myForm :checkbox").formSerialize(false);
 605  * @desc Collect the data from all checkbox elements in myForm (even the unchecked ones) into a query string
 606  *
 607  * @example var data = $(":input").formSerialize();
 608  * @desc Collect the data from all successful input, select, textarea and button elements into a query string
 609  *
 610  * @name fieldSerialize
 611  * @param successful true if only successful controls should be serialized (default is true)
 612  * @type String
 613  * @cat Plugins/Form
 614  */
 615 $.fn.fieldSerialize = function(successful) {
 616     var a = [];
 617     this.each(function() {
 618         var n = this.name;
 619         if (!n) return;
 620         var v = $.fieldValue(this, successful);
 621         if (v && v.constructor == Array) {
 622             for (var i=0,max=v.length; i < max; i++)
 623                 a.push({name: n, value: v[i]});
 624         }
 625         else if (v !== null && typeof v != 'undefined')
 626             a.push({name: this.name, value: v});
 627     });
 628     //hand off to jQuery.param for proper encoding
 629     return $.param(a);
 630 };
 631
 632
 633 /**
 634  * Returns the value(s) of the element in the matched set.  For example, consider the following form:
 635  *
 636  *  <form><fieldset>
 637  *      <input name="A" type="text" />
 638  *      <input name="A" type="text" />
 639  *      <input name="B" type="checkbox" value="B1" />
 640  *      <input name="B" type="checkbox" value="B2"/>
 641  *      <input name="C" type="radio" value="C1" />
 642  *      <input name="C" type="radio" value="C2" />
 643  *  </fieldset></form>
 644  *
 645  *  var v = $(':text').fieldValue();
 646  *  // if no values are entered into the text inputs
 647  *  v == ['','']
 648  *  // if values entered into the text inputs are 'foo' and 'bar'
 649  *  v == ['foo','bar']
 650  *
 651  *  var v = $(':checkbox').fieldValue();
 652  *  // if neither checkbox is checked
 653  *  v === undefined
 654  *  // if both checkboxes are checked
 655  *  v == ['B1', 'B2']
 656  *
 657  *  var v = $(':radio').fieldValue();
 658  *  // if neither radio is checked
 659  *  v === undefined
 660  *  // if first radio is checked
 661  *  v == ['C1']
 662  *
 663  * The successful argument controls whether or not the field element must be 'successful'
 664  * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
 665  * The default value of the successful argument is true.  If this value is false the value(s)
 666  * for each element is returned.
 667  *
 668  * Note: This method *always* returns an array.  If no valid value can be determined the
 669  *       array will be empty, otherwise it will contain one or more values.
 670  *
 671  * @example var data = $("#myPasswordElement").fieldValue();
 672  * alert(data[0]);
 673  * @desc Alerts the current value of the myPasswordElement element
 674  *
 675  * @example var data = $("#myForm :input").fieldValue();
 676  * @desc Get the value(s) of the form elements in myForm
 677  *
 678  * @example var data = $("#myForm :checkbox").fieldValue();
 679  * @desc Get the value(s) for the successful checkbox element(s) in the jQuery object.
 680  *
 681  * @example var data = $("#mySingleSelect").fieldValue();
 682  * @desc Get the value(s) of the select control
 683  *
 684  * @example var data = $(':text').fieldValue();
 685  * @desc Get the value(s) of the text input or textarea elements
 686  *
 687  * @example var data = $("#myMultiSelect").fieldValue();
 688  * @desc Get the values for the select-multiple control
 689  *
 690  * @name fieldValue
 691  * @param Boolean successful true if only the values for successful controls should be returned (default is true)
 692  * @type Array<String>
 693  * @cat Plugins/Form
 694  */
 695 $.fn.fieldValue = function(successful) {
 696     for (var val=[], i=0, max=this.length; i < max; i++) {
 697         var el = this[i];
 698         var v = $.fieldValue(el, successful);
 699         if (v === null || typeof v == 'undefined' || (v.constructor == Array && !v.length))
 700             continue;
 701         v.constructor == Array ? $.merge(val, v) : val.push(v);
 702     }
 703     return val;
 704 };
 705
 706 /**
 707  * Returns the value of the field element.
 708  *
 709  * The successful argument controls whether or not the field element must be 'successful'
 710  * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
 711  * The default value of the successful argument is true.  If the given element is not
 712  * successful and the successful arg is not false then the returned value will be null.
 713  *
 714  * Note: If the successful flag is true (default) but the element is not successful, the return will be null
 715  * Note: The value returned for a successful select-multiple element will always be an array.
 716  * Note: If the element has no value the return value will be undefined.
 717  *
 718  * @example var data = jQuery.fieldValue($("#myPasswordElement")[0]);
 719  * @desc Gets the current value of the myPasswordElement element
 720  *
 721  * @name fieldValue
 722  * @param Element el The DOM element for which the value will be returned
 723  * @param Boolean successful true if value returned must be for a successful controls (default is true)
 724  * @type String or Array<String> or null or undefined
 725  * @cat Plugins/Form
 726  */
 727 $.fieldValue = function(el, successful) {
 728     var n = el.name, t = el.type, tag = el.tagName.toLowerCase();
 729     if (typeof successful == 'undefined') successful = true;
 730
 731     if (successful && (!n || el.disabled || t == 'reset' || t == 'button' ||
 732         (t == 'checkbox' || t == 'radio') && !el.checked ||
 733         (t == 'submit' || t == 'image') && el.form && el.form.clk != el ||
 734         tag == 'select' && el.selectedIndex == -1))
 735             return null;
 736
 737     if (tag == 'select') {
 738         var index = el.selectedIndex;
 739         if (index < 0) return null;
 740         var a = [], ops = el.options;
 741         var one = (t == 'select-one');
 742         var max = (one ? index+1 : ops.length);
 743         for(var i=(one ? index : 0); i < max; i++) {
 744             var op = ops[i];
 745             if (op.selected) {
 746                 // extra pain for IE...
 747                 var v = $.browser.msie && !(op.attributes['value'].specified) ? op.text : op.value;
 748                 if (one) return v;
 749                 a.push(v);
 750             }
 751         }
 752         return a;
 753     }
 754     return el.value;
 755 };
 756
 757
 758 /**
 759  * Clears the form data.  Takes the following actions on the form's input fields:
 760  *  - input text fields will have their 'value' property set to the empty string
 761  *  - select elements will have their 'selectedIndex' property set to -1
 762  *  - checkbox and radio inputs will have their 'checked' property set to false
 763  *  - inputs of type submit, button, reset, and hidden will *not* be effected
 764  *  - button elements will *not* be effected
 765  *
 766  * @example $('form').clearForm();
 767  * @desc Clears all forms on the page.
 768  *
 769  * @name clearForm
 770  * @type jQuery
 771  * @cat Plugins/Form
 772  */
 773 $.fn.clearForm = function() {
 774     return this.each(function() {
 775         $('input,select,textarea', this).clearFields();
 776     });
 777 };
 778
 779 /**
 780  * Clears the selected form elements.  Takes the following actions on the matched elements:
 781  *  - input text fields will have their 'value' property set to the empty string
 782  *  - select elements will have their 'selectedIndex' property set to -1
 783  *  - checkbox and radio inputs will have their 'checked' property set to false
 784  *  - inputs of type submit, button, reset, and hidden will *not* be effected
 785  *  - button elements will *not* be effected
 786  *
 787  * @example $('.myInputs').clearFields();
 788  * @desc Clears all inputs with class myInputs
 789  *
 790  * @name clearFields
 791  * @type jQuery
 792  * @cat Plugins/Form
 793  */
 794 $.fn.clearFields = $.fn.clearInputs = function() {
 795     return this.each(function() {
 796         var t = this.type, tag = this.tagName.toLowerCase();
 797         if (t == 'text' || t == 'password' || tag == 'textarea')
 798             this.value = '';
 799         else if (t == 'checkbox' || t == 'radio')
 800             this.checked = false;
 801         else if (tag == 'select')
 802             this.selectedIndex = -1;
 803     });
 804 };
 805
 806
 807 /**
 808  * Resets the form data.  Causes all form elements to be reset to their original value.
 809  *
 810  * @example $('form').resetForm();
 811  * @desc Resets all forms on the page.
 812  *
 813  * @name resetForm
 814  * @type jQuery
 815  * @cat Plugins/Form
 816  */
 817 $.fn.resetForm = function() {
 818     return this.each(function() {
 819         // guard against an input with the name of 'reset'
 820         // note that IE reports the reset function as an 'object'
 821         if (typeof this.reset == 'function' || (typeof this.reset == 'object' && !this.reset.nodeType))
 822             this.reset();
 823     });
 824 };
 825
 826
 827 /**
 828  * Enables or disables any matching elements.
 829  *
 830  * @example $(':radio').enabled(false);
 831  * @desc Disables all radio buttons
 832  *
 833  * @name select
 834  * @type jQuery
 835  * @cat Plugins/Form
 836  */
 837 $.fn.enable = function(b) {
 838     if (b == undefined) b = true;
 839     return this.each(function() {
 840         this.disabled = !b
 841     });
 842 };
 843
 844 /**
 845  * Checks/unchecks any matching checkboxes or radio buttons and
 846  * selects/deselects and matching option elements.
 847  *
 848  * @example $(':checkbox').selected();
 849  * @desc Checks all checkboxes
 850  *
 851  * @name select
 852  * @type jQuery
 853  * @cat Plugins/Form
 854  */
 855 $.fn.select = function(select) {
 856     if (select == undefined) select = true;
 857     return this.each(function() {
 858         var t = this.type;
 859         if (t == 'checkbox' || t == 'radio')
 860             this.checked = select;
 861         else if (this.tagName.toLowerCase() == 'option') {
 862             var $sel = $(this).parent('select');
 863             if (select && $sel[0] && $sel[0].type == 'select-one') {
 864                 // deselect all other options
 865                 $sel.find('option').select(false);
 866             }
 867             this.selected = select;
 868         }
 869     });
 870 };
 871
 872 })(jQuery);