tenon 1.0.1 → 1.0.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (37) hide show
  1. checksums.yaml +4 -4
  2. data/lib/tenon/version.rb +1 -1
  3. data/vendor/assets/images/Jcrop.gif +0 -0
  4. data/vendor/assets/javascripts/backstretch.js +4 -0
  5. data/vendor/assets/javascripts/bootstrap.collapse.js +179 -0
  6. data/vendor/assets/javascripts/bootstrap.datetimepicker.js +954 -0
  7. data/vendor/assets/javascripts/bootstrap.js +561 -0
  8. data/vendor/assets/javascripts/bootstrap.modal.js +246 -0
  9. data/vendor/assets/javascripts/bootstrap.tabs.js +135 -0
  10. data/vendor/assets/javascripts/canvasjs.min.js +343 -0
  11. data/vendor/assets/javascripts/cufon/Aller_400.font.js +7 -0
  12. data/vendor/assets/javascripts/cufon/Aller_700.font.js +7 -0
  13. data/vendor/assets/javascripts/cufon/cufon.js +7 -0
  14. data/vendor/assets/javascripts/imagesloaded.js +7 -0
  15. data/vendor/assets/javascripts/jquery.Jcrop.js +1704 -0
  16. data/vendor/assets/javascripts/jquery.corner.js +249 -0
  17. data/vendor/assets/javascripts/jquery.debounce.js +9 -0
  18. data/vendor/assets/javascripts/jquery.equalHeights.js +52 -0
  19. data/vendor/assets/javascripts/jquery.form.js +911 -0
  20. data/vendor/assets/javascripts/jquery.hoverIntent.js +115 -0
  21. data/vendor/assets/javascripts/jquery.mousewheel.js +78 -0
  22. data/vendor/assets/javascripts/jquery.radioSlider.js +55 -0
  23. data/vendor/assets/javascripts/jquery.twoLevelSort.js +57 -0
  24. data/vendor/assets/javascripts/jquery.ui.sortable.js +2252 -0
  25. data/vendor/assets/javascripts/jscrollpane.js +1435 -0
  26. data/vendor/assets/javascripts/moment.js +6 -0
  27. data/vendor/assets/javascripts/select2.js +3448 -0
  28. data/vendor/assets/javascripts/underscore.inflection.js +177 -0
  29. data/vendor/assets/javascripts/underscore.string.js +1 -0
  30. data/vendor/assets/javascripts/uri.js +53 -0
  31. data/vendor/assets/stylesheets/bootstrap.css.scss +560 -0
  32. data/vendor/assets/stylesheets/bootstrap.datetimepicker.css +152 -0
  33. data/vendor/assets/stylesheets/bootstrap.tables.css.scss +201 -0
  34. data/vendor/assets/stylesheets/jquery.Jcrop.css +204 -0
  35. data/vendor/assets/stylesheets/jscrollpane.css.scss +20 -0
  36. data/vendor/assets/stylesheets/select2.css +646 -0
  37. metadata +35 -1
@@ -0,0 +1,249 @@
1
+ /*!
2
+ * jQuery corner plugin: simple corner rounding
3
+ * Examples and documentation at: http://jquery.malsup.com/corner/
4
+ * version 2.12 (23-MAY-2011)
5
+ * Requires jQuery v1.3.2 or later
6
+ * Dual licensed under the MIT and GPL licenses:
7
+ * http://www.opensource.org/licenses/mit-license.php
8
+ * http://www.gnu.org/licenses/gpl.html
9
+ * Authors: Dave Methvin and Mike Alsup
10
+ */
11
+
12
+ /**
13
+ * corner() takes a single string argument: $('#myDiv').corner("effect corners width")
14
+ *
15
+ * effect: name of the effect to apply, such as round, bevel, notch, bite, etc (default is round).
16
+ * corners: one or more of: top, bottom, tr, tl, br, or bl. (default is all corners)
17
+ * width: width of the effect; in the case of rounded corners this is the radius.
18
+ * specify this value using the px suffix such as 10px (yes, it must be pixels).
19
+ */
20
+ ;(function($) {
21
+
22
+ var style = document.createElement('div').style,
23
+ moz = style['MozBorderRadius'] !== undefined,
24
+ webkit = style['WebkitBorderRadius'] !== undefined,
25
+ radius = style['borderRadius'] !== undefined || style['BorderRadius'] !== undefined,
26
+ mode = document.documentMode || 0,
27
+ noBottomFold = $.browser.msie && (($.browser.version < 8 && !mode) || mode < 8),
28
+
29
+ expr = $.browser.msie && (function() {
30
+ var div = document.createElement('div');
31
+ try { div.style.setExpression('width','0+0'); div.style.removeExpression('width'); }
32
+ catch(e) { return false; }
33
+ return true;
34
+ })();
35
+
36
+ $.support = $.support || {};
37
+ $.support.borderRadius = moz || webkit || radius; // so you can do: if (!$.support.borderRadius) $('#myDiv').corner();
38
+
39
+ function sz(el, p) {
40
+ return parseInt($.css(el,p))||0;
41
+ };
42
+ function hex2(s) {
43
+ s = parseInt(s).toString(16);
44
+ return ( s.length < 2 ) ? '0'+s : s;
45
+ };
46
+ function gpc(node) {
47
+ while(node) {
48
+ var v = $.css(node,'backgroundColor'), rgb;
49
+ if (v && v != 'transparent' && v != 'rgba(0, 0, 0, 0)') {
50
+ if (v.indexOf('rgb') >= 0) {
51
+ rgb = v.match(/\d+/g);
52
+ return '#'+ hex2(rgb[0]) + hex2(rgb[1]) + hex2(rgb[2]);
53
+ }
54
+ return v;
55
+ }
56
+ if (node.nodeName.toLowerCase() == 'html')
57
+ break;
58
+ node = node.parentNode; // keep walking if transparent
59
+ }
60
+ return '#ffffff';
61
+ };
62
+
63
+ function getWidth(fx, i, width) {
64
+ switch(fx) {
65
+ case 'round': return Math.round(width*(1-Math.cos(Math.asin(i/width))));
66
+ case 'cool': return Math.round(width*(1+Math.cos(Math.asin(i/width))));
67
+ case 'sharp': return width-i;
68
+ case 'bite': return Math.round(width*(Math.cos(Math.asin((width-i-1)/width))));
69
+ case 'slide': return Math.round(width*(Math.atan2(i,width/i)));
70
+ case 'jut': return Math.round(width*(Math.atan2(width,(width-i-1))));
71
+ case 'curl': return Math.round(width*(Math.atan(i)));
72
+ case 'tear': return Math.round(width*(Math.cos(i)));
73
+ case 'wicked': return Math.round(width*(Math.tan(i)));
74
+ case 'long': return Math.round(width*(Math.sqrt(i)));
75
+ case 'sculpt': return Math.round(width*(Math.log((width-i-1),width)));
76
+ case 'dogfold':
77
+ case 'dog': return (i&1) ? (i+1) : width;
78
+ case 'dog2': return (i&2) ? (i+1) : width;
79
+ case 'dog3': return (i&3) ? (i+1) : width;
80
+ case 'fray': return (i%2)*width;
81
+ case 'notch': return width;
82
+ case 'bevelfold':
83
+ case 'bevel': return i+1;
84
+ case 'steep': return i/2 + 1;
85
+ case 'invsteep':return (width-i)/2+1;
86
+ }
87
+ };
88
+
89
+ $.fn.corner = function(options) {
90
+ // in 1.3+ we can fix mistakes with the ready state
91
+ if (this.length == 0) {
92
+ if (!$.isReady && this.selector) {
93
+ var s = this.selector, c = this.context;
94
+ $(function() {
95
+ $(s,c).corner(options);
96
+ });
97
+ }
98
+ return this;
99
+ }
100
+
101
+ return this.each(function(index){
102
+ var $this = $(this),
103
+ // meta values override options
104
+ o = [$this.attr($.fn.corner.defaults.metaAttr) || '', options || ''].join(' ').toLowerCase(),
105
+ keep = /keep/.test(o), // keep borders?
106
+ cc = ((o.match(/cc:(#[0-9a-f]+)/)||[])[1]), // corner color
107
+ sc = ((o.match(/sc:(#[0-9a-f]+)/)||[])[1]), // strip color
108
+ width = parseInt((o.match(/(\d+)px/)||[])[1]) || 10, // corner width
109
+ re = /round|bevelfold|bevel|notch|bite|cool|sharp|slide|jut|curl|tear|fray|wicked|sculpt|long|dog3|dog2|dogfold|dog|invsteep|steep/,
110
+ fx = ((o.match(re)||['round'])[0]),
111
+ fold = /dogfold|bevelfold/.test(o),
112
+ edges = { T:0, B:1 },
113
+ opts = {
114
+ TL: /top|tl|left/.test(o), TR: /top|tr|right/.test(o),
115
+ BL: /bottom|bl|left/.test(o), BR: /bottom|br|right/.test(o)
116
+ },
117
+ // vars used in func later
118
+ strip, pad, cssHeight, j, bot, d, ds, bw, i, w, e, c, common, $horz;
119
+
120
+ if ( !opts.TL && !opts.TR && !opts.BL && !opts.BR )
121
+ opts = { TL:1, TR:1, BL:1, BR:1 };
122
+
123
+ // support native rounding
124
+ if ($.fn.corner.defaults.useNative && fx == 'round' && (radius || moz || webkit) && !cc && !sc) {
125
+ if (opts.TL)
126
+ $this.css(radius ? 'border-top-left-radius' : moz ? '-moz-border-radius-topleft' : '-webkit-border-top-left-radius', width + 'px');
127
+ if (opts.TR)
128
+ $this.css(radius ? 'border-top-right-radius' : moz ? '-moz-border-radius-topright' : '-webkit-border-top-right-radius', width + 'px');
129
+ if (opts.BL)
130
+ $this.css(radius ? 'border-bottom-left-radius' : moz ? '-moz-border-radius-bottomleft' : '-webkit-border-bottom-left-radius', width + 'px');
131
+ if (opts.BR)
132
+ $this.css(radius ? 'border-bottom-right-radius' : moz ? '-moz-border-radius-bottomright' : '-webkit-border-bottom-right-radius', width + 'px');
133
+ return;
134
+ }
135
+
136
+ strip = document.createElement('div');
137
+ $(strip).css({
138
+ overflow: 'hidden',
139
+ height: '1px',
140
+ minHeight: '1px',
141
+ fontSize: '1px',
142
+ backgroundColor: sc || 'transparent',
143
+ borderStyle: 'solid'
144
+ });
145
+
146
+ pad = {
147
+ T: parseInt($.css(this,'paddingTop'))||0, R: parseInt($.css(this,'paddingRight'))||0,
148
+ B: parseInt($.css(this,'paddingBottom'))||0, L: parseInt($.css(this,'paddingLeft'))||0
149
+ };
150
+
151
+ if (typeof this.style.zoom != undefined) this.style.zoom = 1; // force 'hasLayout' in IE
152
+ if (!keep) this.style.border = 'none';
153
+ strip.style.borderColor = cc || gpc(this.parentNode);
154
+ cssHeight = $(this).outerHeight();
155
+
156
+ for (j in edges) {
157
+ bot = edges[j];
158
+ // only add stips if needed
159
+ if ((bot && (opts.BL || opts.BR)) || (!bot && (opts.TL || opts.TR))) {
160
+ strip.style.borderStyle = 'none '+(opts[j+'R']?'solid':'none')+' none '+(opts[j+'L']?'solid':'none');
161
+ d = document.createElement('div');
162
+ $(d).addClass('jquery-corner');
163
+ ds = d.style;
164
+
165
+ bot ? this.appendChild(d) : this.insertBefore(d, this.firstChild);
166
+
167
+ if (bot && cssHeight != 'auto') {
168
+ if ($.css(this,'position') == 'static')
169
+ this.style.position = 'relative';
170
+ ds.position = 'absolute';
171
+ ds.bottom = ds.left = ds.padding = ds.margin = '0';
172
+ if (expr)
173
+ ds.setExpression('width', 'this.parentNode.offsetWidth');
174
+ else
175
+ ds.width = '100%';
176
+ }
177
+ else if (!bot && $.browser.msie) {
178
+ if ($.css(this,'position') == 'static')
179
+ this.style.position = 'relative';
180
+ ds.position = 'absolute';
181
+ ds.top = ds.left = ds.right = ds.padding = ds.margin = '0';
182
+
183
+ // fix ie6 problem when blocked element has a border width
184
+ if (expr) {
185
+ bw = sz(this,'borderLeftWidth') + sz(this,'borderRightWidth');
186
+ ds.setExpression('width', 'this.parentNode.offsetWidth - '+bw+'+ "px"');
187
+ }
188
+ else
189
+ ds.width = '100%';
190
+ }
191
+ else {
192
+ ds.position = 'relative';
193
+ ds.margin = !bot ? '-'+pad.T+'px -'+pad.R+'px '+(pad.T-width)+'px -'+pad.L+'px' :
194
+ (pad.B-width)+'px -'+pad.R+'px -'+pad.B+'px -'+pad.L+'px';
195
+ }
196
+
197
+ for (i=0; i < width; i++) {
198
+ w = Math.max(0,getWidth(fx,i, width));
199
+ e = strip.cloneNode(false);
200
+ e.style.borderWidth = '0 '+(opts[j+'R']?w:0)+'px 0 '+(opts[j+'L']?w:0)+'px';
201
+ bot ? d.appendChild(e) : d.insertBefore(e, d.firstChild);
202
+ }
203
+
204
+ if (fold && $.support.boxModel) {
205
+ if (bot && noBottomFold) continue;
206
+ for (c in opts) {
207
+ if (!opts[c]) continue;
208
+ if (bot && (c == 'TL' || c == 'TR')) continue;
209
+ if (!bot && (c == 'BL' || c == 'BR')) continue;
210
+
211
+ common = { position: 'absolute', border: 'none', margin: 0, padding: 0, overflow: 'hidden', backgroundColor: strip.style.borderColor };
212
+ $horz = $('<div/>').css(common).css({ width: width + 'px', height: '1px' });
213
+ switch(c) {
214
+ case 'TL': $horz.css({ bottom: 0, left: 0 }); break;
215
+ case 'TR': $horz.css({ bottom: 0, right: 0 }); break;
216
+ case 'BL': $horz.css({ top: 0, left: 0 }); break;
217
+ case 'BR': $horz.css({ top: 0, right: 0 }); break;
218
+ }
219
+ d.appendChild($horz[0]);
220
+
221
+ var $vert = $('<div/>').css(common).css({ top: 0, bottom: 0, width: '1px', height: width + 'px' });
222
+ switch(c) {
223
+ case 'TL': $vert.css({ left: width }); break;
224
+ case 'TR': $vert.css({ right: width }); break;
225
+ case 'BL': $vert.css({ left: width }); break;
226
+ case 'BR': $vert.css({ right: width }); break;
227
+ }
228
+ d.appendChild($vert[0]);
229
+ }
230
+ }
231
+ }
232
+ }
233
+ });
234
+ };
235
+
236
+ $.fn.uncorner = function() {
237
+ if (radius || moz || webkit)
238
+ this.css(radius ? 'border-radius' : moz ? '-moz-border-radius' : '-webkit-border-radius', 0);
239
+ $('div.jquery-corner', this).remove();
240
+ return this;
241
+ };
242
+
243
+ // expose options
244
+ $.fn.corner.defaults = {
245
+ useNative: true, // true if plugin should attempt to use native browser support for border radius rounding
246
+ metaAttr: 'data-corner' // name of meta attribute to use for options
247
+ };
248
+
249
+ })(jQuery);
@@ -0,0 +1,9 @@
1
+ /*
2
+ * jQuery throttle / debounce - v1.1 - 3/7/2010
3
+ * http://benalman.com/projects/jquery-throttle-debounce-plugin/
4
+ *
5
+ * Copyright (c) 2010 "Cowboy" Ben Alman
6
+ * Dual licensed under the MIT and GPL licenses.
7
+ * http://benalman.com/about/license/
8
+ */
9
+ (function(b,c){var $=b.jQuery||b.Cowboy||(b.Cowboy={}),a;$.throttle=a=function(e,f,j,i){var h,d=0;if(typeof f!=="boolean"){i=j;j=f;f=c}function g(){var o=this,m=+new Date()-d,n=arguments;function l(){d=+new Date();j.apply(o,n)}function k(){h=c}if(i&&!h){l()}h&&clearTimeout(h);if(i===c&&m>e){l()}else{if(f!==true){h=setTimeout(i?k:l,i===c?e-m:e)}}}if($.guid){g.guid=j.guid=j.guid||$.guid++}return g};$.debounce=function(d,e,f){return f===c?a(d,e,false):a(d,f,e!==false)}})(this);
@@ -0,0 +1,52 @@
1
+ /**
2
+ * Equal Heights Plugin
3
+ * Equalize the heights of elements. Great for columns or any elements
4
+ * that need to be the same size (floats, etc).
5
+ *
6
+ * Version 1.0
7
+ * Updated 12/10/2008
8
+ *
9
+ * Copyright (c) 2008 Rob Glazebrook (cssnewbie.com)
10
+ *
11
+ * Usage: $(object).equalHeights([minHeight], [maxHeight]);
12
+ *
13
+ * Example 1: $(".cols").equalHeights(); Sets all columns to the same height.
14
+ * Example 2: $(".cols").equalHeights(400); Sets all cols to at least 400px tall.
15
+ * Example 3: $(".cols").equalHeights(100,300); Cols are at least 100 but no more
16
+ * than 300 pixels tall. Elements with too much content will gain a scrollbar.
17
+ *
18
+ */
19
+
20
+ (function($) {
21
+ $.fn.equalHeights = function(minHeight, maxHeight) {
22
+ tallest = (minHeight) ? minHeight : 0;
23
+ this.each(function() {
24
+ if($(this).height() > tallest) {
25
+ tallest = $(this).height();
26
+ }
27
+ });
28
+ if((maxHeight) && tallest > maxHeight) tallest = maxHeight;
29
+ return this.each(function() {
30
+ $(this).height(tallest)
31
+ });
32
+ }
33
+ })(jQuery);
34
+
35
+ (function($) {
36
+ $.fn.siblingHeights = function(selector, minHeight, maxHeight) {
37
+ this.each(function() {
38
+ tallest = (minHeight) ? minHeight : 0;
39
+ items = $(this).siblings(selector);
40
+ items.push(this);
41
+ items.each(function() {
42
+ if($(this).height() > tallest) {
43
+ tallest = $(this).height();
44
+ }
45
+ });
46
+ });
47
+ if((maxHeight) && tallest > maxHeight) tallest = maxHeight;
48
+ return this.each(function() {
49
+ $(this).height(tallest)
50
+ });
51
+ }
52
+ })(jQuery);
@@ -0,0 +1,911 @@
1
+ /*!
2
+ * jQuery Form Plugin
3
+ * version: 2.83 (11-JUL-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
+ var method, action, url, $form = this;
54
+
55
+ if (typeof options == 'function') {
56
+ options = { success: options };
57
+ }
58
+
59
+ method = this.attr('method');
60
+ action = this.attr('action');
61
+ url = (typeof action === 'string') ? $.trim(action) : '';
62
+ url = url || window.location.href || '';
63
+ if (url) {
64
+ // clean url (don't include hash vaue)
65
+ url = (url.match(/^([^#]+)/)||[])[1];
66
+ }
67
+
68
+ options = $.extend(true, {
69
+ url: url,
70
+ success: $.ajaxSettings.success,
71
+ type: method || 'GET',
72
+ iframeSrc: /^https/i.test(window.location.href || '') ? 'javascript:false' : 'about:blank'
73
+ }, options);
74
+
75
+ // hook for manipulating the form data before it is extracted;
76
+ // convenient for use with rich editors like tinyMCE or FCKEditor
77
+ var veto = {};
78
+ this.trigger('form-pre-serialize', [this, options, veto]);
79
+ if (veto.veto) {
80
+ log('ajaxSubmit: submit vetoed via form-pre-serialize trigger');
81
+ return this;
82
+ }
83
+
84
+ // provide opportunity to alter form data before it is serialized
85
+ if (options.beforeSerialize && options.beforeSerialize(this, options) === false) {
86
+ log('ajaxSubmit: submit aborted via beforeSerialize callback');
87
+ return this;
88
+ }
89
+
90
+ var n,v,a = this.formToArray(options.semantic);
91
+ if (options.data) {
92
+ options.extraData = options.data;
93
+ for (n in options.data) {
94
+ if(options.data[n] instanceof Array) {
95
+ for (var k in options.data[n]) {
96
+ a.push( { name: n, value: options.data[n][k] } );
97
+ }
98
+ }
99
+ else {
100
+ v = options.data[n];
101
+ v = $.isFunction(v) ? v() : v; // if value is fn, invoke it
102
+ a.push( { name: n, value: v } );
103
+ }
104
+ }
105
+ }
106
+
107
+ // give pre-submit callback an opportunity to abort the submit
108
+ if (options.beforeSubmit && options.beforeSubmit(a, this, options) === false) {
109
+ log('ajaxSubmit: submit aborted via beforeSubmit callback');
110
+ return this;
111
+ }
112
+
113
+ // fire vetoable 'validate' event
114
+ this.trigger('form-submit-validate', [a, this, options, veto]);
115
+ if (veto.veto) {
116
+ log('ajaxSubmit: submit vetoed via form-submit-validate trigger');
117
+ return this;
118
+ }
119
+
120
+ var q = $.param(a);
121
+
122
+ if (options.type.toUpperCase() == 'GET') {
123
+ options.url += (options.url.indexOf('?') >= 0 ? '&' : '?') + q;
124
+ options.data = null; // data is null for 'get'
125
+ }
126
+ else {
127
+ options.data = q; // data is the query string for 'post'
128
+ }
129
+
130
+ var callbacks = [];
131
+ if (options.resetForm) {
132
+ callbacks.push(function() { $form.resetForm(); });
133
+ }
134
+ if (options.clearForm) {
135
+ callbacks.push(function() { $form.clearForm(); });
136
+ }
137
+
138
+ // perform a load on the target only if dataType is not provided
139
+ if (!options.dataType && options.target) {
140
+ var oldSuccess = options.success || function(){};
141
+ callbacks.push(function(data) {
142
+ var fn = options.replaceTarget ? 'replaceWith' : 'html';
143
+ $(options.target)[fn](data).each(oldSuccess, arguments);
144
+ });
145
+ }
146
+ else if (options.success) {
147
+ callbacks.push(options.success);
148
+ }
149
+
150
+ options.success = function(data, status, xhr) { // jQuery 1.4+ passes xhr as 3rd arg
151
+ var context = options.context || options; // jQuery 1.4+ supports scope context
152
+ for (var i=0, max=callbacks.length; i < max; i++) {
153
+ callbacks[i].apply(context, [data, status, xhr || $form, $form]);
154
+ }
155
+ };
156
+
157
+ // are there files to upload?
158
+ var fileInputs = $('input:file', this).length > 0;
159
+ var mp = 'multipart/form-data';
160
+ var multipart = ($form.attr('enctype') == mp || $form.attr('encoding') == mp);
161
+
162
+ // options.iframe allows user to force iframe mode
163
+ // 06-NOV-09: now defaulting to iframe mode if file input is detected
164
+ if (options.iframe !== false && (fileInputs || options.iframe || multipart)) {
165
+ // hack to fix Safari hang (thanks to Tim Molendijk for this)
166
+ // see: http://groups.google.com/group/jquery-dev/browse_thread/thread/36395b7ab510dd5d
167
+ if (options.closeKeepAlive) {
168
+ $.get(options.closeKeepAlive, function() { fileUpload(a); });
169
+ }
170
+ else {
171
+ fileUpload(a);
172
+ }
173
+ }
174
+ else {
175
+ // IE7 massage (see issue 57)
176
+ if ($.browser.msie && method == 'get') {
177
+ var ieMeth = $form[0].getAttribute('method');
178
+ if (typeof ieMeth === 'string')
179
+ options.type = ieMeth;
180
+ }
181
+ $.ajax(options);
182
+ }
183
+
184
+ // fire 'notify' event
185
+ this.trigger('form-submit-notify', [this, options]);
186
+ return this;
187
+
188
+
189
+ // private function for handling file uploads (hat tip to YAHOO!)
190
+ function fileUpload(a) {
191
+ var form = $form[0], el, i, s, g, id, $io, io, xhr, sub, n, timedOut, timeoutHandle;
192
+ var useProp = !!$.fn.prop;
193
+
194
+ if (a) {
195
+ // ensure that every serialized input is still enabled
196
+ for (i=0; i < a.length; i++) {
197
+ el = $(form[a[i].name]);
198
+ el[ useProp ? 'prop' : 'attr' ]('disabled', false);
199
+ }
200
+ }
201
+
202
+ if ($(':input[name=submit],:input[id=submit]', form).length) {
203
+ // if there is an input with a name or id of 'submit' then we won't be
204
+ // able to invoke the submit fn on the form (at least not x-browser)
205
+ alert('Error: Form elements must not have name or id of "submit".');
206
+ return;
207
+ }
208
+
209
+ s = $.extend(true, {}, $.ajaxSettings, options);
210
+ s.context = s.context || s;
211
+ id = 'jqFormIO' + (new Date().getTime());
212
+ if (s.iframeTarget) {
213
+ $io = $(s.iframeTarget);
214
+ n = $io.attr('name');
215
+ if (n == null)
216
+ $io.attr('name', id);
217
+ else
218
+ id = n;
219
+ }
220
+ else {
221
+ $io = $('<iframe name="' + id + '" src="'+ s.iframeSrc +'" />');
222
+ $io.css({ position: 'absolute', top: '-1000px', left: '-1000px' });
223
+ }
224
+ io = $io[0];
225
+
226
+
227
+ xhr = { // mock object
228
+ aborted: 0,
229
+ responseText: null,
230
+ responseXML: null,
231
+ status: 0,
232
+ statusText: 'n/a',
233
+ getAllResponseHeaders: function() {},
234
+ getResponseHeader: function() {},
235
+ setRequestHeader: function() {},
236
+ abort: function(status) {
237
+ var e = (status === 'timeout' ? 'timeout' : 'aborted');
238
+ log('aborting upload... ' + e);
239
+ this.aborted = 1;
240
+ $io.attr('src', s.iframeSrc); // abort op in progress
241
+ xhr.error = e;
242
+ s.error && s.error.call(s.context, xhr, e, status);
243
+ g && $.event.trigger("ajaxError", [xhr, s, e]);
244
+ s.complete && s.complete.call(s.context, xhr, e);
245
+ }
246
+ };
247
+
248
+ g = s.global;
249
+ // trigger ajax global events so that activity/block indicators work like normal
250
+ if (g && ! $.active++) {
251
+ $.event.trigger("ajaxStart");
252
+ }
253
+ if (g) {
254
+ $.event.trigger("ajaxSend", [xhr, s]);
255
+ }
256
+
257
+ if (s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false) {
258
+ if (s.global) {
259
+ $.active--;
260
+ }
261
+ return;
262
+ }
263
+ if (xhr.aborted) {
264
+ return;
265
+ }
266
+
267
+ // add submitting element to data if we know it
268
+ sub = form.clk;
269
+ if (sub) {
270
+ n = sub.name;
271
+ if (n && !sub.disabled) {
272
+ s.extraData = s.extraData || {};
273
+ s.extraData[n] = sub.value;
274
+ if (sub.type == "image") {
275
+ s.extraData[n+'.x'] = form.clk_x;
276
+ s.extraData[n+'.y'] = form.clk_y;
277
+ }
278
+ }
279
+ }
280
+
281
+ var CLIENT_TIMEOUT_ABORT = 1;
282
+ var SERVER_ABORT = 2;
283
+
284
+ function getDoc(frame) {
285
+ var doc = frame.contentWindow ? frame.contentWindow.document : frame.contentDocument ? frame.contentDocument : frame.document;
286
+ return doc;
287
+ }
288
+
289
+ // take a breath so that pending repaints get some cpu time before the upload starts
290
+ function doSubmit() {
291
+ // make sure form attrs are set
292
+ var t = $form.attr('target'), a = $form.attr('action');
293
+
294
+ // update form attrs in IE friendly way
295
+ form.setAttribute('target',id);
296
+ if (!method) {
297
+ form.setAttribute('method', 'POST');
298
+ }
299
+ if (a != s.url) {
300
+ form.setAttribute('action', s.url);
301
+ }
302
+
303
+ // ie borks in some cases when setting encoding
304
+ if (! s.skipEncodingOverride && (!method || /post/i.test(method))) {
305
+ $form.attr({
306
+ encoding: 'multipart/form-data',
307
+ enctype: 'multipart/form-data'
308
+ });
309
+ }
310
+
311
+ // support timout
312
+ if (s.timeout) {
313
+ timeoutHandle = setTimeout(function() { timedOut = true; cb(CLIENT_TIMEOUT_ABORT); }, s.timeout);
314
+ }
315
+
316
+ // look for server aborts
317
+ function checkState() {
318
+ try {
319
+ var state = getDoc(io).readyState;
320
+ log('state = ' + state);
321
+ if (state.toLowerCase() == 'uninitialized')
322
+ setTimeout(checkState,50);
323
+ }
324
+ catch(e) {
325
+ log('Server abort: ' , e, ' (', e.name, ')');
326
+ cb(SERVER_ABORT);
327
+ timeoutHandle && clearTimeout(timeoutHandle);
328
+ timeoutHandle = undefined;
329
+ }
330
+ }
331
+
332
+ // add "extra" data to form if provided in options
333
+ var extraInputs = [];
334
+ try {
335
+ if (s.extraData) {
336
+ for (var n in s.extraData) {
337
+ extraInputs.push(
338
+ $('<input type="hidden" name="'+n+'" />').attr('value',s.extraData[n])
339
+ .appendTo(form)[0]);
340
+ }
341
+ }
342
+
343
+ if (!s.iframeTarget) {
344
+ // add iframe to doc and submit the form
345
+ $io.appendTo('body');
346
+ io.attachEvent ? io.attachEvent('onload', cb) : io.addEventListener('load', cb, false);
347
+ }
348
+ setTimeout(checkState,15);
349
+ form.submit();
350
+ }
351
+ finally {
352
+ // reset attrs and remove "extra" input elements
353
+ form.setAttribute('action',a);
354
+ if(t) {
355
+ form.setAttribute('target', t);
356
+ } else {
357
+ $form.removeAttr('target');
358
+ }
359
+ $(extraInputs).remove();
360
+ }
361
+ }
362
+
363
+ if (s.forceSync) {
364
+ doSubmit();
365
+ }
366
+ else {
367
+ setTimeout(doSubmit, 10); // this lets dom updates render
368
+ }
369
+
370
+ var data, doc, domCheckCount = 50, callbackProcessed;
371
+
372
+ function cb(e) {
373
+ if (xhr.aborted || callbackProcessed) {
374
+ return;
375
+ }
376
+ try {
377
+ doc = getDoc(io);
378
+ }
379
+ catch(ex) {
380
+ log('cannot access response document: ', ex);
381
+ e = SERVER_ABORT;
382
+ }
383
+ if (e === CLIENT_TIMEOUT_ABORT && xhr) {
384
+ xhr.abort('timeout');
385
+ return;
386
+ }
387
+ else if (e == SERVER_ABORT && xhr) {
388
+ xhr.abort('server abort');
389
+ return;
390
+ }
391
+
392
+ if (!doc || doc.location.href == s.iframeSrc) {
393
+ // response not received yet
394
+ if (!timedOut)
395
+ return;
396
+ }
397
+ io.detachEvent ? io.detachEvent('onload', cb) : io.removeEventListener('load', cb, false);
398
+
399
+ var status = 'success', errMsg;
400
+ try {
401
+ if (timedOut) {
402
+ throw 'timeout';
403
+ }
404
+
405
+ var isXml = s.dataType == 'xml' || doc.XMLDocument || $.isXMLDoc(doc);
406
+ log('isXml='+isXml);
407
+ if (!isXml && window.opera && (doc.body == null || doc.body.innerHTML == '')) {
408
+ if (--domCheckCount) {
409
+ // in some browsers (Opera) the iframe DOM is not always traversable when
410
+ // the onload callback fires, so we loop a bit to accommodate
411
+ log('requeing onLoad callback, DOM not available');
412
+ setTimeout(cb, 250);
413
+ return;
414
+ }
415
+ // let this fall through because server response could be an empty document
416
+ //log('Could not access iframe DOM after mutiple tries.');
417
+ //throw 'DOMException: not available';
418
+ }
419
+
420
+ //log('response detected');
421
+ var docRoot = doc.body ? doc.body : doc.documentElement;
422
+ xhr.responseText = docRoot ? docRoot.innerHTML : null;
423
+ xhr.responseXML = doc.XMLDocument ? doc.XMLDocument : doc;
424
+ if (isXml)
425
+ s.dataType = 'xml';
426
+ xhr.getResponseHeader = function(header){
427
+ var headers = {'content-type': s.dataType};
428
+ return headers[header];
429
+ };
430
+ // support for XHR 'status' & 'statusText' emulation :
431
+ if (docRoot) {
432
+ xhr.status = Number( docRoot.getAttribute('status') ) || xhr.status;
433
+ xhr.statusText = docRoot.getAttribute('statusText') || xhr.statusText;
434
+ }
435
+
436
+ var dt = s.dataType || '';
437
+ var scr = /(json|script|text)/.test(dt.toLowerCase());
438
+ if (scr || s.textarea) {
439
+ // see if user embedded response in textarea
440
+ var ta = doc.getElementsByTagName('textarea')[0];
441
+ if (ta) {
442
+ xhr.responseText = ta.value;
443
+ // support for XHR 'status' & 'statusText' emulation :
444
+ xhr.status = Number( ta.getAttribute('status') ) || xhr.status;
445
+ xhr.statusText = ta.getAttribute('statusText') || xhr.statusText;
446
+ }
447
+ else if (scr) {
448
+ // account for browsers injecting pre around json response
449
+ var pre = doc.getElementsByTagName('pre')[0];
450
+ var b = doc.getElementsByTagName('body')[0];
451
+ if (pre) {
452
+ xhr.responseText = pre.textContent ? pre.textContent : pre.innerHTML;
453
+ }
454
+ else if (b) {
455
+ xhr.responseText = b.innerHTML;
456
+ }
457
+ }
458
+ }
459
+ else if (s.dataType == 'xml' && !xhr.responseXML && xhr.responseText != null) {
460
+ xhr.responseXML = toXml(xhr.responseText);
461
+ }
462
+
463
+ try {
464
+ data = httpData(xhr, s.dataType, s);
465
+ }
466
+ catch (e) {
467
+ status = 'parsererror';
468
+ xhr.error = errMsg = (e || status);
469
+ }
470
+ }
471
+ catch (e) {
472
+ log('error caught: ',e);
473
+ status = 'error';
474
+ xhr.error = errMsg = (e || status);
475
+ }
476
+
477
+ if (xhr.aborted) {
478
+ log('upload aborted');
479
+ status = null;
480
+ }
481
+
482
+ if (xhr.status) { // we've set xhr.status
483
+ status = (xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) ? 'success' : 'error';
484
+ }
485
+
486
+ // ordering of these callbacks/triggers is odd, but that's how $.ajax does it
487
+ if (status === 'success') {
488
+ s.success && s.success.call(s.context, data, 'success', xhr);
489
+ g && $.event.trigger("ajaxSuccess", [xhr, s]);
490
+ }
491
+ else if (status) {
492
+ if (errMsg == undefined)
493
+ errMsg = xhr.statusText;
494
+ s.error && s.error.call(s.context, xhr, status, errMsg);
495
+ g && $.event.trigger("ajaxError", [xhr, s, errMsg]);
496
+ }
497
+
498
+ g && $.event.trigger("ajaxComplete", [xhr, s]);
499
+
500
+ if (g && ! --$.active) {
501
+ $.event.trigger("ajaxStop");
502
+ }
503
+
504
+ s.complete && s.complete.call(s.context, xhr, status);
505
+
506
+ callbackProcessed = true;
507
+ if (s.timeout)
508
+ clearTimeout(timeoutHandle);
509
+
510
+ // clean up
511
+ setTimeout(function() {
512
+ if (!s.iframeTarget)
513
+ $io.remove();
514
+ xhr.responseXML = null;
515
+ }, 100);
516
+ }
517
+
518
+ var toXml = $.parseXML || function(s, doc) { // use parseXML if available (jQuery 1.5+)
519
+ if (window.ActiveXObject) {
520
+ doc = new ActiveXObject('Microsoft.XMLDOM');
521
+ doc.async = 'false';
522
+ doc.loadXML(s);
523
+ }
524
+ else {
525
+ doc = (new DOMParser()).parseFromString(s, 'text/xml');
526
+ }
527
+ return (doc && doc.documentElement && doc.documentElement.nodeName != 'parsererror') ? doc : null;
528
+ };
529
+ var parseJSON = $.parseJSON || function(s) {
530
+ return window['eval']('(' + s + ')');
531
+ };
532
+
533
+ var httpData = function( xhr, type, s ) { // mostly lifted from jq1.4.4
534
+
535
+ var ct = xhr.getResponseHeader('content-type') || '',
536
+ xml = type === 'xml' || !type && ct.indexOf('xml') >= 0,
537
+ data = xml ? xhr.responseXML : xhr.responseText;
538
+
539
+ if (xml && data.documentElement.nodeName === 'parsererror') {
540
+ $.error && $.error('parsererror');
541
+ }
542
+ if (s && s.dataFilter) {
543
+ data = s.dataFilter(data, type);
544
+ }
545
+ if (typeof data === 'string') {
546
+ if (type === 'json' || !type && ct.indexOf('json') >= 0) {
547
+ data = parseJSON(data);
548
+ } else if (type === "script" || !type && ct.indexOf("javascript") >= 0) {
549
+ $.globalEval(data);
550
+ }
551
+ }
552
+ return data;
553
+ };
554
+ }
555
+ };
556
+
557
+ /**
558
+ * ajaxForm() provides a mechanism for fully automating form submission.
559
+ *
560
+ * The advantages of using this method instead of ajaxSubmit() are:
561
+ *
562
+ * 1: This method will include coordinates for <input type="image" /> elements (if the element
563
+ * is used to submit the form).
564
+ * 2. This method will include the submit element's name/value data (for the element that was
565
+ * used to submit the form).
566
+ * 3. This method binds the submit() method to the form for you.
567
+ *
568
+ * The options argument for ajaxForm works exactly as it does for ajaxSubmit. ajaxForm merely
569
+ * passes the options argument along after properly binding events for submit elements and
570
+ * the form itself.
571
+ */
572
+ $.fn.ajaxForm = function(options) {
573
+ // in jQuery 1.3+ we can fix mistakes with the ready state
574
+ if (this.length === 0) {
575
+ var o = { s: this.selector, c: this.context };
576
+ if (!$.isReady && o.s) {
577
+ log('DOM not ready, queuing ajaxForm');
578
+ $(function() {
579
+ $(o.s,o.c).ajaxForm(options);
580
+ });
581
+ return this;
582
+ }
583
+ // is your DOM ready? http://docs.jquery.com/Tutorials:Introducing_$(document).ready()
584
+ log('terminating; zero elements found by selector' + ($.isReady ? '' : ' (DOM not ready)'));
585
+ return this;
586
+ }
587
+
588
+ return this.ajaxFormUnbind().bind('submit.form-plugin', function(e) {
589
+ if (!e.isDefaultPrevented()) { // if event has been canceled, don't proceed
590
+ e.preventDefault();
591
+ $(this).ajaxSubmit(options);
592
+ }
593
+ }).bind('click.form-plugin', function(e) {
594
+ var target = e.target;
595
+ var $el = $(target);
596
+ if (!($el.is(":submit,input:image"))) {
597
+ // is this a child element of the submit el? (ex: a span within a button)
598
+ var t = $el.closest(':submit');
599
+ if (t.length == 0) {
600
+ return;
601
+ }
602
+ target = t[0];
603
+ }
604
+ var form = this;
605
+ form.clk = target;
606
+ if (target.type == 'image') {
607
+ if (e.offsetX != undefined) {
608
+ form.clk_x = e.offsetX;
609
+ form.clk_y = e.offsetY;
610
+ } else if (typeof $.fn.offset == 'function') { // try to use dimensions plugin
611
+ var offset = $el.offset();
612
+ form.clk_x = e.pageX - offset.left;
613
+ form.clk_y = e.pageY - offset.top;
614
+ } else {
615
+ form.clk_x = e.pageX - target.offsetLeft;
616
+ form.clk_y = e.pageY - target.offsetTop;
617
+ }
618
+ }
619
+ // clear form vars
620
+ setTimeout(function() { form.clk = form.clk_x = form.clk_y = null; }, 100);
621
+ });
622
+ };
623
+
624
+ // ajaxFormUnbind unbinds the event handlers that were bound by ajaxForm
625
+ $.fn.ajaxFormUnbind = function() {
626
+ return this.unbind('submit.form-plugin click.form-plugin');
627
+ };
628
+
629
+ /**
630
+ * formToArray() gathers form element data into an array of objects that can
631
+ * be passed to any of the following ajax functions: $.get, $.post, or load.
632
+ * Each object in the array has both a 'name' and 'value' property. An example of
633
+ * an array for a simple login form might be:
634
+ *
635
+ * [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ]
636
+ *
637
+ * It is this array that is passed to pre-submit callback functions provided to the
638
+ * ajaxSubmit() and ajaxForm() methods.
639
+ */
640
+ $.fn.formToArray = function(semantic) {
641
+ var a = [];
642
+ if (this.length === 0) {
643
+ return a;
644
+ }
645
+
646
+ var form = this[0];
647
+ var els = semantic ? form.getElementsByTagName('*') : form.elements;
648
+ if (!els) {
649
+ return a;
650
+ }
651
+
652
+ var i,j,n,v,el,max,jmax;
653
+ for(i=0, max=els.length; i < max; i++) {
654
+ el = els[i];
655
+ n = el.name;
656
+ if (!n) {
657
+ continue;
658
+ }
659
+
660
+ if (semantic && form.clk && el.type == "image") {
661
+ // handle image inputs on the fly when semantic == true
662
+ if(!el.disabled && form.clk == el) {
663
+ a.push({name: n, value: $(el).val()});
664
+ a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});
665
+ }
666
+ continue;
667
+ }
668
+
669
+ v = $.fieldValue(el, true);
670
+ if (v && v.constructor == Array) {
671
+ for(j=0, jmax=v.length; j < jmax; j++) {
672
+ a.push({name: n, value: v[j]});
673
+ }
674
+ }
675
+ else if (v !== null && typeof v != 'undefined') {
676
+ a.push({name: n, value: v});
677
+ }
678
+ }
679
+
680
+ if (!semantic && form.clk) {
681
+ // input type=='image' are not found in elements array! handle it here
682
+ var $input = $(form.clk), input = $input[0];
683
+ n = input.name;
684
+ if (n && !input.disabled && input.type == 'image') {
685
+ a.push({name: n, value: $input.val()});
686
+ a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});
687
+ }
688
+ }
689
+ return a;
690
+ };
691
+
692
+ /**
693
+ * Serializes form data into a 'submittable' string. This method will return a string
694
+ * in the format: name1=value1&amp;name2=value2
695
+ */
696
+ $.fn.formSerialize = function(semantic) {
697
+ //hand off to jQuery.param for proper encoding
698
+ return $.param(this.formToArray(semantic));
699
+ };
700
+
701
+ /**
702
+ * Serializes all field elements in the jQuery object into a query string.
703
+ * This method will return a string in the format: name1=value1&amp;name2=value2
704
+ */
705
+ $.fn.fieldSerialize = function(successful) {
706
+ var a = [];
707
+ this.each(function() {
708
+ var n = this.name;
709
+ if (!n) {
710
+ return;
711
+ }
712
+ var v = $.fieldValue(this, successful);
713
+ if (v && v.constructor == Array) {
714
+ for (var i=0,max=v.length; i < max; i++) {
715
+ a.push({name: n, value: v[i]});
716
+ }
717
+ }
718
+ else if (v !== null && typeof v != 'undefined') {
719
+ a.push({name: this.name, value: v});
720
+ }
721
+ });
722
+ //hand off to jQuery.param for proper encoding
723
+ return $.param(a);
724
+ };
725
+
726
+ /**
727
+ * Returns the value(s) of the element in the matched set. For example, consider the following form:
728
+ *
729
+ * <form><fieldset>
730
+ * <input name="A" type="text" />
731
+ * <input name="A" type="text" />
732
+ * <input name="B" type="checkbox" value="B1" />
733
+ * <input name="B" type="checkbox" value="B2"/>
734
+ * <input name="C" type="radio" value="C1" />
735
+ * <input name="C" type="radio" value="C2" />
736
+ * </fieldset></form>
737
+ *
738
+ * var v = $(':text').fieldValue();
739
+ * // if no values are entered into the text inputs
740
+ * v == ['','']
741
+ * // if values entered into the text inputs are 'foo' and 'bar'
742
+ * v == ['foo','bar']
743
+ *
744
+ * var v = $(':checkbox').fieldValue();
745
+ * // if neither checkbox is checked
746
+ * v === undefined
747
+ * // if both checkboxes are checked
748
+ * v == ['B1', 'B2']
749
+ *
750
+ * var v = $(':radio').fieldValue();
751
+ * // if neither radio is checked
752
+ * v === undefined
753
+ * // if first radio is checked
754
+ * v == ['C1']
755
+ *
756
+ * The successful argument controls whether or not the field element must be 'successful'
757
+ * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
758
+ * The default value of the successful argument is true. If this value is false the value(s)
759
+ * for each element is returned.
760
+ *
761
+ * Note: This method *always* returns an array. If no valid value can be determined the
762
+ * array will be empty, otherwise it will contain one or more values.
763
+ */
764
+ $.fn.fieldValue = function(successful) {
765
+ for (var val=[], i=0, max=this.length; i < max; i++) {
766
+ var el = this[i];
767
+ var v = $.fieldValue(el, successful);
768
+ if (v === null || typeof v == 'undefined' || (v.constructor == Array && !v.length)) {
769
+ continue;
770
+ }
771
+ v.constructor == Array ? $.merge(val, v) : val.push(v);
772
+ }
773
+ return val;
774
+ };
775
+
776
+ /**
777
+ * Returns the value of the field element.
778
+ */
779
+ $.fieldValue = function(el, successful) {
780
+ var n = el.name, t = el.type, tag = el.tagName.toLowerCase();
781
+ if (successful === undefined) {
782
+ successful = true;
783
+ }
784
+
785
+ if (successful && (!n || el.disabled || t == 'reset' || t == 'button' ||
786
+ (t == 'checkbox' || t == 'radio') && !el.checked ||
787
+ (t == 'submit' || t == 'image') && el.form && el.form.clk != el ||
788
+ tag == 'select' && el.selectedIndex == -1)) {
789
+ return null;
790
+ }
791
+
792
+ if (tag == 'select') {
793
+ var index = el.selectedIndex;
794
+ if (index < 0) {
795
+ return null;
796
+ }
797
+ var a = [], ops = el.options;
798
+ var one = (t == 'select-one');
799
+ var max = (one ? index+1 : ops.length);
800
+ for(var i=(one ? index : 0); i < max; i++) {
801
+ var op = ops[i];
802
+ if (op.selected) {
803
+ var v = op.value;
804
+ if (!v) { // extra pain for IE...
805
+ v = (op.attributes && op.attributes['value'] && !(op.attributes['value'].specified)) ? op.text : op.value;
806
+ }
807
+ if (one) {
808
+ return v;
809
+ }
810
+ a.push(v);
811
+ }
812
+ }
813
+ return a;
814
+ }
815
+ return $(el).val();
816
+ };
817
+
818
+ /**
819
+ * Clears the form data. Takes the following actions on the form's input fields:
820
+ * - input text fields will have their 'value' property set to the empty string
821
+ * - select elements will have their 'selectedIndex' property set to -1
822
+ * - checkbox and radio inputs will have their 'checked' property set to false
823
+ * - inputs of type submit, button, reset, and hidden will *not* be effected
824
+ * - button elements will *not* be effected
825
+ */
826
+ $.fn.clearForm = function() {
827
+ return this.each(function() {
828
+ $('input,select,textarea', this).clearFields();
829
+ });
830
+ };
831
+
832
+ /**
833
+ * Clears the selected form elements.
834
+ */
835
+ $.fn.clearFields = $.fn.clearInputs = function() {
836
+ var re = /^(?:color|date|datetime|email|month|number|password|range|search|tel|text|time|url|week)$/i; // 'hidden' is not in this list
837
+ return this.each(function() {
838
+ var t = this.type, tag = this.tagName.toLowerCase();
839
+ if (re.test(t) || tag == 'textarea') {
840
+ this.value = '';
841
+ }
842
+ else if (t == 'checkbox' || t == 'radio') {
843
+ this.checked = false;
844
+ }
845
+ else if (tag == 'select') {
846
+ this.selectedIndex = -1;
847
+ }
848
+ });
849
+ };
850
+
851
+ /**
852
+ * Resets the form data. Causes all form elements to be reset to their original value.
853
+ */
854
+ $.fn.resetForm = function() {
855
+ return this.each(function() {
856
+ // guard against an input with the name of 'reset'
857
+ // note that IE reports the reset function as an 'object'
858
+ if (typeof this.reset == 'function' || (typeof this.reset == 'object' && !this.reset.nodeType)) {
859
+ this.reset();
860
+ }
861
+ });
862
+ };
863
+
864
+ /**
865
+ * Enables or disables any matching elements.
866
+ */
867
+ $.fn.enable = function(b) {
868
+ if (b === undefined) {
869
+ b = true;
870
+ }
871
+ return this.each(function() {
872
+ this.disabled = !b;
873
+ });
874
+ };
875
+
876
+ /**
877
+ * Checks/unchecks any matching checkboxes or radio buttons and
878
+ * selects/deselects and matching option elements.
879
+ */
880
+ $.fn.selected = function(select) {
881
+ if (select === undefined) {
882
+ select = true;
883
+ }
884
+ return this.each(function() {
885
+ var t = this.type;
886
+ if (t == 'checkbox' || t == 'radio') {
887
+ this.checked = select;
888
+ }
889
+ else if (this.tagName.toLowerCase() == 'option') {
890
+ var $sel = $(this).parent('select');
891
+ if (select && $sel[0] && $sel[0].type == 'select-one') {
892
+ // deselect all other options
893
+ $sel.find('option').selected(false);
894
+ }
895
+ this.selected = select;
896
+ }
897
+ });
898
+ };
899
+
900
+ // helper fn for console logging
901
+ function log() {
902
+ var msg = '[jquery.form] ' + Array.prototype.join.call(arguments,'');
903
+ if (window.console && window.console.log) {
904
+ window.console.log(msg);
905
+ }
906
+ else if (window.opera && window.opera.postError) {
907
+ window.opera.postError(msg);
908
+ }
909
+ };
910
+
911
+ })(jQuery);