[Summary view] [Print] [Text view]

   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          $.ajax(options);
 173     }
 174  
 175      // fire 'notify' event
 176      this.trigger('form-submit-notify', [this, options]);
 177      return this;
 178  
 179  
 180      // private function for handling file uploads (hat tip to YAHOO!)
 181  	function fileUpload() {
 182          var form = $form[0];
 183  
 184          if ($(':input[name=submit],:input[id=submit]', form).length) {
 185              // if there is an input with a name or id of 'submit' then we won't be
 186              // able to invoke the submit fn on the form (at least not x-browser)
 187              alert('Error: Form elements must not have name or id of "submit".');
 188              return;
 189          }
 190  
 191          var s = $.extend(true, {}, $.ajaxSettings, options);
 192          s.context = s.context || s;
 193          var id = 'jqFormIO' + (new Date().getTime()), fn = '_'+id;
 194          var $io = $('<iframe id="' + id + '" name="' + id + '" src="'+ s.iframeSrc +'" />');
 195          var io = $io[0];
 196  
 197          $io.css({ position: 'absolute', top: '-1000px', left: '-1000px' });
 198  
 199          var xhr = { // mock object
 200              aborted: 0,
 201              responseText: null,
 202              responseXML: null,
 203              status: 0,
 204              statusText: 'n/a',
 205              getAllResponseHeaders: function() {},
 206              getResponseHeader: function() {},
 207              setRequestHeader: function() {},
 208              abort: function(status) {
 209                  var e = (status === 'timeout' ? 'timeout' : 'aborted');
 210                  log('aborting upload... ' + e);
 211                  this.aborted = 1;
 212                  $io.attr('src', s.iframeSrc); // abort op in progress
 213                  xhr.error = e;
 214                  s.error && s.error.call(s.context, xhr, e, e);
 215                  g && $.event.trigger("ajaxError", [xhr, s, e]);
 216                  s.complete && s.complete.call(s.context, xhr, e);
 217              }
 218          };
 219  
 220          var g = s.global;
 221          // trigger ajax global events so that activity/block indicators work like normal
 222          if (g && ! $.active++) {
 223              $.event.trigger("ajaxStart");
 224          }
 225          if (g) {
 226              $.event.trigger("ajaxSend", [xhr, s]);
 227          }
 228  
 229          if (s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false) {
 230              if (s.global) {
 231                  $.active--;
 232              }
 233              return;
 234          }
 235          if (xhr.aborted) {
 236              return;
 237          }
 238  
 239          var timedOut = 0, timeoutHandle;
 240  
 241          // add submitting element to data if we know it
 242          var sub = form.clk;
 243          if (sub) {
 244              var n = sub.name;
 245              if (n && !sub.disabled) {
 246                  s.extraData = s.extraData || {};
 247                  s.extraData[n] = sub.value;
 248                  if (sub.type == "image") {
 249                      s.extraData[n+'.x'] = form.clk_x;
 250                      s.extraData[n+'.y'] = form.clk_y;
 251                  }
 252              }
 253          }
 254  
 255          // take a breath so that pending repaints get some cpu time before the upload starts
 256  		function doSubmit() {
 257              // make sure form attrs are set
 258              var t = $form.attr('target'), a = $form.attr('action');
 259  
 260              // update form attrs in IE friendly way
 261              form.setAttribute('target',id);
 262              if (form.getAttribute('method') != 'POST') {
 263                  form.setAttribute('method', 'POST');
 264              }
 265              if (form.getAttribute('action') != s.url) {
 266                  form.setAttribute('action', s.url);
 267              }
 268  
 269              // ie borks in some cases when setting encoding
 270              if (! s.skipEncodingOverride) {
 271                  $form.attr({
 272                      encoding: 'multipart/form-data',
 273                      enctype:  'multipart/form-data'
 274                  });
 275              }
 276  
 277              // support timout
 278              if (s.timeout) {
 279                  timeoutHandle = setTimeout(function() { timedOut = true; cb(true); }, s.timeout);
 280              }
 281  
 282              // add "extra" data to form if provided in options
 283              var extraInputs = [];
 284              try {
 285                  if (s.extraData) {
 286                      for (var n in s.extraData) {
 287                          extraInputs.push(
 288                              $('<input type="hidden" name="'+n+'" value="'+s.extraData[n]+'" />')
 289                                  .appendTo(form)[0]);
 290                      }
 291                  }
 292  
 293                  // add iframe to doc and submit the form
 294                  $io.appendTo('body');
 295                  io.attachEvent ? io.attachEvent('onload', cb) : io.addEventListener('load', cb, false);
 296                  form.submit();
 297              }
 298              finally {
 299                  // reset attrs and remove "extra" input elements
 300                  form.setAttribute('action',a);
 301                  if(t) {
 302                      form.setAttribute('target', t);
 303                  } else {
 304                      $form.removeAttr('target');
 305                  }
 306                  $(extraInputs).remove();
 307              }
 308          }
 309  
 310          if (s.forceSync) {
 311              doSubmit();
 312          }
 313          else {
 314              setTimeout(doSubmit, 10); // this lets dom updates render
 315          }
 316  
 317          var data, doc, domCheckCount = 50, callbackProcessed;
 318  
 319          function cb(e) {
 320              if (xhr.aborted || callbackProcessed) {
 321                  return;
 322              }
 323              if (e === true && xhr) {
 324                  xhr.abort('timeout');
 325                  return;
 326              }
 327  
 328              var doc = io.contentWindow ? io.contentWindow.document : io.contentDocument ? io.contentDocument : io.document;
 329              if (!doc || doc.location.href == s.iframeSrc) {
 330                  // response not received yet
 331                  if (!timedOut)
 332                      return;
 333              }
 334              io.detachEvent ? io.detachEvent('onload', cb) : io.removeEventListener('load', cb, false);
 335  
 336              var ok = true;
 337              try {
 338                  if (timedOut) {
 339                      throw 'timeout';
 340                  }
 341  
 342                  var isXml = s.dataType == 'xml' || doc.XMLDocument || $.isXMLDoc(doc);
 343                  log('isXml='+isXml);
 344                  if (!isXml && window.opera && (doc.body == null || doc.body.innerHTML == '')) {
 345                      if (--domCheckCount) {
 346                          // in some browsers (Opera) the iframe DOM is not always traversable when
 347                          // the onload callback fires, so we loop a bit to accommodate
 348                          log('requeing onLoad callback, DOM not available');
 349                          setTimeout(cb, 250);
 350                          return;
 351                      }
 352                      // let this fall through because server response could be an empty document
 353                      //log('Could not access iframe DOM after mutiple tries.');
 354                      //throw 'DOMException: not available';
 355                  }
 356  
 357                  //log('response detected');
 358                  xhr.responseText = doc.body ? doc.body.innerHTML : doc.documentElement ? doc.documentElement.innerHTML : null;
 359                  xhr.responseXML = doc.XMLDocument ? doc.XMLDocument : doc;
 360                  if (isXml)
 361                      s.dataType = 'xml';
 362                  xhr.getResponseHeader = function(header){
 363                      var headers = {'content-type': s.dataType};
 364                      return headers[header];
 365                  };
 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              var ct = xhr.getResponseHeader('content-type') || '',
 448                  xml = type === 'xml' || !type && ct.indexOf('xml') >= 0,
 449                  data = xml ? xhr.responseXML : xhr.responseText;
 450  
 451              if (xml && data.documentElement.nodeName === 'parsererror') {
 452                  $.error && $.error('parsererror');
 453              }
 454              if (s && s.dataFilter) {
 455                  data = s.dataFilter(data, type);
 456              }
 457              if (typeof data === 'string') {
 458                  if (type === 'json' || !type && ct.indexOf('json') >= 0) {
 459                      data = parseJSON(data);
 460                  } else if (type === "script" || !type && ct.indexOf("javascript") >= 0) {
 461                      $.globalEval(data);
 462                  }
 463              }
 464              return data;
 465          };
 466      }
 467  };
 468  
 469  /**
 470   * ajaxForm() provides a mechanism for fully automating form submission.
 471   *
 472   * The advantages of using this method instead of ajaxSubmit() are:
 473   *
 474   * 1: This method will include coordinates for <input type="image" /> elements (if the element
 475   *    is used to submit the form).
 476   * 2. This method will include the submit element's name/value data (for the element that was
 477   *    used to submit the form).
 478   * 3. This method binds the submit() method to the form for you.
 479   *
 480   * The options argument for ajaxForm works exactly as it does for ajaxSubmit.  ajaxForm merely
 481   * passes the options argument along after properly binding events for submit elements and
 482   * the form itself.
 483   */
 484  $.fn.ajaxForm = function(options) {
 485      // in jQuery 1.3+ we can fix mistakes with the ready state
 486      if (this.length === 0) {
 487          var o = { s: this.selector, c: this.context };
 488          if (!$.isReady && o.s) {
 489              log('DOM not ready, queuing ajaxForm');
 490              $(function() {
 491                  $(o.s,o.c).ajaxForm(options);
 492              });
 493              return this;
 494          }
 495          // is your DOM ready?  http://docs.jquery.com/Tutorials:Introducing_$(document).ready()
 496          log('terminating; zero elements found by selector' + ($.isReady ? '' : ' (DOM not ready)'));
 497          return this;
 498      }
 499  
 500      return this.ajaxFormUnbind().bind('submit.form-plugin', function(e) {
 501          if (!e.isDefaultPrevented()) { // if event has been canceled, don't proceed
 502              e.preventDefault();
 503              $(this).ajaxSubmit(options);
 504          }
 505      }).bind('click.form-plugin', function(e) {
 506          var target = e.target;
 507          var $el = $(target);
 508          if (!($el.is(":submit,input:image"))) {
 509              // is this a child element of the submit el?  (ex: a span within a button)
 510              var t = $el.closest(':submit');
 511              if (t.length == 0) {
 512                  return;
 513              }
 514              target = t[0];
 515          }
 516          var form = this;
 517          form.clk = target;
 518          if (target.type == 'image') {
 519              if (e.offsetX != undefined) {
 520                  form.clk_x = e.offsetX;
 521                  form.clk_y = e.offsetY;
 522              } else if (typeof $.fn.offset == 'function') { // try to use dimensions plugin
 523                  var offset = $el.offset();
 524                  form.clk_x = e.pageX - offset.left;
 525                  form.clk_y = e.pageY - offset.top;
 526              } else {
 527                  form.clk_x = e.pageX - target.offsetLeft;
 528                  form.clk_y = e.pageY - target.offsetTop;
 529              }
 530          }
 531          // clear form vars
 532          setTimeout(function() { form.clk = form.clk_x = form.clk_y = null; }, 100);
 533      });
 534  };
 535  
 536  // ajaxFormUnbind unbinds the event handlers that were bound by ajaxForm
 537  $.fn.ajaxFormUnbind = function() {
 538      return this.unbind('submit.form-plugin click.form-plugin');
 539  };
 540  
 541  /**
 542   * formToArray() gathers form element data into an array of objects that can
 543   * be passed to any of the following ajax functions: $.get, $.post, or load.
 544   * Each object in the array has both a 'name' and 'value' property.  An example of
 545   * an array for a simple login form might be:
 546   *
 547   * [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ]
 548   *
 549   * It is this array that is passed to pre-submit callback functions provided to the
 550   * ajaxSubmit() and ajaxForm() methods.
 551   */
 552  $.fn.formToArray = function(semantic) {
 553      var a = [];
 554      if (this.length === 0) {
 555          return a;
 556      }
 557  
 558      var form = this[0];
 559      var els = semantic ? form.getElementsByTagName('*') : form.elements;
 560      if (!els) {
 561          return a;
 562      }
 563  
 564      var i,j,n,v,el,max,jmax;
 565      for(i=0, max=els.length; i < max; i++) {
 566          el = els[i];
 567          n = el.name;
 568          if (!n) {
 569              continue;
 570          }
 571  
 572          if (semantic && form.clk && el.type == "image") {
 573              // handle image inputs on the fly when semantic == true
 574              if(!el.disabled && form.clk == el) {
 575                  a.push({name: n, value: $(el).val()});
 576                  a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});
 577              }
 578              continue;
 579          }
 580  
 581          v = $.fieldValue(el, true);
 582          if (v && v.constructor == Array) {
 583              for(j=0, jmax=v.length; j < jmax; j++) {
 584                  a.push({name: n, value: v[j]});
 585              }
 586          }
 587          else if (v !== null && typeof v != 'undefined') {
 588              a.push({name: n, value: v});
 589          }
 590      }
 591  
 592      if (!semantic && form.clk) {
 593          // input type=='image' are not found in elements array! handle it here
 594          var $input = $(form.clk), input = $input[0];
 595          n = input.name;
 596          if (n && !input.disabled && input.type == 'image') {
 597              a.push({name: n, value: $input.val()});
 598              a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});
 599          }
 600      }
 601      return a;
 602  };
 603  
 604  /**
 605   * Serializes form data into a 'submittable' string. This method will return a string
 606   * in the format: name1=value1&amp;name2=value2
 607   */
 608  $.fn.formSerialize = function(semantic) {
 609      //hand off to jQuery.param for proper encoding
 610      return $.param(this.formToArray(semantic));
 611  };
 612  
 613  /**
 614   * Serializes all field elements in the jQuery object into a query string.
 615   * This method will return a string in the format: name1=value1&amp;name2=value2
 616   */
 617  $.fn.fieldSerialize = function(successful) {
 618      var a = [];
 619      this.each(function() {
 620          var n = this.name;
 621          if (!n) {
 622              return;
 623          }
 624          var v = $.fieldValue(this, successful);
 625          if (v && v.constructor == Array) {
 626              for (var i=0,max=v.length; i < max; i++) {
 627                  a.push({name: n, value: v[i]});
 628              }
 629          }
 630          else if (v !== null && typeof v != 'undefined') {
 631              a.push({name: this.name, value: v});
 632          }
 633      });
 634      //hand off to jQuery.param for proper encoding
 635      return $.param(a);
 636  };
 637  
 638  /**
 639   * Returns the value(s) of the element in the matched set.  For example, consider the following form:
 640   *
 641   *  <form><fieldset>
 642   *      <input name="A" type="text" />
 643   *      <input name="A" type="text" />
 644   *      <input name="B" type="checkbox" value="B1" />
 645   *      <input name="B" type="checkbox" value="B2"/>
 646   *      <input name="C" type="radio" value="C1" />
 647   *      <input name="C" type="radio" value="C2" />
 648   *  </fieldset></form>
 649   *
 650   *  var v = $(':text').fieldValue();
 651   *  // if no values are entered into the text inputs
 652   *  v == ['','']
 653   *  // if values entered into the text inputs are 'foo' and 'bar'
 654   *  v == ['foo','bar']
 655   *
 656   *  var v = $(':checkbox').fieldValue();
 657   *  // if neither checkbox is checked
 658   *  v === undefined
 659   *  // if both checkboxes are checked
 660   *  v == ['B1', 'B2']
 661   *
 662   *  var v = $(':radio').fieldValue();
 663   *  // if neither radio is checked
 664   *  v === undefined
 665   *  // if first radio is checked
 666   *  v == ['C1']
 667   *
 668   * The successful argument controls whether or not the field element must be 'successful'
 669   * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
 670   * The default value of the successful argument is true.  If this value is false the value(s)
 671   * for each element is returned.
 672   *
 673   * Note: This method *always* returns an array.  If no valid value can be determined the
 674   *       array will be empty, otherwise it will contain one or more values.
 675   */
 676  $.fn.fieldValue = function(successful) {
 677      for (var val=[], i=0, max=this.length; i < max; i++) {
 678          var el = this[i];
 679          var v = $.fieldValue(el, successful);
 680          if (v === null || typeof v == 'undefined' || (v.constructor == Array && !v.length)) {
 681              continue;
 682          }
 683          v.constructor == Array ? $.merge(val, v) : val.push(v);
 684      }
 685      return val;
 686  };
 687  
 688  /**
 689   * Returns the value of the field element.
 690   */
 691  $.fieldValue = function(el, successful) {
 692      var n = el.name, t = el.type, tag = el.tagName.toLowerCase();
 693      if (successful === undefined) {
 694          successful = true;
 695      }
 696  
 697      if (successful && (!n || el.disabled || t == 'reset' || t == 'button' ||
 698          (t == 'checkbox' || t == 'radio') && !el.checked ||
 699          (t == 'submit' || t == 'image') && el.form && el.form.clk != el ||
 700          tag == 'select' && el.selectedIndex == -1)) {
 701              return null;
 702      }
 703  
 704      if (tag == 'select') {
 705          var index = el.selectedIndex;
 706          if (index < 0) {
 707              return null;
 708          }
 709          var a = [], ops = el.options;
 710          var one = (t == 'select-one');
 711          var max = (one ? index+1 : ops.length);
 712          for(var i=(one ? index : 0); i < max; i++) {
 713              var op = ops[i];
 714              if (op.selected) {
 715                  var v = op.value;
 716                  if (!v) { // extra pain for IE...
 717                      v = (op.attributes && op.attributes['value'] && !(op.attributes['value'].specified)) ? op.text : op.value;
 718                  }
 719                  if (one) {
 720                      return v;
 721                  }
 722                  a.push(v);
 723              }
 724          }
 725          return a;
 726      }
 727      return $(el).val();
 728  };
 729  
 730  /**
 731   * Clears the form data.  Takes the following actions on the form's input fields:
 732   *  - input text fields will have their 'value' property set to the empty string
 733   *  - select elements will have their 'selectedIndex' property set to -1
 734   *  - checkbox and radio inputs will have their 'checked' property set to false
 735   *  - inputs of type submit, button, reset, and hidden will *not* be effected
 736   *  - button elements will *not* be effected
 737   */
 738  $.fn.clearForm = function() {
 739      return this.each(function() {
 740          $('input,select,textarea', this).clearFields();
 741      });
 742  };
 743  
 744  /**
 745   * Clears the selected form elements.
 746   */
 747  $.fn.clearFields = $.fn.clearInputs = function() {
 748      return this.each(function() {
 749          var t = this.type, tag = this.tagName.toLowerCase();
 750          if (t == 'text' || t == 'password' || tag == 'textarea') {
 751              this.value = '';
 752          }
 753          else if (t == 'checkbox' || t == 'radio') {
 754              this.checked = false;
 755          }
 756          else if (tag == 'select') {
 757              this.selectedIndex = -1;
 758          }
 759      });
 760  };
 761  
 762  /**
 763   * Resets the form data.  Causes all form elements to be reset to their original value.
 764   */
 765  $.fn.resetForm = function() {
 766      return this.each(function() {
 767          // guard against an input with the name of 'reset'
 768          // note that IE reports the reset function as an 'object'
 769          if (typeof this.reset == 'function' || (typeof this.reset == 'object' && !this.reset.nodeType)) {
 770              this.reset();
 771          }
 772      });
 773  };
 774  
 775  /**
 776   * Enables or disables any matching elements.
 777   */
 778  $.fn.enable = function(b) {
 779      if (b === undefined) {
 780          b = true;
 781      }
 782      return this.each(function() {
 783          this.disabled = !b;
 784      });
 785  };
 786  
 787  /**
 788   * Checks/unchecks any matching checkboxes or radio buttons and
 789   * selects/deselects and matching option elements.
 790   */
 791  $.fn.selected = function(select) {
 792      if (select === undefined) {
 793          select = true;
 794      }
 795      return this.each(function() {
 796          var t = this.type;
 797          if (t == 'checkbox' || t == 'radio') {
 798              this.checked = select;
 799          }
 800          else if (this.tagName.toLowerCase() == 'option') {
 801              var $sel = $(this).parent('select');
 802              if (select && $sel[0] && $sel[0].type == 'select-one') {
 803                  // deselect all other options
 804                  $sel.find('option').selected(false);
 805              }
 806              this.selected = select;
 807          }
 808      });
 809  };
 810  
 811  // helper fn for console logging
 812  // set $.fn.ajaxSubmit.debug to true to enable debug logging
 813  function log() {
 814      if ($.fn.ajaxSubmit.debug) {
 815          var msg = '[jquery.form] ' + Array.prototype.join.call(arguments,'');
 816          if (window.console && window.console.log) {
 817              window.console.log(msg);
 818          }
 819          else if (window.opera && window.opera.postError) {
 820              window.opera.postError(msg);
 821          }
 822      }
 823  };
 824  
 825  })(jQuery);