|
1 /*! |
|
2 * jQuery Form Plugin |
|
3 * version: 3.37.0-2013.07.11 |
|
4 * @requires jQuery v1.5 or later |
|
5 * Copyright (c) 2013 M. Alsup |
|
6 * Examples and documentation at: http://malsup.com/jquery/form/ |
|
7 * Project repository: https://github.com/malsup/form |
|
8 * Dual licensed under the MIT and GPL licenses. |
|
9 * https://github.com/malsup/form#copyright-and-license |
|
10 */ |
|
11 /*global ActiveXObject */ |
|
12 ;(function($) { |
|
13 "use strict"; |
|
14 |
|
15 /* |
|
16 Usage Note: |
|
17 ----------- |
|
18 Do not use both ajaxSubmit and ajaxForm on the same form. These |
|
19 functions are mutually exclusive. Use ajaxSubmit if you want |
|
20 to bind your own submit handler to the form. For example, |
|
21 |
|
22 $(document).ready(function() { |
|
23 $('#myForm').on('submit', function(e) { |
|
24 e.preventDefault(); // <-- important |
|
25 $(this).ajaxSubmit({ |
|
26 target: '#output' |
|
27 }); |
|
28 }); |
|
29 }); |
|
30 |
|
31 Use ajaxForm when you want the plugin to manage all the event binding |
|
32 for you. For example, |
|
33 |
|
34 $(document).ready(function() { |
|
35 $('#myForm').ajaxForm({ |
|
36 target: '#output' |
|
37 }); |
|
38 }); |
|
39 |
|
40 You can also use ajaxForm with delegation (requires jQuery v1.7+), so the |
|
41 form does not have to exist when you invoke ajaxForm: |
|
42 |
|
43 $('#myForm').ajaxForm({ |
|
44 delegation: true, |
|
45 target: '#output' |
|
46 }); |
|
47 |
|
48 When using ajaxForm, the ajaxSubmit function will be invoked for you |
|
49 at the appropriate time. |
|
50 */ |
|
51 |
|
52 /** |
|
53 * Feature detection |
|
54 */ |
|
55 var feature = {}; |
|
56 feature.fileapi = $("<input type='file'/>").get(0).files !== undefined; |
|
57 feature.formdata = window.FormData !== undefined; |
|
58 |
|
59 var hasProp = !!$.fn.prop; |
|
60 |
|
61 // attr2 uses prop when it can but checks the return type for |
|
62 // an expected string. this accounts for the case where a form |
|
63 // contains inputs with names like "action" or "method"; in those |
|
64 // cases "prop" returns the element |
|
65 $.fn.attr2 = function() { |
|
66 if ( ! hasProp ) |
|
67 return this.attr.apply(this, arguments); |
|
68 var val = this.prop.apply(this, arguments); |
|
69 if ( ( val && val.jquery ) || typeof val === 'string' ) |
|
70 return val; |
|
71 return this.attr.apply(this, arguments); |
|
72 }; |
|
73 |
|
74 /** |
|
75 * ajaxSubmit() provides a mechanism for immediately submitting |
|
76 * an HTML form using AJAX. |
|
77 */ |
|
78 $.fn.ajaxSubmit = function(options) { |
|
79 /*jshint scripturl:true */ |
|
80 |
|
81 // fast fail if nothing selected (http://dev.jquery.com/ticket/2752) |
|
82 if (!this.length) { |
|
83 log('ajaxSubmit: skipping submit process - no element selected'); |
|
84 return this; |
|
85 } |
|
86 |
|
87 var method, action, url, $form = this; |
|
88 |
|
89 if (typeof options == 'function') { |
|
90 options = { success: options }; |
|
91 } |
|
92 else if ( options === undefined ) { |
|
93 options = {}; |
|
94 } |
|
95 |
|
96 method = options.type || this.attr2('method'); |
|
97 action = options.url || this.attr2('action'); |
|
98 |
|
99 url = (typeof action === 'string') ? $.trim(action) : ''; |
|
100 url = url || window.location.href || ''; |
|
101 if (url) { |
|
102 // clean url (don't include hash vaue) |
|
103 url = (url.match(/^([^#]+)/)||[])[1]; |
|
104 } |
|
105 |
|
106 options = $.extend(true, { |
|
107 url: url, |
|
108 success: $.ajaxSettings.success, |
|
109 type: method || 'GET', |
|
110 iframeSrc: /^https/i.test(window.location.href || '') ? 'javascript:false' : 'about:blank' |
|
111 }, options); |
|
112 |
|
113 // hook for manipulating the form data before it is extracted; |
|
114 // convenient for use with rich editors like tinyMCE or FCKEditor |
|
115 var veto = {}; |
|
116 this.trigger('form-pre-serialize', [this, options, veto]); |
|
117 if (veto.veto) { |
|
118 log('ajaxSubmit: submit vetoed via form-pre-serialize trigger'); |
|
119 return this; |
|
120 } |
|
121 |
|
122 // provide opportunity to alter form data before it is serialized |
|
123 if (options.beforeSerialize && options.beforeSerialize(this, options) === false) { |
|
124 log('ajaxSubmit: submit aborted via beforeSerialize callback'); |
|
125 return this; |
|
126 } |
|
127 |
|
128 var traditional = options.traditional; |
|
129 if ( traditional === undefined ) { |
|
130 traditional = $.ajaxSettings.traditional; |
|
131 } |
|
132 |
|
133 var elements = []; |
|
134 var qx, a = this.formToArray(options.semantic, elements); |
|
135 if (options.data) { |
|
136 options.extraData = options.data; |
|
137 qx = $.param(options.data, traditional); |
|
138 } |
|
139 |
|
140 // give pre-submit callback an opportunity to abort the submit |
|
141 if (options.beforeSubmit && options.beforeSubmit(a, this, options) === false) { |
|
142 log('ajaxSubmit: submit aborted via beforeSubmit callback'); |
|
143 return this; |
|
144 } |
|
145 |
|
146 // fire vetoable 'validate' event |
|
147 this.trigger('form-submit-validate', [a, this, options, veto]); |
|
148 if (veto.veto) { |
|
149 log('ajaxSubmit: submit vetoed via form-submit-validate trigger'); |
|
150 return this; |
|
151 } |
|
152 |
|
153 var q = $.param(a, traditional); |
|
154 if (qx) { |
|
155 q = ( q ? (q + '&' + qx) : qx ); |
|
156 } |
|
157 if (options.type.toUpperCase() == 'GET') { |
|
158 options.url += (options.url.indexOf('?') >= 0 ? '&' : '?') + q; |
|
159 options.data = null; // data is null for 'get' |
|
160 } |
|
161 else { |
|
162 options.data = q; // data is the query string for 'post' |
|
163 } |
|
164 |
|
165 var callbacks = []; |
|
166 if (options.resetForm) { |
|
167 callbacks.push(function() { $form.resetForm(); }); |
|
168 } |
|
169 if (options.clearForm) { |
|
170 callbacks.push(function() { $form.clearForm(options.includeHidden); }); |
|
171 } |
|
172 |
|
173 // perform a load on the target only if dataType is not provided |
|
174 if (!options.dataType && options.target) { |
|
175 var oldSuccess = options.success || function(){}; |
|
176 callbacks.push(function(data) { |
|
177 var fn = options.replaceTarget ? 'replaceWith' : 'html'; |
|
178 $(options.target)[fn](data).each(oldSuccess, arguments); |
|
179 }); |
|
180 } |
|
181 else if (options.success) { |
|
182 callbacks.push(options.success); |
|
183 } |
|
184 |
|
185 options.success = function(data, status, xhr) { // jQuery 1.4+ passes xhr as 3rd arg |
|
186 var context = options.context || this ; // jQuery 1.4+ supports scope context |
|
187 for (var i=0, max=callbacks.length; i < max; i++) { |
|
188 callbacks[i].apply(context, [data, status, xhr || $form, $form]); |
|
189 } |
|
190 }; |
|
191 |
|
192 if (options.error) { |
|
193 var oldError = options.error; |
|
194 options.error = function(xhr, status, error) { |
|
195 var context = options.context || this; |
|
196 oldError.apply(context, [xhr, status, error, $form]); |
|
197 }; |
|
198 } |
|
199 |
|
200 if (options.complete) { |
|
201 var oldComplete = options.complete; |
|
202 options.complete = function(xhr, status) { |
|
203 var context = options.context || this; |
|
204 oldComplete.apply(context, [xhr, status, $form]); |
|
205 }; |
|
206 } |
|
207 |
|
208 // are there files to upload? |
|
209 |
|
210 // [value] (issue #113), also see comment: |
|
211 // https://github.com/malsup/form/commit/588306aedba1de01388032d5f42a60159eea9228#commitcomment-2180219 |
|
212 var fileInputs = $('input[type=file]:enabled[value!=""]', this); |
|
213 |
|
214 var hasFileInputs = fileInputs.length > 0; |
|
215 var mp = 'multipart/form-data'; |
|
216 var multipart = ($form.attr('enctype') == mp || $form.attr('encoding') == mp); |
|
217 |
|
218 var fileAPI = feature.fileapi && feature.formdata; |
|
219 log("fileAPI :" + fileAPI); |
|
220 var shouldUseFrame = (hasFileInputs || multipart) && !fileAPI; |
|
221 |
|
222 var jqxhr; |
|
223 |
|
224 // options.iframe allows user to force iframe mode |
|
225 // 06-NOV-09: now defaulting to iframe mode if file input is detected |
|
226 if (options.iframe !== false && (options.iframe || shouldUseFrame)) { |
|
227 // hack to fix Safari hang (thanks to Tim Molendijk for this) |
|
228 // see: http://groups.google.com/group/jquery-dev/browse_thread/thread/36395b7ab510dd5d |
|
229 if (options.closeKeepAlive) { |
|
230 $.get(options.closeKeepAlive, function() { |
|
231 jqxhr = fileUploadIframe(a); |
|
232 }); |
|
233 } |
|
234 else { |
|
235 jqxhr = fileUploadIframe(a); |
|
236 } |
|
237 } |
|
238 else if ((hasFileInputs || multipart) && fileAPI) { |
|
239 jqxhr = fileUploadXhr(a); |
|
240 } |
|
241 else { |
|
242 jqxhr = $.ajax(options); |
|
243 } |
|
244 |
|
245 $form.removeData('jqxhr').data('jqxhr', jqxhr); |
|
246 |
|
247 // clear element array |
|
248 for (var k=0; k < elements.length; k++) |
|
249 elements[k] = null; |
|
250 |
|
251 // fire 'notify' event |
|
252 this.trigger('form-submit-notify', [this, options]); |
|
253 return this; |
|
254 |
|
255 // utility fn for deep serialization |
|
256 function deepSerialize(extraData){ |
|
257 var serialized = $.param(extraData, options.traditional).split('&'); |
|
258 var len = serialized.length; |
|
259 var result = []; |
|
260 var i, part; |
|
261 for (i=0; i < len; i++) { |
|
262 // #252; undo param space replacement |
|
263 serialized[i] = serialized[i].replace(/\+/g,' '); |
|
264 part = serialized[i].split('='); |
|
265 // #278; use array instead of object storage, favoring array serializations |
|
266 result.push([decodeURIComponent(part[0]), decodeURIComponent(part[1])]); |
|
267 } |
|
268 return result; |
|
269 } |
|
270 |
|
271 // XMLHttpRequest Level 2 file uploads (big hat tip to francois2metz) |
|
272 function fileUploadXhr(a) { |
|
273 var formdata = new FormData(); |
|
274 |
|
275 for (var i=0; i < a.length; i++) { |
|
276 formdata.append(a[i].name, a[i].value); |
|
277 } |
|
278 |
|
279 if (options.extraData) { |
|
280 var serializedData = deepSerialize(options.extraData); |
|
281 for (i=0; i < serializedData.length; i++) |
|
282 if (serializedData[i]) |
|
283 formdata.append(serializedData[i][0], serializedData[i][1]); |
|
284 } |
|
285 |
|
286 options.data = null; |
|
287 |
|
288 var s = $.extend(true, {}, $.ajaxSettings, options, { |
|
289 contentType: false, |
|
290 processData: false, |
|
291 cache: false, |
|
292 type: method || 'POST' |
|
293 }); |
|
294 |
|
295 if (options.uploadProgress) { |
|
296 // workaround because jqXHR does not expose upload property |
|
297 s.xhr = function() { |
|
298 var xhr = $.ajaxSettings.xhr(); |
|
299 if (xhr.upload) { |
|
300 xhr.upload.addEventListener('progress', function(event) { |
|
301 var percent = 0; |
|
302 var position = event.loaded || event.position; /*event.position is deprecated*/ |
|
303 var total = event.total; |
|
304 if (event.lengthComputable) { |
|
305 percent = Math.ceil(position / total * 100); |
|
306 } |
|
307 options.uploadProgress(event, position, total, percent); |
|
308 }, false); |
|
309 } |
|
310 return xhr; |
|
311 }; |
|
312 } |
|
313 |
|
314 s.data = null; |
|
315 var beforeSend = s.beforeSend; |
|
316 s.beforeSend = function(xhr, o) { |
|
317 o.data = formdata; |
|
318 if(beforeSend) |
|
319 beforeSend.call(this, xhr, o); |
|
320 }; |
|
321 return $.ajax(s); |
|
322 } |
|
323 |
|
324 // private function for handling file uploads (hat tip to YAHOO!) |
|
325 function fileUploadIframe(a) { |
|
326 var form = $form[0], el, i, s, g, id, $io, io, xhr, sub, n, timedOut, timeoutHandle; |
|
327 var deferred = $.Deferred(); |
|
328 |
|
329 if (a) { |
|
330 // ensure that every serialized input is still enabled |
|
331 for (i=0; i < elements.length; i++) { |
|
332 el = $(elements[i]); |
|
333 if ( hasProp ) |
|
334 el.prop('disabled', false); |
|
335 else |
|
336 el.removeAttr('disabled'); |
|
337 } |
|
338 } |
|
339 |
|
340 s = $.extend(true, {}, $.ajaxSettings, options); |
|
341 s.context = s.context || s; |
|
342 id = 'jqFormIO' + (new Date().getTime()); |
|
343 if (s.iframeTarget) { |
|
344 $io = $(s.iframeTarget); |
|
345 n = $io.attr2('name'); |
|
346 if (!n) |
|
347 $io.attr2('name', id); |
|
348 else |
|
349 id = n; |
|
350 } |
|
351 else { |
|
352 $io = $('<iframe name="' + id + '" src="'+ s.iframeSrc +'" />'); |
|
353 $io.css({ position: 'absolute', top: '-1000px', left: '-1000px' }); |
|
354 } |
|
355 io = $io[0]; |
|
356 |
|
357 |
|
358 xhr = { // mock object |
|
359 aborted: 0, |
|
360 responseText: null, |
|
361 responseXML: null, |
|
362 status: 0, |
|
363 statusText: 'n/a', |
|
364 getAllResponseHeaders: function() {}, |
|
365 getResponseHeader: function() {}, |
|
366 setRequestHeader: function() {}, |
|
367 abort: function(status) { |
|
368 var e = (status === 'timeout' ? 'timeout' : 'aborted'); |
|
369 log('aborting upload... ' + e); |
|
370 this.aborted = 1; |
|
371 |
|
372 try { // #214, #257 |
|
373 if (io.contentWindow.document.execCommand) { |
|
374 io.contentWindow.document.execCommand('Stop'); |
|
375 } |
|
376 } |
|
377 catch(ignore) {} |
|
378 |
|
379 $io.attr('src', s.iframeSrc); // abort op in progress |
|
380 xhr.error = e; |
|
381 if (s.error) |
|
382 s.error.call(s.context, xhr, e, status); |
|
383 if (g) |
|
384 $.event.trigger("ajaxError", [xhr, s, e]); |
|
385 if (s.complete) |
|
386 s.complete.call(s.context, xhr, e); |
|
387 } |
|
388 }; |
|
389 |
|
390 g = s.global; |
|
391 // trigger ajax global events so that activity/block indicators work like normal |
|
392 if (g && 0 === $.active++) { |
|
393 $.event.trigger("ajaxStart"); |
|
394 } |
|
395 if (g) { |
|
396 $.event.trigger("ajaxSend", [xhr, s]); |
|
397 } |
|
398 |
|
399 if (s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false) { |
|
400 if (s.global) { |
|
401 $.active--; |
|
402 } |
|
403 deferred.reject(); |
|
404 return deferred; |
|
405 } |
|
406 if (xhr.aborted) { |
|
407 deferred.reject(); |
|
408 return deferred; |
|
409 } |
|
410 |
|
411 // add submitting element to data if we know it |
|
412 sub = form.clk; |
|
413 if (sub) { |
|
414 n = sub.name; |
|
415 if (n && !sub.disabled) { |
|
416 s.extraData = s.extraData || {}; |
|
417 s.extraData[n] = sub.value; |
|
418 if (sub.type == "image") { |
|
419 s.extraData[n+'.x'] = form.clk_x; |
|
420 s.extraData[n+'.y'] = form.clk_y; |
|
421 } |
|
422 } |
|
423 } |
|
424 |
|
425 var CLIENT_TIMEOUT_ABORT = 1; |
|
426 var SERVER_ABORT = 2; |
|
427 |
|
428 function getDoc(frame) { |
|
429 /* it looks like contentWindow or contentDocument do not |
|
430 * carry the protocol property in ie8, when running under ssl |
|
431 * frame.document is the only valid response document, since |
|
432 * the protocol is know but not on the other two objects. strange? |
|
433 * "Same origin policy" http://en.wikipedia.org/wiki/Same_origin_policy |
|
434 */ |
|
435 |
|
436 var doc = null; |
|
437 |
|
438 // IE8 cascading access check |
|
439 try { |
|
440 if (frame.contentWindow) { |
|
441 doc = frame.contentWindow.document; |
|
442 } |
|
443 } catch(err) { |
|
444 // IE8 access denied under ssl & missing protocol |
|
445 log('cannot get iframe.contentWindow document: ' + err); |
|
446 } |
|
447 |
|
448 if (doc) { // successful getting content |
|
449 return doc; |
|
450 } |
|
451 |
|
452 try { // simply checking may throw in ie8 under ssl or mismatched protocol |
|
453 doc = frame.contentDocument ? frame.contentDocument : frame.document; |
|
454 } catch(err) { |
|
455 // last attempt |
|
456 log('cannot get iframe.contentDocument: ' + err); |
|
457 doc = frame.document; |
|
458 } |
|
459 return doc; |
|
460 } |
|
461 |
|
462 // Rails CSRF hack (thanks to Yvan Barthelemy) |
|
463 var csrf_token = $('meta[name=csrf-token]').attr('content'); |
|
464 var csrf_param = $('meta[name=csrf-param]').attr('content'); |
|
465 if (csrf_param && csrf_token) { |
|
466 s.extraData = s.extraData || {}; |
|
467 s.extraData[csrf_param] = csrf_token; |
|
468 } |
|
469 |
|
470 // take a breath so that pending repaints get some cpu time before the upload starts |
|
471 function doSubmit() { |
|
472 // make sure form attrs are set |
|
473 var t = $form.attr2('target'), a = $form.attr2('action'); |
|
474 |
|
475 // update form attrs in IE friendly way |
|
476 form.setAttribute('target',id); |
|
477 if (!method) { |
|
478 form.setAttribute('method', 'POST'); |
|
479 } |
|
480 if (a != s.url) { |
|
481 form.setAttribute('action', s.url); |
|
482 } |
|
483 |
|
484 // ie borks in some cases when setting encoding |
|
485 if (! s.skipEncodingOverride && (!method || /post/i.test(method))) { |
|
486 $form.attr({ |
|
487 encoding: 'multipart/form-data', |
|
488 enctype: 'multipart/form-data' |
|
489 }); |
|
490 } |
|
491 |
|
492 // support timout |
|
493 if (s.timeout) { |
|
494 timeoutHandle = setTimeout(function() { timedOut = true; cb(CLIENT_TIMEOUT_ABORT); }, s.timeout); |
|
495 } |
|
496 |
|
497 // look for server aborts |
|
498 function checkState() { |
|
499 try { |
|
500 var state = getDoc(io).readyState; |
|
501 log('state = ' + state); |
|
502 if (state && state.toLowerCase() == 'uninitialized') |
|
503 setTimeout(checkState,50); |
|
504 } |
|
505 catch(e) { |
|
506 log('Server abort: ' , e, ' (', e.name, ')'); |
|
507 cb(SERVER_ABORT); |
|
508 if (timeoutHandle) |
|
509 clearTimeout(timeoutHandle); |
|
510 timeoutHandle = undefined; |
|
511 } |
|
512 } |
|
513 |
|
514 // add "extra" data to form if provided in options |
|
515 var extraInputs = []; |
|
516 try { |
|
517 if (s.extraData) { |
|
518 for (var n in s.extraData) { |
|
519 if (s.extraData.hasOwnProperty(n)) { |
|
520 // if using the $.param format that allows for multiple values with the same name |
|
521 if($.isPlainObject(s.extraData[n]) && s.extraData[n].hasOwnProperty('name') && s.extraData[n].hasOwnProperty('value')) { |
|
522 extraInputs.push( |
|
523 $('<input type="hidden" name="'+s.extraData[n].name+'">').val(s.extraData[n].value) |
|
524 .appendTo(form)[0]); |
|
525 } else { |
|
526 extraInputs.push( |
|
527 $('<input type="hidden" name="'+n+'">').val(s.extraData[n]) |
|
528 .appendTo(form)[0]); |
|
529 } |
|
530 } |
|
531 } |
|
532 } |
|
533 |
|
534 if (!s.iframeTarget) { |
|
535 // add iframe to doc and submit the form |
|
536 $io.appendTo('body'); |
|
537 if (io.attachEvent) |
|
538 io.attachEvent('onload', cb); |
|
539 else |
|
540 io.addEventListener('load', cb, false); |
|
541 } |
|
542 setTimeout(checkState,15); |
|
543 |
|
544 try { |
|
545 form.submit(); |
|
546 } catch(err) { |
|
547 // just in case form has element with name/id of 'submit' |
|
548 var submitFn = document.createElement('form').submit; |
|
549 submitFn.apply(form); |
|
550 } |
|
551 } |
|
552 finally { |
|
553 // reset attrs and remove "extra" input elements |
|
554 form.setAttribute('action',a); |
|
555 if(t) { |
|
556 form.setAttribute('target', t); |
|
557 } else { |
|
558 $form.removeAttr('target'); |
|
559 } |
|
560 $(extraInputs).remove(); |
|
561 } |
|
562 } |
|
563 |
|
564 if (s.forceSync) { |
|
565 doSubmit(); |
|
566 } |
|
567 else { |
|
568 setTimeout(doSubmit, 10); // this lets dom updates render |
|
569 } |
|
570 |
|
571 var data, doc, domCheckCount = 50, callbackProcessed; |
|
572 |
|
573 function cb(e) { |
|
574 if (xhr.aborted || callbackProcessed) { |
|
575 return; |
|
576 } |
|
577 |
|
578 doc = getDoc(io); |
|
579 if(!doc) { |
|
580 log('cannot access response document'); |
|
581 e = SERVER_ABORT; |
|
582 } |
|
583 if (e === CLIENT_TIMEOUT_ABORT && xhr) { |
|
584 xhr.abort('timeout'); |
|
585 deferred.reject(xhr, 'timeout'); |
|
586 return; |
|
587 } |
|
588 else if (e == SERVER_ABORT && xhr) { |
|
589 xhr.abort('server abort'); |
|
590 deferred.reject(xhr, 'error', 'server abort'); |
|
591 return; |
|
592 } |
|
593 |
|
594 if (!doc || doc.location.href == s.iframeSrc) { |
|
595 // response not received yet |
|
596 if (!timedOut) |
|
597 return; |
|
598 } |
|
599 if (io.detachEvent) |
|
600 io.detachEvent('onload', cb); |
|
601 else |
|
602 io.removeEventListener('load', cb, false); |
|
603 |
|
604 var status = 'success', errMsg; |
|
605 try { |
|
606 if (timedOut) { |
|
607 throw 'timeout'; |
|
608 } |
|
609 |
|
610 var isXml = s.dataType == 'xml' || doc.XMLDocument || $.isXMLDoc(doc); |
|
611 log('isXml='+isXml); |
|
612 if (!isXml && window.opera && (doc.body === null || !doc.body.innerHTML)) { |
|
613 if (--domCheckCount) { |
|
614 // in some browsers (Opera) the iframe DOM is not always traversable when |
|
615 // the onload callback fires, so we loop a bit to accommodate |
|
616 log('requeing onLoad callback, DOM not available'); |
|
617 setTimeout(cb, 250); |
|
618 return; |
|
619 } |
|
620 // let this fall through because server response could be an empty document |
|
621 //log('Could not access iframe DOM after mutiple tries.'); |
|
622 //throw 'DOMException: not available'; |
|
623 } |
|
624 |
|
625 //log('response detected'); |
|
626 var docRoot = doc.body ? doc.body : doc.documentElement; |
|
627 xhr.responseText = docRoot ? docRoot.innerHTML : null; |
|
628 xhr.responseXML = doc.XMLDocument ? doc.XMLDocument : doc; |
|
629 if (isXml) |
|
630 s.dataType = 'xml'; |
|
631 xhr.getResponseHeader = function(header){ |
|
632 var headers = {'content-type': s.dataType}; |
|
633 return headers[header]; |
|
634 }; |
|
635 // support for XHR 'status' & 'statusText' emulation : |
|
636 if (docRoot) { |
|
637 xhr.status = Number( docRoot.getAttribute('status') ) || xhr.status; |
|
638 xhr.statusText = docRoot.getAttribute('statusText') || xhr.statusText; |
|
639 } |
|
640 |
|
641 var dt = (s.dataType || '').toLowerCase(); |
|
642 var scr = /(json|script|text)/.test(dt); |
|
643 if (scr || s.textarea) { |
|
644 // see if user embedded response in textarea |
|
645 var ta = doc.getElementsByTagName('textarea')[0]; |
|
646 if (ta) { |
|
647 xhr.responseText = ta.value; |
|
648 // support for XHR 'status' & 'statusText' emulation : |
|
649 xhr.status = Number( ta.getAttribute('status') ) || xhr.status; |
|
650 xhr.statusText = ta.getAttribute('statusText') || xhr.statusText; |
|
651 } |
|
652 else if (scr) { |
|
653 // account for browsers injecting pre around json response |
|
654 var pre = doc.getElementsByTagName('pre')[0]; |
|
655 var b = doc.getElementsByTagName('body')[0]; |
|
656 if (pre) { |
|
657 xhr.responseText = pre.textContent ? pre.textContent : pre.innerText; |
|
658 } |
|
659 else if (b) { |
|
660 xhr.responseText = b.textContent ? b.textContent : b.innerText; |
|
661 } |
|
662 } |
|
663 } |
|
664 else if (dt == 'xml' && !xhr.responseXML && xhr.responseText) { |
|
665 xhr.responseXML = toXml(xhr.responseText); |
|
666 } |
|
667 |
|
668 try { |
|
669 data = httpData(xhr, dt, s); |
|
670 } |
|
671 catch (err) { |
|
672 status = 'parsererror'; |
|
673 xhr.error = errMsg = (err || status); |
|
674 } |
|
675 } |
|
676 catch (err) { |
|
677 log('error caught: ',err); |
|
678 status = 'error'; |
|
679 xhr.error = errMsg = (err || status); |
|
680 } |
|
681 |
|
682 if (xhr.aborted) { |
|
683 log('upload aborted'); |
|
684 status = null; |
|
685 } |
|
686 |
|
687 if (xhr.status) { // we've set xhr.status |
|
688 status = (xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) ? 'success' : 'error'; |
|
689 } |
|
690 |
|
691 // ordering of these callbacks/triggers is odd, but that's how $.ajax does it |
|
692 if (status === 'success') { |
|
693 if (s.success) |
|
694 s.success.call(s.context, data, 'success', xhr); |
|
695 deferred.resolve(xhr.responseText, 'success', xhr); |
|
696 if (g) |
|
697 $.event.trigger("ajaxSuccess", [xhr, s]); |
|
698 } |
|
699 else if (status) { |
|
700 if (errMsg === undefined) |
|
701 errMsg = xhr.statusText; |
|
702 if (s.error) |
|
703 s.error.call(s.context, xhr, status, errMsg); |
|
704 deferred.reject(xhr, 'error', errMsg); |
|
705 if (g) |
|
706 $.event.trigger("ajaxError", [xhr, s, errMsg]); |
|
707 } |
|
708 |
|
709 if (g) |
|
710 $.event.trigger("ajaxComplete", [xhr, s]); |
|
711 |
|
712 if (g && ! --$.active) { |
|
713 $.event.trigger("ajaxStop"); |
|
714 } |
|
715 |
|
716 if (s.complete) |
|
717 s.complete.call(s.context, xhr, status); |
|
718 |
|
719 callbackProcessed = true; |
|
720 if (s.timeout) |
|
721 clearTimeout(timeoutHandle); |
|
722 |
|
723 // clean up |
|
724 setTimeout(function() { |
|
725 if (!s.iframeTarget) |
|
726 $io.remove(); |
|
727 xhr.responseXML = null; |
|
728 }, 100); |
|
729 } |
|
730 |
|
731 var toXml = $.parseXML || function(s, doc) { // use parseXML if available (jQuery 1.5+) |
|
732 if (window.ActiveXObject) { |
|
733 doc = new ActiveXObject('Microsoft.XMLDOM'); |
|
734 doc.async = 'false'; |
|
735 doc.loadXML(s); |
|
736 } |
|
737 else { |
|
738 doc = (new DOMParser()).parseFromString(s, 'text/xml'); |
|
739 } |
|
740 return (doc && doc.documentElement && doc.documentElement.nodeName != 'parsererror') ? doc : null; |
|
741 }; |
|
742 var parseJSON = $.parseJSON || function(s) { |
|
743 /*jslint evil:true */ |
|
744 return window['eval']('(' + s + ')'); |
|
745 }; |
|
746 |
|
747 var httpData = function( xhr, type, s ) { // mostly lifted from jq1.4.4 |
|
748 |
|
749 var ct = xhr.getResponseHeader('content-type') || '', |
|
750 xml = type === 'xml' || !type && ct.indexOf('xml') >= 0, |
|
751 data = xml ? xhr.responseXML : xhr.responseText; |
|
752 |
|
753 if (xml && data.documentElement.nodeName === 'parsererror') { |
|
754 if ($.error) |
|
755 $.error('parsererror'); |
|
756 } |
|
757 if (s && s.dataFilter) { |
|
758 data = s.dataFilter(data, type); |
|
759 } |
|
760 if (typeof data === 'string') { |
|
761 if (type === 'json' || !type && ct.indexOf('json') >= 0) { |
|
762 data = parseJSON(data); |
|
763 } else if (type === "script" || !type && ct.indexOf("javascript") >= 0) { |
|
764 $.globalEval(data); |
|
765 } |
|
766 } |
|
767 return data; |
|
768 }; |
|
769 |
|
770 return deferred; |
|
771 } |
|
772 }; |
|
773 |
|
774 /** |
|
775 * ajaxForm() provides a mechanism for fully automating form submission. |
|
776 * |
|
777 * The advantages of using this method instead of ajaxSubmit() are: |
|
778 * |
|
779 * 1: This method will include coordinates for <input type="image" /> elements (if the element |
|
780 * is used to submit the form). |
|
781 * 2. This method will include the submit element's name/value data (for the element that was |
|
782 * used to submit the form). |
|
783 * 3. This method binds the submit() method to the form for you. |
|
784 * |
|
785 * The options argument for ajaxForm works exactly as it does for ajaxSubmit. ajaxForm merely |
|
786 * passes the options argument along after properly binding events for submit elements and |
|
787 * the form itself. |
|
788 */ |
|
789 $.fn.ajaxForm = function(options) { |
|
790 options = options || {}; |
|
791 options.delegation = options.delegation && $.isFunction($.fn.on); |
|
792 |
|
793 // in jQuery 1.3+ we can fix mistakes with the ready state |
|
794 if (!options.delegation && this.length === 0) { |
|
795 var o = { s: this.selector, c: this.context }; |
|
796 if (!$.isReady && o.s) { |
|
797 log('DOM not ready, queuing ajaxForm'); |
|
798 $(function() { |
|
799 $(o.s,o.c).ajaxForm(options); |
|
800 }); |
|
801 return this; |
|
802 } |
|
803 // is your DOM ready? http://docs.jquery.com/Tutorials:Introducing_$(document).ready() |
|
804 log('terminating; zero elements found by selector' + ($.isReady ? '' : ' (DOM not ready)')); |
|
805 return this; |
|
806 } |
|
807 |
|
808 if ( options.delegation ) { |
|
809 $(document) |
|
810 .off('submit.form-plugin', this.selector, doAjaxSubmit) |
|
811 .off('click.form-plugin', this.selector, captureSubmittingElement) |
|
812 .on('submit.form-plugin', this.selector, options, doAjaxSubmit) |
|
813 .on('click.form-plugin', this.selector, options, captureSubmittingElement); |
|
814 return this; |
|
815 } |
|
816 |
|
817 return this.ajaxFormUnbind() |
|
818 .bind('submit.form-plugin', options, doAjaxSubmit) |
|
819 .bind('click.form-plugin', options, captureSubmittingElement); |
|
820 }; |
|
821 |
|
822 // private event handlers |
|
823 function doAjaxSubmit(e) { |
|
824 /*jshint validthis:true */ |
|
825 var options = e.data; |
|
826 if (!e.isDefaultPrevented()) { // if event has been canceled, don't proceed |
|
827 e.preventDefault(); |
|
828 $(this).ajaxSubmit(options); |
|
829 } |
|
830 } |
|
831 |
|
832 function captureSubmittingElement(e) { |
|
833 /*jshint validthis:true */ |
|
834 var target = e.target; |
|
835 var $el = $(target); |
|
836 if (!($el.is("[type=submit],[type=image]"))) { |
|
837 // is this a child element of the submit el? (ex: a span within a button) |
|
838 var t = $el.closest('[type=submit]'); |
|
839 if (t.length === 0) { |
|
840 return; |
|
841 } |
|
842 target = t[0]; |
|
843 } |
|
844 var form = this; |
|
845 form.clk = target; |
|
846 if (target.type == 'image') { |
|
847 if (e.offsetX !== undefined) { |
|
848 form.clk_x = e.offsetX; |
|
849 form.clk_y = e.offsetY; |
|
850 } else if (typeof $.fn.offset == 'function') { |
|
851 var offset = $el.offset(); |
|
852 form.clk_x = e.pageX - offset.left; |
|
853 form.clk_y = e.pageY - offset.top; |
|
854 } else { |
|
855 form.clk_x = e.pageX - target.offsetLeft; |
|
856 form.clk_y = e.pageY - target.offsetTop; |
|
857 } |
|
858 } |
|
859 // clear form vars |
|
860 setTimeout(function() { form.clk = form.clk_x = form.clk_y = null; }, 100); |
|
861 } |
|
862 |
|
863 |
|
864 // ajaxFormUnbind unbinds the event handlers that were bound by ajaxForm |
|
865 $.fn.ajaxFormUnbind = function() { |
|
866 return this.unbind('submit.form-plugin click.form-plugin'); |
|
867 }; |
|
868 |
|
869 /** |
|
870 * formToArray() gathers form element data into an array of objects that can |
|
871 * be passed to any of the following ajax functions: $.get, $.post, or load. |
|
872 * Each object in the array has both a 'name' and 'value' property. An example of |
|
873 * an array for a simple login form might be: |
|
874 * |
|
875 * [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ] |
|
876 * |
|
877 * It is this array that is passed to pre-submit callback functions provided to the |
|
878 * ajaxSubmit() and ajaxForm() methods. |
|
879 */ |
|
880 $.fn.formToArray = function(semantic, elements) { |
|
881 var a = []; |
|
882 if (this.length === 0) { |
|
883 return a; |
|
884 } |
|
885 |
|
886 var form = this[0]; |
|
887 var els = semantic ? form.getElementsByTagName('*') : form.elements; |
|
888 if (!els) { |
|
889 return a; |
|
890 } |
|
891 |
|
892 var i,j,n,v,el,max,jmax; |
|
893 for(i=0, max=els.length; i < max; i++) { |
|
894 el = els[i]; |
|
895 n = el.name; |
|
896 if (!n || el.disabled) { |
|
897 continue; |
|
898 } |
|
899 |
|
900 if (semantic && form.clk && el.type == "image") { |
|
901 // handle image inputs on the fly when semantic == true |
|
902 if(form.clk == el) { |
|
903 a.push({name: n, value: $(el).val(), type: el.type }); |
|
904 a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y}); |
|
905 } |
|
906 continue; |
|
907 } |
|
908 |
|
909 v = $.fieldValue(el, true); |
|
910 if (v && v.constructor == Array) { |
|
911 if (elements) |
|
912 elements.push(el); |
|
913 for(j=0, jmax=v.length; j < jmax; j++) { |
|
914 a.push({name: n, value: v[j]}); |
|
915 } |
|
916 } |
|
917 else if (feature.fileapi && el.type == 'file') { |
|
918 if (elements) |
|
919 elements.push(el); |
|
920 var files = el.files; |
|
921 if (files.length) { |
|
922 for (j=0; j < files.length; j++) { |
|
923 a.push({name: n, value: files[j], type: el.type}); |
|
924 } |
|
925 } |
|
926 else { |
|
927 // #180 |
|
928 a.push({ name: n, value: '', type: el.type }); |
|
929 } |
|
930 } |
|
931 else if (v !== null && typeof v != 'undefined') { |
|
932 if (elements) |
|
933 elements.push(el); |
|
934 a.push({name: n, value: v, type: el.type, required: el.required}); |
|
935 } |
|
936 } |
|
937 |
|
938 if (!semantic && form.clk) { |
|
939 // input type=='image' are not found in elements array! handle it here |
|
940 var $input = $(form.clk), input = $input[0]; |
|
941 n = input.name; |
|
942 if (n && !input.disabled && input.type == 'image') { |
|
943 a.push({name: n, value: $input.val()}); |
|
944 a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y}); |
|
945 } |
|
946 } |
|
947 return a; |
|
948 }; |
|
949 |
|
950 /** |
|
951 * Serializes form data into a 'submittable' string. This method will return a string |
|
952 * in the format: name1=value1&name2=value2 |
|
953 */ |
|
954 $.fn.formSerialize = function(semantic) { |
|
955 //hand off to jQuery.param for proper encoding |
|
956 return $.param(this.formToArray(semantic)); |
|
957 }; |
|
958 |
|
959 /** |
|
960 * Serializes all field elements in the jQuery object into a query string. |
|
961 * This method will return a string in the format: name1=value1&name2=value2 |
|
962 */ |
|
963 $.fn.fieldSerialize = function(successful) { |
|
964 var a = []; |
|
965 this.each(function() { |
|
966 var n = this.name; |
|
967 if (!n) { |
|
968 return; |
|
969 } |
|
970 var v = $.fieldValue(this, successful); |
|
971 if (v && v.constructor == Array) { |
|
972 for (var i=0,max=v.length; i < max; i++) { |
|
973 a.push({name: n, value: v[i]}); |
|
974 } |
|
975 } |
|
976 else if (v !== null && typeof v != 'undefined') { |
|
977 a.push({name: this.name, value: v}); |
|
978 } |
|
979 }); |
|
980 //hand off to jQuery.param for proper encoding |
|
981 return $.param(a); |
|
982 }; |
|
983 |
|
984 /** |
|
985 * Returns the value(s) of the element in the matched set. For example, consider the following form: |
|
986 * |
|
987 * <form><fieldset> |
|
988 * <input name="A" type="text" /> |
|
989 * <input name="A" type="text" /> |
|
990 * <input name="B" type="checkbox" value="B1" /> |
|
991 * <input name="B" type="checkbox" value="B2"/> |
|
992 * <input name="C" type="radio" value="C1" /> |
|
993 * <input name="C" type="radio" value="C2" /> |
|
994 * </fieldset></form> |
|
995 * |
|
996 * var v = $('input[type=text]').fieldValue(); |
|
997 * // if no values are entered into the text inputs |
|
998 * v == ['',''] |
|
999 * // if values entered into the text inputs are 'foo' and 'bar' |
|
1000 * v == ['foo','bar'] |
|
1001 * |
|
1002 * var v = $('input[type=checkbox]').fieldValue(); |
|
1003 * // if neither checkbox is checked |
|
1004 * v === undefined |
|
1005 * // if both checkboxes are checked |
|
1006 * v == ['B1', 'B2'] |
|
1007 * |
|
1008 * var v = $('input[type=radio]').fieldValue(); |
|
1009 * // if neither radio is checked |
|
1010 * v === undefined |
|
1011 * // if first radio is checked |
|
1012 * v == ['C1'] |
|
1013 * |
|
1014 * The successful argument controls whether or not the field element must be 'successful' |
|
1015 * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls). |
|
1016 * The default value of the successful argument is true. If this value is false the value(s) |
|
1017 * for each element is returned. |
|
1018 * |
|
1019 * Note: This method *always* returns an array. If no valid value can be determined the |
|
1020 * array will be empty, otherwise it will contain one or more values. |
|
1021 */ |
|
1022 $.fn.fieldValue = function(successful) { |
|
1023 for (var val=[], i=0, max=this.length; i < max; i++) { |
|
1024 var el = this[i]; |
|
1025 var v = $.fieldValue(el, successful); |
|
1026 if (v === null || typeof v == 'undefined' || (v.constructor == Array && !v.length)) { |
|
1027 continue; |
|
1028 } |
|
1029 if (v.constructor == Array) |
|
1030 $.merge(val, v); |
|
1031 else |
|
1032 val.push(v); |
|
1033 } |
|
1034 return val; |
|
1035 }; |
|
1036 |
|
1037 /** |
|
1038 * Returns the value of the field element. |
|
1039 */ |
|
1040 $.fieldValue = function(el, successful) { |
|
1041 var n = el.name, t = el.type, tag = el.tagName.toLowerCase(); |
|
1042 if (successful === undefined) { |
|
1043 successful = true; |
|
1044 } |
|
1045 |
|
1046 if (successful && (!n || el.disabled || t == 'reset' || t == 'button' || |
|
1047 (t == 'checkbox' || t == 'radio') && !el.checked || |
|
1048 (t == 'submit' || t == 'image') && el.form && el.form.clk != el || |
|
1049 tag == 'select' && el.selectedIndex == -1)) { |
|
1050 return null; |
|
1051 } |
|
1052 |
|
1053 if (tag == 'select') { |
|
1054 var index = el.selectedIndex; |
|
1055 if (index < 0) { |
|
1056 return null; |
|
1057 } |
|
1058 var a = [], ops = el.options; |
|
1059 var one = (t == 'select-one'); |
|
1060 var max = (one ? index+1 : ops.length); |
|
1061 for(var i=(one ? index : 0); i < max; i++) { |
|
1062 var op = ops[i]; |
|
1063 if (op.selected) { |
|
1064 var v = op.value; |
|
1065 if (!v) { // extra pain for IE... |
|
1066 v = (op.attributes && op.attributes['value'] && !(op.attributes['value'].specified)) ? op.text : op.value; |
|
1067 } |
|
1068 if (one) { |
|
1069 return v; |
|
1070 } |
|
1071 a.push(v); |
|
1072 } |
|
1073 } |
|
1074 return a; |
|
1075 } |
|
1076 return $(el).val(); |
|
1077 }; |
|
1078 |
|
1079 /** |
|
1080 * Clears the form data. Takes the following actions on the form's input fields: |
|
1081 * - input text fields will have their 'value' property set to the empty string |
|
1082 * - select elements will have their 'selectedIndex' property set to -1 |
|
1083 * - checkbox and radio inputs will have their 'checked' property set to false |
|
1084 * - inputs of type submit, button, reset, and hidden will *not* be effected |
|
1085 * - button elements will *not* be effected |
|
1086 */ |
|
1087 $.fn.clearForm = function(includeHidden) { |
|
1088 return this.each(function() { |
|
1089 $('input,select,textarea', this).clearFields(includeHidden); |
|
1090 }); |
|
1091 }; |
|
1092 |
|
1093 /** |
|
1094 * Clears the selected form elements. |
|
1095 */ |
|
1096 $.fn.clearFields = $.fn.clearInputs = function(includeHidden) { |
|
1097 var re = /^(?:color|date|datetime|email|month|number|password|range|search|tel|text|time|url|week)$/i; // 'hidden' is not in this list |
|
1098 return this.each(function() { |
|
1099 var t = this.type, tag = this.tagName.toLowerCase(); |
|
1100 if (re.test(t) || tag == 'textarea') { |
|
1101 this.value = ''; |
|
1102 } |
|
1103 else if (t == 'checkbox' || t == 'radio') { |
|
1104 this.checked = false; |
|
1105 } |
|
1106 else if (tag == 'select') { |
|
1107 this.selectedIndex = -1; |
|
1108 } |
|
1109 else if (t == "file") { |
|
1110 if (/MSIE/.test(navigator.userAgent)) { |
|
1111 $(this).replaceWith($(this).clone(true)); |
|
1112 } else { |
|
1113 $(this).val(''); |
|
1114 } |
|
1115 } |
|
1116 else if (includeHidden) { |
|
1117 // includeHidden can be the value true, or it can be a selector string |
|
1118 // indicating a special test; for example: |
|
1119 // $('#myForm').clearForm('.special:hidden') |
|
1120 // the above would clean hidden inputs that have the class of 'special' |
|
1121 if ( (includeHidden === true && /hidden/.test(t)) || |
|
1122 (typeof includeHidden == 'string' && $(this).is(includeHidden)) ) |
|
1123 this.value = ''; |
|
1124 } |
|
1125 }); |
|
1126 }; |
|
1127 |
|
1128 /** |
|
1129 * Resets the form data. Causes all form elements to be reset to their original value. |
|
1130 */ |
|
1131 $.fn.resetForm = function() { |
|
1132 return this.each(function() { |
|
1133 // guard against an input with the name of 'reset' |
|
1134 // note that IE reports the reset function as an 'object' |
|
1135 if (typeof this.reset == 'function' || (typeof this.reset == 'object' && !this.reset.nodeType)) { |
|
1136 this.reset(); |
|
1137 } |
|
1138 }); |
|
1139 }; |
|
1140 |
|
1141 /** |
|
1142 * Enables or disables any matching elements. |
|
1143 */ |
|
1144 $.fn.enable = function(b) { |
|
1145 if (b === undefined) { |
|
1146 b = true; |
|
1147 } |
|
1148 return this.each(function() { |
|
1149 this.disabled = !b; |
|
1150 }); |
|
1151 }; |
|
1152 |
|
1153 /** |
|
1154 * Checks/unchecks any matching checkboxes or radio buttons and |
|
1155 * selects/deselects and matching option elements. |
|
1156 */ |
|
1157 $.fn.selected = function(select) { |
|
1158 if (select === undefined) { |
|
1159 select = true; |
|
1160 } |
|
1161 return this.each(function() { |
|
1162 var t = this.type; |
|
1163 if (t == 'checkbox' || t == 'radio') { |
|
1164 this.checked = select; |
|
1165 } |
|
1166 else if (this.tagName.toLowerCase() == 'option') { |
|
1167 var $sel = $(this).parent('select'); |
|
1168 if (select && $sel[0] && $sel[0].type == 'select-one') { |
|
1169 // deselect all other options |
|
1170 $sel.find('option').selected(false); |
|
1171 } |
|
1172 this.selected = select; |
|
1173 } |
|
1174 }); |
|
1175 }; |
|
1176 |
|
1177 // expose debug var |
|
1178 $.fn.ajaxSubmit.debug = false; |
|
1179 |
|
1180 // helper fn for console logging |
|
1181 function log() { |
|
1182 if (!$.fn.ajaxSubmit.debug) |
|
1183 return; |
|
1184 var msg = '[jquery.form] ' + Array.prototype.join.call(arguments,''); |
|
1185 if (window.console && window.console.log) { |
|
1186 window.console.log(msg); |
|
1187 } |
|
1188 else if (window.opera && window.opera.postError) { |
|
1189 window.opera.postError(msg); |
|
1190 } |
|
1191 } |
|
1192 |
|
1193 })(jQuery); |