|
7
|
1 /*!
|
|
|
2 * jQuery JavaScript Library v1.6.1
|
|
|
3 * http://jquery.com/
|
|
|
4 *
|
|
|
5 * Copyright 2011, John Resig
|
|
|
6 * Dual licensed under the MIT or GPL Version 2 licenses.
|
|
|
7 * http://jquery.org/license
|
|
|
8 *
|
|
|
9 * Includes Sizzle.js
|
|
|
10 * http://sizzlejs.com/
|
|
|
11 * Copyright 2011, The Dojo Foundation
|
|
|
12 * Released under the MIT, BSD, and GPL Licenses.
|
|
|
13 *
|
|
|
14 * Date: Thu May 12 15:04:36 2011 -0400
|
|
|
15 */
|
|
|
16 (function( window, undefined ) {
|
|
|
17
|
|
|
18 // Use the correct document accordingly with window argument (sandbox)
|
|
|
19 var document = window.document,
|
|
|
20 navigator = window.navigator,
|
|
|
21 location = window.location;
|
|
|
22 var jQuery = (function() {
|
|
|
23
|
|
|
24 // Define a local copy of jQuery
|
|
|
25 var jQuery = function( selector, context ) {
|
|
|
26 // The jQuery object is actually just the init constructor 'enhanced'
|
|
|
27 return new jQuery.fn.init( selector, context, rootjQuery );
|
|
|
28 },
|
|
|
29
|
|
|
30 // Map over jQuery in case of overwrite
|
|
|
31 _jQuery = window.jQuery,
|
|
|
32
|
|
|
33 // Map over the $ in case of overwrite
|
|
|
34 _$ = window.$,
|
|
|
35
|
|
|
36 // A central reference to the root jQuery(document)
|
|
|
37 rootjQuery,
|
|
|
38
|
|
|
39 // A simple way to check for HTML strings or ID strings
|
|
|
40 // (both of which we optimize for)
|
|
|
41 quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
|
|
|
42
|
|
|
43 // Check if a string has a non-whitespace character in it
|
|
|
44 rnotwhite = /\S/,
|
|
|
45
|
|
|
46 // Used for trimming whitespace
|
|
|
47 trimLeft = /^\s+/,
|
|
|
48 trimRight = /\s+$/,
|
|
|
49
|
|
|
50 // Check for digits
|
|
|
51 rdigit = /\d/,
|
|
|
52
|
|
|
53 // Match a standalone tag
|
|
|
54 rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
|
|
|
55
|
|
|
56 // JSON RegExp
|
|
|
57 rvalidchars = /^[\],:{}\s]*$/,
|
|
|
58 rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
|
|
|
59 rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
|
|
|
60 rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
|
|
|
61
|
|
|
62 // Useragent RegExp
|
|
|
63 rwebkit = /(webkit)[ \/]([\w.]+)/,
|
|
|
64 ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
|
|
|
65 rmsie = /(msie) ([\w.]+)/,
|
|
|
66 rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
|
|
|
67
|
|
|
68 // Keep a UserAgent string for use with jQuery.browser
|
|
|
69 userAgent = navigator.userAgent,
|
|
|
70
|
|
|
71 // For matching the engine and version of the browser
|
|
|
72 browserMatch,
|
|
|
73
|
|
|
74 // The deferred used on DOM ready
|
|
|
75 readyList,
|
|
|
76
|
|
|
77 // The ready event handler
|
|
|
78 DOMContentLoaded,
|
|
|
79
|
|
|
80 // Save a reference to some core methods
|
|
|
81 toString = Object.prototype.toString,
|
|
|
82 hasOwn = Object.prototype.hasOwnProperty,
|
|
|
83 push = Array.prototype.push,
|
|
|
84 slice = Array.prototype.slice,
|
|
|
85 trim = String.prototype.trim,
|
|
|
86 indexOf = Array.prototype.indexOf,
|
|
|
87
|
|
|
88 // [[Class]] -> type pairs
|
|
|
89 class2type = {};
|
|
|
90
|
|
|
91 jQuery.fn = jQuery.prototype = {
|
|
|
92 constructor: jQuery,
|
|
|
93 init: function( selector, context, rootjQuery ) {
|
|
|
94 var match, elem, ret, doc;
|
|
|
95
|
|
|
96 // Handle $(""), $(null), or $(undefined)
|
|
|
97 if ( !selector ) {
|
|
|
98 return this;
|
|
|
99 }
|
|
|
100
|
|
|
101 // Handle $(DOMElement)
|
|
|
102 if ( selector.nodeType ) {
|
|
|
103 this.context = this[0] = selector;
|
|
|
104 this.length = 1;
|
|
|
105 return this;
|
|
|
106 }
|
|
|
107
|
|
|
108 // The body element only exists once, optimize finding it
|
|
|
109 if ( selector === "body" && !context && document.body ) {
|
|
|
110 this.context = document;
|
|
|
111 this[0] = document.body;
|
|
|
112 this.selector = selector;
|
|
|
113 this.length = 1;
|
|
|
114 return this;
|
|
|
115 }
|
|
|
116
|
|
|
117 // Handle HTML strings
|
|
|
118 if ( typeof selector === "string" ) {
|
|
|
119 // Are we dealing with HTML string or an ID?
|
|
|
120 if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
|
|
|
121 // Assume that strings that start and end with <> are HTML and skip the regex check
|
|
|
122 match = [ null, selector, null ];
|
|
|
123
|
|
|
124 } else {
|
|
|
125 match = quickExpr.exec( selector );
|
|
|
126 }
|
|
|
127
|
|
|
128 // Verify a match, and that no context was specified for #id
|
|
|
129 if ( match && (match[1] || !context) ) {
|
|
|
130
|
|
|
131 // HANDLE: $(html) -> $(array)
|
|
|
132 if ( match[1] ) {
|
|
|
133 context = context instanceof jQuery ? context[0] : context;
|
|
|
134 doc = (context ? context.ownerDocument || context : document);
|
|
|
135
|
|
|
136 // If a single string is passed in and it's a single tag
|
|
|
137 // just do a createElement and skip the rest
|
|
|
138 ret = rsingleTag.exec( selector );
|
|
|
139
|
|
|
140 if ( ret ) {
|
|
|
141 if ( jQuery.isPlainObject( context ) ) {
|
|
|
142 selector = [ document.createElement( ret[1] ) ];
|
|
|
143 jQuery.fn.attr.call( selector, context, true );
|
|
|
144
|
|
|
145 } else {
|
|
|
146 selector = [ doc.createElement( ret[1] ) ];
|
|
|
147 }
|
|
|
148
|
|
|
149 } else {
|
|
|
150 ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
|
|
|
151 selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
|
|
|
152 }
|
|
|
153
|
|
|
154 return jQuery.merge( this, selector );
|
|
|
155
|
|
|
156 // HANDLE: $("#id")
|
|
|
157 } else {
|
|
|
158 elem = document.getElementById( match[2] );
|
|
|
159
|
|
|
160 // Check parentNode to catch when Blackberry 4.6 returns
|
|
|
161 // nodes that are no longer in the document #6963
|
|
|
162 if ( elem && elem.parentNode ) {
|
|
|
163 // Handle the case where IE and Opera return items
|
|
|
164 // by name instead of ID
|
|
|
165 if ( elem.id !== match[2] ) {
|
|
|
166 return rootjQuery.find( selector );
|
|
|
167 }
|
|
|
168
|
|
|
169 // Otherwise, we inject the element directly into the jQuery object
|
|
|
170 this.length = 1;
|
|
|
171 this[0] = elem;
|
|
|
172 }
|
|
|
173
|
|
|
174 this.context = document;
|
|
|
175 this.selector = selector;
|
|
|
176 return this;
|
|
|
177 }
|
|
|
178
|
|
|
179 // HANDLE: $(expr, $(...))
|
|
|
180 } else if ( !context || context.jquery ) {
|
|
|
181 return (context || rootjQuery).find( selector );
|
|
|
182
|
|
|
183 // HANDLE: $(expr, context)
|
|
|
184 // (which is just equivalent to: $(context).find(expr)
|
|
|
185 } else {
|
|
|
186 return this.constructor( context ).find( selector );
|
|
|
187 }
|
|
|
188
|
|
|
189 // HANDLE: $(function)
|
|
|
190 // Shortcut for document ready
|
|
|
191 } else if ( jQuery.isFunction( selector ) ) {
|
|
|
192 return rootjQuery.ready( selector );
|
|
|
193 }
|
|
|
194
|
|
|
195 if (selector.selector !== undefined) {
|
|
|
196 this.selector = selector.selector;
|
|
|
197 this.context = selector.context;
|
|
|
198 }
|
|
|
199
|
|
|
200 return jQuery.makeArray( selector, this );
|
|
|
201 },
|
|
|
202
|
|
|
203 // Start with an empty selector
|
|
|
204 selector: "",
|
|
|
205
|
|
|
206 // The current version of jQuery being used
|
|
|
207 jquery: "1.6.1",
|
|
|
208
|
|
|
209 // The default length of a jQuery object is 0
|
|
|
210 length: 0,
|
|
|
211
|
|
|
212 // The number of elements contained in the matched element set
|
|
|
213 size: function() {
|
|
|
214 return this.length;
|
|
|
215 },
|
|
|
216
|
|
|
217 toArray: function() {
|
|
|
218 return slice.call( this, 0 );
|
|
|
219 },
|
|
|
220
|
|
|
221 // Get the Nth element in the matched element set OR
|
|
|
222 // Get the whole matched element set as a clean array
|
|
|
223 get: function( num ) {
|
|
|
224 return num == null ?
|
|
|
225
|
|
|
226 // Return a 'clean' array
|
|
|
227 this.toArray() :
|
|
|
228
|
|
|
229 // Return just the object
|
|
|
230 ( num < 0 ? this[ this.length + num ] : this[ num ] );
|
|
|
231 },
|
|
|
232
|
|
|
233 // Take an array of elements and push it onto the stack
|
|
|
234 // (returning the new matched element set)
|
|
|
235 pushStack: function( elems, name, selector ) {
|
|
|
236 // Build a new jQuery matched element set
|
|
|
237 var ret = this.constructor();
|
|
|
238
|
|
|
239 if ( jQuery.isArray( elems ) ) {
|
|
|
240 push.apply( ret, elems );
|
|
|
241
|
|
|
242 } else {
|
|
|
243 jQuery.merge( ret, elems );
|
|
|
244 }
|
|
|
245
|
|
|
246 // Add the old object onto the stack (as a reference)
|
|
|
247 ret.prevObject = this;
|
|
|
248
|
|
|
249 ret.context = this.context;
|
|
|
250
|
|
|
251 if ( name === "find" ) {
|
|
|
252 ret.selector = this.selector + (this.selector ? " " : "") + selector;
|
|
|
253 } else if ( name ) {
|
|
|
254 ret.selector = this.selector + "." + name + "(" + selector + ")";
|
|
|
255 }
|
|
|
256
|
|
|
257 // Return the newly-formed element set
|
|
|
258 return ret;
|
|
|
259 },
|
|
|
260
|
|
|
261 // Execute a callback for every element in the matched set.
|
|
|
262 // (You can seed the arguments with an array of args, but this is
|
|
|
263 // only used internally.)
|
|
|
264 each: function( callback, args ) {
|
|
|
265 return jQuery.each( this, callback, args );
|
|
|
266 },
|
|
|
267
|
|
|
268 ready: function( fn ) {
|
|
|
269 // Attach the listeners
|
|
|
270 jQuery.bindReady();
|
|
|
271
|
|
|
272 // Add the callback
|
|
|
273 readyList.done( fn );
|
|
|
274
|
|
|
275 return this;
|
|
|
276 },
|
|
|
277
|
|
|
278 eq: function( i ) {
|
|
|
279 return i === -1 ?
|
|
|
280 this.slice( i ) :
|
|
|
281 this.slice( i, +i + 1 );
|
|
|
282 },
|
|
|
283
|
|
|
284 first: function() {
|
|
|
285 return this.eq( 0 );
|
|
|
286 },
|
|
|
287
|
|
|
288 last: function() {
|
|
|
289 return this.eq( -1 );
|
|
|
290 },
|
|
|
291
|
|
|
292 slice: function() {
|
|
|
293 return this.pushStack( slice.apply( this, arguments ),
|
|
|
294 "slice", slice.call(arguments).join(",") );
|
|
|
295 },
|
|
|
296
|
|
|
297 map: function( callback ) {
|
|
|
298 return this.pushStack( jQuery.map(this, function( elem, i ) {
|
|
|
299 return callback.call( elem, i, elem );
|
|
|
300 }));
|
|
|
301 },
|
|
|
302
|
|
|
303 end: function() {
|
|
|
304 return this.prevObject || this.constructor(null);
|
|
|
305 },
|
|
|
306
|
|
|
307 // For internal use only.
|
|
|
308 // Behaves like an Array's method, not like a jQuery method.
|
|
|
309 push: push,
|
|
|
310 sort: [].sort,
|
|
|
311 splice: [].splice
|
|
|
312 };
|
|
|
313
|
|
|
314 // Give the init function the jQuery prototype for later instantiation
|
|
|
315 jQuery.fn.init.prototype = jQuery.fn;
|
|
|
316
|
|
|
317 jQuery.extend = jQuery.fn.extend = function() {
|
|
|
318 var options, name, src, copy, copyIsArray, clone,
|
|
|
319 target = arguments[0] || {},
|
|
|
320 i = 1,
|
|
|
321 length = arguments.length,
|
|
|
322 deep = false;
|
|
|
323
|
|
|
324 // Handle a deep copy situation
|
|
|
325 if ( typeof target === "boolean" ) {
|
|
|
326 deep = target;
|
|
|
327 target = arguments[1] || {};
|
|
|
328 // skip the boolean and the target
|
|
|
329 i = 2;
|
|
|
330 }
|
|
|
331
|
|
|
332 // Handle case when target is a string or something (possible in deep copy)
|
|
|
333 if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
|
|
|
334 target = {};
|
|
|
335 }
|
|
|
336
|
|
|
337 // extend jQuery itself if only one argument is passed
|
|
|
338 if ( length === i ) {
|
|
|
339 target = this;
|
|
|
340 --i;
|
|
|
341 }
|
|
|
342
|
|
|
343 for ( ; i < length; i++ ) {
|
|
|
344 // Only deal with non-null/undefined values
|
|
|
345 if ( (options = arguments[ i ]) != null ) {
|
|
|
346 // Extend the base object
|
|
|
347 for ( name in options ) {
|
|
|
348 src = target[ name ];
|
|
|
349 copy = options[ name ];
|
|
|
350
|
|
|
351 // Prevent never-ending loop
|
|
|
352 if ( target === copy ) {
|
|
|
353 continue;
|
|
|
354 }
|
|
|
355
|
|
|
356 // Recurse if we're merging plain objects or arrays
|
|
|
357 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
|
|
|
358 if ( copyIsArray ) {
|
|
|
359 copyIsArray = false;
|
|
|
360 clone = src && jQuery.isArray(src) ? src : [];
|
|
|
361
|
|
|
362 } else {
|
|
|
363 clone = src && jQuery.isPlainObject(src) ? src : {};
|
|
|
364 }
|
|
|
365
|
|
|
366 // Never move original objects, clone them
|
|
|
367 target[ name ] = jQuery.extend( deep, clone, copy );
|
|
|
368
|
|
|
369 // Don't bring in undefined values
|
|
|
370 } else if ( copy !== undefined ) {
|
|
|
371 target[ name ] = copy;
|
|
|
372 }
|
|
|
373 }
|
|
|
374 }
|
|
|
375 }
|
|
|
376
|
|
|
377 // Return the modified object
|
|
|
378 return target;
|
|
|
379 };
|
|
|
380
|
|
|
381 jQuery.extend({
|
|
|
382 noConflict: function( deep ) {
|
|
|
383 if ( window.$ === jQuery ) {
|
|
|
384 window.$ = _$;
|
|
|
385 }
|
|
|
386
|
|
|
387 if ( deep && window.jQuery === jQuery ) {
|
|
|
388 window.jQuery = _jQuery;
|
|
|
389 }
|
|
|
390
|
|
|
391 return jQuery;
|
|
|
392 },
|
|
|
393
|
|
|
394 // Is the DOM ready to be used? Set to true once it occurs.
|
|
|
395 isReady: false,
|
|
|
396
|
|
|
397 // A counter to track how many items to wait for before
|
|
|
398 // the ready event fires. See #6781
|
|
|
399 readyWait: 1,
|
|
|
400
|
|
|
401 // Hold (or release) the ready event
|
|
|
402 holdReady: function( hold ) {
|
|
|
403 if ( hold ) {
|
|
|
404 jQuery.readyWait++;
|
|
|
405 } else {
|
|
|
406 jQuery.ready( true );
|
|
|
407 }
|
|
|
408 },
|
|
|
409
|
|
|
410 // Handle when the DOM is ready
|
|
|
411 ready: function( wait ) {
|
|
|
412 // Either a released hold or an DOMready/load event and not yet ready
|
|
|
413 if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
|
|
|
414 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
|
|
|
415 if ( !document.body ) {
|
|
|
416 return setTimeout( jQuery.ready, 1 );
|
|
|
417 }
|
|
|
418
|
|
|
419 // Remember that the DOM is ready
|
|
|
420 jQuery.isReady = true;
|
|
|
421
|
|
|
422 // If a normal DOM Ready event fired, decrement, and wait if need be
|
|
|
423 if ( wait !== true && --jQuery.readyWait > 0 ) {
|
|
|
424 return;
|
|
|
425 }
|
|
|
426
|
|
|
427 // If there are functions bound, to execute
|
|
|
428 readyList.resolveWith( document, [ jQuery ] );
|
|
|
429
|
|
|
430 // Trigger any bound ready events
|
|
|
431 if ( jQuery.fn.trigger ) {
|
|
|
432 jQuery( document ).trigger( "ready" ).unbind( "ready" );
|
|
|
433 }
|
|
|
434 }
|
|
|
435 },
|
|
|
436
|
|
|
437 bindReady: function() {
|
|
|
438 if ( readyList ) {
|
|
|
439 return;
|
|
|
440 }
|
|
|
441
|
|
|
442 readyList = jQuery._Deferred();
|
|
|
443
|
|
|
444 // Catch cases where $(document).ready() is called after the
|
|
|
445 // browser event has already occurred.
|
|
|
446 if ( document.readyState === "complete" ) {
|
|
|
447 // Handle it asynchronously to allow scripts the opportunity to delay ready
|
|
|
448 return setTimeout( jQuery.ready, 1 );
|
|
|
449 }
|
|
|
450
|
|
|
451 // Mozilla, Opera and webkit nightlies currently support this event
|
|
|
452 if ( document.addEventListener ) {
|
|
|
453 // Use the handy event callback
|
|
|
454 document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
|
|
|
455
|
|
|
456 // A fallback to window.onload, that will always work
|
|
|
457 window.addEventListener( "load", jQuery.ready, false );
|
|
|
458
|
|
|
459 // If IE event model is used
|
|
|
460 } else if ( document.attachEvent ) {
|
|
|
461 // ensure firing before onload,
|
|
|
462 // maybe late but safe also for iframes
|
|
|
463 document.attachEvent( "onreadystatechange", DOMContentLoaded );
|
|
|
464
|
|
|
465 // A fallback to window.onload, that will always work
|
|
|
466 window.attachEvent( "onload", jQuery.ready );
|
|
|
467
|
|
|
468 // If IE and not a frame
|
|
|
469 // continually check to see if the document is ready
|
|
|
470 var toplevel = false;
|
|
|
471
|
|
|
472 try {
|
|
|
473 toplevel = window.frameElement == null;
|
|
|
474 } catch(e) {}
|
|
|
475
|
|
|
476 if ( document.documentElement.doScroll && toplevel ) {
|
|
|
477 doScrollCheck();
|
|
|
478 }
|
|
|
479 }
|
|
|
480 },
|
|
|
481
|
|
|
482 // See test/unit/core.js for details concerning isFunction.
|
|
|
483 // Since version 1.3, DOM methods and functions like alert
|
|
|
484 // aren't supported. They return false on IE (#2968).
|
|
|
485 isFunction: function( obj ) {
|
|
|
486 return jQuery.type(obj) === "function";
|
|
|
487 },
|
|
|
488
|
|
|
489 isArray: Array.isArray || function( obj ) {
|
|
|
490 return jQuery.type(obj) === "array";
|
|
|
491 },
|
|
|
492
|
|
|
493 // A crude way of determining if an object is a window
|
|
|
494 isWindow: function( obj ) {
|
|
|
495 return obj && typeof obj === "object" && "setInterval" in obj;
|
|
|
496 },
|
|
|
497
|
|
|
498 isNaN: function( obj ) {
|
|
|
499 return obj == null || !rdigit.test( obj ) || isNaN( obj );
|
|
|
500 },
|
|
|
501
|
|
|
502 type: function( obj ) {
|
|
|
503 return obj == null ?
|
|
|
504 String( obj ) :
|
|
|
505 class2type[ toString.call(obj) ] || "object";
|
|
|
506 },
|
|
|
507
|
|
|
508 isPlainObject: function( obj ) {
|
|
|
509 // Must be an Object.
|
|
|
510 // Because of IE, we also have to check the presence of the constructor property.
|
|
|
511 // Make sure that DOM nodes and window objects don't pass through, as well
|
|
|
512 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
|
|
|
513 return false;
|
|
|
514 }
|
|
|
515
|
|
|
516 // Not own constructor property must be Object
|
|
|
517 if ( obj.constructor &&
|
|
|
518 !hasOwn.call(obj, "constructor") &&
|
|
|
519 !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
|
|
|
520 return false;
|
|
|
521 }
|
|
|
522
|
|
|
523 // Own properties are enumerated firstly, so to speed up,
|
|
|
524 // if last one is own, then all properties are own.
|
|
|
525
|
|
|
526 var key;
|
|
|
527 for ( key in obj ) {}
|
|
|
528
|
|
|
529 return key === undefined || hasOwn.call( obj, key );
|
|
|
530 },
|
|
|
531
|
|
|
532 isEmptyObject: function( obj ) {
|
|
|
533 for ( var name in obj ) {
|
|
|
534 return false;
|
|
|
535 }
|
|
|
536 return true;
|
|
|
537 },
|
|
|
538
|
|
|
539 error: function( msg ) {
|
|
|
540 throw msg;
|
|
|
541 },
|
|
|
542
|
|
|
543 parseJSON: function( data ) {
|
|
|
544 if ( typeof data !== "string" || !data ) {
|
|
|
545 return null;
|
|
|
546 }
|
|
|
547
|
|
|
548 // Make sure leading/trailing whitespace is removed (IE can't handle it)
|
|
|
549 data = jQuery.trim( data );
|
|
|
550
|
|
|
551 // Attempt to parse using the native JSON parser first
|
|
|
552 if ( window.JSON && window.JSON.parse ) {
|
|
|
553 return window.JSON.parse( data );
|
|
|
554 }
|
|
|
555
|
|
|
556 // Make sure the incoming data is actual JSON
|
|
|
557 // Logic borrowed from http://json.org/json2.js
|
|
|
558 if ( rvalidchars.test( data.replace( rvalidescape, "@" )
|
|
|
559 .replace( rvalidtokens, "]" )
|
|
|
560 .replace( rvalidbraces, "")) ) {
|
|
|
561
|
|
|
562 return (new Function( "return " + data ))();
|
|
|
563
|
|
|
564 }
|
|
|
565 jQuery.error( "Invalid JSON: " + data );
|
|
|
566 },
|
|
|
567
|
|
|
568 // Cross-browser xml parsing
|
|
|
569 // (xml & tmp used internally)
|
|
|
570 parseXML: function( data , xml , tmp ) {
|
|
|
571
|
|
|
572 if ( window.DOMParser ) { // Standard
|
|
|
573 tmp = new DOMParser();
|
|
|
574 xml = tmp.parseFromString( data , "text/xml" );
|
|
|
575 } else { // IE
|
|
|
576 xml = new ActiveXObject( "Microsoft.XMLDOM" );
|
|
|
577 xml.async = "false";
|
|
|
578 xml.loadXML( data );
|
|
|
579 }
|
|
|
580
|
|
|
581 tmp = xml.documentElement;
|
|
|
582
|
|
|
583 if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
|
|
|
584 jQuery.error( "Invalid XML: " + data );
|
|
|
585 }
|
|
|
586
|
|
|
587 return xml;
|
|
|
588 },
|
|
|
589
|
|
|
590 noop: function() {},
|
|
|
591
|
|
|
592 // Evaluates a script in a global context
|
|
|
593 // Workarounds based on findings by Jim Driscoll
|
|
|
594 // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
|
|
|
595 globalEval: function( data ) {
|
|
|
596 if ( data && rnotwhite.test( data ) ) {
|
|
|
597 // We use execScript on Internet Explorer
|
|
|
598 // We use an anonymous function so that context is window
|
|
|
599 // rather than jQuery in Firefox
|
|
|
600 ( window.execScript || function( data ) {
|
|
|
601 window[ "eval" ].call( window, data );
|
|
|
602 } )( data );
|
|
|
603 }
|
|
|
604 },
|
|
|
605
|
|
|
606 nodeName: function( elem, name ) {
|
|
|
607 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
|
|
|
608 },
|
|
|
609
|
|
|
610 // args is for internal usage only
|
|
|
611 each: function( object, callback, args ) {
|
|
|
612 var name, i = 0,
|
|
|
613 length = object.length,
|
|
|
614 isObj = length === undefined || jQuery.isFunction( object );
|
|
|
615
|
|
|
616 if ( args ) {
|
|
|
617 if ( isObj ) {
|
|
|
618 for ( name in object ) {
|
|
|
619 if ( callback.apply( object[ name ], args ) === false ) {
|
|
|
620 break;
|
|
|
621 }
|
|
|
622 }
|
|
|
623 } else {
|
|
|
624 for ( ; i < length; ) {
|
|
|
625 if ( callback.apply( object[ i++ ], args ) === false ) {
|
|
|
626 break;
|
|
|
627 }
|
|
|
628 }
|
|
|
629 }
|
|
|
630
|
|
|
631 // A special, fast, case for the most common use of each
|
|
|
632 } else {
|
|
|
633 if ( isObj ) {
|
|
|
634 for ( name in object ) {
|
|
|
635 if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
|
|
|
636 break;
|
|
|
637 }
|
|
|
638 }
|
|
|
639 } else {
|
|
|
640 for ( ; i < length; ) {
|
|
|
641 if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
|
|
|
642 break;
|
|
|
643 }
|
|
|
644 }
|
|
|
645 }
|
|
|
646 }
|
|
|
647
|
|
|
648 return object;
|
|
|
649 },
|
|
|
650
|
|
|
651 // Use native String.trim function wherever possible
|
|
|
652 trim: trim ?
|
|
|
653 function( text ) {
|
|
|
654 return text == null ?
|
|
|
655 "" :
|
|
|
656 trim.call( text );
|
|
|
657 } :
|
|
|
658
|
|
|
659 // Otherwise use our own trimming functionality
|
|
|
660 function( text ) {
|
|
|
661 return text == null ?
|
|
|
662 "" :
|
|
|
663 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
|
|
|
664 },
|
|
|
665
|
|
|
666 // results is for internal usage only
|
|
|
667 makeArray: function( array, results ) {
|
|
|
668 var ret = results || [];
|
|
|
669
|
|
|
670 if ( array != null ) {
|
|
|
671 // The window, strings (and functions) also have 'length'
|
|
|
672 // The extra typeof function check is to prevent crashes
|
|
|
673 // in Safari 2 (See: #3039)
|
|
|
674 // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
|
|
|
675 var type = jQuery.type( array );
|
|
|
676
|
|
|
677 if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
|
|
|
678 push.call( ret, array );
|
|
|
679 } else {
|
|
|
680 jQuery.merge( ret, array );
|
|
|
681 }
|
|
|
682 }
|
|
|
683
|
|
|
684 return ret;
|
|
|
685 },
|
|
|
686
|
|
|
687 inArray: function( elem, array ) {
|
|
|
688
|
|
|
689 if ( indexOf ) {
|
|
|
690 return indexOf.call( array, elem );
|
|
|
691 }
|
|
|
692
|
|
|
693 for ( var i = 0, length = array.length; i < length; i++ ) {
|
|
|
694 if ( array[ i ] === elem ) {
|
|
|
695 return i;
|
|
|
696 }
|
|
|
697 }
|
|
|
698
|
|
|
699 return -1;
|
|
|
700 },
|
|
|
701
|
|
|
702 merge: function( first, second ) {
|
|
|
703 var i = first.length,
|
|
|
704 j = 0;
|
|
|
705
|
|
|
706 if ( typeof second.length === "number" ) {
|
|
|
707 for ( var l = second.length; j < l; j++ ) {
|
|
|
708 first[ i++ ] = second[ j ];
|
|
|
709 }
|
|
|
710
|
|
|
711 } else {
|
|
|
712 while ( second[j] !== undefined ) {
|
|
|
713 first[ i++ ] = second[ j++ ];
|
|
|
714 }
|
|
|
715 }
|
|
|
716
|
|
|
717 first.length = i;
|
|
|
718
|
|
|
719 return first;
|
|
|
720 },
|
|
|
721
|
|
|
722 grep: function( elems, callback, inv ) {
|
|
|
723 var ret = [], retVal;
|
|
|
724 inv = !!inv;
|
|
|
725
|
|
|
726 // Go through the array, only saving the items
|
|
|
727 // that pass the validator function
|
|
|
728 for ( var i = 0, length = elems.length; i < length; i++ ) {
|
|
|
729 retVal = !!callback( elems[ i ], i );
|
|
|
730 if ( inv !== retVal ) {
|
|
|
731 ret.push( elems[ i ] );
|
|
|
732 }
|
|
|
733 }
|
|
|
734
|
|
|
735 return ret;
|
|
|
736 },
|
|
|
737
|
|
|
738 // arg is for internal usage only
|
|
|
739 map: function( elems, callback, arg ) {
|
|
|
740 var value, key, ret = [],
|
|
|
741 i = 0,
|
|
|
742 length = elems.length,
|
|
|
743 // jquery objects are treated as arrays
|
|
|
744 isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
|
|
|
745
|
|
|
746 // Go through the array, translating each of the items to their
|
|
|
747 if ( isArray ) {
|
|
|
748 for ( ; i < length; i++ ) {
|
|
|
749 value = callback( elems[ i ], i, arg );
|
|
|
750
|
|
|
751 if ( value != null ) {
|
|
|
752 ret[ ret.length ] = value;
|
|
|
753 }
|
|
|
754 }
|
|
|
755
|
|
|
756 // Go through every key on the object,
|
|
|
757 } else {
|
|
|
758 for ( key in elems ) {
|
|
|
759 value = callback( elems[ key ], key, arg );
|
|
|
760
|
|
|
761 if ( value != null ) {
|
|
|
762 ret[ ret.length ] = value;
|
|
|
763 }
|
|
|
764 }
|
|
|
765 }
|
|
|
766
|
|
|
767 // Flatten any nested arrays
|
|
|
768 return ret.concat.apply( [], ret );
|
|
|
769 },
|
|
|
770
|
|
|
771 // A global GUID counter for objects
|
|
|
772 guid: 1,
|
|
|
773
|
|
|
774 // Bind a function to a context, optionally partially applying any
|
|
|
775 // arguments.
|
|
|
776 proxy: function( fn, context ) {
|
|
|
777 if ( typeof context === "string" ) {
|
|
|
778 var tmp = fn[ context ];
|
|
|
779 context = fn;
|
|
|
780 fn = tmp;
|
|
|
781 }
|
|
|
782
|
|
|
783 // Quick check to determine if target is callable, in the spec
|
|
|
784 // this throws a TypeError, but we will just return undefined.
|
|
|
785 if ( !jQuery.isFunction( fn ) ) {
|
|
|
786 return undefined;
|
|
|
787 }
|
|
|
788
|
|
|
789 // Simulated bind
|
|
|
790 var args = slice.call( arguments, 2 ),
|
|
|
791 proxy = function() {
|
|
|
792 return fn.apply( context, args.concat( slice.call( arguments ) ) );
|
|
|
793 };
|
|
|
794
|
|
|
795 // Set the guid of unique handler to the same of original handler, so it can be removed
|
|
|
796 proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
|
|
|
797
|
|
|
798 return proxy;
|
|
|
799 },
|
|
|
800
|
|
|
801 // Mutifunctional method to get and set values to a collection
|
|
|
802 // The value/s can be optionally by executed if its a function
|
|
|
803 access: function( elems, key, value, exec, fn, pass ) {
|
|
|
804 var length = elems.length;
|
|
|
805
|
|
|
806 // Setting many attributes
|
|
|
807 if ( typeof key === "object" ) {
|
|
|
808 for ( var k in key ) {
|
|
|
809 jQuery.access( elems, k, key[k], exec, fn, value );
|
|
|
810 }
|
|
|
811 return elems;
|
|
|
812 }
|
|
|
813
|
|
|
814 // Setting one attribute
|
|
|
815 if ( value !== undefined ) {
|
|
|
816 // Optionally, function values get executed if exec is true
|
|
|
817 exec = !pass && exec && jQuery.isFunction(value);
|
|
|
818
|
|
|
819 for ( var i = 0; i < length; i++ ) {
|
|
|
820 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
|
|
|
821 }
|
|
|
822
|
|
|
823 return elems;
|
|
|
824 }
|
|
|
825
|
|
|
826 // Getting an attribute
|
|
|
827 return length ? fn( elems[0], key ) : undefined;
|
|
|
828 },
|
|
|
829
|
|
|
830 now: function() {
|
|
|
831 return (new Date()).getTime();
|
|
|
832 },
|
|
|
833
|
|
|
834 // Use of jQuery.browser is frowned upon.
|
|
|
835 // More details: http://docs.jquery.com/Utilities/jQuery.browser
|
|
|
836 uaMatch: function( ua ) {
|
|
|
837 ua = ua.toLowerCase();
|
|
|
838
|
|
|
839 var match = rwebkit.exec( ua ) ||
|
|
|
840 ropera.exec( ua ) ||
|
|
|
841 rmsie.exec( ua ) ||
|
|
|
842 ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
|
|
|
843 [];
|
|
|
844
|
|
|
845 return { browser: match[1] || "", version: match[2] || "0" };
|
|
|
846 },
|
|
|
847
|
|
|
848 sub: function() {
|
|
|
849 function jQuerySub( selector, context ) {
|
|
|
850 return new jQuerySub.fn.init( selector, context );
|
|
|
851 }
|
|
|
852 jQuery.extend( true, jQuerySub, this );
|
|
|
853 jQuerySub.superclass = this;
|
|
|
854 jQuerySub.fn = jQuerySub.prototype = this();
|
|
|
855 jQuerySub.fn.constructor = jQuerySub;
|
|
|
856 jQuerySub.sub = this.sub;
|
|
|
857 jQuerySub.fn.init = function init( selector, context ) {
|
|
|
858 if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
|
|
|
859 context = jQuerySub( context );
|
|
|
860 }
|
|
|
861
|
|
|
862 return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
|
|
|
863 };
|
|
|
864 jQuerySub.fn.init.prototype = jQuerySub.fn;
|
|
|
865 var rootjQuerySub = jQuerySub(document);
|
|
|
866 return jQuerySub;
|
|
|
867 },
|
|
|
868
|
|
|
869 browser: {}
|
|
|
870 });
|
|
|
871
|
|
|
872 // Populate the class2type map
|
|
|
873 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
|
|
|
874 class2type[ "[object " + name + "]" ] = name.toLowerCase();
|
|
|
875 });
|
|
|
876
|
|
|
877 browserMatch = jQuery.uaMatch( userAgent );
|
|
|
878 if ( browserMatch.browser ) {
|
|
|
879 jQuery.browser[ browserMatch.browser ] = true;
|
|
|
880 jQuery.browser.version = browserMatch.version;
|
|
|
881 }
|
|
|
882
|
|
|
883 // Deprecated, use jQuery.browser.webkit instead
|
|
|
884 if ( jQuery.browser.webkit ) {
|
|
|
885 jQuery.browser.safari = true;
|
|
|
886 }
|
|
|
887
|
|
|
888 // IE doesn't match non-breaking spaces with \s
|
|
|
889 if ( rnotwhite.test( "\xA0" ) ) {
|
|
|
890 trimLeft = /^[\s\xA0]+/;
|
|
|
891 trimRight = /[\s\xA0]+$/;
|
|
|
892 }
|
|
|
893
|
|
|
894 // All jQuery objects should point back to these
|
|
|
895 rootjQuery = jQuery(document);
|
|
|
896
|
|
|
897 // Cleanup functions for the document ready method
|
|
|
898 if ( document.addEventListener ) {
|
|
|
899 DOMContentLoaded = function() {
|
|
|
900 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
|
|
|
901 jQuery.ready();
|
|
|
902 };
|
|
|
903
|
|
|
904 } else if ( document.attachEvent ) {
|
|
|
905 DOMContentLoaded = function() {
|
|
|
906 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
|
|
|
907 if ( document.readyState === "complete" ) {
|
|
|
908 document.detachEvent( "onreadystatechange", DOMContentLoaded );
|
|
|
909 jQuery.ready();
|
|
|
910 }
|
|
|
911 };
|
|
|
912 }
|
|
|
913
|
|
|
914 // The DOM ready check for Internet Explorer
|
|
|
915 function doScrollCheck() {
|
|
|
916 if ( jQuery.isReady ) {
|
|
|
917 return;
|
|
|
918 }
|
|
|
919
|
|
|
920 try {
|
|
|
921 // If IE is used, use the trick by Diego Perini
|
|
|
922 // http://javascript.nwbox.com/IEContentLoaded/
|
|
|
923 document.documentElement.doScroll("left");
|
|
|
924 } catch(e) {
|
|
|
925 setTimeout( doScrollCheck, 1 );
|
|
|
926 return;
|
|
|
927 }
|
|
|
928
|
|
|
929 // and execute any waiting functions
|
|
|
930 jQuery.ready();
|
|
|
931 }
|
|
|
932
|
|
|
933 // Expose jQuery to the global object
|
|
|
934 return jQuery;
|
|
|
935
|
|
|
936 })();
|
|
|
937
|
|
|
938
|
|
|
939 var // Promise methods
|
|
|
940 promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
|
|
|
941 // Static reference to slice
|
|
|
942 sliceDeferred = [].slice;
|
|
|
943
|
|
|
944 jQuery.extend({
|
|
|
945 // Create a simple deferred (one callbacks list)
|
|
|
946 _Deferred: function() {
|
|
|
947 var // callbacks list
|
|
|
948 callbacks = [],
|
|
|
949 // stored [ context , args ]
|
|
|
950 fired,
|
|
|
951 // to avoid firing when already doing so
|
|
|
952 firing,
|
|
|
953 // flag to know if the deferred has been cancelled
|
|
|
954 cancelled,
|
|
|
955 // the deferred itself
|
|
|
956 deferred = {
|
|
|
957
|
|
|
958 // done( f1, f2, ...)
|
|
|
959 done: function() {
|
|
|
960 if ( !cancelled ) {
|
|
|
961 var args = arguments,
|
|
|
962 i,
|
|
|
963 length,
|
|
|
964 elem,
|
|
|
965 type,
|
|
|
966 _fired;
|
|
|
967 if ( fired ) {
|
|
|
968 _fired = fired;
|
|
|
969 fired = 0;
|
|
|
970 }
|
|
|
971 for ( i = 0, length = args.length; i < length; i++ ) {
|
|
|
972 elem = args[ i ];
|
|
|
973 type = jQuery.type( elem );
|
|
|
974 if ( type === "array" ) {
|
|
|
975 deferred.done.apply( deferred, elem );
|
|
|
976 } else if ( type === "function" ) {
|
|
|
977 callbacks.push( elem );
|
|
|
978 }
|
|
|
979 }
|
|
|
980 if ( _fired ) {
|
|
|
981 deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
|
|
|
982 }
|
|
|
983 }
|
|
|
984 return this;
|
|
|
985 },
|
|
|
986
|
|
|
987 // resolve with given context and args
|
|
|
988 resolveWith: function( context, args ) {
|
|
|
989 if ( !cancelled && !fired && !firing ) {
|
|
|
990 // make sure args are available (#8421)
|
|
|
991 args = args || [];
|
|
|
992 firing = 1;
|
|
|
993 try {
|
|
|
994 while( callbacks[ 0 ] ) {
|
|
|
995 callbacks.shift().apply( context, args );
|
|
|
996 }
|
|
|
997 }
|
|
|
998 finally {
|
|
|
999 fired = [ context, args ];
|
|
|
1000 firing = 0;
|
|
|
1001 }
|
|
|
1002 }
|
|
|
1003 return this;
|
|
|
1004 },
|
|
|
1005
|
|
|
1006 // resolve with this as context and given arguments
|
|
|
1007 resolve: function() {
|
|
|
1008 deferred.resolveWith( this, arguments );
|
|
|
1009 return this;
|
|
|
1010 },
|
|
|
1011
|
|
|
1012 // Has this deferred been resolved?
|
|
|
1013 isResolved: function() {
|
|
|
1014 return !!( firing || fired );
|
|
|
1015 },
|
|
|
1016
|
|
|
1017 // Cancel
|
|
|
1018 cancel: function() {
|
|
|
1019 cancelled = 1;
|
|
|
1020 callbacks = [];
|
|
|
1021 return this;
|
|
|
1022 }
|
|
|
1023 };
|
|
|
1024
|
|
|
1025 return deferred;
|
|
|
1026 },
|
|
|
1027
|
|
|
1028 // Full fledged deferred (two callbacks list)
|
|
|
1029 Deferred: function( func ) {
|
|
|
1030 var deferred = jQuery._Deferred(),
|
|
|
1031 failDeferred = jQuery._Deferred(),
|
|
|
1032 promise;
|
|
|
1033 // Add errorDeferred methods, then and promise
|
|
|
1034 jQuery.extend( deferred, {
|
|
|
1035 then: function( doneCallbacks, failCallbacks ) {
|
|
|
1036 deferred.done( doneCallbacks ).fail( failCallbacks );
|
|
|
1037 return this;
|
|
|
1038 },
|
|
|
1039 always: function() {
|
|
|
1040 return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
|
|
|
1041 },
|
|
|
1042 fail: failDeferred.done,
|
|
|
1043 rejectWith: failDeferred.resolveWith,
|
|
|
1044 reject: failDeferred.resolve,
|
|
|
1045 isRejected: failDeferred.isResolved,
|
|
|
1046 pipe: function( fnDone, fnFail ) {
|
|
|
1047 return jQuery.Deferred(function( newDefer ) {
|
|
|
1048 jQuery.each( {
|
|
|
1049 done: [ fnDone, "resolve" ],
|
|
|
1050 fail: [ fnFail, "reject" ]
|
|
|
1051 }, function( handler, data ) {
|
|
|
1052 var fn = data[ 0 ],
|
|
|
1053 action = data[ 1 ],
|
|
|
1054 returned;
|
|
|
1055 if ( jQuery.isFunction( fn ) ) {
|
|
|
1056 deferred[ handler ](function() {
|
|
|
1057 returned = fn.apply( this, arguments );
|
|
|
1058 if ( returned && jQuery.isFunction( returned.promise ) ) {
|
|
|
1059 returned.promise().then( newDefer.resolve, newDefer.reject );
|
|
|
1060 } else {
|
|
|
1061 newDefer[ action ]( returned );
|
|
|
1062 }
|
|
|
1063 });
|
|
|
1064 } else {
|
|
|
1065 deferred[ handler ]( newDefer[ action ] );
|
|
|
1066 }
|
|
|
1067 });
|
|
|
1068 }).promise();
|
|
|
1069 },
|
|
|
1070 // Get a promise for this deferred
|
|
|
1071 // If obj is provided, the promise aspect is added to the object
|
|
|
1072 promise: function( obj ) {
|
|
|
1073 if ( obj == null ) {
|
|
|
1074 if ( promise ) {
|
|
|
1075 return promise;
|
|
|
1076 }
|
|
|
1077 promise = obj = {};
|
|
|
1078 }
|
|
|
1079 var i = promiseMethods.length;
|
|
|
1080 while( i-- ) {
|
|
|
1081 obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
|
|
|
1082 }
|
|
|
1083 return obj;
|
|
|
1084 }
|
|
|
1085 });
|
|
|
1086 // Make sure only one callback list will be used
|
|
|
1087 deferred.done( failDeferred.cancel ).fail( deferred.cancel );
|
|
|
1088 // Unexpose cancel
|
|
|
1089 delete deferred.cancel;
|
|
|
1090 // Call given func if any
|
|
|
1091 if ( func ) {
|
|
|
1092 func.call( deferred, deferred );
|
|
|
1093 }
|
|
|
1094 return deferred;
|
|
|
1095 },
|
|
|
1096
|
|
|
1097 // Deferred helper
|
|
|
1098 when: function( firstParam ) {
|
|
|
1099 var args = arguments,
|
|
|
1100 i = 0,
|
|
|
1101 length = args.length,
|
|
|
1102 count = length,
|
|
|
1103 deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
|
|
|
1104 firstParam :
|
|
|
1105 jQuery.Deferred();
|
|
|
1106 function resolveFunc( i ) {
|
|
|
1107 return function( value ) {
|
|
|
1108 args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
|
|
|
1109 if ( !( --count ) ) {
|
|
|
1110 // Strange bug in FF4:
|
|
|
1111 // Values changed onto the arguments object sometimes end up as undefined values
|
|
|
1112 // outside the $.when method. Cloning the object into a fresh array solves the issue
|
|
|
1113 deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
|
|
|
1114 }
|
|
|
1115 };
|
|
|
1116 }
|
|
|
1117 if ( length > 1 ) {
|
|
|
1118 for( ; i < length; i++ ) {
|
|
|
1119 if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
|
|
|
1120 args[ i ].promise().then( resolveFunc(i), deferred.reject );
|
|
|
1121 } else {
|
|
|
1122 --count;
|
|
|
1123 }
|
|
|
1124 }
|
|
|
1125 if ( !count ) {
|
|
|
1126 deferred.resolveWith( deferred, args );
|
|
|
1127 }
|
|
|
1128 } else if ( deferred !== firstParam ) {
|
|
|
1129 deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
|
|
|
1130 }
|
|
|
1131 return deferred.promise();
|
|
|
1132 }
|
|
|
1133 });
|
|
|
1134
|
|
|
1135
|
|
|
1136
|
|
|
1137 jQuery.support = (function() {
|
|
|
1138
|
|
|
1139 var div = document.createElement( "div" ),
|
|
|
1140 documentElement = document.documentElement,
|
|
|
1141 all,
|
|
|
1142 a,
|
|
|
1143 select,
|
|
|
1144 opt,
|
|
|
1145 input,
|
|
|
1146 marginDiv,
|
|
|
1147 support,
|
|
|
1148 fragment,
|
|
|
1149 body,
|
|
|
1150 bodyStyle,
|
|
|
1151 tds,
|
|
|
1152 events,
|
|
|
1153 eventName,
|
|
|
1154 i,
|
|
|
1155 isSupported;
|
|
|
1156
|
|
|
1157 // Preliminary tests
|
|
|
1158 div.setAttribute("className", "t");
|
|
|
1159 div.innerHTML = " <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
|
|
|
1160
|
|
|
1161 all = div.getElementsByTagName( "*" );
|
|
|
1162 a = div.getElementsByTagName( "a" )[ 0 ];
|
|
|
1163
|
|
|
1164 // Can't get basic test support
|
|
|
1165 if ( !all || !all.length || !a ) {
|
|
|
1166 return {};
|
|
|
1167 }
|
|
|
1168
|
|
|
1169 // First batch of supports tests
|
|
|
1170 select = document.createElement( "select" );
|
|
|
1171 opt = select.appendChild( document.createElement("option") );
|
|
|
1172 input = div.getElementsByTagName( "input" )[ 0 ];
|
|
|
1173
|
|
|
1174 support = {
|
|
|
1175 // IE strips leading whitespace when .innerHTML is used
|
|
|
1176 leadingWhitespace: ( div.firstChild.nodeType === 3 ),
|
|
|
1177
|
|
|
1178 // Make sure that tbody elements aren't automatically inserted
|
|
|
1179 // IE will insert them into empty tables
|
|
|
1180 tbody: !div.getElementsByTagName( "tbody" ).length,
|
|
|
1181
|
|
|
1182 // Make sure that link elements get serialized correctly by innerHTML
|
|
|
1183 // This requires a wrapper element in IE
|
|
|
1184 htmlSerialize: !!div.getElementsByTagName( "link" ).length,
|
|
|
1185
|
|
|
1186 // Get the style information from getAttribute
|
|
|
1187 // (IE uses .cssText instead)
|
|
|
1188 style: /top/.test( a.getAttribute("style") ),
|
|
|
1189
|
|
|
1190 // Make sure that URLs aren't manipulated
|
|
|
1191 // (IE normalizes it by default)
|
|
|
1192 hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
|
|
|
1193
|
|
|
1194 // Make sure that element opacity exists
|
|
|
1195 // (IE uses filter instead)
|
|
|
1196 // Use a regex to work around a WebKit issue. See #5145
|
|
|
1197 opacity: /^0.55$/.test( a.style.opacity ),
|
|
|
1198
|
|
|
1199 // Verify style float existence
|
|
|
1200 // (IE uses styleFloat instead of cssFloat)
|
|
|
1201 cssFloat: !!a.style.cssFloat,
|
|
|
1202
|
|
|
1203 // Make sure that if no value is specified for a checkbox
|
|
|
1204 // that it defaults to "on".
|
|
|
1205 // (WebKit defaults to "" instead)
|
|
|
1206 checkOn: ( input.value === "on" ),
|
|
|
1207
|
|
|
1208 // Make sure that a selected-by-default option has a working selected property.
|
|
|
1209 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
|
|
|
1210 optSelected: opt.selected,
|
|
|
1211
|
|
|
1212 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
|
|
|
1213 getSetAttribute: div.className !== "t",
|
|
|
1214
|
|
|
1215 // Will be defined later
|
|
|
1216 submitBubbles: true,
|
|
|
1217 changeBubbles: true,
|
|
|
1218 focusinBubbles: false,
|
|
|
1219 deleteExpando: true,
|
|
|
1220 noCloneEvent: true,
|
|
|
1221 inlineBlockNeedsLayout: false,
|
|
|
1222 shrinkWrapBlocks: false,
|
|
|
1223 reliableMarginRight: true
|
|
|
1224 };
|
|
|
1225
|
|
|
1226 // Make sure checked status is properly cloned
|
|
|
1227 input.checked = true;
|
|
|
1228 support.noCloneChecked = input.cloneNode( true ).checked;
|
|
|
1229
|
|
|
1230 // Make sure that the options inside disabled selects aren't marked as disabled
|
|
|
1231 // (WebKit marks them as disabled)
|
|
|
1232 select.disabled = true;
|
|
|
1233 support.optDisabled = !opt.disabled;
|
|
|
1234
|
|
|
1235 // Test to see if it's possible to delete an expando from an element
|
|
|
1236 // Fails in Internet Explorer
|
|
|
1237 try {
|
|
|
1238 delete div.test;
|
|
|
1239 } catch( e ) {
|
|
|
1240 support.deleteExpando = false;
|
|
|
1241 }
|
|
|
1242
|
|
|
1243 if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
|
|
|
1244 div.attachEvent( "onclick", function click() {
|
|
|
1245 // Cloning a node shouldn't copy over any
|
|
|
1246 // bound event handlers (IE does this)
|
|
|
1247 support.noCloneEvent = false;
|
|
|
1248 div.detachEvent( "onclick", click );
|
|
|
1249 });
|
|
|
1250 div.cloneNode( true ).fireEvent( "onclick" );
|
|
|
1251 }
|
|
|
1252
|
|
|
1253 // Check if a radio maintains it's value
|
|
|
1254 // after being appended to the DOM
|
|
|
1255 input = document.createElement("input");
|
|
|
1256 input.value = "t";
|
|
|
1257 input.setAttribute("type", "radio");
|
|
|
1258 support.radioValue = input.value === "t";
|
|
|
1259
|
|
|
1260 input.setAttribute("checked", "checked");
|
|
|
1261 div.appendChild( input );
|
|
|
1262 fragment = document.createDocumentFragment();
|
|
|
1263 fragment.appendChild( div.firstChild );
|
|
|
1264
|
|
|
1265 // WebKit doesn't clone checked state correctly in fragments
|
|
|
1266 support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
|
|
|
1267
|
|
|
1268 div.innerHTML = "";
|
|
|
1269
|
|
|
1270 // Figure out if the W3C box model works as expected
|
|
|
1271 div.style.width = div.style.paddingLeft = "1px";
|
|
|
1272
|
|
|
1273 // We use our own, invisible, body
|
|
|
1274 body = document.createElement( "body" );
|
|
|
1275 bodyStyle = {
|
|
|
1276 visibility: "hidden",
|
|
|
1277 width: 0,
|
|
|
1278 height: 0,
|
|
|
1279 border: 0,
|
|
|
1280 margin: 0,
|
|
|
1281 // Set background to avoid IE crashes when removing (#9028)
|
|
|
1282 background: "none"
|
|
|
1283 };
|
|
|
1284 for ( i in bodyStyle ) {
|
|
|
1285 body.style[ i ] = bodyStyle[ i ];
|
|
|
1286 }
|
|
|
1287 body.appendChild( div );
|
|
|
1288 documentElement.insertBefore( body, documentElement.firstChild );
|
|
|
1289
|
|
|
1290 // Check if a disconnected checkbox will retain its checked
|
|
|
1291 // value of true after appended to the DOM (IE6/7)
|
|
|
1292 support.appendChecked = input.checked;
|
|
|
1293
|
|
|
1294 support.boxModel = div.offsetWidth === 2;
|
|
|
1295
|
|
|
1296 if ( "zoom" in div.style ) {
|
|
|
1297 // Check if natively block-level elements act like inline-block
|
|
|
1298 // elements when setting their display to 'inline' and giving
|
|
|
1299 // them layout
|
|
|
1300 // (IE < 8 does this)
|
|
|
1301 div.style.display = "inline";
|
|
|
1302 div.style.zoom = 1;
|
|
|
1303 support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
|
|
|
1304
|
|
|
1305 // Check if elements with layout shrink-wrap their children
|
|
|
1306 // (IE 6 does this)
|
|
|
1307 div.style.display = "";
|
|
|
1308 div.innerHTML = "<div style='width:4px;'></div>";
|
|
|
1309 support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
|
|
|
1310 }
|
|
|
1311
|
|
|
1312 div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
|
|
|
1313 tds = div.getElementsByTagName( "td" );
|
|
|
1314
|
|
|
1315 // Check if table cells still have offsetWidth/Height when they are set
|
|
|
1316 // to display:none and there are still other visible table cells in a
|
|
|
1317 // table row; if so, offsetWidth/Height are not reliable for use when
|
|
|
1318 // determining if an element has been hidden directly using
|
|
|
1319 // display:none (it is still safe to use offsets if a parent element is
|
|
|
1320 // hidden; don safety goggles and see bug #4512 for more information).
|
|
|
1321 // (only IE 8 fails this test)
|
|
|
1322 isSupported = ( tds[ 0 ].offsetHeight === 0 );
|
|
|
1323
|
|
|
1324 tds[ 0 ].style.display = "";
|
|
|
1325 tds[ 1 ].style.display = "none";
|
|
|
1326
|
|
|
1327 // Check if empty table cells still have offsetWidth/Height
|
|
|
1328 // (IE < 8 fail this test)
|
|
|
1329 support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
|
|
|
1330 div.innerHTML = "";
|
|
|
1331
|
|
|
1332 // Check if div with explicit width and no margin-right incorrectly
|
|
|
1333 // gets computed margin-right based on width of container. For more
|
|
|
1334 // info see bug #3333
|
|
|
1335 // Fails in WebKit before Feb 2011 nightlies
|
|
|
1336 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
|
|
|
1337 if ( document.defaultView && document.defaultView.getComputedStyle ) {
|
|
|
1338 marginDiv = document.createElement( "div" );
|
|
|
1339 marginDiv.style.width = "0";
|
|
|
1340 marginDiv.style.marginRight = "0";
|
|
|
1341 div.appendChild( marginDiv );
|
|
|
1342 support.reliableMarginRight =
|
|
|
1343 ( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
|
|
|
1344 }
|
|
|
1345
|
|
|
1346 // Remove the body element we added
|
|
|
1347 body.innerHTML = "";
|
|
|
1348 documentElement.removeChild( body );
|
|
|
1349
|
|
|
1350 // Technique from Juriy Zaytsev
|
|
|
1351 // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
|
|
|
1352 // We only care about the case where non-standard event systems
|
|
|
1353 // are used, namely in IE. Short-circuiting here helps us to
|
|
|
1354 // avoid an eval call (in setAttribute) which can cause CSP
|
|
|
1355 // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
|
|
|
1356 if ( div.attachEvent ) {
|
|
|
1357 for( i in {
|
|
|
1358 submit: 1,
|
|
|
1359 change: 1,
|
|
|
1360 focusin: 1
|
|
|
1361 } ) {
|
|
|
1362 eventName = "on" + i;
|
|
|
1363 isSupported = ( eventName in div );
|
|
|
1364 if ( !isSupported ) {
|
|
|
1365 div.setAttribute( eventName, "return;" );
|
|
|
1366 isSupported = ( typeof div[ eventName ] === "function" );
|
|
|
1367 }
|
|
|
1368 support[ i + "Bubbles" ] = isSupported;
|
|
|
1369 }
|
|
|
1370 }
|
|
|
1371
|
|
|
1372 return support;
|
|
|
1373 })();
|
|
|
1374
|
|
|
1375 // Keep track of boxModel
|
|
|
1376 jQuery.boxModel = jQuery.support.boxModel;
|
|
|
1377
|
|
|
1378
|
|
|
1379
|
|
|
1380
|
|
|
1381 var rbrace = /^(?:\{.*\}|\[.*\])$/,
|
|
|
1382 rmultiDash = /([a-z])([A-Z])/g;
|
|
|
1383
|
|
|
1384 jQuery.extend({
|
|
|
1385 cache: {},
|
|
|
1386
|
|
|
1387 // Please use with caution
|
|
|
1388 uuid: 0,
|
|
|
1389
|
|
|
1390 // Unique for each copy of jQuery on the page
|
|
|
1391 // Non-digits removed to match rinlinejQuery
|
|
|
1392 expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
|
|
|
1393
|
|
|
1394 // The following elements throw uncatchable exceptions if you
|
|
|
1395 // attempt to add expando properties to them.
|
|
|
1396 noData: {
|
|
|
1397 "embed": true,
|
|
|
1398 // Ban all objects except for Flash (which handle expandos)
|
|
|
1399 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
|
|
|
1400 "applet": true
|
|
|
1401 },
|
|
|
1402
|
|
|
1403 hasData: function( elem ) {
|
|
|
1404 elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
|
|
|
1405
|
|
|
1406 return !!elem && !isEmptyDataObject( elem );
|
|
|
1407 },
|
|
|
1408
|
|
|
1409 data: function( elem, name, data, pvt /* Internal Use Only */ ) {
|
|
|
1410 if ( !jQuery.acceptData( elem ) ) {
|
|
|
1411 return;
|
|
|
1412 }
|
|
|
1413
|
|
|
1414 var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
|
|
|
1415
|
|
|
1416 // We have to handle DOM nodes and JS objects differently because IE6-7
|
|
|
1417 // can't GC object references properly across the DOM-JS boundary
|
|
|
1418 isNode = elem.nodeType,
|
|
|
1419
|
|
|
1420 // Only DOM nodes need the global jQuery cache; JS object data is
|
|
|
1421 // attached directly to the object so GC can occur automatically
|
|
|
1422 cache = isNode ? jQuery.cache : elem,
|
|
|
1423
|
|
|
1424 // Only defining an ID for JS objects if its cache already exists allows
|
|
|
1425 // the code to shortcut on the same path as a DOM node with no cache
|
|
|
1426 id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
|
|
|
1427
|
|
|
1428 // Avoid doing any more work than we need to when trying to get data on an
|
|
|
1429 // object that has no data at all
|
|
|
1430 if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
|
|
|
1431 return;
|
|
|
1432 }
|
|
|
1433
|
|
|
1434 if ( !id ) {
|
|
|
1435 // Only DOM nodes need a new unique ID for each element since their data
|
|
|
1436 // ends up in the global cache
|
|
|
1437 if ( isNode ) {
|
|
|
1438 elem[ jQuery.expando ] = id = ++jQuery.uuid;
|
|
|
1439 } else {
|
|
|
1440 id = jQuery.expando;
|
|
|
1441 }
|
|
|
1442 }
|
|
|
1443
|
|
|
1444 if ( !cache[ id ] ) {
|
|
|
1445 cache[ id ] = {};
|
|
|
1446
|
|
|
1447 // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
|
|
|
1448 // metadata on plain JS objects when the object is serialized using
|
|
|
1449 // JSON.stringify
|
|
|
1450 if ( !isNode ) {
|
|
|
1451 cache[ id ].toJSON = jQuery.noop;
|
|
|
1452 }
|
|
|
1453 }
|
|
|
1454
|
|
|
1455 // An object can be passed to jQuery.data instead of a key/value pair; this gets
|
|
|
1456 // shallow copied over onto the existing cache
|
|
|
1457 if ( typeof name === "object" || typeof name === "function" ) {
|
|
|
1458 if ( pvt ) {
|
|
|
1459 cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
|
|
|
1460 } else {
|
|
|
1461 cache[ id ] = jQuery.extend(cache[ id ], name);
|
|
|
1462 }
|
|
|
1463 }
|
|
|
1464
|
|
|
1465 thisCache = cache[ id ];
|
|
|
1466
|
|
|
1467 // Internal jQuery data is stored in a separate object inside the object's data
|
|
|
1468 // cache in order to avoid key collisions between internal data and user-defined
|
|
|
1469 // data
|
|
|
1470 if ( pvt ) {
|
|
|
1471 if ( !thisCache[ internalKey ] ) {
|
|
|
1472 thisCache[ internalKey ] = {};
|
|
|
1473 }
|
|
|
1474
|
|
|
1475 thisCache = thisCache[ internalKey ];
|
|
|
1476 }
|
|
|
1477
|
|
|
1478 if ( data !== undefined ) {
|
|
|
1479 thisCache[ jQuery.camelCase( name ) ] = data;
|
|
|
1480 }
|
|
|
1481
|
|
|
1482 // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
|
|
|
1483 // not attempt to inspect the internal events object using jQuery.data, as this
|
|
|
1484 // internal data object is undocumented and subject to change.
|
|
|
1485 if ( name === "events" && !thisCache[name] ) {
|
|
|
1486 return thisCache[ internalKey ] && thisCache[ internalKey ].events;
|
|
|
1487 }
|
|
|
1488
|
|
|
1489 return getByName ? thisCache[ jQuery.camelCase( name ) ] : thisCache;
|
|
|
1490 },
|
|
|
1491
|
|
|
1492 removeData: function( elem, name, pvt /* Internal Use Only */ ) {
|
|
|
1493 if ( !jQuery.acceptData( elem ) ) {
|
|
|
1494 return;
|
|
|
1495 }
|
|
|
1496
|
|
|
1497 var internalKey = jQuery.expando, isNode = elem.nodeType,
|
|
|
1498
|
|
|
1499 // See jQuery.data for more information
|
|
|
1500 cache = isNode ? jQuery.cache : elem,
|
|
|
1501
|
|
|
1502 // See jQuery.data for more information
|
|
|
1503 id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
|
|
|
1504
|
|
|
1505 // If there is already no cache entry for this object, there is no
|
|
|
1506 // purpose in continuing
|
|
|
1507 if ( !cache[ id ] ) {
|
|
|
1508 return;
|
|
|
1509 }
|
|
|
1510
|
|
|
1511 if ( name ) {
|
|
|
1512 var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
|
|
|
1513
|
|
|
1514 if ( thisCache ) {
|
|
|
1515 delete thisCache[ name ];
|
|
|
1516
|
|
|
1517 // If there is no data left in the cache, we want to continue
|
|
|
1518 // and let the cache object itself get destroyed
|
|
|
1519 if ( !isEmptyDataObject(thisCache) ) {
|
|
|
1520 return;
|
|
|
1521 }
|
|
|
1522 }
|
|
|
1523 }
|
|
|
1524
|
|
|
1525 // See jQuery.data for more information
|
|
|
1526 if ( pvt ) {
|
|
|
1527 delete cache[ id ][ internalKey ];
|
|
|
1528
|
|
|
1529 // Don't destroy the parent cache unless the internal data object
|
|
|
1530 // had been the only thing left in it
|
|
|
1531 if ( !isEmptyDataObject(cache[ id ]) ) {
|
|
|
1532 return;
|
|
|
1533 }
|
|
|
1534 }
|
|
|
1535
|
|
|
1536 var internalCache = cache[ id ][ internalKey ];
|
|
|
1537
|
|
|
1538 // Browsers that fail expando deletion also refuse to delete expandos on
|
|
|
1539 // the window, but it will allow it on all other JS objects; other browsers
|
|
|
1540 // don't care
|
|
|
1541 if ( jQuery.support.deleteExpando || cache != window ) {
|
|
|
1542 delete cache[ id ];
|
|
|
1543 } else {
|
|
|
1544 cache[ id ] = null;
|
|
|
1545 }
|
|
|
1546
|
|
|
1547 // We destroyed the entire user cache at once because it's faster than
|
|
|
1548 // iterating through each key, but we need to continue to persist internal
|
|
|
1549 // data if it existed
|
|
|
1550 if ( internalCache ) {
|
|
|
1551 cache[ id ] = {};
|
|
|
1552 // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
|
|
|
1553 // metadata on plain JS objects when the object is serialized using
|
|
|
1554 // JSON.stringify
|
|
|
1555 if ( !isNode ) {
|
|
|
1556 cache[ id ].toJSON = jQuery.noop;
|
|
|
1557 }
|
|
|
1558
|
|
|
1559 cache[ id ][ internalKey ] = internalCache;
|
|
|
1560
|
|
|
1561 // Otherwise, we need to eliminate the expando on the node to avoid
|
|
|
1562 // false lookups in the cache for entries that no longer exist
|
|
|
1563 } else if ( isNode ) {
|
|
|
1564 // IE does not allow us to delete expando properties from nodes,
|
|
|
1565 // nor does it have a removeAttribute function on Document nodes;
|
|
|
1566 // we must handle all of these cases
|
|
|
1567 if ( jQuery.support.deleteExpando ) {
|
|
|
1568 delete elem[ jQuery.expando ];
|
|
|
1569 } else if ( elem.removeAttribute ) {
|
|
|
1570 elem.removeAttribute( jQuery.expando );
|
|
|
1571 } else {
|
|
|
1572 elem[ jQuery.expando ] = null;
|
|
|
1573 }
|
|
|
1574 }
|
|
|
1575 },
|
|
|
1576
|
|
|
1577 // For internal use only.
|
|
|
1578 _data: function( elem, name, data ) {
|
|
|
1579 return jQuery.data( elem, name, data, true );
|
|
|
1580 },
|
|
|
1581
|
|
|
1582 // A method for determining if a DOM node can handle the data expando
|
|
|
1583 acceptData: function( elem ) {
|
|
|
1584 if ( elem.nodeName ) {
|
|
|
1585 var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
|
|
|
1586
|
|
|
1587 if ( match ) {
|
|
|
1588 return !(match === true || elem.getAttribute("classid") !== match);
|
|
|
1589 }
|
|
|
1590 }
|
|
|
1591
|
|
|
1592 return true;
|
|
|
1593 }
|
|
|
1594 });
|
|
|
1595
|
|
|
1596 jQuery.fn.extend({
|
|
|
1597 data: function( key, value ) {
|
|
|
1598 var data = null;
|
|
|
1599
|
|
|
1600 if ( typeof key === "undefined" ) {
|
|
|
1601 if ( this.length ) {
|
|
|
1602 data = jQuery.data( this[0] );
|
|
|
1603
|
|
|
1604 if ( this[0].nodeType === 1 ) {
|
|
|
1605 var attr = this[0].attributes, name;
|
|
|
1606 for ( var i = 0, l = attr.length; i < l; i++ ) {
|
|
|
1607 name = attr[i].name;
|
|
|
1608
|
|
|
1609 if ( name.indexOf( "data-" ) === 0 ) {
|
|
|
1610 name = jQuery.camelCase( name.substring(5) );
|
|
|
1611
|
|
|
1612 dataAttr( this[0], name, data[ name ] );
|
|
|
1613 }
|
|
|
1614 }
|
|
|
1615 }
|
|
|
1616 }
|
|
|
1617
|
|
|
1618 return data;
|
|
|
1619
|
|
|
1620 } else if ( typeof key === "object" ) {
|
|
|
1621 return this.each(function() {
|
|
|
1622 jQuery.data( this, key );
|
|
|
1623 });
|
|
|
1624 }
|
|
|
1625
|
|
|
1626 var parts = key.split(".");
|
|
|
1627 parts[1] = parts[1] ? "." + parts[1] : "";
|
|
|
1628
|
|
|
1629 if ( value === undefined ) {
|
|
|
1630 data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
|
|
|
1631
|
|
|
1632 // Try to fetch any internally stored data first
|
|
|
1633 if ( data === undefined && this.length ) {
|
|
|
1634 data = jQuery.data( this[0], key );
|
|
|
1635 data = dataAttr( this[0], key, data );
|
|
|
1636 }
|
|
|
1637
|
|
|
1638 return data === undefined && parts[1] ?
|
|
|
1639 this.data( parts[0] ) :
|
|
|
1640 data;
|
|
|
1641
|
|
|
1642 } else {
|
|
|
1643 return this.each(function() {
|
|
|
1644 var $this = jQuery( this ),
|
|
|
1645 args = [ parts[0], value ];
|
|
|
1646
|
|
|
1647 $this.triggerHandler( "setData" + parts[1] + "!", args );
|
|
|
1648 jQuery.data( this, key, value );
|
|
|
1649 $this.triggerHandler( "changeData" + parts[1] + "!", args );
|
|
|
1650 });
|
|
|
1651 }
|
|
|
1652 },
|
|
|
1653
|
|
|
1654 removeData: function( key ) {
|
|
|
1655 return this.each(function() {
|
|
|
1656 jQuery.removeData( this, key );
|
|
|
1657 });
|
|
|
1658 }
|
|
|
1659 });
|
|
|
1660
|
|
|
1661 function dataAttr( elem, key, data ) {
|
|
|
1662 // If nothing was found internally, try to fetch any
|
|
|
1663 // data from the HTML5 data-* attribute
|
|
|
1664 if ( data === undefined && elem.nodeType === 1 ) {
|
|
|
1665 var name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase();
|
|
|
1666
|
|
|
1667 data = elem.getAttribute( name );
|
|
|
1668
|
|
|
1669 if ( typeof data === "string" ) {
|
|
|
1670 try {
|
|
|
1671 data = data === "true" ? true :
|
|
|
1672 data === "false" ? false :
|
|
|
1673 data === "null" ? null :
|
|
|
1674 !jQuery.isNaN( data ) ? parseFloat( data ) :
|
|
|
1675 rbrace.test( data ) ? jQuery.parseJSON( data ) :
|
|
|
1676 data;
|
|
|
1677 } catch( e ) {}
|
|
|
1678
|
|
|
1679 // Make sure we set the data so it isn't changed later
|
|
|
1680 jQuery.data( elem, key, data );
|
|
|
1681
|
|
|
1682 } else {
|
|
|
1683 data = undefined;
|
|
|
1684 }
|
|
|
1685 }
|
|
|
1686
|
|
|
1687 return data;
|
|
|
1688 }
|
|
|
1689
|
|
|
1690 // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
|
|
|
1691 // property to be considered empty objects; this property always exists in
|
|
|
1692 // order to make sure JSON.stringify does not expose internal metadata
|
|
|
1693 function isEmptyDataObject( obj ) {
|
|
|
1694 for ( var name in obj ) {
|
|
|
1695 if ( name !== "toJSON" ) {
|
|
|
1696 return false;
|
|
|
1697 }
|
|
|
1698 }
|
|
|
1699
|
|
|
1700 return true;
|
|
|
1701 }
|
|
|
1702
|
|
|
1703
|
|
|
1704
|
|
|
1705
|
|
|
1706 function handleQueueMarkDefer( elem, type, src ) {
|
|
|
1707 var deferDataKey = type + "defer",
|
|
|
1708 queueDataKey = type + "queue",
|
|
|
1709 markDataKey = type + "mark",
|
|
|
1710 defer = jQuery.data( elem, deferDataKey, undefined, true );
|
|
|
1711 if ( defer &&
|
|
|
1712 ( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
|
|
|
1713 ( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
|
|
|
1714 // Give room for hard-coded callbacks to fire first
|
|
|
1715 // and eventually mark/queue something else on the element
|
|
|
1716 setTimeout( function() {
|
|
|
1717 if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
|
|
|
1718 !jQuery.data( elem, markDataKey, undefined, true ) ) {
|
|
|
1719 jQuery.removeData( elem, deferDataKey, true );
|
|
|
1720 defer.resolve();
|
|
|
1721 }
|
|
|
1722 }, 0 );
|
|
|
1723 }
|
|
|
1724 }
|
|
|
1725
|
|
|
1726 jQuery.extend({
|
|
|
1727
|
|
|
1728 _mark: function( elem, type ) {
|
|
|
1729 if ( elem ) {
|
|
|
1730 type = (type || "fx") + "mark";
|
|
|
1731 jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
|
|
|
1732 }
|
|
|
1733 },
|
|
|
1734
|
|
|
1735 _unmark: function( force, elem, type ) {
|
|
|
1736 if ( force !== true ) {
|
|
|
1737 type = elem;
|
|
|
1738 elem = force;
|
|
|
1739 force = false;
|
|
|
1740 }
|
|
|
1741 if ( elem ) {
|
|
|
1742 type = type || "fx";
|
|
|
1743 var key = type + "mark",
|
|
|
1744 count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
|
|
|
1745 if ( count ) {
|
|
|
1746 jQuery.data( elem, key, count, true );
|
|
|
1747 } else {
|
|
|
1748 jQuery.removeData( elem, key, true );
|
|
|
1749 handleQueueMarkDefer( elem, type, "mark" );
|
|
|
1750 }
|
|
|
1751 }
|
|
|
1752 },
|
|
|
1753
|
|
|
1754 queue: function( elem, type, data ) {
|
|
|
1755 if ( elem ) {
|
|
|
1756 type = (type || "fx") + "queue";
|
|
|
1757 var q = jQuery.data( elem, type, undefined, true );
|
|
|
1758 // Speed up dequeue by getting out quickly if this is just a lookup
|
|
|
1759 if ( data ) {
|
|
|
1760 if ( !q || jQuery.isArray(data) ) {
|
|
|
1761 q = jQuery.data( elem, type, jQuery.makeArray(data), true );
|
|
|
1762 } else {
|
|
|
1763 q.push( data );
|
|
|
1764 }
|
|
|
1765 }
|
|
|
1766 return q || [];
|
|
|
1767 }
|
|
|
1768 },
|
|
|
1769
|
|
|
1770 dequeue: function( elem, type ) {
|
|
|
1771 type = type || "fx";
|
|
|
1772
|
|
|
1773 var queue = jQuery.queue( elem, type ),
|
|
|
1774 fn = queue.shift(),
|
|
|
1775 defer;
|
|
|
1776
|
|
|
1777 // If the fx queue is dequeued, always remove the progress sentinel
|
|
|
1778 if ( fn === "inprogress" ) {
|
|
|
1779 fn = queue.shift();
|
|
|
1780 }
|
|
|
1781
|
|
|
1782 if ( fn ) {
|
|
|
1783 // Add a progress sentinel to prevent the fx queue from being
|
|
|
1784 // automatically dequeued
|
|
|
1785 if ( type === "fx" ) {
|
|
|
1786 queue.unshift("inprogress");
|
|
|
1787 }
|
|
|
1788
|
|
|
1789 fn.call(elem, function() {
|
|
|
1790 jQuery.dequeue(elem, type);
|
|
|
1791 });
|
|
|
1792 }
|
|
|
1793
|
|
|
1794 if ( !queue.length ) {
|
|
|
1795 jQuery.removeData( elem, type + "queue", true );
|
|
|
1796 handleQueueMarkDefer( elem, type, "queue" );
|
|
|
1797 }
|
|
|
1798 }
|
|
|
1799 });
|
|
|
1800
|
|
|
1801 jQuery.fn.extend({
|
|
|
1802 queue: function( type, data ) {
|
|
|
1803 if ( typeof type !== "string" ) {
|
|
|
1804 data = type;
|
|
|
1805 type = "fx";
|
|
|
1806 }
|
|
|
1807
|
|
|
1808 if ( data === undefined ) {
|
|
|
1809 return jQuery.queue( this[0], type );
|
|
|
1810 }
|
|
|
1811 return this.each(function() {
|
|
|
1812 var queue = jQuery.queue( this, type, data );
|
|
|
1813
|
|
|
1814 if ( type === "fx" && queue[0] !== "inprogress" ) {
|
|
|
1815 jQuery.dequeue( this, type );
|
|
|
1816 }
|
|
|
1817 });
|
|
|
1818 },
|
|
|
1819 dequeue: function( type ) {
|
|
|
1820 return this.each(function() {
|
|
|
1821 jQuery.dequeue( this, type );
|
|
|
1822 });
|
|
|
1823 },
|
|
|
1824 // Based off of the plugin by Clint Helfers, with permission.
|
|
|
1825 // http://blindsignals.com/index.php/2009/07/jquery-delay/
|
|
|
1826 delay: function( time, type ) {
|
|
|
1827 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
|
|
|
1828 type = type || "fx";
|
|
|
1829
|
|
|
1830 return this.queue( type, function() {
|
|
|
1831 var elem = this;
|
|
|
1832 setTimeout(function() {
|
|
|
1833 jQuery.dequeue( elem, type );
|
|
|
1834 }, time );
|
|
|
1835 });
|
|
|
1836 },
|
|
|
1837 clearQueue: function( type ) {
|
|
|
1838 return this.queue( type || "fx", [] );
|
|
|
1839 },
|
|
|
1840 // Get a promise resolved when queues of a certain type
|
|
|
1841 // are emptied (fx is the type by default)
|
|
|
1842 promise: function( type, object ) {
|
|
|
1843 if ( typeof type !== "string" ) {
|
|
|
1844 object = type;
|
|
|
1845 type = undefined;
|
|
|
1846 }
|
|
|
1847 type = type || "fx";
|
|
|
1848 var defer = jQuery.Deferred(),
|
|
|
1849 elements = this,
|
|
|
1850 i = elements.length,
|
|
|
1851 count = 1,
|
|
|
1852 deferDataKey = type + "defer",
|
|
|
1853 queueDataKey = type + "queue",
|
|
|
1854 markDataKey = type + "mark",
|
|
|
1855 tmp;
|
|
|
1856 function resolve() {
|
|
|
1857 if ( !( --count ) ) {
|
|
|
1858 defer.resolveWith( elements, [ elements ] );
|
|
|
1859 }
|
|
|
1860 }
|
|
|
1861 while( i-- ) {
|
|
|
1862 if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
|
|
|
1863 ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
|
|
|
1864 jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
|
|
|
1865 jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
|
|
|
1866 count++;
|
|
|
1867 tmp.done( resolve );
|
|
|
1868 }
|
|
|
1869 }
|
|
|
1870 resolve();
|
|
|
1871 return defer.promise();
|
|
|
1872 }
|
|
|
1873 });
|
|
|
1874
|
|
|
1875
|
|
|
1876
|
|
|
1877
|
|
|
1878 var rclass = /[\n\t\r]/g,
|
|
|
1879 rspace = /\s+/,
|
|
|
1880 rreturn = /\r/g,
|
|
|
1881 rtype = /^(?:button|input)$/i,
|
|
|
1882 rfocusable = /^(?:button|input|object|select|textarea)$/i,
|
|
|
1883 rclickable = /^a(?:rea)?$/i,
|
|
|
1884 rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
|
|
|
1885 rinvalidChar = /\:/,
|
|
|
1886 formHook, boolHook;
|
|
|
1887
|
|
|
1888 jQuery.fn.extend({
|
|
|
1889 attr: function( name, value ) {
|
|
|
1890 return jQuery.access( this, name, value, true, jQuery.attr );
|
|
|
1891 },
|
|
|
1892
|
|
|
1893 removeAttr: function( name ) {
|
|
|
1894 return this.each(function() {
|
|
|
1895 jQuery.removeAttr( this, name );
|
|
|
1896 });
|
|
|
1897 },
|
|
|
1898
|
|
|
1899 prop: function( name, value ) {
|
|
|
1900 return jQuery.access( this, name, value, true, jQuery.prop );
|
|
|
1901 },
|
|
|
1902
|
|
|
1903 removeProp: function( name ) {
|
|
|
1904 name = jQuery.propFix[ name ] || name;
|
|
|
1905 return this.each(function() {
|
|
|
1906 // try/catch handles cases where IE balks (such as removing a property on window)
|
|
|
1907 try {
|
|
|
1908 this[ name ] = undefined;
|
|
|
1909 delete this[ name ];
|
|
|
1910 } catch( e ) {}
|
|
|
1911 });
|
|
|
1912 },
|
|
|
1913
|
|
|
1914 addClass: function( value ) {
|
|
|
1915 if ( jQuery.isFunction( value ) ) {
|
|
|
1916 return this.each(function(i) {
|
|
|
1917 var self = jQuery(this);
|
|
|
1918 self.addClass( value.call(this, i, self.attr("class") || "") );
|
|
|
1919 });
|
|
|
1920 }
|
|
|
1921
|
|
|
1922 if ( value && typeof value === "string" ) {
|
|
|
1923 var classNames = (value || "").split( rspace );
|
|
|
1924
|
|
|
1925 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
1926 var elem = this[i];
|
|
|
1927
|
|
|
1928 if ( elem.nodeType === 1 ) {
|
|
|
1929 if ( !elem.className ) {
|
|
|
1930 elem.className = value;
|
|
|
1931
|
|
|
1932 } else {
|
|
|
1933 var className = " " + elem.className + " ",
|
|
|
1934 setClass = elem.className;
|
|
|
1935
|
|
|
1936 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
|
|
|
1937 if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
|
|
|
1938 setClass += " " + classNames[c];
|
|
|
1939 }
|
|
|
1940 }
|
|
|
1941 elem.className = jQuery.trim( setClass );
|
|
|
1942 }
|
|
|
1943 }
|
|
|
1944 }
|
|
|
1945 }
|
|
|
1946
|
|
|
1947 return this;
|
|
|
1948 },
|
|
|
1949
|
|
|
1950 removeClass: function( value ) {
|
|
|
1951 if ( jQuery.isFunction(value) ) {
|
|
|
1952 return this.each(function(i) {
|
|
|
1953 var self = jQuery(this);
|
|
|
1954 self.removeClass( value.call(this, i, self.attr("class")) );
|
|
|
1955 });
|
|
|
1956 }
|
|
|
1957
|
|
|
1958 if ( (value && typeof value === "string") || value === undefined ) {
|
|
|
1959 var classNames = (value || "").split( rspace );
|
|
|
1960
|
|
|
1961 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
1962 var elem = this[i];
|
|
|
1963
|
|
|
1964 if ( elem.nodeType === 1 && elem.className ) {
|
|
|
1965 if ( value ) {
|
|
|
1966 var className = (" " + elem.className + " ").replace(rclass, " ");
|
|
|
1967 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
|
|
|
1968 className = className.replace(" " + classNames[c] + " ", " ");
|
|
|
1969 }
|
|
|
1970 elem.className = jQuery.trim( className );
|
|
|
1971
|
|
|
1972 } else {
|
|
|
1973 elem.className = "";
|
|
|
1974 }
|
|
|
1975 }
|
|
|
1976 }
|
|
|
1977 }
|
|
|
1978
|
|
|
1979 return this;
|
|
|
1980 },
|
|
|
1981
|
|
|
1982 toggleClass: function( value, stateVal ) {
|
|
|
1983 var type = typeof value,
|
|
|
1984 isBool = typeof stateVal === "boolean";
|
|
|
1985
|
|
|
1986 if ( jQuery.isFunction( value ) ) {
|
|
|
1987 return this.each(function(i) {
|
|
|
1988 var self = jQuery(this);
|
|
|
1989 self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
|
|
|
1990 });
|
|
|
1991 }
|
|
|
1992
|
|
|
1993 return this.each(function() {
|
|
|
1994 if ( type === "string" ) {
|
|
|
1995 // toggle individual class names
|
|
|
1996 var className,
|
|
|
1997 i = 0,
|
|
|
1998 self = jQuery( this ),
|
|
|
1999 state = stateVal,
|
|
|
2000 classNames = value.split( rspace );
|
|
|
2001
|
|
|
2002 while ( (className = classNames[ i++ ]) ) {
|
|
|
2003 // check each className given, space seperated list
|
|
|
2004 state = isBool ? state : !self.hasClass( className );
|
|
|
2005 self[ state ? "addClass" : "removeClass" ]( className );
|
|
|
2006 }
|
|
|
2007
|
|
|
2008 } else if ( type === "undefined" || type === "boolean" ) {
|
|
|
2009 if ( this.className ) {
|
|
|
2010 // store className if set
|
|
|
2011 jQuery._data( this, "__className__", this.className );
|
|
|
2012 }
|
|
|
2013
|
|
|
2014 // toggle whole className
|
|
|
2015 this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
|
|
|
2016 }
|
|
|
2017 });
|
|
|
2018 },
|
|
|
2019
|
|
|
2020 hasClass: function( selector ) {
|
|
|
2021 var className = " " + selector + " ";
|
|
|
2022 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
2023 if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
|
|
|
2024 return true;
|
|
|
2025 }
|
|
|
2026 }
|
|
|
2027
|
|
|
2028 return false;
|
|
|
2029 },
|
|
|
2030
|
|
|
2031 val: function( value ) {
|
|
|
2032 var hooks, ret,
|
|
|
2033 elem = this[0];
|
|
|
2034
|
|
|
2035 if ( !arguments.length ) {
|
|
|
2036 if ( elem ) {
|
|
|
2037 hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
|
|
|
2038
|
|
|
2039 if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
|
|
|
2040 return ret;
|
|
|
2041 }
|
|
|
2042
|
|
|
2043 return (elem.value || "").replace(rreturn, "");
|
|
|
2044 }
|
|
|
2045
|
|
|
2046 return undefined;
|
|
|
2047 }
|
|
|
2048
|
|
|
2049 var isFunction = jQuery.isFunction( value );
|
|
|
2050
|
|
|
2051 return this.each(function( i ) {
|
|
|
2052 var self = jQuery(this), val;
|
|
|
2053
|
|
|
2054 if ( this.nodeType !== 1 ) {
|
|
|
2055 return;
|
|
|
2056 }
|
|
|
2057
|
|
|
2058 if ( isFunction ) {
|
|
|
2059 val = value.call( this, i, self.val() );
|
|
|
2060 } else {
|
|
|
2061 val = value;
|
|
|
2062 }
|
|
|
2063
|
|
|
2064 // Treat null/undefined as ""; convert numbers to string
|
|
|
2065 if ( val == null ) {
|
|
|
2066 val = "";
|
|
|
2067 } else if ( typeof val === "number" ) {
|
|
|
2068 val += "";
|
|
|
2069 } else if ( jQuery.isArray( val ) ) {
|
|
|
2070 val = jQuery.map(val, function ( value ) {
|
|
|
2071 return value == null ? "" : value + "";
|
|
|
2072 });
|
|
|
2073 }
|
|
|
2074
|
|
|
2075 hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
|
|
|
2076
|
|
|
2077 // If set returns undefined, fall back to normal setting
|
|
|
2078 if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
|
|
|
2079 this.value = val;
|
|
|
2080 }
|
|
|
2081 });
|
|
|
2082 }
|
|
|
2083 });
|
|
|
2084
|
|
|
2085 jQuery.extend({
|
|
|
2086 valHooks: {
|
|
|
2087 option: {
|
|
|
2088 get: function( elem ) {
|
|
|
2089 // attributes.value is undefined in Blackberry 4.7 but
|
|
|
2090 // uses .value. See #6932
|
|
|
2091 var val = elem.attributes.value;
|
|
|
2092 return !val || val.specified ? elem.value : elem.text;
|
|
|
2093 }
|
|
|
2094 },
|
|
|
2095 select: {
|
|
|
2096 get: function( elem ) {
|
|
|
2097 var value,
|
|
|
2098 index = elem.selectedIndex,
|
|
|
2099 values = [],
|
|
|
2100 options = elem.options,
|
|
|
2101 one = elem.type === "select-one";
|
|
|
2102
|
|
|
2103 // Nothing was selected
|
|
|
2104 if ( index < 0 ) {
|
|
|
2105 return null;
|
|
|
2106 }
|
|
|
2107
|
|
|
2108 // Loop through all the selected options
|
|
|
2109 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
|
|
|
2110 var option = options[ i ];
|
|
|
2111
|
|
|
2112 // Don't return options that are disabled or in a disabled optgroup
|
|
|
2113 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
|
|
|
2114 (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
|
|
|
2115
|
|
|
2116 // Get the specific value for the option
|
|
|
2117 value = jQuery( option ).val();
|
|
|
2118
|
|
|
2119 // We don't need an array for one selects
|
|
|
2120 if ( one ) {
|
|
|
2121 return value;
|
|
|
2122 }
|
|
|
2123
|
|
|
2124 // Multi-Selects return an array
|
|
|
2125 values.push( value );
|
|
|
2126 }
|
|
|
2127 }
|
|
|
2128
|
|
|
2129 // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
|
|
|
2130 if ( one && !values.length && options.length ) {
|
|
|
2131 return jQuery( options[ index ] ).val();
|
|
|
2132 }
|
|
|
2133
|
|
|
2134 return values;
|
|
|
2135 },
|
|
|
2136
|
|
|
2137 set: function( elem, value ) {
|
|
|
2138 var values = jQuery.makeArray( value );
|
|
|
2139
|
|
|
2140 jQuery(elem).find("option").each(function() {
|
|
|
2141 this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
|
|
|
2142 });
|
|
|
2143
|
|
|
2144 if ( !values.length ) {
|
|
|
2145 elem.selectedIndex = -1;
|
|
|
2146 }
|
|
|
2147 return values;
|
|
|
2148 }
|
|
|
2149 }
|
|
|
2150 },
|
|
|
2151
|
|
|
2152 attrFn: {
|
|
|
2153 val: true,
|
|
|
2154 css: true,
|
|
|
2155 html: true,
|
|
|
2156 text: true,
|
|
|
2157 data: true,
|
|
|
2158 width: true,
|
|
|
2159 height: true,
|
|
|
2160 offset: true
|
|
|
2161 },
|
|
|
2162
|
|
|
2163 attrFix: {
|
|
|
2164 // Always normalize to ensure hook usage
|
|
|
2165 tabindex: "tabIndex"
|
|
|
2166 },
|
|
|
2167
|
|
|
2168 attr: function( elem, name, value, pass ) {
|
|
|
2169 var nType = elem.nodeType;
|
|
|
2170
|
|
|
2171 // don't get/set attributes on text, comment and attribute nodes
|
|
|
2172 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
|
|
|
2173 return undefined;
|
|
|
2174 }
|
|
|
2175
|
|
|
2176 if ( pass && name in jQuery.attrFn ) {
|
|
|
2177 return jQuery( elem )[ name ]( value );
|
|
|
2178 }
|
|
|
2179
|
|
|
2180 // Fallback to prop when attributes are not supported
|
|
|
2181 if ( !("getAttribute" in elem) ) {
|
|
|
2182 return jQuery.prop( elem, name, value );
|
|
|
2183 }
|
|
|
2184
|
|
|
2185 var ret, hooks,
|
|
|
2186 notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
|
|
|
2187
|
|
|
2188 // Normalize the name if needed
|
|
|
2189 name = notxml && jQuery.attrFix[ name ] || name;
|
|
|
2190
|
|
|
2191 hooks = jQuery.attrHooks[ name ];
|
|
|
2192
|
|
|
2193 if ( !hooks ) {
|
|
|
2194 // Use boolHook for boolean attributes
|
|
|
2195 if ( rboolean.test( name ) &&
|
|
|
2196 (typeof value === "boolean" || value === undefined || value.toLowerCase() === name.toLowerCase()) ) {
|
|
|
2197
|
|
|
2198 hooks = boolHook;
|
|
|
2199
|
|
|
2200 // Use formHook for forms and if the name contains certain characters
|
|
|
2201 } else if ( formHook && (jQuery.nodeName( elem, "form" ) || rinvalidChar.test( name )) ) {
|
|
|
2202 hooks = formHook;
|
|
|
2203 }
|
|
|
2204 }
|
|
|
2205
|
|
|
2206 if ( value !== undefined ) {
|
|
|
2207
|
|
|
2208 if ( value === null ) {
|
|
|
2209 jQuery.removeAttr( elem, name );
|
|
|
2210 return undefined;
|
|
|
2211
|
|
|
2212 } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
|
|
|
2213 return ret;
|
|
|
2214
|
|
|
2215 } else {
|
|
|
2216 elem.setAttribute( name, "" + value );
|
|
|
2217 return value;
|
|
|
2218 }
|
|
|
2219
|
|
|
2220 } else if ( hooks && "get" in hooks && notxml ) {
|
|
|
2221 return hooks.get( elem, name );
|
|
|
2222
|
|
|
2223 } else {
|
|
|
2224
|
|
|
2225 ret = elem.getAttribute( name );
|
|
|
2226
|
|
|
2227 // Non-existent attributes return null, we normalize to undefined
|
|
|
2228 return ret === null ?
|
|
|
2229 undefined :
|
|
|
2230 ret;
|
|
|
2231 }
|
|
|
2232 },
|
|
|
2233
|
|
|
2234 removeAttr: function( elem, name ) {
|
|
|
2235 var propName;
|
|
|
2236 if ( elem.nodeType === 1 ) {
|
|
|
2237 name = jQuery.attrFix[ name ] || name;
|
|
|
2238
|
|
|
2239 if ( jQuery.support.getSetAttribute ) {
|
|
|
2240 // Use removeAttribute in browsers that support it
|
|
|
2241 elem.removeAttribute( name );
|
|
|
2242 } else {
|
|
|
2243 jQuery.attr( elem, name, "" );
|
|
|
2244 elem.removeAttributeNode( elem.getAttributeNode( name ) );
|
|
|
2245 }
|
|
|
2246
|
|
|
2247 // Set corresponding property to false for boolean attributes
|
|
|
2248 if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) {
|
|
|
2249 elem[ propName ] = false;
|
|
|
2250 }
|
|
|
2251 }
|
|
|
2252 },
|
|
|
2253
|
|
|
2254 attrHooks: {
|
|
|
2255 type: {
|
|
|
2256 set: function( elem, value ) {
|
|
|
2257 // We can't allow the type property to be changed (since it causes problems in IE)
|
|
|
2258 if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
|
|
|
2259 jQuery.error( "type property can't be changed" );
|
|
|
2260 } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
|
|
|
2261 // Setting the type on a radio button after the value resets the value in IE6-9
|
|
|
2262 // Reset value to it's default in case type is set after value
|
|
|
2263 // This is for element creation
|
|
|
2264 var val = elem.value;
|
|
|
2265 elem.setAttribute( "type", value );
|
|
|
2266 if ( val ) {
|
|
|
2267 elem.value = val;
|
|
|
2268 }
|
|
|
2269 return value;
|
|
|
2270 }
|
|
|
2271 }
|
|
|
2272 },
|
|
|
2273 tabIndex: {
|
|
|
2274 get: function( elem ) {
|
|
|
2275 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
|
|
|
2276 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
|
|
|
2277 var attributeNode = elem.getAttributeNode("tabIndex");
|
|
|
2278
|
|
|
2279 return attributeNode && attributeNode.specified ?
|
|
|
2280 parseInt( attributeNode.value, 10 ) :
|
|
|
2281 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
|
|
|
2282 0 :
|
|
|
2283 undefined;
|
|
|
2284 }
|
|
|
2285 }
|
|
|
2286 },
|
|
|
2287
|
|
|
2288 propFix: {
|
|
|
2289 tabindex: "tabIndex",
|
|
|
2290 readonly: "readOnly",
|
|
|
2291 "for": "htmlFor",
|
|
|
2292 "class": "className",
|
|
|
2293 maxlength: "maxLength",
|
|
|
2294 cellspacing: "cellSpacing",
|
|
|
2295 cellpadding: "cellPadding",
|
|
|
2296 rowspan: "rowSpan",
|
|
|
2297 colspan: "colSpan",
|
|
|
2298 usemap: "useMap",
|
|
|
2299 frameborder: "frameBorder",
|
|
|
2300 contenteditable: "contentEditable"
|
|
|
2301 },
|
|
|
2302
|
|
|
2303 prop: function( elem, name, value ) {
|
|
|
2304 var nType = elem.nodeType;
|
|
|
2305
|
|
|
2306 // don't get/set properties on text, comment and attribute nodes
|
|
|
2307 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
|
|
|
2308 return undefined;
|
|
|
2309 }
|
|
|
2310
|
|
|
2311 var ret, hooks,
|
|
|
2312 notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
|
|
|
2313
|
|
|
2314 // Try to normalize/fix the name
|
|
|
2315 name = notxml && jQuery.propFix[ name ] || name;
|
|
|
2316
|
|
|
2317 hooks = jQuery.propHooks[ name ];
|
|
|
2318
|
|
|
2319 if ( value !== undefined ) {
|
|
|
2320 if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
|
|
|
2321 return ret;
|
|
|
2322
|
|
|
2323 } else {
|
|
|
2324 return (elem[ name ] = value);
|
|
|
2325 }
|
|
|
2326
|
|
|
2327 } else {
|
|
|
2328 if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== undefined ) {
|
|
|
2329 return ret;
|
|
|
2330
|
|
|
2331 } else {
|
|
|
2332 return elem[ name ];
|
|
|
2333 }
|
|
|
2334 }
|
|
|
2335 },
|
|
|
2336
|
|
|
2337 propHooks: {}
|
|
|
2338 });
|
|
|
2339
|
|
|
2340 // Hook for boolean attributes
|
|
|
2341 boolHook = {
|
|
|
2342 get: function( elem, name ) {
|
|
|
2343 // Align boolean attributes with corresponding properties
|
|
|
2344 return elem[ jQuery.propFix[ name ] || name ] ?
|
|
|
2345 name.toLowerCase() :
|
|
|
2346 undefined;
|
|
|
2347 },
|
|
|
2348 set: function( elem, value, name ) {
|
|
|
2349 var propName;
|
|
|
2350 if ( value === false ) {
|
|
|
2351 // Remove boolean attributes when set to false
|
|
|
2352 jQuery.removeAttr( elem, name );
|
|
|
2353 } else {
|
|
|
2354 // value is true since we know at this point it's type boolean and not false
|
|
|
2355 // Set boolean attributes to the same name and set the DOM property
|
|
|
2356 propName = jQuery.propFix[ name ] || name;
|
|
|
2357 if ( propName in elem ) {
|
|
|
2358 // Only set the IDL specifically if it already exists on the element
|
|
|
2359 elem[ propName ] = value;
|
|
|
2360 }
|
|
|
2361
|
|
|
2362 elem.setAttribute( name, name.toLowerCase() );
|
|
|
2363 }
|
|
|
2364 return name;
|
|
|
2365 }
|
|
|
2366 };
|
|
|
2367
|
|
|
2368 // Use the value property for back compat
|
|
|
2369 // Use the formHook for button elements in IE6/7 (#1954)
|
|
|
2370 jQuery.attrHooks.value = {
|
|
|
2371 get: function( elem, name ) {
|
|
|
2372 if ( formHook && jQuery.nodeName( elem, "button" ) ) {
|
|
|
2373 return formHook.get( elem, name );
|
|
|
2374 }
|
|
|
2375 return elem.value;
|
|
|
2376 },
|
|
|
2377 set: function( elem, value, name ) {
|
|
|
2378 if ( formHook && jQuery.nodeName( elem, "button" ) ) {
|
|
|
2379 return formHook.set( elem, value, name );
|
|
|
2380 }
|
|
|
2381 // Does not return so that setAttribute is also used
|
|
|
2382 elem.value = value;
|
|
|
2383 }
|
|
|
2384 };
|
|
|
2385
|
|
|
2386 // IE6/7 do not support getting/setting some attributes with get/setAttribute
|
|
|
2387 if ( !jQuery.support.getSetAttribute ) {
|
|
|
2388
|
|
|
2389 // propFix is more comprehensive and contains all fixes
|
|
|
2390 jQuery.attrFix = jQuery.propFix;
|
|
|
2391
|
|
|
2392 // Use this for any attribute on a form in IE6/7
|
|
|
2393 formHook = jQuery.attrHooks.name = jQuery.valHooks.button = {
|
|
|
2394 get: function( elem, name ) {
|
|
|
2395 var ret;
|
|
|
2396 ret = elem.getAttributeNode( name );
|
|
|
2397 // Return undefined if nodeValue is empty string
|
|
|
2398 return ret && ret.nodeValue !== "" ?
|
|
|
2399 ret.nodeValue :
|
|
|
2400 undefined;
|
|
|
2401 },
|
|
|
2402 set: function( elem, value, name ) {
|
|
|
2403 // Check form objects in IE (multiple bugs related)
|
|
|
2404 // Only use nodeValue if the attribute node exists on the form
|
|
|
2405 var ret = elem.getAttributeNode( name );
|
|
|
2406 if ( ret ) {
|
|
|
2407 ret.nodeValue = value;
|
|
|
2408 return value;
|
|
|
2409 }
|
|
|
2410 }
|
|
|
2411 };
|
|
|
2412
|
|
|
2413 // Set width and height to auto instead of 0 on empty string( Bug #8150 )
|
|
|
2414 // This is for removals
|
|
|
2415 jQuery.each([ "width", "height" ], function( i, name ) {
|
|
|
2416 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
|
|
|
2417 set: function( elem, value ) {
|
|
|
2418 if ( value === "" ) {
|
|
|
2419 elem.setAttribute( name, "auto" );
|
|
|
2420 return value;
|
|
|
2421 }
|
|
|
2422 }
|
|
|
2423 });
|
|
|
2424 });
|
|
|
2425 }
|
|
|
2426
|
|
|
2427
|
|
|
2428 // Some attributes require a special call on IE
|
|
|
2429 if ( !jQuery.support.hrefNormalized ) {
|
|
|
2430 jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
|
|
|
2431 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
|
|
|
2432 get: function( elem ) {
|
|
|
2433 var ret = elem.getAttribute( name, 2 );
|
|
|
2434 return ret === null ? undefined : ret;
|
|
|
2435 }
|
|
|
2436 });
|
|
|
2437 });
|
|
|
2438 }
|
|
|
2439
|
|
|
2440 if ( !jQuery.support.style ) {
|
|
|
2441 jQuery.attrHooks.style = {
|
|
|
2442 get: function( elem ) {
|
|
|
2443 // Return undefined in the case of empty string
|
|
|
2444 // Normalize to lowercase since IE uppercases css property names
|
|
|
2445 return elem.style.cssText.toLowerCase() || undefined;
|
|
|
2446 },
|
|
|
2447 set: function( elem, value ) {
|
|
|
2448 return (elem.style.cssText = "" + value);
|
|
|
2449 }
|
|
|
2450 };
|
|
|
2451 }
|
|
|
2452
|
|
|
2453 // Safari mis-reports the default selected property of an option
|
|
|
2454 // Accessing the parent's selectedIndex property fixes it
|
|
|
2455 if ( !jQuery.support.optSelected ) {
|
|
|
2456 jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
|
|
|
2457 get: function( elem ) {
|
|
|
2458 var parent = elem.parentNode;
|
|
|
2459
|
|
|
2460 if ( parent ) {
|
|
|
2461 parent.selectedIndex;
|
|
|
2462
|
|
|
2463 // Make sure that it also works with optgroups, see #5701
|
|
|
2464 if ( parent.parentNode ) {
|
|
|
2465 parent.parentNode.selectedIndex;
|
|
|
2466 }
|
|
|
2467 }
|
|
|
2468 }
|
|
|
2469 });
|
|
|
2470 }
|
|
|
2471
|
|
|
2472 // Radios and checkboxes getter/setter
|
|
|
2473 if ( !jQuery.support.checkOn ) {
|
|
|
2474 jQuery.each([ "radio", "checkbox" ], function() {
|
|
|
2475 jQuery.valHooks[ this ] = {
|
|
|
2476 get: function( elem ) {
|
|
|
2477 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
|
|
|
2478 return elem.getAttribute("value") === null ? "on" : elem.value;
|
|
|
2479 }
|
|
|
2480 };
|
|
|
2481 });
|
|
|
2482 }
|
|
|
2483 jQuery.each([ "radio", "checkbox" ], function() {
|
|
|
2484 jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
|
|
|
2485 set: function( elem, value ) {
|
|
|
2486 if ( jQuery.isArray( value ) ) {
|
|
|
2487 return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
|
|
|
2488 }
|
|
|
2489 }
|
|
|
2490 });
|
|
|
2491 });
|
|
|
2492
|
|
|
2493
|
|
|
2494
|
|
|
2495
|
|
|
2496 var hasOwn = Object.prototype.hasOwnProperty,
|
|
|
2497 rnamespaces = /\.(.*)$/,
|
|
|
2498 rformElems = /^(?:textarea|input|select)$/i,
|
|
|
2499 rperiod = /\./g,
|
|
|
2500 rspaces = / /g,
|
|
|
2501 rescape = /[^\w\s.|`]/g,
|
|
|
2502 fcleanup = function( nm ) {
|
|
|
2503 return nm.replace(rescape, "\\$&");
|
|
|
2504 };
|
|
|
2505
|
|
|
2506 /*
|
|
|
2507 * A number of helper functions used for managing events.
|
|
|
2508 * Many of the ideas behind this code originated from
|
|
|
2509 * Dean Edwards' addEvent library.
|
|
|
2510 */
|
|
|
2511 jQuery.event = {
|
|
|
2512
|
|
|
2513 // Bind an event to an element
|
|
|
2514 // Original by Dean Edwards
|
|
|
2515 add: function( elem, types, handler, data ) {
|
|
|
2516 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
|
2517 return;
|
|
|
2518 }
|
|
|
2519
|
|
|
2520 if ( handler === false ) {
|
|
|
2521 handler = returnFalse;
|
|
|
2522 } else if ( !handler ) {
|
|
|
2523 // Fixes bug #7229. Fix recommended by jdalton
|
|
|
2524 return;
|
|
|
2525 }
|
|
|
2526
|
|
|
2527 var handleObjIn, handleObj;
|
|
|
2528
|
|
|
2529 if ( handler.handler ) {
|
|
|
2530 handleObjIn = handler;
|
|
|
2531 handler = handleObjIn.handler;
|
|
|
2532 }
|
|
|
2533
|
|
|
2534 // Make sure that the function being executed has a unique ID
|
|
|
2535 if ( !handler.guid ) {
|
|
|
2536 handler.guid = jQuery.guid++;
|
|
|
2537 }
|
|
|
2538
|
|
|
2539 // Init the element's event structure
|
|
|
2540 var elemData = jQuery._data( elem );
|
|
|
2541
|
|
|
2542 // If no elemData is found then we must be trying to bind to one of the
|
|
|
2543 // banned noData elements
|
|
|
2544 if ( !elemData ) {
|
|
|
2545 return;
|
|
|
2546 }
|
|
|
2547
|
|
|
2548 var events = elemData.events,
|
|
|
2549 eventHandle = elemData.handle;
|
|
|
2550
|
|
|
2551 if ( !events ) {
|
|
|
2552 elemData.events = events = {};
|
|
|
2553 }
|
|
|
2554
|
|
|
2555 if ( !eventHandle ) {
|
|
|
2556 elemData.handle = eventHandle = function( e ) {
|
|
|
2557 // Discard the second event of a jQuery.event.trigger() and
|
|
|
2558 // when an event is called after a page has unloaded
|
|
|
2559 return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
|
|
|
2560 jQuery.event.handle.apply( eventHandle.elem, arguments ) :
|
|
|
2561 undefined;
|
|
|
2562 };
|
|
|
2563 }
|
|
|
2564
|
|
|
2565 // Add elem as a property of the handle function
|
|
|
2566 // This is to prevent a memory leak with non-native events in IE.
|
|
|
2567 eventHandle.elem = elem;
|
|
|
2568
|
|
|
2569 // Handle multiple events separated by a space
|
|
|
2570 // jQuery(...).bind("mouseover mouseout", fn);
|
|
|
2571 types = types.split(" ");
|
|
|
2572
|
|
|
2573 var type, i = 0, namespaces;
|
|
|
2574
|
|
|
2575 while ( (type = types[ i++ ]) ) {
|
|
|
2576 handleObj = handleObjIn ?
|
|
|
2577 jQuery.extend({}, handleObjIn) :
|
|
|
2578 { handler: handler, data: data };
|
|
|
2579
|
|
|
2580 // Namespaced event handlers
|
|
|
2581 if ( type.indexOf(".") > -1 ) {
|
|
|
2582 namespaces = type.split(".");
|
|
|
2583 type = namespaces.shift();
|
|
|
2584 handleObj.namespace = namespaces.slice(0).sort().join(".");
|
|
|
2585
|
|
|
2586 } else {
|
|
|
2587 namespaces = [];
|
|
|
2588 handleObj.namespace = "";
|
|
|
2589 }
|
|
|
2590
|
|
|
2591 handleObj.type = type;
|
|
|
2592 if ( !handleObj.guid ) {
|
|
|
2593 handleObj.guid = handler.guid;
|
|
|
2594 }
|
|
|
2595
|
|
|
2596 // Get the current list of functions bound to this event
|
|
|
2597 var handlers = events[ type ],
|
|
|
2598 special = jQuery.event.special[ type ] || {};
|
|
|
2599
|
|
|
2600 // Init the event handler queue
|
|
|
2601 if ( !handlers ) {
|
|
|
2602 handlers = events[ type ] = [];
|
|
|
2603
|
|
|
2604 // Check for a special event handler
|
|
|
2605 // Only use addEventListener/attachEvent if the special
|
|
|
2606 // events handler returns false
|
|
|
2607 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
|
|
|
2608 // Bind the global event handler to the element
|
|
|
2609 if ( elem.addEventListener ) {
|
|
|
2610 elem.addEventListener( type, eventHandle, false );
|
|
|
2611
|
|
|
2612 } else if ( elem.attachEvent ) {
|
|
|
2613 elem.attachEvent( "on" + type, eventHandle );
|
|
|
2614 }
|
|
|
2615 }
|
|
|
2616 }
|
|
|
2617
|
|
|
2618 if ( special.add ) {
|
|
|
2619 special.add.call( elem, handleObj );
|
|
|
2620
|
|
|
2621 if ( !handleObj.handler.guid ) {
|
|
|
2622 handleObj.handler.guid = handler.guid;
|
|
|
2623 }
|
|
|
2624 }
|
|
|
2625
|
|
|
2626 // Add the function to the element's handler list
|
|
|
2627 handlers.push( handleObj );
|
|
|
2628
|
|
|
2629 // Keep track of which events have been used, for event optimization
|
|
|
2630 jQuery.event.global[ type ] = true;
|
|
|
2631 }
|
|
|
2632
|
|
|
2633 // Nullify elem to prevent memory leaks in IE
|
|
|
2634 elem = null;
|
|
|
2635 },
|
|
|
2636
|
|
|
2637 global: {},
|
|
|
2638
|
|
|
2639 // Detach an event or set of events from an element
|
|
|
2640 remove: function( elem, types, handler, pos ) {
|
|
|
2641 // don't do events on text and comment nodes
|
|
|
2642 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
|
2643 return;
|
|
|
2644 }
|
|
|
2645
|
|
|
2646 if ( handler === false ) {
|
|
|
2647 handler = returnFalse;
|
|
|
2648 }
|
|
|
2649
|
|
|
2650 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
|
|
|
2651 elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
|
|
|
2652 events = elemData && elemData.events;
|
|
|
2653
|
|
|
2654 if ( !elemData || !events ) {
|
|
|
2655 return;
|
|
|
2656 }
|
|
|
2657
|
|
|
2658 // types is actually an event object here
|
|
|
2659 if ( types && types.type ) {
|
|
|
2660 handler = types.handler;
|
|
|
2661 types = types.type;
|
|
|
2662 }
|
|
|
2663
|
|
|
2664 // Unbind all events for the element
|
|
|
2665 if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
|
|
|
2666 types = types || "";
|
|
|
2667
|
|
|
2668 for ( type in events ) {
|
|
|
2669 jQuery.event.remove( elem, type + types );
|
|
|
2670 }
|
|
|
2671
|
|
|
2672 return;
|
|
|
2673 }
|
|
|
2674
|
|
|
2675 // Handle multiple events separated by a space
|
|
|
2676 // jQuery(...).unbind("mouseover mouseout", fn);
|
|
|
2677 types = types.split(" ");
|
|
|
2678
|
|
|
2679 while ( (type = types[ i++ ]) ) {
|
|
|
2680 origType = type;
|
|
|
2681 handleObj = null;
|
|
|
2682 all = type.indexOf(".") < 0;
|
|
|
2683 namespaces = [];
|
|
|
2684
|
|
|
2685 if ( !all ) {
|
|
|
2686 // Namespaced event handlers
|
|
|
2687 namespaces = type.split(".");
|
|
|
2688 type = namespaces.shift();
|
|
|
2689
|
|
|
2690 namespace = new RegExp("(^|\\.)" +
|
|
|
2691 jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
|
|
|
2692 }
|
|
|
2693
|
|
|
2694 eventType = events[ type ];
|
|
|
2695
|
|
|
2696 if ( !eventType ) {
|
|
|
2697 continue;
|
|
|
2698 }
|
|
|
2699
|
|
|
2700 if ( !handler ) {
|
|
|
2701 for ( j = 0; j < eventType.length; j++ ) {
|
|
|
2702 handleObj = eventType[ j ];
|
|
|
2703
|
|
|
2704 if ( all || namespace.test( handleObj.namespace ) ) {
|
|
|
2705 jQuery.event.remove( elem, origType, handleObj.handler, j );
|
|
|
2706 eventType.splice( j--, 1 );
|
|
|
2707 }
|
|
|
2708 }
|
|
|
2709
|
|
|
2710 continue;
|
|
|
2711 }
|
|
|
2712
|
|
|
2713 special = jQuery.event.special[ type ] || {};
|
|
|
2714
|
|
|
2715 for ( j = pos || 0; j < eventType.length; j++ ) {
|
|
|
2716 handleObj = eventType[ j ];
|
|
|
2717
|
|
|
2718 if ( handler.guid === handleObj.guid ) {
|
|
|
2719 // remove the given handler for the given type
|
|
|
2720 if ( all || namespace.test( handleObj.namespace ) ) {
|
|
|
2721 if ( pos == null ) {
|
|
|
2722 eventType.splice( j--, 1 );
|
|
|
2723 }
|
|
|
2724
|
|
|
2725 if ( special.remove ) {
|
|
|
2726 special.remove.call( elem, handleObj );
|
|
|
2727 }
|
|
|
2728 }
|
|
|
2729
|
|
|
2730 if ( pos != null ) {
|
|
|
2731 break;
|
|
|
2732 }
|
|
|
2733 }
|
|
|
2734 }
|
|
|
2735
|
|
|
2736 // remove generic event handler if no more handlers exist
|
|
|
2737 if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
|
|
|
2738 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
|
|
|
2739 jQuery.removeEvent( elem, type, elemData.handle );
|
|
|
2740 }
|
|
|
2741
|
|
|
2742 ret = null;
|
|
|
2743 delete events[ type ];
|
|
|
2744 }
|
|
|
2745 }
|
|
|
2746
|
|
|
2747 // Remove the expando if it's no longer used
|
|
|
2748 if ( jQuery.isEmptyObject( events ) ) {
|
|
|
2749 var handle = elemData.handle;
|
|
|
2750 if ( handle ) {
|
|
|
2751 handle.elem = null;
|
|
|
2752 }
|
|
|
2753
|
|
|
2754 delete elemData.events;
|
|
|
2755 delete elemData.handle;
|
|
|
2756
|
|
|
2757 if ( jQuery.isEmptyObject( elemData ) ) {
|
|
|
2758 jQuery.removeData( elem, undefined, true );
|
|
|
2759 }
|
|
|
2760 }
|
|
|
2761 },
|
|
|
2762
|
|
|
2763 // Events that are safe to short-circuit if no handlers are attached.
|
|
|
2764 // Native DOM events should not be added, they may have inline handlers.
|
|
|
2765 customEvent: {
|
|
|
2766 "getData": true,
|
|
|
2767 "setData": true,
|
|
|
2768 "changeData": true
|
|
|
2769 },
|
|
|
2770
|
|
|
2771 trigger: function( event, data, elem, onlyHandlers ) {
|
|
|
2772 // Event object or event type
|
|
|
2773 var type = event.type || event,
|
|
|
2774 namespaces = [],
|
|
|
2775 exclusive;
|
|
|
2776
|
|
|
2777 if ( type.indexOf("!") >= 0 ) {
|
|
|
2778 // Exclusive events trigger only for the exact event (no namespaces)
|
|
|
2779 type = type.slice(0, -1);
|
|
|
2780 exclusive = true;
|
|
|
2781 }
|
|
|
2782
|
|
|
2783 if ( type.indexOf(".") >= 0 ) {
|
|
|
2784 // Namespaced trigger; create a regexp to match event type in handle()
|
|
|
2785 namespaces = type.split(".");
|
|
|
2786 type = namespaces.shift();
|
|
|
2787 namespaces.sort();
|
|
|
2788 }
|
|
|
2789
|
|
|
2790 if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
|
|
|
2791 // No jQuery handlers for this event type, and it can't have inline handlers
|
|
|
2792 return;
|
|
|
2793 }
|
|
|
2794
|
|
|
2795 // Caller can pass in an Event, Object, or just an event type string
|
|
|
2796 event = typeof event === "object" ?
|
|
|
2797 // jQuery.Event object
|
|
|
2798 event[ jQuery.expando ] ? event :
|
|
|
2799 // Object literal
|
|
|
2800 new jQuery.Event( type, event ) :
|
|
|
2801 // Just the event type (string)
|
|
|
2802 new jQuery.Event( type );
|
|
|
2803
|
|
|
2804 event.type = type;
|
|
|
2805 event.exclusive = exclusive;
|
|
|
2806 event.namespace = namespaces.join(".");
|
|
|
2807 event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
|
|
|
2808
|
|
|
2809 // triggerHandler() and global events don't bubble or run the default action
|
|
|
2810 if ( onlyHandlers || !elem ) {
|
|
|
2811 event.preventDefault();
|
|
|
2812 event.stopPropagation();
|
|
|
2813 }
|
|
|
2814
|
|
|
2815 // Handle a global trigger
|
|
|
2816 if ( !elem ) {
|
|
|
2817 // TODO: Stop taunting the data cache; remove global events and always attach to document
|
|
|
2818 jQuery.each( jQuery.cache, function() {
|
|
|
2819 // internalKey variable is just used to make it easier to find
|
|
|
2820 // and potentially change this stuff later; currently it just
|
|
|
2821 // points to jQuery.expando
|
|
|
2822 var internalKey = jQuery.expando,
|
|
|
2823 internalCache = this[ internalKey ];
|
|
|
2824 if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
|
|
|
2825 jQuery.event.trigger( event, data, internalCache.handle.elem );
|
|
|
2826 }
|
|
|
2827 });
|
|
|
2828 return;
|
|
|
2829 }
|
|
|
2830
|
|
|
2831 // Don't do events on text and comment nodes
|
|
|
2832 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
|
2833 return;
|
|
|
2834 }
|
|
|
2835
|
|
|
2836 // Clean up the event in case it is being reused
|
|
|
2837 event.result = undefined;
|
|
|
2838 event.target = elem;
|
|
|
2839
|
|
|
2840 // Clone any incoming data and prepend the event, creating the handler arg list
|
|
|
2841 data = data ? jQuery.makeArray( data ) : [];
|
|
|
2842 data.unshift( event );
|
|
|
2843
|
|
|
2844 var cur = elem,
|
|
|
2845 // IE doesn't like method names with a colon (#3533, #8272)
|
|
|
2846 ontype = type.indexOf(":") < 0 ? "on" + type : "";
|
|
|
2847
|
|
|
2848 // Fire event on the current element, then bubble up the DOM tree
|
|
|
2849 do {
|
|
|
2850 var handle = jQuery._data( cur, "handle" );
|
|
|
2851
|
|
|
2852 event.currentTarget = cur;
|
|
|
2853 if ( handle ) {
|
|
|
2854 handle.apply( cur, data );
|
|
|
2855 }
|
|
|
2856
|
|
|
2857 // Trigger an inline bound script
|
|
|
2858 if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
|
|
|
2859 event.result = false;
|
|
|
2860 event.preventDefault();
|
|
|
2861 }
|
|
|
2862
|
|
|
2863 // Bubble up to document, then to window
|
|
|
2864 cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
|
|
|
2865 } while ( cur && !event.isPropagationStopped() );
|
|
|
2866
|
|
|
2867 // If nobody prevented the default action, do it now
|
|
|
2868 if ( !event.isDefaultPrevented() ) {
|
|
|
2869 var old,
|
|
|
2870 special = jQuery.event.special[ type ] || {};
|
|
|
2871
|
|
|
2872 if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
|
|
|
2873 !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
|
|
|
2874
|
|
|
2875 // Call a native DOM method on the target with the same name name as the event.
|
|
|
2876 // Can't use an .isFunction)() check here because IE6/7 fails that test.
|
|
|
2877 // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
|
|
|
2878 try {
|
|
|
2879 if ( ontype && elem[ type ] ) {
|
|
|
2880 // Don't re-trigger an onFOO event when we call its FOO() method
|
|
|
2881 old = elem[ ontype ];
|
|
|
2882
|
|
|
2883 if ( old ) {
|
|
|
2884 elem[ ontype ] = null;
|
|
|
2885 }
|
|
|
2886
|
|
|
2887 jQuery.event.triggered = type;
|
|
|
2888 elem[ type ]();
|
|
|
2889 }
|
|
|
2890 } catch ( ieError ) {}
|
|
|
2891
|
|
|
2892 if ( old ) {
|
|
|
2893 elem[ ontype ] = old;
|
|
|
2894 }
|
|
|
2895
|
|
|
2896 jQuery.event.triggered = undefined;
|
|
|
2897 }
|
|
|
2898 }
|
|
|
2899
|
|
|
2900 return event.result;
|
|
|
2901 },
|
|
|
2902
|
|
|
2903 handle: function( event ) {
|
|
|
2904 event = jQuery.event.fix( event || window.event );
|
|
|
2905 // Snapshot the handlers list since a called handler may add/remove events.
|
|
|
2906 var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
|
|
|
2907 run_all = !event.exclusive && !event.namespace,
|
|
|
2908 args = Array.prototype.slice.call( arguments, 0 );
|
|
|
2909
|
|
|
2910 // Use the fix-ed Event rather than the (read-only) native event
|
|
|
2911 args[0] = event;
|
|
|
2912 event.currentTarget = this;
|
|
|
2913
|
|
|
2914 for ( var j = 0, l = handlers.length; j < l; j++ ) {
|
|
|
2915 var handleObj = handlers[ j ];
|
|
|
2916
|
|
|
2917 // Triggered event must 1) be non-exclusive and have no namespace, or
|
|
|
2918 // 2) have namespace(s) a subset or equal to those in the bound event.
|
|
|
2919 if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {
|
|
|
2920 // Pass in a reference to the handler function itself
|
|
|
2921 // So that we can later remove it
|
|
|
2922 event.handler = handleObj.handler;
|
|
|
2923 event.data = handleObj.data;
|
|
|
2924 event.handleObj = handleObj;
|
|
|
2925
|
|
|
2926 var ret = handleObj.handler.apply( this, args );
|
|
|
2927
|
|
|
2928 if ( ret !== undefined ) {
|
|
|
2929 event.result = ret;
|
|
|
2930 if ( ret === false ) {
|
|
|
2931 event.preventDefault();
|
|
|
2932 event.stopPropagation();
|
|
|
2933 }
|
|
|
2934 }
|
|
|
2935
|
|
|
2936 if ( event.isImmediatePropagationStopped() ) {
|
|
|
2937 break;
|
|
|
2938 }
|
|
|
2939 }
|
|
|
2940 }
|
|
|
2941 return event.result;
|
|
|
2942 },
|
|
|
2943
|
|
|
2944 props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
|
|
|
2945
|
|
|
2946 fix: function( event ) {
|
|
|
2947 if ( event[ jQuery.expando ] ) {
|
|
|
2948 return event;
|
|
|
2949 }
|
|
|
2950
|
|
|
2951 // store a copy of the original event object
|
|
|
2952 // and "clone" to set read-only properties
|
|
|
2953 var originalEvent = event;
|
|
|
2954 event = jQuery.Event( originalEvent );
|
|
|
2955
|
|
|
2956 for ( var i = this.props.length, prop; i; ) {
|
|
|
2957 prop = this.props[ --i ];
|
|
|
2958 event[ prop ] = originalEvent[ prop ];
|
|
|
2959 }
|
|
|
2960
|
|
|
2961 // Fix target property, if necessary
|
|
|
2962 if ( !event.target ) {
|
|
|
2963 // Fixes #1925 where srcElement might not be defined either
|
|
|
2964 event.target = event.srcElement || document;
|
|
|
2965 }
|
|
|
2966
|
|
|
2967 // check if target is a textnode (safari)
|
|
|
2968 if ( event.target.nodeType === 3 ) {
|
|
|
2969 event.target = event.target.parentNode;
|
|
|
2970 }
|
|
|
2971
|
|
|
2972 // Add relatedTarget, if necessary
|
|
|
2973 if ( !event.relatedTarget && event.fromElement ) {
|
|
|
2974 event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
|
|
|
2975 }
|
|
|
2976
|
|
|
2977 // Calculate pageX/Y if missing and clientX/Y available
|
|
|
2978 if ( event.pageX == null && event.clientX != null ) {
|
|
|
2979 var eventDocument = event.target.ownerDocument || document,
|
|
|
2980 doc = eventDocument.documentElement,
|
|
|
2981 body = eventDocument.body;
|
|
|
2982
|
|
|
2983 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
|
|
|
2984 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
|
|
|
2985 }
|
|
|
2986
|
|
|
2987 // Add which for key events
|
|
|
2988 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
|
|
|
2989 event.which = event.charCode != null ? event.charCode : event.keyCode;
|
|
|
2990 }
|
|
|
2991
|
|
|
2992 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
|
|
|
2993 if ( !event.metaKey && event.ctrlKey ) {
|
|
|
2994 event.metaKey = event.ctrlKey;
|
|
|
2995 }
|
|
|
2996
|
|
|
2997 // Add which for click: 1 === left; 2 === middle; 3 === right
|
|
|
2998 // Note: button is not normalized, so don't use it
|
|
|
2999 if ( !event.which && event.button !== undefined ) {
|
|
|
3000 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
|
|
|
3001 }
|
|
|
3002
|
|
|
3003 return event;
|
|
|
3004 },
|
|
|
3005
|
|
|
3006 // Deprecated, use jQuery.guid instead
|
|
|
3007 guid: 1E8,
|
|
|
3008
|
|
|
3009 // Deprecated, use jQuery.proxy instead
|
|
|
3010 proxy: jQuery.proxy,
|
|
|
3011
|
|
|
3012 special: {
|
|
|
3013 ready: {
|
|
|
3014 // Make sure the ready event is setup
|
|
|
3015 setup: jQuery.bindReady,
|
|
|
3016 teardown: jQuery.noop
|
|
|
3017 },
|
|
|
3018
|
|
|
3019 live: {
|
|
|
3020 add: function( handleObj ) {
|
|
|
3021 jQuery.event.add( this,
|
|
|
3022 liveConvert( handleObj.origType, handleObj.selector ),
|
|
|
3023 jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
|
|
|
3024 },
|
|
|
3025
|
|
|
3026 remove: function( handleObj ) {
|
|
|
3027 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
|
|
|
3028 }
|
|
|
3029 },
|
|
|
3030
|
|
|
3031 beforeunload: {
|
|
|
3032 setup: function( data, namespaces, eventHandle ) {
|
|
|
3033 // We only want to do this special case on windows
|
|
|
3034 if ( jQuery.isWindow( this ) ) {
|
|
|
3035 this.onbeforeunload = eventHandle;
|
|
|
3036 }
|
|
|
3037 },
|
|
|
3038
|
|
|
3039 teardown: function( namespaces, eventHandle ) {
|
|
|
3040 if ( this.onbeforeunload === eventHandle ) {
|
|
|
3041 this.onbeforeunload = null;
|
|
|
3042 }
|
|
|
3043 }
|
|
|
3044 }
|
|
|
3045 }
|
|
|
3046 };
|
|
|
3047
|
|
|
3048 jQuery.removeEvent = document.removeEventListener ?
|
|
|
3049 function( elem, type, handle ) {
|
|
|
3050 if ( elem.removeEventListener ) {
|
|
|
3051 elem.removeEventListener( type, handle, false );
|
|
|
3052 }
|
|
|
3053 } :
|
|
|
3054 function( elem, type, handle ) {
|
|
|
3055 if ( elem.detachEvent ) {
|
|
|
3056 elem.detachEvent( "on" + type, handle );
|
|
|
3057 }
|
|
|
3058 };
|
|
|
3059
|
|
|
3060 jQuery.Event = function( src, props ) {
|
|
|
3061 // Allow instantiation without the 'new' keyword
|
|
|
3062 if ( !this.preventDefault ) {
|
|
|
3063 return new jQuery.Event( src, props );
|
|
|
3064 }
|
|
|
3065
|
|
|
3066 // Event object
|
|
|
3067 if ( src && src.type ) {
|
|
|
3068 this.originalEvent = src;
|
|
|
3069 this.type = src.type;
|
|
|
3070
|
|
|
3071 // Events bubbling up the document may have been marked as prevented
|
|
|
3072 // by a handler lower down the tree; reflect the correct value.
|
|
|
3073 this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
|
|
|
3074 src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
|
|
|
3075
|
|
|
3076 // Event type
|
|
|
3077 } else {
|
|
|
3078 this.type = src;
|
|
|
3079 }
|
|
|
3080
|
|
|
3081 // Put explicitly provided properties onto the event object
|
|
|
3082 if ( props ) {
|
|
|
3083 jQuery.extend( this, props );
|
|
|
3084 }
|
|
|
3085
|
|
|
3086 // timeStamp is buggy for some events on Firefox(#3843)
|
|
|
3087 // So we won't rely on the native value
|
|
|
3088 this.timeStamp = jQuery.now();
|
|
|
3089
|
|
|
3090 // Mark it as fixed
|
|
|
3091 this[ jQuery.expando ] = true;
|
|
|
3092 };
|
|
|
3093
|
|
|
3094 function returnFalse() {
|
|
|
3095 return false;
|
|
|
3096 }
|
|
|
3097 function returnTrue() {
|
|
|
3098 return true;
|
|
|
3099 }
|
|
|
3100
|
|
|
3101 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
|
|
|
3102 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
|
|
|
3103 jQuery.Event.prototype = {
|
|
|
3104 preventDefault: function() {
|
|
|
3105 this.isDefaultPrevented = returnTrue;
|
|
|
3106
|
|
|
3107 var e = this.originalEvent;
|
|
|
3108 if ( !e ) {
|
|
|
3109 return;
|
|
|
3110 }
|
|
|
3111
|
|
|
3112 // if preventDefault exists run it on the original event
|
|
|
3113 if ( e.preventDefault ) {
|
|
|
3114 e.preventDefault();
|
|
|
3115
|
|
|
3116 // otherwise set the returnValue property of the original event to false (IE)
|
|
|
3117 } else {
|
|
|
3118 e.returnValue = false;
|
|
|
3119 }
|
|
|
3120 },
|
|
|
3121 stopPropagation: function() {
|
|
|
3122 this.isPropagationStopped = returnTrue;
|
|
|
3123
|
|
|
3124 var e = this.originalEvent;
|
|
|
3125 if ( !e ) {
|
|
|
3126 return;
|
|
|
3127 }
|
|
|
3128 // if stopPropagation exists run it on the original event
|
|
|
3129 if ( e.stopPropagation ) {
|
|
|
3130 e.stopPropagation();
|
|
|
3131 }
|
|
|
3132 // otherwise set the cancelBubble property of the original event to true (IE)
|
|
|
3133 e.cancelBubble = true;
|
|
|
3134 },
|
|
|
3135 stopImmediatePropagation: function() {
|
|
|
3136 this.isImmediatePropagationStopped = returnTrue;
|
|
|
3137 this.stopPropagation();
|
|
|
3138 },
|
|
|
3139 isDefaultPrevented: returnFalse,
|
|
|
3140 isPropagationStopped: returnFalse,
|
|
|
3141 isImmediatePropagationStopped: returnFalse
|
|
|
3142 };
|
|
|
3143
|
|
|
3144 // Checks if an event happened on an element within another element
|
|
|
3145 // Used in jQuery.event.special.mouseenter and mouseleave handlers
|
|
|
3146 var withinElement = function( event ) {
|
|
|
3147 // Check if mouse(over|out) are still within the same parent element
|
|
|
3148 var parent = event.relatedTarget;
|
|
|
3149
|
|
|
3150 // set the correct event type
|
|
|
3151 event.type = event.data;
|
|
|
3152
|
|
|
3153 // Firefox sometimes assigns relatedTarget a XUL element
|
|
|
3154 // which we cannot access the parentNode property of
|
|
|
3155 try {
|
|
|
3156
|
|
|
3157 // Chrome does something similar, the parentNode property
|
|
|
3158 // can be accessed but is null.
|
|
|
3159 if ( parent && parent !== document && !parent.parentNode ) {
|
|
|
3160 return;
|
|
|
3161 }
|
|
|
3162
|
|
|
3163 // Traverse up the tree
|
|
|
3164 while ( parent && parent !== this ) {
|
|
|
3165 parent = parent.parentNode;
|
|
|
3166 }
|
|
|
3167
|
|
|
3168 if ( parent !== this ) {
|
|
|
3169 // handle event if we actually just moused on to a non sub-element
|
|
|
3170 jQuery.event.handle.apply( this, arguments );
|
|
|
3171 }
|
|
|
3172
|
|
|
3173 // assuming we've left the element since we most likely mousedover a xul element
|
|
|
3174 } catch(e) { }
|
|
|
3175 },
|
|
|
3176
|
|
|
3177 // In case of event delegation, we only need to rename the event.type,
|
|
|
3178 // liveHandler will take care of the rest.
|
|
|
3179 delegate = function( event ) {
|
|
|
3180 event.type = event.data;
|
|
|
3181 jQuery.event.handle.apply( this, arguments );
|
|
|
3182 };
|
|
|
3183
|
|
|
3184 // Create mouseenter and mouseleave events
|
|
|
3185 jQuery.each({
|
|
|
3186 mouseenter: "mouseover",
|
|
|
3187 mouseleave: "mouseout"
|
|
|
3188 }, function( orig, fix ) {
|
|
|
3189 jQuery.event.special[ orig ] = {
|
|
|
3190 setup: function( data ) {
|
|
|
3191 jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
|
|
|
3192 },
|
|
|
3193 teardown: function( data ) {
|
|
|
3194 jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
|
|
|
3195 }
|
|
|
3196 };
|
|
|
3197 });
|
|
|
3198
|
|
|
3199 // submit delegation
|
|
|
3200 if ( !jQuery.support.submitBubbles ) {
|
|
|
3201
|
|
|
3202 jQuery.event.special.submit = {
|
|
|
3203 setup: function( data, namespaces ) {
|
|
|
3204 if ( !jQuery.nodeName( this, "form" ) ) {
|
|
|
3205 jQuery.event.add(this, "click.specialSubmit", function( e ) {
|
|
|
3206 var elem = e.target,
|
|
|
3207 type = elem.type;
|
|
|
3208
|
|
|
3209 if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
|
|
|
3210 trigger( "submit", this, arguments );
|
|
|
3211 }
|
|
|
3212 });
|
|
|
3213
|
|
|
3214 jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
|
|
|
3215 var elem = e.target,
|
|
|
3216 type = elem.type;
|
|
|
3217
|
|
|
3218 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
|
|
|
3219 trigger( "submit", this, arguments );
|
|
|
3220 }
|
|
|
3221 });
|
|
|
3222
|
|
|
3223 } else {
|
|
|
3224 return false;
|
|
|
3225 }
|
|
|
3226 },
|
|
|
3227
|
|
|
3228 teardown: function( namespaces ) {
|
|
|
3229 jQuery.event.remove( this, ".specialSubmit" );
|
|
|
3230 }
|
|
|
3231 };
|
|
|
3232
|
|
|
3233 }
|
|
|
3234
|
|
|
3235 // change delegation, happens here so we have bind.
|
|
|
3236 if ( !jQuery.support.changeBubbles ) {
|
|
|
3237
|
|
|
3238 var changeFilters,
|
|
|
3239
|
|
|
3240 getVal = function( elem ) {
|
|
|
3241 var type = elem.type, val = elem.value;
|
|
|
3242
|
|
|
3243 if ( type === "radio" || type === "checkbox" ) {
|
|
|
3244 val = elem.checked;
|
|
|
3245
|
|
|
3246 } else if ( type === "select-multiple" ) {
|
|
|
3247 val = elem.selectedIndex > -1 ?
|
|
|
3248 jQuery.map( elem.options, function( elem ) {
|
|
|
3249 return elem.selected;
|
|
|
3250 }).join("-") :
|
|
|
3251 "";
|
|
|
3252
|
|
|
3253 } else if ( jQuery.nodeName( elem, "select" ) ) {
|
|
|
3254 val = elem.selectedIndex;
|
|
|
3255 }
|
|
|
3256
|
|
|
3257 return val;
|
|
|
3258 },
|
|
|
3259
|
|
|
3260 testChange = function testChange( e ) {
|
|
|
3261 var elem = e.target, data, val;
|
|
|
3262
|
|
|
3263 if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
|
|
|
3264 return;
|
|
|
3265 }
|
|
|
3266
|
|
|
3267 data = jQuery._data( elem, "_change_data" );
|
|
|
3268 val = getVal(elem);
|
|
|
3269
|
|
|
3270 // the current data will be also retrieved by beforeactivate
|
|
|
3271 if ( e.type !== "focusout" || elem.type !== "radio" ) {
|
|
|
3272 jQuery._data( elem, "_change_data", val );
|
|
|
3273 }
|
|
|
3274
|
|
|
3275 if ( data === undefined || val === data ) {
|
|
|
3276 return;
|
|
|
3277 }
|
|
|
3278
|
|
|
3279 if ( data != null || val ) {
|
|
|
3280 e.type = "change";
|
|
|
3281 e.liveFired = undefined;
|
|
|
3282 jQuery.event.trigger( e, arguments[1], elem );
|
|
|
3283 }
|
|
|
3284 };
|
|
|
3285
|
|
|
3286 jQuery.event.special.change = {
|
|
|
3287 filters: {
|
|
|
3288 focusout: testChange,
|
|
|
3289
|
|
|
3290 beforedeactivate: testChange,
|
|
|
3291
|
|
|
3292 click: function( e ) {
|
|
|
3293 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
|
|
|
3294
|
|
|
3295 if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) {
|
|
|
3296 testChange.call( this, e );
|
|
|
3297 }
|
|
|
3298 },
|
|
|
3299
|
|
|
3300 // Change has to be called before submit
|
|
|
3301 // Keydown will be called before keypress, which is used in submit-event delegation
|
|
|
3302 keydown: function( e ) {
|
|
|
3303 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
|
|
|
3304
|
|
|
3305 if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) ||
|
|
|
3306 (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
|
|
|
3307 type === "select-multiple" ) {
|
|
|
3308 testChange.call( this, e );
|
|
|
3309 }
|
|
|
3310 },
|
|
|
3311
|
|
|
3312 // Beforeactivate happens also before the previous element is blurred
|
|
|
3313 // with this event you can't trigger a change event, but you can store
|
|
|
3314 // information
|
|
|
3315 beforeactivate: function( e ) {
|
|
|
3316 var elem = e.target;
|
|
|
3317 jQuery._data( elem, "_change_data", getVal(elem) );
|
|
|
3318 }
|
|
|
3319 },
|
|
|
3320
|
|
|
3321 setup: function( data, namespaces ) {
|
|
|
3322 if ( this.type === "file" ) {
|
|
|
3323 return false;
|
|
|
3324 }
|
|
|
3325
|
|
|
3326 for ( var type in changeFilters ) {
|
|
|
3327 jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
|
|
|
3328 }
|
|
|
3329
|
|
|
3330 return rformElems.test( this.nodeName );
|
|
|
3331 },
|
|
|
3332
|
|
|
3333 teardown: function( namespaces ) {
|
|
|
3334 jQuery.event.remove( this, ".specialChange" );
|
|
|
3335
|
|
|
3336 return rformElems.test( this.nodeName );
|
|
|
3337 }
|
|
|
3338 };
|
|
|
3339
|
|
|
3340 changeFilters = jQuery.event.special.change.filters;
|
|
|
3341
|
|
|
3342 // Handle when the input is .focus()'d
|
|
|
3343 changeFilters.focus = changeFilters.beforeactivate;
|
|
|
3344 }
|
|
|
3345
|
|
|
3346 function trigger( type, elem, args ) {
|
|
|
3347 // Piggyback on a donor event to simulate a different one.
|
|
|
3348 // Fake originalEvent to avoid donor's stopPropagation, but if the
|
|
|
3349 // simulated event prevents default then we do the same on the donor.
|
|
|
3350 // Don't pass args or remember liveFired; they apply to the donor event.
|
|
|
3351 var event = jQuery.extend( {}, args[ 0 ] );
|
|
|
3352 event.type = type;
|
|
|
3353 event.originalEvent = {};
|
|
|
3354 event.liveFired = undefined;
|
|
|
3355 jQuery.event.handle.call( elem, event );
|
|
|
3356 if ( event.isDefaultPrevented() ) {
|
|
|
3357 args[ 0 ].preventDefault();
|
|
|
3358 }
|
|
|
3359 }
|
|
|
3360
|
|
|
3361 // Create "bubbling" focus and blur events
|
|
|
3362 if ( !jQuery.support.focusinBubbles ) {
|
|
|
3363 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
|
|
|
3364
|
|
|
3365 // Attach a single capturing handler while someone wants focusin/focusout
|
|
|
3366 var attaches = 0;
|
|
|
3367
|
|
|
3368 jQuery.event.special[ fix ] = {
|
|
|
3369 setup: function() {
|
|
|
3370 if ( attaches++ === 0 ) {
|
|
|
3371 document.addEventListener( orig, handler, true );
|
|
|
3372 }
|
|
|
3373 },
|
|
|
3374 teardown: function() {
|
|
|
3375 if ( --attaches === 0 ) {
|
|
|
3376 document.removeEventListener( orig, handler, true );
|
|
|
3377 }
|
|
|
3378 }
|
|
|
3379 };
|
|
|
3380
|
|
|
3381 function handler( donor ) {
|
|
|
3382 // Donor event is always a native one; fix it and switch its type.
|
|
|
3383 // Let focusin/out handler cancel the donor focus/blur event.
|
|
|
3384 var e = jQuery.event.fix( donor );
|
|
|
3385 e.type = fix;
|
|
|
3386 e.originalEvent = {};
|
|
|
3387 jQuery.event.trigger( e, null, e.target );
|
|
|
3388 if ( e.isDefaultPrevented() ) {
|
|
|
3389 donor.preventDefault();
|
|
|
3390 }
|
|
|
3391 }
|
|
|
3392 });
|
|
|
3393 }
|
|
|
3394
|
|
|
3395 jQuery.each(["bind", "one"], function( i, name ) {
|
|
|
3396 jQuery.fn[ name ] = function( type, data, fn ) {
|
|
|
3397 var handler;
|
|
|
3398
|
|
|
3399 // Handle object literals
|
|
|
3400 if ( typeof type === "object" ) {
|
|
|
3401 for ( var key in type ) {
|
|
|
3402 this[ name ](key, data, type[key], fn);
|
|
|
3403 }
|
|
|
3404 return this;
|
|
|
3405 }
|
|
|
3406
|
|
|
3407 if ( arguments.length === 2 || data === false ) {
|
|
|
3408 fn = data;
|
|
|
3409 data = undefined;
|
|
|
3410 }
|
|
|
3411
|
|
|
3412 if ( name === "one" ) {
|
|
|
3413 handler = function( event ) {
|
|
|
3414 jQuery( this ).unbind( event, handler );
|
|
|
3415 return fn.apply( this, arguments );
|
|
|
3416 };
|
|
|
3417 handler.guid = fn.guid || jQuery.guid++;
|
|
|
3418 } else {
|
|
|
3419 handler = fn;
|
|
|
3420 }
|
|
|
3421
|
|
|
3422 if ( type === "unload" && name !== "one" ) {
|
|
|
3423 this.one( type, data, fn );
|
|
|
3424
|
|
|
3425 } else {
|
|
|
3426 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
3427 jQuery.event.add( this[i], type, handler, data );
|
|
|
3428 }
|
|
|
3429 }
|
|
|
3430
|
|
|
3431 return this;
|
|
|
3432 };
|
|
|
3433 });
|
|
|
3434
|
|
|
3435 jQuery.fn.extend({
|
|
|
3436 unbind: function( type, fn ) {
|
|
|
3437 // Handle object literals
|
|
|
3438 if ( typeof type === "object" && !type.preventDefault ) {
|
|
|
3439 for ( var key in type ) {
|
|
|
3440 this.unbind(key, type[key]);
|
|
|
3441 }
|
|
|
3442
|
|
|
3443 } else {
|
|
|
3444 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
3445 jQuery.event.remove( this[i], type, fn );
|
|
|
3446 }
|
|
|
3447 }
|
|
|
3448
|
|
|
3449 return this;
|
|
|
3450 },
|
|
|
3451
|
|
|
3452 delegate: function( selector, types, data, fn ) {
|
|
|
3453 return this.live( types, data, fn, selector );
|
|
|
3454 },
|
|
|
3455
|
|
|
3456 undelegate: function( selector, types, fn ) {
|
|
|
3457 if ( arguments.length === 0 ) {
|
|
|
3458 return this.unbind( "live" );
|
|
|
3459
|
|
|
3460 } else {
|
|
|
3461 return this.die( types, null, fn, selector );
|
|
|
3462 }
|
|
|
3463 },
|
|
|
3464
|
|
|
3465 trigger: function( type, data ) {
|
|
|
3466 return this.each(function() {
|
|
|
3467 jQuery.event.trigger( type, data, this );
|
|
|
3468 });
|
|
|
3469 },
|
|
|
3470
|
|
|
3471 triggerHandler: function( type, data ) {
|
|
|
3472 if ( this[0] ) {
|
|
|
3473 return jQuery.event.trigger( type, data, this[0], true );
|
|
|
3474 }
|
|
|
3475 },
|
|
|
3476
|
|
|
3477 toggle: function( fn ) {
|
|
|
3478 // Save reference to arguments for access in closure
|
|
|
3479 var args = arguments,
|
|
|
3480 guid = fn.guid || jQuery.guid++,
|
|
|
3481 i = 0,
|
|
|
3482 toggler = function( event ) {
|
|
|
3483 // Figure out which function to execute
|
|
|
3484 var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
|
|
|
3485 jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
|
|
|
3486
|
|
|
3487 // Make sure that clicks stop
|
|
|
3488 event.preventDefault();
|
|
|
3489
|
|
|
3490 // and execute the function
|
|
|
3491 return args[ lastToggle ].apply( this, arguments ) || false;
|
|
|
3492 };
|
|
|
3493
|
|
|
3494 // link all the functions, so any of them can unbind this click handler
|
|
|
3495 toggler.guid = guid;
|
|
|
3496 while ( i < args.length ) {
|
|
|
3497 args[ i++ ].guid = guid;
|
|
|
3498 }
|
|
|
3499
|
|
|
3500 return this.click( toggler );
|
|
|
3501 },
|
|
|
3502
|
|
|
3503 hover: function( fnOver, fnOut ) {
|
|
|
3504 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
|
|
|
3505 }
|
|
|
3506 });
|
|
|
3507
|
|
|
3508 var liveMap = {
|
|
|
3509 focus: "focusin",
|
|
|
3510 blur: "focusout",
|
|
|
3511 mouseenter: "mouseover",
|
|
|
3512 mouseleave: "mouseout"
|
|
|
3513 };
|
|
|
3514
|
|
|
3515 jQuery.each(["live", "die"], function( i, name ) {
|
|
|
3516 jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
|
|
|
3517 var type, i = 0, match, namespaces, preType,
|
|
|
3518 selector = origSelector || this.selector,
|
|
|
3519 context = origSelector ? this : jQuery( this.context );
|
|
|
3520
|
|
|
3521 if ( typeof types === "object" && !types.preventDefault ) {
|
|
|
3522 for ( var key in types ) {
|
|
|
3523 context[ name ]( key, data, types[key], selector );
|
|
|
3524 }
|
|
|
3525
|
|
|
3526 return this;
|
|
|
3527 }
|
|
|
3528
|
|
|
3529 if ( name === "die" && !types &&
|
|
|
3530 origSelector && origSelector.charAt(0) === "." ) {
|
|
|
3531
|
|
|
3532 context.unbind( origSelector );
|
|
|
3533
|
|
|
3534 return this;
|
|
|
3535 }
|
|
|
3536
|
|
|
3537 if ( data === false || jQuery.isFunction( data ) ) {
|
|
|
3538 fn = data || returnFalse;
|
|
|
3539 data = undefined;
|
|
|
3540 }
|
|
|
3541
|
|
|
3542 types = (types || "").split(" ");
|
|
|
3543
|
|
|
3544 while ( (type = types[ i++ ]) != null ) {
|
|
|
3545 match = rnamespaces.exec( type );
|
|
|
3546 namespaces = "";
|
|
|
3547
|
|
|
3548 if ( match ) {
|
|
|
3549 namespaces = match[0];
|
|
|
3550 type = type.replace( rnamespaces, "" );
|
|
|
3551 }
|
|
|
3552
|
|
|
3553 if ( type === "hover" ) {
|
|
|
3554 types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
|
|
|
3555 continue;
|
|
|
3556 }
|
|
|
3557
|
|
|
3558 preType = type;
|
|
|
3559
|
|
|
3560 if ( liveMap[ type ] ) {
|
|
|
3561 types.push( liveMap[ type ] + namespaces );
|
|
|
3562 type = type + namespaces;
|
|
|
3563
|
|
|
3564 } else {
|
|
|
3565 type = (liveMap[ type ] || type) + namespaces;
|
|
|
3566 }
|
|
|
3567
|
|
|
3568 if ( name === "live" ) {
|
|
|
3569 // bind live handler
|
|
|
3570 for ( var j = 0, l = context.length; j < l; j++ ) {
|
|
|
3571 jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
|
|
|
3572 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
|
|
|
3573 }
|
|
|
3574
|
|
|
3575 } else {
|
|
|
3576 // unbind live handler
|
|
|
3577 context.unbind( "live." + liveConvert( type, selector ), fn );
|
|
|
3578 }
|
|
|
3579 }
|
|
|
3580
|
|
|
3581 return this;
|
|
|
3582 };
|
|
|
3583 });
|
|
|
3584
|
|
|
3585 function liveHandler( event ) {
|
|
|
3586 var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
|
|
|
3587 elems = [],
|
|
|
3588 selectors = [],
|
|
|
3589 events = jQuery._data( this, "events" );
|
|
|
3590
|
|
|
3591 // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
|
|
|
3592 if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
|
|
|
3593 return;
|
|
|
3594 }
|
|
|
3595
|
|
|
3596 if ( event.namespace ) {
|
|
|
3597 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
|
|
|
3598 }
|
|
|
3599
|
|
|
3600 event.liveFired = this;
|
|
|
3601
|
|
|
3602 var live = events.live.slice(0);
|
|
|
3603
|
|
|
3604 for ( j = 0; j < live.length; j++ ) {
|
|
|
3605 handleObj = live[j];
|
|
|
3606
|
|
|
3607 if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
|
|
|
3608 selectors.push( handleObj.selector );
|
|
|
3609
|
|
|
3610 } else {
|
|
|
3611 live.splice( j--, 1 );
|
|
|
3612 }
|
|
|
3613 }
|
|
|
3614
|
|
|
3615 match = jQuery( event.target ).closest( selectors, event.currentTarget );
|
|
|
3616
|
|
|
3617 for ( i = 0, l = match.length; i < l; i++ ) {
|
|
|
3618 close = match[i];
|
|
|
3619
|
|
|
3620 for ( j = 0; j < live.length; j++ ) {
|
|
|
3621 handleObj = live[j];
|
|
|
3622
|
|
|
3623 if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
|
|
|
3624 elem = close.elem;
|
|
|
3625 related = null;
|
|
|
3626
|
|
|
3627 // Those two events require additional checking
|
|
|
3628 if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
|
|
|
3629 event.type = handleObj.preType;
|
|
|
3630 related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
|
|
|
3631
|
|
|
3632 // Make sure not to accidentally match a child element with the same selector
|
|
|
3633 if ( related && jQuery.contains( elem, related ) ) {
|
|
|
3634 related = elem;
|
|
|
3635 }
|
|
|
3636 }
|
|
|
3637
|
|
|
3638 if ( !related || related !== elem ) {
|
|
|
3639 elems.push({ elem: elem, handleObj: handleObj, level: close.level });
|
|
|
3640 }
|
|
|
3641 }
|
|
|
3642 }
|
|
|
3643 }
|
|
|
3644
|
|
|
3645 for ( i = 0, l = elems.length; i < l; i++ ) {
|
|
|
3646 match = elems[i];
|
|
|
3647
|
|
|
3648 if ( maxLevel && match.level > maxLevel ) {
|
|
|
3649 break;
|
|
|
3650 }
|
|
|
3651
|
|
|
3652 event.currentTarget = match.elem;
|
|
|
3653 event.data = match.handleObj.data;
|
|
|
3654 event.handleObj = match.handleObj;
|
|
|
3655
|
|
|
3656 ret = match.handleObj.origHandler.apply( match.elem, arguments );
|
|
|
3657
|
|
|
3658 if ( ret === false || event.isPropagationStopped() ) {
|
|
|
3659 maxLevel = match.level;
|
|
|
3660
|
|
|
3661 if ( ret === false ) {
|
|
|
3662 stop = false;
|
|
|
3663 }
|
|
|
3664 if ( event.isImmediatePropagationStopped() ) {
|
|
|
3665 break;
|
|
|
3666 }
|
|
|
3667 }
|
|
|
3668 }
|
|
|
3669
|
|
|
3670 return stop;
|
|
|
3671 }
|
|
|
3672
|
|
|
3673 function liveConvert( type, selector ) {
|
|
|
3674 return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
|
|
|
3675 }
|
|
|
3676
|
|
|
3677 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
|
|
|
3678 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
|
|
|
3679 "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
|
|
|
3680
|
|
|
3681 // Handle event binding
|
|
|
3682 jQuery.fn[ name ] = function( data, fn ) {
|
|
|
3683 if ( fn == null ) {
|
|
|
3684 fn = data;
|
|
|
3685 data = null;
|
|
|
3686 }
|
|
|
3687
|
|
|
3688 return arguments.length > 0 ?
|
|
|
3689 this.bind( name, data, fn ) :
|
|
|
3690 this.trigger( name );
|
|
|
3691 };
|
|
|
3692
|
|
|
3693 if ( jQuery.attrFn ) {
|
|
|
3694 jQuery.attrFn[ name ] = true;
|
|
|
3695 }
|
|
|
3696 });
|
|
|
3697
|
|
|
3698
|
|
|
3699
|
|
|
3700 /*!
|
|
|
3701 * Sizzle CSS Selector Engine
|
|
|
3702 * Copyright 2011, The Dojo Foundation
|
|
|
3703 * Released under the MIT, BSD, and GPL Licenses.
|
|
|
3704 * More information: http://sizzlejs.com/
|
|
|
3705 */
|
|
|
3706 (function(){
|
|
|
3707
|
|
|
3708 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
|
|
|
3709 done = 0,
|
|
|
3710 toString = Object.prototype.toString,
|
|
|
3711 hasDuplicate = false,
|
|
|
3712 baseHasDuplicate = true,
|
|
|
3713 rBackslash = /\\/g,
|
|
|
3714 rNonWord = /\W/;
|
|
|
3715
|
|
|
3716 // Here we check if the JavaScript engine is using some sort of
|
|
|
3717 // optimization where it does not always call our comparision
|
|
|
3718 // function. If that is the case, discard the hasDuplicate value.
|
|
|
3719 // Thus far that includes Google Chrome.
|
|
|
3720 [0, 0].sort(function() {
|
|
|
3721 baseHasDuplicate = false;
|
|
|
3722 return 0;
|
|
|
3723 });
|
|
|
3724
|
|
|
3725 var Sizzle = function( selector, context, results, seed ) {
|
|
|
3726 results = results || [];
|
|
|
3727 context = context || document;
|
|
|
3728
|
|
|
3729 var origContext = context;
|
|
|
3730
|
|
|
3731 if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
|
|
|
3732 return [];
|
|
|
3733 }
|
|
|
3734
|
|
|
3735 if ( !selector || typeof selector !== "string" ) {
|
|
|
3736 return results;
|
|
|
3737 }
|
|
|
3738
|
|
|
3739 var m, set, checkSet, extra, ret, cur, pop, i,
|
|
|
3740 prune = true,
|
|
|
3741 contextXML = Sizzle.isXML( context ),
|
|
|
3742 parts = [],
|
|
|
3743 soFar = selector;
|
|
|
3744
|
|
|
3745 // Reset the position of the chunker regexp (start from head)
|
|
|
3746 do {
|
|
|
3747 chunker.exec( "" );
|
|
|
3748 m = chunker.exec( soFar );
|
|
|
3749
|
|
|
3750 if ( m ) {
|
|
|
3751 soFar = m[3];
|
|
|
3752
|
|
|
3753 parts.push( m[1] );
|
|
|
3754
|
|
|
3755 if ( m[2] ) {
|
|
|
3756 extra = m[3];
|
|
|
3757 break;
|
|
|
3758 }
|
|
|
3759 }
|
|
|
3760 } while ( m );
|
|
|
3761
|
|
|
3762 if ( parts.length > 1 && origPOS.exec( selector ) ) {
|
|
|
3763
|
|
|
3764 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
|
|
|
3765 set = posProcess( parts[0] + parts[1], context );
|
|
|
3766
|
|
|
3767 } else {
|
|
|
3768 set = Expr.relative[ parts[0] ] ?
|
|
|
3769 [ context ] :
|
|
|
3770 Sizzle( parts.shift(), context );
|
|
|
3771
|
|
|
3772 while ( parts.length ) {
|
|
|
3773 selector = parts.shift();
|
|
|
3774
|
|
|
3775 if ( Expr.relative[ selector ] ) {
|
|
|
3776 selector += parts.shift();
|
|
|
3777 }
|
|
|
3778
|
|
|
3779 set = posProcess( selector, set );
|
|
|
3780 }
|
|
|
3781 }
|
|
|
3782
|
|
|
3783 } else {
|
|
|
3784 // Take a shortcut and set the context if the root selector is an ID
|
|
|
3785 // (but not if it'll be faster if the inner selector is an ID)
|
|
|
3786 if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
|
|
|
3787 Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
|
|
|
3788
|
|
|
3789 ret = Sizzle.find( parts.shift(), context, contextXML );
|
|
|
3790 context = ret.expr ?
|
|
|
3791 Sizzle.filter( ret.expr, ret.set )[0] :
|
|
|
3792 ret.set[0];
|
|
|
3793 }
|
|
|
3794
|
|
|
3795 if ( context ) {
|
|
|
3796 ret = seed ?
|
|
|
3797 { expr: parts.pop(), set: makeArray(seed) } :
|
|
|
3798 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
|
|
|
3799
|
|
|
3800 set = ret.expr ?
|
|
|
3801 Sizzle.filter( ret.expr, ret.set ) :
|
|
|
3802 ret.set;
|
|
|
3803
|
|
|
3804 if ( parts.length > 0 ) {
|
|
|
3805 checkSet = makeArray( set );
|
|
|
3806
|
|
|
3807 } else {
|
|
|
3808 prune = false;
|
|
|
3809 }
|
|
|
3810
|
|
|
3811 while ( parts.length ) {
|
|
|
3812 cur = parts.pop();
|
|
|
3813 pop = cur;
|
|
|
3814
|
|
|
3815 if ( !Expr.relative[ cur ] ) {
|
|
|
3816 cur = "";
|
|
|
3817 } else {
|
|
|
3818 pop = parts.pop();
|
|
|
3819 }
|
|
|
3820
|
|
|
3821 if ( pop == null ) {
|
|
|
3822 pop = context;
|
|
|
3823 }
|
|
|
3824
|
|
|
3825 Expr.relative[ cur ]( checkSet, pop, contextXML );
|
|
|
3826 }
|
|
|
3827
|
|
|
3828 } else {
|
|
|
3829 checkSet = parts = [];
|
|
|
3830 }
|
|
|
3831 }
|
|
|
3832
|
|
|
3833 if ( !checkSet ) {
|
|
|
3834 checkSet = set;
|
|
|
3835 }
|
|
|
3836
|
|
|
3837 if ( !checkSet ) {
|
|
|
3838 Sizzle.error( cur || selector );
|
|
|
3839 }
|
|
|
3840
|
|
|
3841 if ( toString.call(checkSet) === "[object Array]" ) {
|
|
|
3842 if ( !prune ) {
|
|
|
3843 results.push.apply( results, checkSet );
|
|
|
3844
|
|
|
3845 } else if ( context && context.nodeType === 1 ) {
|
|
|
3846 for ( i = 0; checkSet[i] != null; i++ ) {
|
|
|
3847 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
|
|
|
3848 results.push( set[i] );
|
|
|
3849 }
|
|
|
3850 }
|
|
|
3851
|
|
|
3852 } else {
|
|
|
3853 for ( i = 0; checkSet[i] != null; i++ ) {
|
|
|
3854 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
|
|
|
3855 results.push( set[i] );
|
|
|
3856 }
|
|
|
3857 }
|
|
|
3858 }
|
|
|
3859
|
|
|
3860 } else {
|
|
|
3861 makeArray( checkSet, results );
|
|
|
3862 }
|
|
|
3863
|
|
|
3864 if ( extra ) {
|
|
|
3865 Sizzle( extra, origContext, results, seed );
|
|
|
3866 Sizzle.uniqueSort( results );
|
|
|
3867 }
|
|
|
3868
|
|
|
3869 return results;
|
|
|
3870 };
|
|
|
3871
|
|
|
3872 Sizzle.uniqueSort = function( results ) {
|
|
|
3873 if ( sortOrder ) {
|
|
|
3874 hasDuplicate = baseHasDuplicate;
|
|
|
3875 results.sort( sortOrder );
|
|
|
3876
|
|
|
3877 if ( hasDuplicate ) {
|
|
|
3878 for ( var i = 1; i < results.length; i++ ) {
|
|
|
3879 if ( results[i] === results[ i - 1 ] ) {
|
|
|
3880 results.splice( i--, 1 );
|
|
|
3881 }
|
|
|
3882 }
|
|
|
3883 }
|
|
|
3884 }
|
|
|
3885
|
|
|
3886 return results;
|
|
|
3887 };
|
|
|
3888
|
|
|
3889 Sizzle.matches = function( expr, set ) {
|
|
|
3890 return Sizzle( expr, null, null, set );
|
|
|
3891 };
|
|
|
3892
|
|
|
3893 Sizzle.matchesSelector = function( node, expr ) {
|
|
|
3894 return Sizzle( expr, null, null, [node] ).length > 0;
|
|
|
3895 };
|
|
|
3896
|
|
|
3897 Sizzle.find = function( expr, context, isXML ) {
|
|
|
3898 var set;
|
|
|
3899
|
|
|
3900 if ( !expr ) {
|
|
|
3901 return [];
|
|
|
3902 }
|
|
|
3903
|
|
|
3904 for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
|
|
|
3905 var match,
|
|
|
3906 type = Expr.order[i];
|
|
|
3907
|
|
|
3908 if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
|
|
|
3909 var left = match[1];
|
|
|
3910 match.splice( 1, 1 );
|
|
|
3911
|
|
|
3912 if ( left.substr( left.length - 1 ) !== "\\" ) {
|
|
|
3913 match[1] = (match[1] || "").replace( rBackslash, "" );
|
|
|
3914 set = Expr.find[ type ]( match, context, isXML );
|
|
|
3915
|
|
|
3916 if ( set != null ) {
|
|
|
3917 expr = expr.replace( Expr.match[ type ], "" );
|
|
|
3918 break;
|
|
|
3919 }
|
|
|
3920 }
|
|
|
3921 }
|
|
|
3922 }
|
|
|
3923
|
|
|
3924 if ( !set ) {
|
|
|
3925 set = typeof context.getElementsByTagName !== "undefined" ?
|
|
|
3926 context.getElementsByTagName( "*" ) :
|
|
|
3927 [];
|
|
|
3928 }
|
|
|
3929
|
|
|
3930 return { set: set, expr: expr };
|
|
|
3931 };
|
|
|
3932
|
|
|
3933 Sizzle.filter = function( expr, set, inplace, not ) {
|
|
|
3934 var match, anyFound,
|
|
|
3935 old = expr,
|
|
|
3936 result = [],
|
|
|
3937 curLoop = set,
|
|
|
3938 isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
|
|
|
3939
|
|
|
3940 while ( expr && set.length ) {
|
|
|
3941 for ( var type in Expr.filter ) {
|
|
|
3942 if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
|
|
|
3943 var found, item,
|
|
|
3944 filter = Expr.filter[ type ],
|
|
|
3945 left = match[1];
|
|
|
3946
|
|
|
3947 anyFound = false;
|
|
|
3948
|
|
|
3949 match.splice(1,1);
|
|
|
3950
|
|
|
3951 if ( left.substr( left.length - 1 ) === "\\" ) {
|
|
|
3952 continue;
|
|
|
3953 }
|
|
|
3954
|
|
|
3955 if ( curLoop === result ) {
|
|
|
3956 result = [];
|
|
|
3957 }
|
|
|
3958
|
|
|
3959 if ( Expr.preFilter[ type ] ) {
|
|
|
3960 match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
|
|
|
3961
|
|
|
3962 if ( !match ) {
|
|
|
3963 anyFound = found = true;
|
|
|
3964
|
|
|
3965 } else if ( match === true ) {
|
|
|
3966 continue;
|
|
|
3967 }
|
|
|
3968 }
|
|
|
3969
|
|
|
3970 if ( match ) {
|
|
|
3971 for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
|
|
|
3972 if ( item ) {
|
|
|
3973 found = filter( item, match, i, curLoop );
|
|
|
3974 var pass = not ^ !!found;
|
|
|
3975
|
|
|
3976 if ( inplace && found != null ) {
|
|
|
3977 if ( pass ) {
|
|
|
3978 anyFound = true;
|
|
|
3979
|
|
|
3980 } else {
|
|
|
3981 curLoop[i] = false;
|
|
|
3982 }
|
|
|
3983
|
|
|
3984 } else if ( pass ) {
|
|
|
3985 result.push( item );
|
|
|
3986 anyFound = true;
|
|
|
3987 }
|
|
|
3988 }
|
|
|
3989 }
|
|
|
3990 }
|
|
|
3991
|
|
|
3992 if ( found !== undefined ) {
|
|
|
3993 if ( !inplace ) {
|
|
|
3994 curLoop = result;
|
|
|
3995 }
|
|
|
3996
|
|
|
3997 expr = expr.replace( Expr.match[ type ], "" );
|
|
|
3998
|
|
|
3999 if ( !anyFound ) {
|
|
|
4000 return [];
|
|
|
4001 }
|
|
|
4002
|
|
|
4003 break;
|
|
|
4004 }
|
|
|
4005 }
|
|
|
4006 }
|
|
|
4007
|
|
|
4008 // Improper expression
|
|
|
4009 if ( expr === old ) {
|
|
|
4010 if ( anyFound == null ) {
|
|
|
4011 Sizzle.error( expr );
|
|
|
4012
|
|
|
4013 } else {
|
|
|
4014 break;
|
|
|
4015 }
|
|
|
4016 }
|
|
|
4017
|
|
|
4018 old = expr;
|
|
|
4019 }
|
|
|
4020
|
|
|
4021 return curLoop;
|
|
|
4022 };
|
|
|
4023
|
|
|
4024 Sizzle.error = function( msg ) {
|
|
|
4025 throw "Syntax error, unrecognized expression: " + msg;
|
|
|
4026 };
|
|
|
4027
|
|
|
4028 var Expr = Sizzle.selectors = {
|
|
|
4029 order: [ "ID", "NAME", "TAG" ],
|
|
|
4030
|
|
|
4031 match: {
|
|
|
4032 ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
|
|
|
4033 CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
|
|
|
4034 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
|
|
|
4035 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
|
|
|
4036 TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
|
|
|
4037 CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
|
|
|
4038 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
|
|
|
4039 PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
|
|
|
4040 },
|
|
|
4041
|
|
|
4042 leftMatch: {},
|
|
|
4043
|
|
|
4044 attrMap: {
|
|
|
4045 "class": "className",
|
|
|
4046 "for": "htmlFor"
|
|
|
4047 },
|
|
|
4048
|
|
|
4049 attrHandle: {
|
|
|
4050 href: function( elem ) {
|
|
|
4051 return elem.getAttribute( "href" );
|
|
|
4052 },
|
|
|
4053 type: function( elem ) {
|
|
|
4054 return elem.getAttribute( "type" );
|
|
|
4055 }
|
|
|
4056 },
|
|
|
4057
|
|
|
4058 relative: {
|
|
|
4059 "+": function(checkSet, part){
|
|
|
4060 var isPartStr = typeof part === "string",
|
|
|
4061 isTag = isPartStr && !rNonWord.test( part ),
|
|
|
4062 isPartStrNotTag = isPartStr && !isTag;
|
|
|
4063
|
|
|
4064 if ( isTag ) {
|
|
|
4065 part = part.toLowerCase();
|
|
|
4066 }
|
|
|
4067
|
|
|
4068 for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
|
|
|
4069 if ( (elem = checkSet[i]) ) {
|
|
|
4070 while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
|
|
|
4071
|
|
|
4072 checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
|
|
|
4073 elem || false :
|
|
|
4074 elem === part;
|
|
|
4075 }
|
|
|
4076 }
|
|
|
4077
|
|
|
4078 if ( isPartStrNotTag ) {
|
|
|
4079 Sizzle.filter( part, checkSet, true );
|
|
|
4080 }
|
|
|
4081 },
|
|
|
4082
|
|
|
4083 ">": function( checkSet, part ) {
|
|
|
4084 var elem,
|
|
|
4085 isPartStr = typeof part === "string",
|
|
|
4086 i = 0,
|
|
|
4087 l = checkSet.length;
|
|
|
4088
|
|
|
4089 if ( isPartStr && !rNonWord.test( part ) ) {
|
|
|
4090 part = part.toLowerCase();
|
|
|
4091
|
|
|
4092 for ( ; i < l; i++ ) {
|
|
|
4093 elem = checkSet[i];
|
|
|
4094
|
|
|
4095 if ( elem ) {
|
|
|
4096 var parent = elem.parentNode;
|
|
|
4097 checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
|
|
|
4098 }
|
|
|
4099 }
|
|
|
4100
|
|
|
4101 } else {
|
|
|
4102 for ( ; i < l; i++ ) {
|
|
|
4103 elem = checkSet[i];
|
|
|
4104
|
|
|
4105 if ( elem ) {
|
|
|
4106 checkSet[i] = isPartStr ?
|
|
|
4107 elem.parentNode :
|
|
|
4108 elem.parentNode === part;
|
|
|
4109 }
|
|
|
4110 }
|
|
|
4111
|
|
|
4112 if ( isPartStr ) {
|
|
|
4113 Sizzle.filter( part, checkSet, true );
|
|
|
4114 }
|
|
|
4115 }
|
|
|
4116 },
|
|
|
4117
|
|
|
4118 "": function(checkSet, part, isXML){
|
|
|
4119 var nodeCheck,
|
|
|
4120 doneName = done++,
|
|
|
4121 checkFn = dirCheck;
|
|
|
4122
|
|
|
4123 if ( typeof part === "string" && !rNonWord.test( part ) ) {
|
|
|
4124 part = part.toLowerCase();
|
|
|
4125 nodeCheck = part;
|
|
|
4126 checkFn = dirNodeCheck;
|
|
|
4127 }
|
|
|
4128
|
|
|
4129 checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
|
|
|
4130 },
|
|
|
4131
|
|
|
4132 "~": function( checkSet, part, isXML ) {
|
|
|
4133 var nodeCheck,
|
|
|
4134 doneName = done++,
|
|
|
4135 checkFn = dirCheck;
|
|
|
4136
|
|
|
4137 if ( typeof part === "string" && !rNonWord.test( part ) ) {
|
|
|
4138 part = part.toLowerCase();
|
|
|
4139 nodeCheck = part;
|
|
|
4140 checkFn = dirNodeCheck;
|
|
|
4141 }
|
|
|
4142
|
|
|
4143 checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
|
|
|
4144 }
|
|
|
4145 },
|
|
|
4146
|
|
|
4147 find: {
|
|
|
4148 ID: function( match, context, isXML ) {
|
|
|
4149 if ( typeof context.getElementById !== "undefined" && !isXML ) {
|
|
|
4150 var m = context.getElementById(match[1]);
|
|
|
4151 // Check parentNode to catch when Blackberry 4.6 returns
|
|
|
4152 // nodes that are no longer in the document #6963
|
|
|
4153 return m && m.parentNode ? [m] : [];
|
|
|
4154 }
|
|
|
4155 },
|
|
|
4156
|
|
|
4157 NAME: function( match, context ) {
|
|
|
4158 if ( typeof context.getElementsByName !== "undefined" ) {
|
|
|
4159 var ret = [],
|
|
|
4160 results = context.getElementsByName( match[1] );
|
|
|
4161
|
|
|
4162 for ( var i = 0, l = results.length; i < l; i++ ) {
|
|
|
4163 if ( results[i].getAttribute("name") === match[1] ) {
|
|
|
4164 ret.push( results[i] );
|
|
|
4165 }
|
|
|
4166 }
|
|
|
4167
|
|
|
4168 return ret.length === 0 ? null : ret;
|
|
|
4169 }
|
|
|
4170 },
|
|
|
4171
|
|
|
4172 TAG: function( match, context ) {
|
|
|
4173 if ( typeof context.getElementsByTagName !== "undefined" ) {
|
|
|
4174 return context.getElementsByTagName( match[1] );
|
|
|
4175 }
|
|
|
4176 }
|
|
|
4177 },
|
|
|
4178 preFilter: {
|
|
|
4179 CLASS: function( match, curLoop, inplace, result, not, isXML ) {
|
|
|
4180 match = " " + match[1].replace( rBackslash, "" ) + " ";
|
|
|
4181
|
|
|
4182 if ( isXML ) {
|
|
|
4183 return match;
|
|
|
4184 }
|
|
|
4185
|
|
|
4186 for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
|
|
|
4187 if ( elem ) {
|
|
|
4188 if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
|
|
|
4189 if ( !inplace ) {
|
|
|
4190 result.push( elem );
|
|
|
4191 }
|
|
|
4192
|
|
|
4193 } else if ( inplace ) {
|
|
|
4194 curLoop[i] = false;
|
|
|
4195 }
|
|
|
4196 }
|
|
|
4197 }
|
|
|
4198
|
|
|
4199 return false;
|
|
|
4200 },
|
|
|
4201
|
|
|
4202 ID: function( match ) {
|
|
|
4203 return match[1].replace( rBackslash, "" );
|
|
|
4204 },
|
|
|
4205
|
|
|
4206 TAG: function( match, curLoop ) {
|
|
|
4207 return match[1].replace( rBackslash, "" ).toLowerCase();
|
|
|
4208 },
|
|
|
4209
|
|
|
4210 CHILD: function( match ) {
|
|
|
4211 if ( match[1] === "nth" ) {
|
|
|
4212 if ( !match[2] ) {
|
|
|
4213 Sizzle.error( match[0] );
|
|
|
4214 }
|
|
|
4215
|
|
|
4216 match[2] = match[2].replace(/^\+|\s*/g, '');
|
|
|
4217
|
|
|
4218 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
|
|
|
4219 var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
|
|
|
4220 match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
|
|
|
4221 !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
|
|
|
4222
|
|
|
4223 // calculate the numbers (first)n+(last) including if they are negative
|
|
|
4224 match[2] = (test[1] + (test[2] || 1)) - 0;
|
|
|
4225 match[3] = test[3] - 0;
|
|
|
4226 }
|
|
|
4227 else if ( match[2] ) {
|
|
|
4228 Sizzle.error( match[0] );
|
|
|
4229 }
|
|
|
4230
|
|
|
4231 // TODO: Move to normal caching system
|
|
|
4232 match[0] = done++;
|
|
|
4233
|
|
|
4234 return match;
|
|
|
4235 },
|
|
|
4236
|
|
|
4237 ATTR: function( match, curLoop, inplace, result, not, isXML ) {
|
|
|
4238 var name = match[1] = match[1].replace( rBackslash, "" );
|
|
|
4239
|
|
|
4240 if ( !isXML && Expr.attrMap[name] ) {
|
|
|
4241 match[1] = Expr.attrMap[name];
|
|
|
4242 }
|
|
|
4243
|
|
|
4244 // Handle if an un-quoted value was used
|
|
|
4245 match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
|
|
|
4246
|
|
|
4247 if ( match[2] === "~=" ) {
|
|
|
4248 match[4] = " " + match[4] + " ";
|
|
|
4249 }
|
|
|
4250
|
|
|
4251 return match;
|
|
|
4252 },
|
|
|
4253
|
|
|
4254 PSEUDO: function( match, curLoop, inplace, result, not ) {
|
|
|
4255 if ( match[1] === "not" ) {
|
|
|
4256 // If we're dealing with a complex expression, or a simple one
|
|
|
4257 if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
|
|
|
4258 match[3] = Sizzle(match[3], null, null, curLoop);
|
|
|
4259
|
|
|
4260 } else {
|
|
|
4261 var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
|
|
|
4262
|
|
|
4263 if ( !inplace ) {
|
|
|
4264 result.push.apply( result, ret );
|
|
|
4265 }
|
|
|
4266
|
|
|
4267 return false;
|
|
|
4268 }
|
|
|
4269
|
|
|
4270 } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
|
|
|
4271 return true;
|
|
|
4272 }
|
|
|
4273
|
|
|
4274 return match;
|
|
|
4275 },
|
|
|
4276
|
|
|
4277 POS: function( match ) {
|
|
|
4278 match.unshift( true );
|
|
|
4279
|
|
|
4280 return match;
|
|
|
4281 }
|
|
|
4282 },
|
|
|
4283
|
|
|
4284 filters: {
|
|
|
4285 enabled: function( elem ) {
|
|
|
4286 return elem.disabled === false && elem.type !== "hidden";
|
|
|
4287 },
|
|
|
4288
|
|
|
4289 disabled: function( elem ) {
|
|
|
4290 return elem.disabled === true;
|
|
|
4291 },
|
|
|
4292
|
|
|
4293 checked: function( elem ) {
|
|
|
4294 return elem.checked === true;
|
|
|
4295 },
|
|
|
4296
|
|
|
4297 selected: function( elem ) {
|
|
|
4298 // Accessing this property makes selected-by-default
|
|
|
4299 // options in Safari work properly
|
|
|
4300 if ( elem.parentNode ) {
|
|
|
4301 elem.parentNode.selectedIndex;
|
|
|
4302 }
|
|
|
4303
|
|
|
4304 return elem.selected === true;
|
|
|
4305 },
|
|
|
4306
|
|
|
4307 parent: function( elem ) {
|
|
|
4308 return !!elem.firstChild;
|
|
|
4309 },
|
|
|
4310
|
|
|
4311 empty: function( elem ) {
|
|
|
4312 return !elem.firstChild;
|
|
|
4313 },
|
|
|
4314
|
|
|
4315 has: function( elem, i, match ) {
|
|
|
4316 return !!Sizzle( match[3], elem ).length;
|
|
|
4317 },
|
|
|
4318
|
|
|
4319 header: function( elem ) {
|
|
|
4320 return (/h\d/i).test( elem.nodeName );
|
|
|
4321 },
|
|
|
4322
|
|
|
4323 text: function( elem ) {
|
|
|
4324 var attr = elem.getAttribute( "type" ), type = elem.type;
|
|
|
4325 // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
|
|
|
4326 // use getAttribute instead to test this case
|
|
|
4327 return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
|
|
|
4328 },
|
|
|
4329
|
|
|
4330 radio: function( elem ) {
|
|
|
4331 return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
|
|
|
4332 },
|
|
|
4333
|
|
|
4334 checkbox: function( elem ) {
|
|
|
4335 return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
|
|
|
4336 },
|
|
|
4337
|
|
|
4338 file: function( elem ) {
|
|
|
4339 return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
|
|
|
4340 },
|
|
|
4341
|
|
|
4342 password: function( elem ) {
|
|
|
4343 return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
|
|
|
4344 },
|
|
|
4345
|
|
|
4346 submit: function( elem ) {
|
|
|
4347 var name = elem.nodeName.toLowerCase();
|
|
|
4348 return (name === "input" || name === "button") && "submit" === elem.type;
|
|
|
4349 },
|
|
|
4350
|
|
|
4351 image: function( elem ) {
|
|
|
4352 return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
|
|
|
4353 },
|
|
|
4354
|
|
|
4355 reset: function( elem ) {
|
|
|
4356 var name = elem.nodeName.toLowerCase();
|
|
|
4357 return (name === "input" || name === "button") && "reset" === elem.type;
|
|
|
4358 },
|
|
|
4359
|
|
|
4360 button: function( elem ) {
|
|
|
4361 var name = elem.nodeName.toLowerCase();
|
|
|
4362 return name === "input" && "button" === elem.type || name === "button";
|
|
|
4363 },
|
|
|
4364
|
|
|
4365 input: function( elem ) {
|
|
|
4366 return (/input|select|textarea|button/i).test( elem.nodeName );
|
|
|
4367 },
|
|
|
4368
|
|
|
4369 focus: function( elem ) {
|
|
|
4370 return elem === elem.ownerDocument.activeElement;
|
|
|
4371 }
|
|
|
4372 },
|
|
|
4373 setFilters: {
|
|
|
4374 first: function( elem, i ) {
|
|
|
4375 return i === 0;
|
|
|
4376 },
|
|
|
4377
|
|
|
4378 last: function( elem, i, match, array ) {
|
|
|
4379 return i === array.length - 1;
|
|
|
4380 },
|
|
|
4381
|
|
|
4382 even: function( elem, i ) {
|
|
|
4383 return i % 2 === 0;
|
|
|
4384 },
|
|
|
4385
|
|
|
4386 odd: function( elem, i ) {
|
|
|
4387 return i % 2 === 1;
|
|
|
4388 },
|
|
|
4389
|
|
|
4390 lt: function( elem, i, match ) {
|
|
|
4391 return i < match[3] - 0;
|
|
|
4392 },
|
|
|
4393
|
|
|
4394 gt: function( elem, i, match ) {
|
|
|
4395 return i > match[3] - 0;
|
|
|
4396 },
|
|
|
4397
|
|
|
4398 nth: function( elem, i, match ) {
|
|
|
4399 return match[3] - 0 === i;
|
|
|
4400 },
|
|
|
4401
|
|
|
4402 eq: function( elem, i, match ) {
|
|
|
4403 return match[3] - 0 === i;
|
|
|
4404 }
|
|
|
4405 },
|
|
|
4406 filter: {
|
|
|
4407 PSEUDO: function( elem, match, i, array ) {
|
|
|
4408 var name = match[1],
|
|
|
4409 filter = Expr.filters[ name ];
|
|
|
4410
|
|
|
4411 if ( filter ) {
|
|
|
4412 return filter( elem, i, match, array );
|
|
|
4413
|
|
|
4414 } else if ( name === "contains" ) {
|
|
|
4415 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
|
|
|
4416
|
|
|
4417 } else if ( name === "not" ) {
|
|
|
4418 var not = match[3];
|
|
|
4419
|
|
|
4420 for ( var j = 0, l = not.length; j < l; j++ ) {
|
|
|
4421 if ( not[j] === elem ) {
|
|
|
4422 return false;
|
|
|
4423 }
|
|
|
4424 }
|
|
|
4425
|
|
|
4426 return true;
|
|
|
4427
|
|
|
4428 } else {
|
|
|
4429 Sizzle.error( name );
|
|
|
4430 }
|
|
|
4431 },
|
|
|
4432
|
|
|
4433 CHILD: function( elem, match ) {
|
|
|
4434 var type = match[1],
|
|
|
4435 node = elem;
|
|
|
4436
|
|
|
4437 switch ( type ) {
|
|
|
4438 case "only":
|
|
|
4439 case "first":
|
|
|
4440 while ( (node = node.previousSibling) ) {
|
|
|
4441 if ( node.nodeType === 1 ) {
|
|
|
4442 return false;
|
|
|
4443 }
|
|
|
4444 }
|
|
|
4445
|
|
|
4446 if ( type === "first" ) {
|
|
|
4447 return true;
|
|
|
4448 }
|
|
|
4449
|
|
|
4450 node = elem;
|
|
|
4451
|
|
|
4452 case "last":
|
|
|
4453 while ( (node = node.nextSibling) ) {
|
|
|
4454 if ( node.nodeType === 1 ) {
|
|
|
4455 return false;
|
|
|
4456 }
|
|
|
4457 }
|
|
|
4458
|
|
|
4459 return true;
|
|
|
4460
|
|
|
4461 case "nth":
|
|
|
4462 var first = match[2],
|
|
|
4463 last = match[3];
|
|
|
4464
|
|
|
4465 if ( first === 1 && last === 0 ) {
|
|
|
4466 return true;
|
|
|
4467 }
|
|
|
4468
|
|
|
4469 var doneName = match[0],
|
|
|
4470 parent = elem.parentNode;
|
|
|
4471
|
|
|
4472 if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
|
|
|
4473 var count = 0;
|
|
|
4474
|
|
|
4475 for ( node = parent.firstChild; node; node = node.nextSibling ) {
|
|
|
4476 if ( node.nodeType === 1 ) {
|
|
|
4477 node.nodeIndex = ++count;
|
|
|
4478 }
|
|
|
4479 }
|
|
|
4480
|
|
|
4481 parent.sizcache = doneName;
|
|
|
4482 }
|
|
|
4483
|
|
|
4484 var diff = elem.nodeIndex - last;
|
|
|
4485
|
|
|
4486 if ( first === 0 ) {
|
|
|
4487 return diff === 0;
|
|
|
4488
|
|
|
4489 } else {
|
|
|
4490 return ( diff % first === 0 && diff / first >= 0 );
|
|
|
4491 }
|
|
|
4492 }
|
|
|
4493 },
|
|
|
4494
|
|
|
4495 ID: function( elem, match ) {
|
|
|
4496 return elem.nodeType === 1 && elem.getAttribute("id") === match;
|
|
|
4497 },
|
|
|
4498
|
|
|
4499 TAG: function( elem, match ) {
|
|
|
4500 return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
|
|
|
4501 },
|
|
|
4502
|
|
|
4503 CLASS: function( elem, match ) {
|
|
|
4504 return (" " + (elem.className || elem.getAttribute("class")) + " ")
|
|
|
4505 .indexOf( match ) > -1;
|
|
|
4506 },
|
|
|
4507
|
|
|
4508 ATTR: function( elem, match ) {
|
|
|
4509 var name = match[1],
|
|
|
4510 result = Expr.attrHandle[ name ] ?
|
|
|
4511 Expr.attrHandle[ name ]( elem ) :
|
|
|
4512 elem[ name ] != null ?
|
|
|
4513 elem[ name ] :
|
|
|
4514 elem.getAttribute( name ),
|
|
|
4515 value = result + "",
|
|
|
4516 type = match[2],
|
|
|
4517 check = match[4];
|
|
|
4518
|
|
|
4519 return result == null ?
|
|
|
4520 type === "!=" :
|
|
|
4521 type === "=" ?
|
|
|
4522 value === check :
|
|
|
4523 type === "*=" ?
|
|
|
4524 value.indexOf(check) >= 0 :
|
|
|
4525 type === "~=" ?
|
|
|
4526 (" " + value + " ").indexOf(check) >= 0 :
|
|
|
4527 !check ?
|
|
|
4528 value && result !== false :
|
|
|
4529 type === "!=" ?
|
|
|
4530 value !== check :
|
|
|
4531 type === "^=" ?
|
|
|
4532 value.indexOf(check) === 0 :
|
|
|
4533 type === "$=" ?
|
|
|
4534 value.substr(value.length - check.length) === check :
|
|
|
4535 type === "|=" ?
|
|
|
4536 value === check || value.substr(0, check.length + 1) === check + "-" :
|
|
|
4537 false;
|
|
|
4538 },
|
|
|
4539
|
|
|
4540 POS: function( elem, match, i, array ) {
|
|
|
4541 var name = match[2],
|
|
|
4542 filter = Expr.setFilters[ name ];
|
|
|
4543
|
|
|
4544 if ( filter ) {
|
|
|
4545 return filter( elem, i, match, array );
|
|
|
4546 }
|
|
|
4547 }
|
|
|
4548 }
|
|
|
4549 };
|
|
|
4550
|
|
|
4551 var origPOS = Expr.match.POS,
|
|
|
4552 fescape = function(all, num){
|
|
|
4553 return "\\" + (num - 0 + 1);
|
|
|
4554 };
|
|
|
4555
|
|
|
4556 for ( var type in Expr.match ) {
|
|
|
4557 Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
|
|
|
4558 Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
|
|
|
4559 }
|
|
|
4560
|
|
|
4561 var makeArray = function( array, results ) {
|
|
|
4562 array = Array.prototype.slice.call( array, 0 );
|
|
|
4563
|
|
|
4564 if ( results ) {
|
|
|
4565 results.push.apply( results, array );
|
|
|
4566 return results;
|
|
|
4567 }
|
|
|
4568
|
|
|
4569 return array;
|
|
|
4570 };
|
|
|
4571
|
|
|
4572 // Perform a simple check to determine if the browser is capable of
|
|
|
4573 // converting a NodeList to an array using builtin methods.
|
|
|
4574 // Also verifies that the returned array holds DOM nodes
|
|
|
4575 // (which is not the case in the Blackberry browser)
|
|
|
4576 try {
|
|
|
4577 Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
|
|
|
4578
|
|
|
4579 // Provide a fallback method if it does not work
|
|
|
4580 } catch( e ) {
|
|
|
4581 makeArray = function( array, results ) {
|
|
|
4582 var i = 0,
|
|
|
4583 ret = results || [];
|
|
|
4584
|
|
|
4585 if ( toString.call(array) === "[object Array]" ) {
|
|
|
4586 Array.prototype.push.apply( ret, array );
|
|
|
4587
|
|
|
4588 } else {
|
|
|
4589 if ( typeof array.length === "number" ) {
|
|
|
4590 for ( var l = array.length; i < l; i++ ) {
|
|
|
4591 ret.push( array[i] );
|
|
|
4592 }
|
|
|
4593
|
|
|
4594 } else {
|
|
|
4595 for ( ; array[i]; i++ ) {
|
|
|
4596 ret.push( array[i] );
|
|
|
4597 }
|
|
|
4598 }
|
|
|
4599 }
|
|
|
4600
|
|
|
4601 return ret;
|
|
|
4602 };
|
|
|
4603 }
|
|
|
4604
|
|
|
4605 var sortOrder, siblingCheck;
|
|
|
4606
|
|
|
4607 if ( document.documentElement.compareDocumentPosition ) {
|
|
|
4608 sortOrder = function( a, b ) {
|
|
|
4609 if ( a === b ) {
|
|
|
4610 hasDuplicate = true;
|
|
|
4611 return 0;
|
|
|
4612 }
|
|
|
4613
|
|
|
4614 if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
|
|
|
4615 return a.compareDocumentPosition ? -1 : 1;
|
|
|
4616 }
|
|
|
4617
|
|
|
4618 return a.compareDocumentPosition(b) & 4 ? -1 : 1;
|
|
|
4619 };
|
|
|
4620
|
|
|
4621 } else {
|
|
|
4622 sortOrder = function( a, b ) {
|
|
|
4623 // The nodes are identical, we can exit early
|
|
|
4624 if ( a === b ) {
|
|
|
4625 hasDuplicate = true;
|
|
|
4626 return 0;
|
|
|
4627
|
|
|
4628 // Fallback to using sourceIndex (in IE) if it's available on both nodes
|
|
|
4629 } else if ( a.sourceIndex && b.sourceIndex ) {
|
|
|
4630 return a.sourceIndex - b.sourceIndex;
|
|
|
4631 }
|
|
|
4632
|
|
|
4633 var al, bl,
|
|
|
4634 ap = [],
|
|
|
4635 bp = [],
|
|
|
4636 aup = a.parentNode,
|
|
|
4637 bup = b.parentNode,
|
|
|
4638 cur = aup;
|
|
|
4639
|
|
|
4640 // If the nodes are siblings (or identical) we can do a quick check
|
|
|
4641 if ( aup === bup ) {
|
|
|
4642 return siblingCheck( a, b );
|
|
|
4643
|
|
|
4644 // If no parents were found then the nodes are disconnected
|
|
|
4645 } else if ( !aup ) {
|
|
|
4646 return -1;
|
|
|
4647
|
|
|
4648 } else if ( !bup ) {
|
|
|
4649 return 1;
|
|
|
4650 }
|
|
|
4651
|
|
|
4652 // Otherwise they're somewhere else in the tree so we need
|
|
|
4653 // to build up a full list of the parentNodes for comparison
|
|
|
4654 while ( cur ) {
|
|
|
4655 ap.unshift( cur );
|
|
|
4656 cur = cur.parentNode;
|
|
|
4657 }
|
|
|
4658
|
|
|
4659 cur = bup;
|
|
|
4660
|
|
|
4661 while ( cur ) {
|
|
|
4662 bp.unshift( cur );
|
|
|
4663 cur = cur.parentNode;
|
|
|
4664 }
|
|
|
4665
|
|
|
4666 al = ap.length;
|
|
|
4667 bl = bp.length;
|
|
|
4668
|
|
|
4669 // Start walking down the tree looking for a discrepancy
|
|
|
4670 for ( var i = 0; i < al && i < bl; i++ ) {
|
|
|
4671 if ( ap[i] !== bp[i] ) {
|
|
|
4672 return siblingCheck( ap[i], bp[i] );
|
|
|
4673 }
|
|
|
4674 }
|
|
|
4675
|
|
|
4676 // We ended someplace up the tree so do a sibling check
|
|
|
4677 return i === al ?
|
|
|
4678 siblingCheck( a, bp[i], -1 ) :
|
|
|
4679 siblingCheck( ap[i], b, 1 );
|
|
|
4680 };
|
|
|
4681
|
|
|
4682 siblingCheck = function( a, b, ret ) {
|
|
|
4683 if ( a === b ) {
|
|
|
4684 return ret;
|
|
|
4685 }
|
|
|
4686
|
|
|
4687 var cur = a.nextSibling;
|
|
|
4688
|
|
|
4689 while ( cur ) {
|
|
|
4690 if ( cur === b ) {
|
|
|
4691 return -1;
|
|
|
4692 }
|
|
|
4693
|
|
|
4694 cur = cur.nextSibling;
|
|
|
4695 }
|
|
|
4696
|
|
|
4697 return 1;
|
|
|
4698 };
|
|
|
4699 }
|
|
|
4700
|
|
|
4701 // Utility function for retreiving the text value of an array of DOM nodes
|
|
|
4702 Sizzle.getText = function( elems ) {
|
|
|
4703 var ret = "", elem;
|
|
|
4704
|
|
|
4705 for ( var i = 0; elems[i]; i++ ) {
|
|
|
4706 elem = elems[i];
|
|
|
4707
|
|
|
4708 // Get the text from text nodes and CDATA nodes
|
|
|
4709 if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
|
|
|
4710 ret += elem.nodeValue;
|
|
|
4711
|
|
|
4712 // Traverse everything else, except comment nodes
|
|
|
4713 } else if ( elem.nodeType !== 8 ) {
|
|
|
4714 ret += Sizzle.getText( elem.childNodes );
|
|
|
4715 }
|
|
|
4716 }
|
|
|
4717
|
|
|
4718 return ret;
|
|
|
4719 };
|
|
|
4720
|
|
|
4721 // Check to see if the browser returns elements by name when
|
|
|
4722 // querying by getElementById (and provide a workaround)
|
|
|
4723 (function(){
|
|
|
4724 // We're going to inject a fake input element with a specified name
|
|
|
4725 var form = document.createElement("div"),
|
|
|
4726 id = "script" + (new Date()).getTime(),
|
|
|
4727 root = document.documentElement;
|
|
|
4728
|
|
|
4729 form.innerHTML = "<a name='" + id + "'/>";
|
|
|
4730
|
|
|
4731 // Inject it into the root element, check its status, and remove it quickly
|
|
|
4732 root.insertBefore( form, root.firstChild );
|
|
|
4733
|
|
|
4734 // The workaround has to do additional checks after a getElementById
|
|
|
4735 // Which slows things down for other browsers (hence the branching)
|
|
|
4736 if ( document.getElementById( id ) ) {
|
|
|
4737 Expr.find.ID = function( match, context, isXML ) {
|
|
|
4738 if ( typeof context.getElementById !== "undefined" && !isXML ) {
|
|
|
4739 var m = context.getElementById(match[1]);
|
|
|
4740
|
|
|
4741 return m ?
|
|
|
4742 m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
|
|
|
4743 [m] :
|
|
|
4744 undefined :
|
|
|
4745 [];
|
|
|
4746 }
|
|
|
4747 };
|
|
|
4748
|
|
|
4749 Expr.filter.ID = function( elem, match ) {
|
|
|
4750 var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
|
|
|
4751
|
|
|
4752 return elem.nodeType === 1 && node && node.nodeValue === match;
|
|
|
4753 };
|
|
|
4754 }
|
|
|
4755
|
|
|
4756 root.removeChild( form );
|
|
|
4757
|
|
|
4758 // release memory in IE
|
|
|
4759 root = form = null;
|
|
|
4760 })();
|
|
|
4761
|
|
|
4762 (function(){
|
|
|
4763 // Check to see if the browser returns only elements
|
|
|
4764 // when doing getElementsByTagName("*")
|
|
|
4765
|
|
|
4766 // Create a fake element
|
|
|
4767 var div = document.createElement("div");
|
|
|
4768 div.appendChild( document.createComment("") );
|
|
|
4769
|
|
|
4770 // Make sure no comments are found
|
|
|
4771 if ( div.getElementsByTagName("*").length > 0 ) {
|
|
|
4772 Expr.find.TAG = function( match, context ) {
|
|
|
4773 var results = context.getElementsByTagName( match[1] );
|
|
|
4774
|
|
|
4775 // Filter out possible comments
|
|
|
4776 if ( match[1] === "*" ) {
|
|
|
4777 var tmp = [];
|
|
|
4778
|
|
|
4779 for ( var i = 0; results[i]; i++ ) {
|
|
|
4780 if ( results[i].nodeType === 1 ) {
|
|
|
4781 tmp.push( results[i] );
|
|
|
4782 }
|
|
|
4783 }
|
|
|
4784
|
|
|
4785 results = tmp;
|
|
|
4786 }
|
|
|
4787
|
|
|
4788 return results;
|
|
|
4789 };
|
|
|
4790 }
|
|
|
4791
|
|
|
4792 // Check to see if an attribute returns normalized href attributes
|
|
|
4793 div.innerHTML = "<a href='#'></a>";
|
|
|
4794
|
|
|
4795 if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
|
|
|
4796 div.firstChild.getAttribute("href") !== "#" ) {
|
|
|
4797
|
|
|
4798 Expr.attrHandle.href = function( elem ) {
|
|
|
4799 return elem.getAttribute( "href", 2 );
|
|
|
4800 };
|
|
|
4801 }
|
|
|
4802
|
|
|
4803 // release memory in IE
|
|
|
4804 div = null;
|
|
|
4805 })();
|
|
|
4806
|
|
|
4807 if ( document.querySelectorAll ) {
|
|
|
4808 (function(){
|
|
|
4809 var oldSizzle = Sizzle,
|
|
|
4810 div = document.createElement("div"),
|
|
|
4811 id = "__sizzle__";
|
|
|
4812
|
|
|
4813 div.innerHTML = "<p class='TEST'></p>";
|
|
|
4814
|
|
|
4815 // Safari can't handle uppercase or unicode characters when
|
|
|
4816 // in quirks mode.
|
|
|
4817 if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
|
|
|
4818 return;
|
|
|
4819 }
|
|
|
4820
|
|
|
4821 Sizzle = function( query, context, extra, seed ) {
|
|
|
4822 context = context || document;
|
|
|
4823
|
|
|
4824 // Only use querySelectorAll on non-XML documents
|
|
|
4825 // (ID selectors don't work in non-HTML documents)
|
|
|
4826 if ( !seed && !Sizzle.isXML(context) ) {
|
|
|
4827 // See if we find a selector to speed up
|
|
|
4828 var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
|
|
|
4829
|
|
|
4830 if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
|
|
|
4831 // Speed-up: Sizzle("TAG")
|
|
|
4832 if ( match[1] ) {
|
|
|
4833 return makeArray( context.getElementsByTagName( query ), extra );
|
|
|
4834
|
|
|
4835 // Speed-up: Sizzle(".CLASS")
|
|
|
4836 } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
|
|
|
4837 return makeArray( context.getElementsByClassName( match[2] ), extra );
|
|
|
4838 }
|
|
|
4839 }
|
|
|
4840
|
|
|
4841 if ( context.nodeType === 9 ) {
|
|
|
4842 // Speed-up: Sizzle("body")
|
|
|
4843 // The body element only exists once, optimize finding it
|
|
|
4844 if ( query === "body" && context.body ) {
|
|
|
4845 return makeArray( [ context.body ], extra );
|
|
|
4846
|
|
|
4847 // Speed-up: Sizzle("#ID")
|
|
|
4848 } else if ( match && match[3] ) {
|
|
|
4849 var elem = context.getElementById( match[3] );
|
|
|
4850
|
|
|
4851 // Check parentNode to catch when Blackberry 4.6 returns
|
|
|
4852 // nodes that are no longer in the document #6963
|
|
|
4853 if ( elem && elem.parentNode ) {
|
|
|
4854 // Handle the case where IE and Opera return items
|
|
|
4855 // by name instead of ID
|
|
|
4856 if ( elem.id === match[3] ) {
|
|
|
4857 return makeArray( [ elem ], extra );
|
|
|
4858 }
|
|
|
4859
|
|
|
4860 } else {
|
|
|
4861 return makeArray( [], extra );
|
|
|
4862 }
|
|
|
4863 }
|
|
|
4864
|
|
|
4865 try {
|
|
|
4866 return makeArray( context.querySelectorAll(query), extra );
|
|
|
4867 } catch(qsaError) {}
|
|
|
4868
|
|
|
4869 // qSA works strangely on Element-rooted queries
|
|
|
4870 // We can work around this by specifying an extra ID on the root
|
|
|
4871 // and working up from there (Thanks to Andrew Dupont for the technique)
|
|
|
4872 // IE 8 doesn't work on object elements
|
|
|
4873 } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
|
|
|
4874 var oldContext = context,
|
|
|
4875 old = context.getAttribute( "id" ),
|
|
|
4876 nid = old || id,
|
|
|
4877 hasParent = context.parentNode,
|
|
|
4878 relativeHierarchySelector = /^\s*[+~]/.test( query );
|
|
|
4879
|
|
|
4880 if ( !old ) {
|
|
|
4881 context.setAttribute( "id", nid );
|
|
|
4882 } else {
|
|
|
4883 nid = nid.replace( /'/g, "\\$&" );
|
|
|
4884 }
|
|
|
4885 if ( relativeHierarchySelector && hasParent ) {
|
|
|
4886 context = context.parentNode;
|
|
|
4887 }
|
|
|
4888
|
|
|
4889 try {
|
|
|
4890 if ( !relativeHierarchySelector || hasParent ) {
|
|
|
4891 return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
|
|
|
4892 }
|
|
|
4893
|
|
|
4894 } catch(pseudoError) {
|
|
|
4895 } finally {
|
|
|
4896 if ( !old ) {
|
|
|
4897 oldContext.removeAttribute( "id" );
|
|
|
4898 }
|
|
|
4899 }
|
|
|
4900 }
|
|
|
4901 }
|
|
|
4902
|
|
|
4903 return oldSizzle(query, context, extra, seed);
|
|
|
4904 };
|
|
|
4905
|
|
|
4906 for ( var prop in oldSizzle ) {
|
|
|
4907 Sizzle[ prop ] = oldSizzle[ prop ];
|
|
|
4908 }
|
|
|
4909
|
|
|
4910 // release memory in IE
|
|
|
4911 div = null;
|
|
|
4912 })();
|
|
|
4913 }
|
|
|
4914
|
|
|
4915 (function(){
|
|
|
4916 var html = document.documentElement,
|
|
|
4917 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
|
|
|
4918
|
|
|
4919 if ( matches ) {
|
|
|
4920 // Check to see if it's possible to do matchesSelector
|
|
|
4921 // on a disconnected node (IE 9 fails this)
|
|
|
4922 var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
|
|
|
4923 pseudoWorks = false;
|
|
|
4924
|
|
|
4925 try {
|
|
|
4926 // This should fail with an exception
|
|
|
4927 // Gecko does not error, returns false instead
|
|
|
4928 matches.call( document.documentElement, "[test!='']:sizzle" );
|
|
|
4929
|
|
|
4930 } catch( pseudoError ) {
|
|
|
4931 pseudoWorks = true;
|
|
|
4932 }
|
|
|
4933
|
|
|
4934 Sizzle.matchesSelector = function( node, expr ) {
|
|
|
4935 // Make sure that attribute selectors are quoted
|
|
|
4936 expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
|
|
|
4937
|
|
|
4938 if ( !Sizzle.isXML( node ) ) {
|
|
|
4939 try {
|
|
|
4940 if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
|
|
|
4941 var ret = matches.call( node, expr );
|
|
|
4942
|
|
|
4943 // IE 9's matchesSelector returns false on disconnected nodes
|
|
|
4944 if ( ret || !disconnectedMatch ||
|
|
|
4945 // As well, disconnected nodes are said to be in a document
|
|
|
4946 // fragment in IE 9, so check for that
|
|
|
4947 node.document && node.document.nodeType !== 11 ) {
|
|
|
4948 return ret;
|
|
|
4949 }
|
|
|
4950 }
|
|
|
4951 } catch(e) {}
|
|
|
4952 }
|
|
|
4953
|
|
|
4954 return Sizzle(expr, null, null, [node]).length > 0;
|
|
|
4955 };
|
|
|
4956 }
|
|
|
4957 })();
|
|
|
4958
|
|
|
4959 (function(){
|
|
|
4960 var div = document.createElement("div");
|
|
|
4961
|
|
|
4962 div.innerHTML = "<div class='test e'></div><div class='test'></div>";
|
|
|
4963
|
|
|
4964 // Opera can't find a second classname (in 9.6)
|
|
|
4965 // Also, make sure that getElementsByClassName actually exists
|
|
|
4966 if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
|
|
|
4967 return;
|
|
|
4968 }
|
|
|
4969
|
|
|
4970 // Safari caches class attributes, doesn't catch changes (in 3.2)
|
|
|
4971 div.lastChild.className = "e";
|
|
|
4972
|
|
|
4973 if ( div.getElementsByClassName("e").length === 1 ) {
|
|
|
4974 return;
|
|
|
4975 }
|
|
|
4976
|
|
|
4977 Expr.order.splice(1, 0, "CLASS");
|
|
|
4978 Expr.find.CLASS = function( match, context, isXML ) {
|
|
|
4979 if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
|
|
|
4980 return context.getElementsByClassName(match[1]);
|
|
|
4981 }
|
|
|
4982 };
|
|
|
4983
|
|
|
4984 // release memory in IE
|
|
|
4985 div = null;
|
|
|
4986 })();
|
|
|
4987
|
|
|
4988 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
|
|
|
4989 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
|
|
|
4990 var elem = checkSet[i];
|
|
|
4991
|
|
|
4992 if ( elem ) {
|
|
|
4993 var match = false;
|
|
|
4994
|
|
|
4995 elem = elem[dir];
|
|
|
4996
|
|
|
4997 while ( elem ) {
|
|
|
4998 if ( elem.sizcache === doneName ) {
|
|
|
4999 match = checkSet[elem.sizset];
|
|
|
5000 break;
|
|
|
5001 }
|
|
|
5002
|
|
|
5003 if ( elem.nodeType === 1 && !isXML ){
|
|
|
5004 elem.sizcache = doneName;
|
|
|
5005 elem.sizset = i;
|
|
|
5006 }
|
|
|
5007
|
|
|
5008 if ( elem.nodeName.toLowerCase() === cur ) {
|
|
|
5009 match = elem;
|
|
|
5010 break;
|
|
|
5011 }
|
|
|
5012
|
|
|
5013 elem = elem[dir];
|
|
|
5014 }
|
|
|
5015
|
|
|
5016 checkSet[i] = match;
|
|
|
5017 }
|
|
|
5018 }
|
|
|
5019 }
|
|
|
5020
|
|
|
5021 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
|
|
|
5022 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
|
|
|
5023 var elem = checkSet[i];
|
|
|
5024
|
|
|
5025 if ( elem ) {
|
|
|
5026 var match = false;
|
|
|
5027
|
|
|
5028 elem = elem[dir];
|
|
|
5029
|
|
|
5030 while ( elem ) {
|
|
|
5031 if ( elem.sizcache === doneName ) {
|
|
|
5032 match = checkSet[elem.sizset];
|
|
|
5033 break;
|
|
|
5034 }
|
|
|
5035
|
|
|
5036 if ( elem.nodeType === 1 ) {
|
|
|
5037 if ( !isXML ) {
|
|
|
5038 elem.sizcache = doneName;
|
|
|
5039 elem.sizset = i;
|
|
|
5040 }
|
|
|
5041
|
|
|
5042 if ( typeof cur !== "string" ) {
|
|
|
5043 if ( elem === cur ) {
|
|
|
5044 match = true;
|
|
|
5045 break;
|
|
|
5046 }
|
|
|
5047
|
|
|
5048 } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
|
|
|
5049 match = elem;
|
|
|
5050 break;
|
|
|
5051 }
|
|
|
5052 }
|
|
|
5053
|
|
|
5054 elem = elem[dir];
|
|
|
5055 }
|
|
|
5056
|
|
|
5057 checkSet[i] = match;
|
|
|
5058 }
|
|
|
5059 }
|
|
|
5060 }
|
|
|
5061
|
|
|
5062 if ( document.documentElement.contains ) {
|
|
|
5063 Sizzle.contains = function( a, b ) {
|
|
|
5064 return a !== b && (a.contains ? a.contains(b) : true);
|
|
|
5065 };
|
|
|
5066
|
|
|
5067 } else if ( document.documentElement.compareDocumentPosition ) {
|
|
|
5068 Sizzle.contains = function( a, b ) {
|
|
|
5069 return !!(a.compareDocumentPosition(b) & 16);
|
|
|
5070 };
|
|
|
5071
|
|
|
5072 } else {
|
|
|
5073 Sizzle.contains = function() {
|
|
|
5074 return false;
|
|
|
5075 };
|
|
|
5076 }
|
|
|
5077
|
|
|
5078 Sizzle.isXML = function( elem ) {
|
|
|
5079 // documentElement is verified for cases where it doesn't yet exist
|
|
|
5080 // (such as loading iframes in IE - #4833)
|
|
|
5081 var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
|
|
|
5082
|
|
|
5083 return documentElement ? documentElement.nodeName !== "HTML" : false;
|
|
|
5084 };
|
|
|
5085
|
|
|
5086 var posProcess = function( selector, context ) {
|
|
|
5087 var match,
|
|
|
5088 tmpSet = [],
|
|
|
5089 later = "",
|
|
|
5090 root = context.nodeType ? [context] : context;
|
|
|
5091
|
|
|
5092 // Position selectors must be done after the filter
|
|
|
5093 // And so must :not(positional) so we move all PSEUDOs to the end
|
|
|
5094 while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
|
|
|
5095 later += match[0];
|
|
|
5096 selector = selector.replace( Expr.match.PSEUDO, "" );
|
|
|
5097 }
|
|
|
5098
|
|
|
5099 selector = Expr.relative[selector] ? selector + "*" : selector;
|
|
|
5100
|
|
|
5101 for ( var i = 0, l = root.length; i < l; i++ ) {
|
|
|
5102 Sizzle( selector, root[i], tmpSet );
|
|
|
5103 }
|
|
|
5104
|
|
|
5105 return Sizzle.filter( later, tmpSet );
|
|
|
5106 };
|
|
|
5107
|
|
|
5108 // EXPOSE
|
|
|
5109 jQuery.find = Sizzle;
|
|
|
5110 jQuery.expr = Sizzle.selectors;
|
|
|
5111 jQuery.expr[":"] = jQuery.expr.filters;
|
|
|
5112 jQuery.unique = Sizzle.uniqueSort;
|
|
|
5113 jQuery.text = Sizzle.getText;
|
|
|
5114 jQuery.isXMLDoc = Sizzle.isXML;
|
|
|
5115 jQuery.contains = Sizzle.contains;
|
|
|
5116
|
|
|
5117
|
|
|
5118 })();
|
|
|
5119
|
|
|
5120
|
|
|
5121 var runtil = /Until$/,
|
|
|
5122 rparentsprev = /^(?:parents|prevUntil|prevAll)/,
|
|
|
5123 // Note: This RegExp should be improved, or likely pulled from Sizzle
|
|
|
5124 rmultiselector = /,/,
|
|
|
5125 isSimple = /^.[^:#\[\.,]*$/,
|
|
|
5126 slice = Array.prototype.slice,
|
|
|
5127 POS = jQuery.expr.match.POS,
|
|
|
5128 // methods guaranteed to produce a unique set when starting from a unique set
|
|
|
5129 guaranteedUnique = {
|
|
|
5130 children: true,
|
|
|
5131 contents: true,
|
|
|
5132 next: true,
|
|
|
5133 prev: true
|
|
|
5134 };
|
|
|
5135
|
|
|
5136 jQuery.fn.extend({
|
|
|
5137 find: function( selector ) {
|
|
|
5138 var self = this,
|
|
|
5139 i, l;
|
|
|
5140
|
|
|
5141 if ( typeof selector !== "string" ) {
|
|
|
5142 return jQuery( selector ).filter(function() {
|
|
|
5143 for ( i = 0, l = self.length; i < l; i++ ) {
|
|
|
5144 if ( jQuery.contains( self[ i ], this ) ) {
|
|
|
5145 return true;
|
|
|
5146 }
|
|
|
5147 }
|
|
|
5148 });
|
|
|
5149 }
|
|
|
5150
|
|
|
5151 var ret = this.pushStack( "", "find", selector ),
|
|
|
5152 length, n, r;
|
|
|
5153
|
|
|
5154 for ( i = 0, l = this.length; i < l; i++ ) {
|
|
|
5155 length = ret.length;
|
|
|
5156 jQuery.find( selector, this[i], ret );
|
|
|
5157
|
|
|
5158 if ( i > 0 ) {
|
|
|
5159 // Make sure that the results are unique
|
|
|
5160 for ( n = length; n < ret.length; n++ ) {
|
|
|
5161 for ( r = 0; r < length; r++ ) {
|
|
|
5162 if ( ret[r] === ret[n] ) {
|
|
|
5163 ret.splice(n--, 1);
|
|
|
5164 break;
|
|
|
5165 }
|
|
|
5166 }
|
|
|
5167 }
|
|
|
5168 }
|
|
|
5169 }
|
|
|
5170
|
|
|
5171 return ret;
|
|
|
5172 },
|
|
|
5173
|
|
|
5174 has: function( target ) {
|
|
|
5175 var targets = jQuery( target );
|
|
|
5176 return this.filter(function() {
|
|
|
5177 for ( var i = 0, l = targets.length; i < l; i++ ) {
|
|
|
5178 if ( jQuery.contains( this, targets[i] ) ) {
|
|
|
5179 return true;
|
|
|
5180 }
|
|
|
5181 }
|
|
|
5182 });
|
|
|
5183 },
|
|
|
5184
|
|
|
5185 not: function( selector ) {
|
|
|
5186 return this.pushStack( winnow(this, selector, false), "not", selector);
|
|
|
5187 },
|
|
|
5188
|
|
|
5189 filter: function( selector ) {
|
|
|
5190 return this.pushStack( winnow(this, selector, true), "filter", selector );
|
|
|
5191 },
|
|
|
5192
|
|
|
5193 is: function( selector ) {
|
|
|
5194 return !!selector && ( typeof selector === "string" ?
|
|
|
5195 jQuery.filter( selector, this ).length > 0 :
|
|
|
5196 this.filter( selector ).length > 0 );
|
|
|
5197 },
|
|
|
5198
|
|
|
5199 closest: function( selectors, context ) {
|
|
|
5200 var ret = [], i, l, cur = this[0];
|
|
|
5201
|
|
|
5202 // Array
|
|
|
5203 if ( jQuery.isArray( selectors ) ) {
|
|
|
5204 var match, selector,
|
|
|
5205 matches = {},
|
|
|
5206 level = 1;
|
|
|
5207
|
|
|
5208 if ( cur && selectors.length ) {
|
|
|
5209 for ( i = 0, l = selectors.length; i < l; i++ ) {
|
|
|
5210 selector = selectors[i];
|
|
|
5211
|
|
|
5212 if ( !matches[ selector ] ) {
|
|
|
5213 matches[ selector ] = POS.test( selector ) ?
|
|
|
5214 jQuery( selector, context || this.context ) :
|
|
|
5215 selector;
|
|
|
5216 }
|
|
|
5217 }
|
|
|
5218
|
|
|
5219 while ( cur && cur.ownerDocument && cur !== context ) {
|
|
|
5220 for ( selector in matches ) {
|
|
|
5221 match = matches[ selector ];
|
|
|
5222
|
|
|
5223 if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
|
|
|
5224 ret.push({ selector: selector, elem: cur, level: level });
|
|
|
5225 }
|
|
|
5226 }
|
|
|
5227
|
|
|
5228 cur = cur.parentNode;
|
|
|
5229 level++;
|
|
|
5230 }
|
|
|
5231 }
|
|
|
5232
|
|
|
5233 return ret;
|
|
|
5234 }
|
|
|
5235
|
|
|
5236 // String
|
|
|
5237 var pos = POS.test( selectors ) || typeof selectors !== "string" ?
|
|
|
5238 jQuery( selectors, context || this.context ) :
|
|
|
5239 0;
|
|
|
5240
|
|
|
5241 for ( i = 0, l = this.length; i < l; i++ ) {
|
|
|
5242 cur = this[i];
|
|
|
5243
|
|
|
5244 while ( cur ) {
|
|
|
5245 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
|
|
|
5246 ret.push( cur );
|
|
|
5247 break;
|
|
|
5248
|
|
|
5249 } else {
|
|
|
5250 cur = cur.parentNode;
|
|
|
5251 if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
|
|
|
5252 break;
|
|
|
5253 }
|
|
|
5254 }
|
|
|
5255 }
|
|
|
5256 }
|
|
|
5257
|
|
|
5258 ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
|
|
|
5259
|
|
|
5260 return this.pushStack( ret, "closest", selectors );
|
|
|
5261 },
|
|
|
5262
|
|
|
5263 // Determine the position of an element within
|
|
|
5264 // the matched set of elements
|
|
|
5265 index: function( elem ) {
|
|
|
5266 if ( !elem || typeof elem === "string" ) {
|
|
|
5267 return jQuery.inArray( this[0],
|
|
|
5268 // If it receives a string, the selector is used
|
|
|
5269 // If it receives nothing, the siblings are used
|
|
|
5270 elem ? jQuery( elem ) : this.parent().children() );
|
|
|
5271 }
|
|
|
5272 // Locate the position of the desired element
|
|
|
5273 return jQuery.inArray(
|
|
|
5274 // If it receives a jQuery object, the first element is used
|
|
|
5275 elem.jquery ? elem[0] : elem, this );
|
|
|
5276 },
|
|
|
5277
|
|
|
5278 add: function( selector, context ) {
|
|
|
5279 var set = typeof selector === "string" ?
|
|
|
5280 jQuery( selector, context ) :
|
|
|
5281 jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
|
|
|
5282 all = jQuery.merge( this.get(), set );
|
|
|
5283
|
|
|
5284 return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
|
|
|
5285 all :
|
|
|
5286 jQuery.unique( all ) );
|
|
|
5287 },
|
|
|
5288
|
|
|
5289 andSelf: function() {
|
|
|
5290 return this.add( this.prevObject );
|
|
|
5291 }
|
|
|
5292 });
|
|
|
5293
|
|
|
5294 // A painfully simple check to see if an element is disconnected
|
|
|
5295 // from a document (should be improved, where feasible).
|
|
|
5296 function isDisconnected( node ) {
|
|
|
5297 return !node || !node.parentNode || node.parentNode.nodeType === 11;
|
|
|
5298 }
|
|
|
5299
|
|
|
5300 jQuery.each({
|
|
|
5301 parent: function( elem ) {
|
|
|
5302 var parent = elem.parentNode;
|
|
|
5303 return parent && parent.nodeType !== 11 ? parent : null;
|
|
|
5304 },
|
|
|
5305 parents: function( elem ) {
|
|
|
5306 return jQuery.dir( elem, "parentNode" );
|
|
|
5307 },
|
|
|
5308 parentsUntil: function( elem, i, until ) {
|
|
|
5309 return jQuery.dir( elem, "parentNode", until );
|
|
|
5310 },
|
|
|
5311 next: function( elem ) {
|
|
|
5312 return jQuery.nth( elem, 2, "nextSibling" );
|
|
|
5313 },
|
|
|
5314 prev: function( elem ) {
|
|
|
5315 return jQuery.nth( elem, 2, "previousSibling" );
|
|
|
5316 },
|
|
|
5317 nextAll: function( elem ) {
|
|
|
5318 return jQuery.dir( elem, "nextSibling" );
|
|
|
5319 },
|
|
|
5320 prevAll: function( elem ) {
|
|
|
5321 return jQuery.dir( elem, "previousSibling" );
|
|
|
5322 },
|
|
|
5323 nextUntil: function( elem, i, until ) {
|
|
|
5324 return jQuery.dir( elem, "nextSibling", until );
|
|
|
5325 },
|
|
|
5326 prevUntil: function( elem, i, until ) {
|
|
|
5327 return jQuery.dir( elem, "previousSibling", until );
|
|
|
5328 },
|
|
|
5329 siblings: function( elem ) {
|
|
|
5330 return jQuery.sibling( elem.parentNode.firstChild, elem );
|
|
|
5331 },
|
|
|
5332 children: function( elem ) {
|
|
|
5333 return jQuery.sibling( elem.firstChild );
|
|
|
5334 },
|
|
|
5335 contents: function( elem ) {
|
|
|
5336 return jQuery.nodeName( elem, "iframe" ) ?
|
|
|
5337 elem.contentDocument || elem.contentWindow.document :
|
|
|
5338 jQuery.makeArray( elem.childNodes );
|
|
|
5339 }
|
|
|
5340 }, function( name, fn ) {
|
|
|
5341 jQuery.fn[ name ] = function( until, selector ) {
|
|
|
5342 var ret = jQuery.map( this, fn, until ),
|
|
|
5343 // The variable 'args' was introduced in
|
|
|
5344 // https://github.com/jquery/jquery/commit/52a0238
|
|
|
5345 // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
|
|
|
5346 // http://code.google.com/p/v8/issues/detail?id=1050
|
|
|
5347 args = slice.call(arguments);
|
|
|
5348
|
|
|
5349 if ( !runtil.test( name ) ) {
|
|
|
5350 selector = until;
|
|
|
5351 }
|
|
|
5352
|
|
|
5353 if ( selector && typeof selector === "string" ) {
|
|
|
5354 ret = jQuery.filter( selector, ret );
|
|
|
5355 }
|
|
|
5356
|
|
|
5357 ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
|
|
|
5358
|
|
|
5359 if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
|
|
|
5360 ret = ret.reverse();
|
|
|
5361 }
|
|
|
5362
|
|
|
5363 return this.pushStack( ret, name, args.join(",") );
|
|
|
5364 };
|
|
|
5365 });
|
|
|
5366
|
|
|
5367 jQuery.extend({
|
|
|
5368 filter: function( expr, elems, not ) {
|
|
|
5369 if ( not ) {
|
|
|
5370 expr = ":not(" + expr + ")";
|
|
|
5371 }
|
|
|
5372
|
|
|
5373 return elems.length === 1 ?
|
|
|
5374 jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
|
|
|
5375 jQuery.find.matches(expr, elems);
|
|
|
5376 },
|
|
|
5377
|
|
|
5378 dir: function( elem, dir, until ) {
|
|
|
5379 var matched = [],
|
|
|
5380 cur = elem[ dir ];
|
|
|
5381
|
|
|
5382 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
|
|
|
5383 if ( cur.nodeType === 1 ) {
|
|
|
5384 matched.push( cur );
|
|
|
5385 }
|
|
|
5386 cur = cur[dir];
|
|
|
5387 }
|
|
|
5388 return matched;
|
|
|
5389 },
|
|
|
5390
|
|
|
5391 nth: function( cur, result, dir, elem ) {
|
|
|
5392 result = result || 1;
|
|
|
5393 var num = 0;
|
|
|
5394
|
|
|
5395 for ( ; cur; cur = cur[dir] ) {
|
|
|
5396 if ( cur.nodeType === 1 && ++num === result ) {
|
|
|
5397 break;
|
|
|
5398 }
|
|
|
5399 }
|
|
|
5400
|
|
|
5401 return cur;
|
|
|
5402 },
|
|
|
5403
|
|
|
5404 sibling: function( n, elem ) {
|
|
|
5405 var r = [];
|
|
|
5406
|
|
|
5407 for ( ; n; n = n.nextSibling ) {
|
|
|
5408 if ( n.nodeType === 1 && n !== elem ) {
|
|
|
5409 r.push( n );
|
|
|
5410 }
|
|
|
5411 }
|
|
|
5412
|
|
|
5413 return r;
|
|
|
5414 }
|
|
|
5415 });
|
|
|
5416
|
|
|
5417 // Implement the identical functionality for filter and not
|
|
|
5418 function winnow( elements, qualifier, keep ) {
|
|
|
5419
|
|
|
5420 // Can't pass null or undefined to indexOf in Firefox 4
|
|
|
5421 // Set to 0 to skip string check
|
|
|
5422 qualifier = qualifier || 0;
|
|
|
5423
|
|
|
5424 if ( jQuery.isFunction( qualifier ) ) {
|
|
|
5425 return jQuery.grep(elements, function( elem, i ) {
|
|
|
5426 var retVal = !!qualifier.call( elem, i, elem );
|
|
|
5427 return retVal === keep;
|
|
|
5428 });
|
|
|
5429
|
|
|
5430 } else if ( qualifier.nodeType ) {
|
|
|
5431 return jQuery.grep(elements, function( elem, i ) {
|
|
|
5432 return (elem === qualifier) === keep;
|
|
|
5433 });
|
|
|
5434
|
|
|
5435 } else if ( typeof qualifier === "string" ) {
|
|
|
5436 var filtered = jQuery.grep(elements, function( elem ) {
|
|
|
5437 return elem.nodeType === 1;
|
|
|
5438 });
|
|
|
5439
|
|
|
5440 if ( isSimple.test( qualifier ) ) {
|
|
|
5441 return jQuery.filter(qualifier, filtered, !keep);
|
|
|
5442 } else {
|
|
|
5443 qualifier = jQuery.filter( qualifier, filtered );
|
|
|
5444 }
|
|
|
5445 }
|
|
|
5446
|
|
|
5447 return jQuery.grep(elements, function( elem, i ) {
|
|
|
5448 return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
|
|
|
5449 });
|
|
|
5450 }
|
|
|
5451
|
|
|
5452
|
|
|
5453
|
|
|
5454
|
|
|
5455 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
|
|
|
5456 rleadingWhitespace = /^\s+/,
|
|
|
5457 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
|
|
|
5458 rtagName = /<([\w:]+)/,
|
|
|
5459 rtbody = /<tbody/i,
|
|
|
5460 rhtml = /<|&#?\w+;/,
|
|
|
5461 rnocache = /<(?:script|object|embed|option|style)/i,
|
|
|
5462 // checked="checked" or checked
|
|
|
5463 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
|
|
|
5464 rscriptType = /\/(java|ecma)script/i,
|
|
|
5465 rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
|
|
|
5466 wrapMap = {
|
|
|
5467 option: [ 1, "<select multiple='multiple'>", "</select>" ],
|
|
|
5468 legend: [ 1, "<fieldset>", "</fieldset>" ],
|
|
|
5469 thead: [ 1, "<table>", "</table>" ],
|
|
|
5470 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
|
|
|
5471 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
|
|
|
5472 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
|
|
|
5473 area: [ 1, "<map>", "</map>" ],
|
|
|
5474 _default: [ 0, "", "" ]
|
|
|
5475 };
|
|
|
5476
|
|
|
5477 wrapMap.optgroup = wrapMap.option;
|
|
|
5478 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
|
|
|
5479 wrapMap.th = wrapMap.td;
|
|
|
5480
|
|
|
5481 // IE can't serialize <link> and <script> tags normally
|
|
|
5482 if ( !jQuery.support.htmlSerialize ) {
|
|
|
5483 wrapMap._default = [ 1, "div<div>", "</div>" ];
|
|
|
5484 }
|
|
|
5485
|
|
|
5486 jQuery.fn.extend({
|
|
|
5487 text: function( text ) {
|
|
|
5488 if ( jQuery.isFunction(text) ) {
|
|
|
5489 return this.each(function(i) {
|
|
|
5490 var self = jQuery( this );
|
|
|
5491
|
|
|
5492 self.text( text.call(this, i, self.text()) );
|
|
|
5493 });
|
|
|
5494 }
|
|
|
5495
|
|
|
5496 if ( typeof text !== "object" && text !== undefined ) {
|
|
|
5497 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
|
|
|
5498 }
|
|
|
5499
|
|
|
5500 return jQuery.text( this );
|
|
|
5501 },
|
|
|
5502
|
|
|
5503 wrapAll: function( html ) {
|
|
|
5504 if ( jQuery.isFunction( html ) ) {
|
|
|
5505 return this.each(function(i) {
|
|
|
5506 jQuery(this).wrapAll( html.call(this, i) );
|
|
|
5507 });
|
|
|
5508 }
|
|
|
5509
|
|
|
5510 if ( this[0] ) {
|
|
|
5511 // The elements to wrap the target around
|
|
|
5512 var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
|
|
|
5513
|
|
|
5514 if ( this[0].parentNode ) {
|
|
|
5515 wrap.insertBefore( this[0] );
|
|
|
5516 }
|
|
|
5517
|
|
|
5518 wrap.map(function() {
|
|
|
5519 var elem = this;
|
|
|
5520
|
|
|
5521 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
|
|
|
5522 elem = elem.firstChild;
|
|
|
5523 }
|
|
|
5524
|
|
|
5525 return elem;
|
|
|
5526 }).append( this );
|
|
|
5527 }
|
|
|
5528
|
|
|
5529 return this;
|
|
|
5530 },
|
|
|
5531
|
|
|
5532 wrapInner: function( html ) {
|
|
|
5533 if ( jQuery.isFunction( html ) ) {
|
|
|
5534 return this.each(function(i) {
|
|
|
5535 jQuery(this).wrapInner( html.call(this, i) );
|
|
|
5536 });
|
|
|
5537 }
|
|
|
5538
|
|
|
5539 return this.each(function() {
|
|
|
5540 var self = jQuery( this ),
|
|
|
5541 contents = self.contents();
|
|
|
5542
|
|
|
5543 if ( contents.length ) {
|
|
|
5544 contents.wrapAll( html );
|
|
|
5545
|
|
|
5546 } else {
|
|
|
5547 self.append( html );
|
|
|
5548 }
|
|
|
5549 });
|
|
|
5550 },
|
|
|
5551
|
|
|
5552 wrap: function( html ) {
|
|
|
5553 return this.each(function() {
|
|
|
5554 jQuery( this ).wrapAll( html );
|
|
|
5555 });
|
|
|
5556 },
|
|
|
5557
|
|
|
5558 unwrap: function() {
|
|
|
5559 return this.parent().each(function() {
|
|
|
5560 if ( !jQuery.nodeName( this, "body" ) ) {
|
|
|
5561 jQuery( this ).replaceWith( this.childNodes );
|
|
|
5562 }
|
|
|
5563 }).end();
|
|
|
5564 },
|
|
|
5565
|
|
|
5566 append: function() {
|
|
|
5567 return this.domManip(arguments, true, function( elem ) {
|
|
|
5568 if ( this.nodeType === 1 ) {
|
|
|
5569 this.appendChild( elem );
|
|
|
5570 }
|
|
|
5571 });
|
|
|
5572 },
|
|
|
5573
|
|
|
5574 prepend: function() {
|
|
|
5575 return this.domManip(arguments, true, function( elem ) {
|
|
|
5576 if ( this.nodeType === 1 ) {
|
|
|
5577 this.insertBefore( elem, this.firstChild );
|
|
|
5578 }
|
|
|
5579 });
|
|
|
5580 },
|
|
|
5581
|
|
|
5582 before: function() {
|
|
|
5583 if ( this[0] && this[0].parentNode ) {
|
|
|
5584 return this.domManip(arguments, false, function( elem ) {
|
|
|
5585 this.parentNode.insertBefore( elem, this );
|
|
|
5586 });
|
|
|
5587 } else if ( arguments.length ) {
|
|
|
5588 var set = jQuery(arguments[0]);
|
|
|
5589 set.push.apply( set, this.toArray() );
|
|
|
5590 return this.pushStack( set, "before", arguments );
|
|
|
5591 }
|
|
|
5592 },
|
|
|
5593
|
|
|
5594 after: function() {
|
|
|
5595 if ( this[0] && this[0].parentNode ) {
|
|
|
5596 return this.domManip(arguments, false, function( elem ) {
|
|
|
5597 this.parentNode.insertBefore( elem, this.nextSibling );
|
|
|
5598 });
|
|
|
5599 } else if ( arguments.length ) {
|
|
|
5600 var set = this.pushStack( this, "after", arguments );
|
|
|
5601 set.push.apply( set, jQuery(arguments[0]).toArray() );
|
|
|
5602 return set;
|
|
|
5603 }
|
|
|
5604 },
|
|
|
5605
|
|
|
5606 // keepData is for internal use only--do not document
|
|
|
5607 remove: function( selector, keepData ) {
|
|
|
5608 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
|
|
|
5609 if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
|
|
|
5610 if ( !keepData && elem.nodeType === 1 ) {
|
|
|
5611 jQuery.cleanData( elem.getElementsByTagName("*") );
|
|
|
5612 jQuery.cleanData( [ elem ] );
|
|
|
5613 }
|
|
|
5614
|
|
|
5615 if ( elem.parentNode ) {
|
|
|
5616 elem.parentNode.removeChild( elem );
|
|
|
5617 }
|
|
|
5618 }
|
|
|
5619 }
|
|
|
5620
|
|
|
5621 return this;
|
|
|
5622 },
|
|
|
5623
|
|
|
5624 empty: function() {
|
|
|
5625 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
|
|
|
5626 // Remove element nodes and prevent memory leaks
|
|
|
5627 if ( elem.nodeType === 1 ) {
|
|
|
5628 jQuery.cleanData( elem.getElementsByTagName("*") );
|
|
|
5629 }
|
|
|
5630
|
|
|
5631 // Remove any remaining nodes
|
|
|
5632 while ( elem.firstChild ) {
|
|
|
5633 elem.removeChild( elem.firstChild );
|
|
|
5634 }
|
|
|
5635 }
|
|
|
5636
|
|
|
5637 return this;
|
|
|
5638 },
|
|
|
5639
|
|
|
5640 clone: function( dataAndEvents, deepDataAndEvents ) {
|
|
|
5641 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
|
|
|
5642 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
|
|
|
5643
|
|
|
5644 return this.map( function () {
|
|
|
5645 return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
|
|
|
5646 });
|
|
|
5647 },
|
|
|
5648
|
|
|
5649 html: function( value ) {
|
|
|
5650 if ( value === undefined ) {
|
|
|
5651 return this[0] && this[0].nodeType === 1 ?
|
|
|
5652 this[0].innerHTML.replace(rinlinejQuery, "") :
|
|
|
5653 null;
|
|
|
5654
|
|
|
5655 // See if we can take a shortcut and just use innerHTML
|
|
|
5656 } else if ( typeof value === "string" && !rnocache.test( value ) &&
|
|
|
5657 (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
|
|
|
5658 !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
|
|
|
5659
|
|
|
5660 value = value.replace(rxhtmlTag, "<$1></$2>");
|
|
|
5661
|
|
|
5662 try {
|
|
|
5663 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
5664 // Remove element nodes and prevent memory leaks
|
|
|
5665 if ( this[i].nodeType === 1 ) {
|
|
|
5666 jQuery.cleanData( this[i].getElementsByTagName("*") );
|
|
|
5667 this[i].innerHTML = value;
|
|
|
5668 }
|
|
|
5669 }
|
|
|
5670
|
|
|
5671 // If using innerHTML throws an exception, use the fallback method
|
|
|
5672 } catch(e) {
|
|
|
5673 this.empty().append( value );
|
|
|
5674 }
|
|
|
5675
|
|
|
5676 } else if ( jQuery.isFunction( value ) ) {
|
|
|
5677 this.each(function(i){
|
|
|
5678 var self = jQuery( this );
|
|
|
5679
|
|
|
5680 self.html( value.call(this, i, self.html()) );
|
|
|
5681 });
|
|
|
5682
|
|
|
5683 } else {
|
|
|
5684 this.empty().append( value );
|
|
|
5685 }
|
|
|
5686
|
|
|
5687 return this;
|
|
|
5688 },
|
|
|
5689
|
|
|
5690 replaceWith: function( value ) {
|
|
|
5691 if ( this[0] && this[0].parentNode ) {
|
|
|
5692 // Make sure that the elements are removed from the DOM before they are inserted
|
|
|
5693 // this can help fix replacing a parent with child elements
|
|
|
5694 if ( jQuery.isFunction( value ) ) {
|
|
|
5695 return this.each(function(i) {
|
|
|
5696 var self = jQuery(this), old = self.html();
|
|
|
5697 self.replaceWith( value.call( this, i, old ) );
|
|
|
5698 });
|
|
|
5699 }
|
|
|
5700
|
|
|
5701 if ( typeof value !== "string" ) {
|
|
|
5702 value = jQuery( value ).detach();
|
|
|
5703 }
|
|
|
5704
|
|
|
5705 return this.each(function() {
|
|
|
5706 var next = this.nextSibling,
|
|
|
5707 parent = this.parentNode;
|
|
|
5708
|
|
|
5709 jQuery( this ).remove();
|
|
|
5710
|
|
|
5711 if ( next ) {
|
|
|
5712 jQuery(next).before( value );
|
|
|
5713 } else {
|
|
|
5714 jQuery(parent).append( value );
|
|
|
5715 }
|
|
|
5716 });
|
|
|
5717 } else {
|
|
|
5718 return this.length ?
|
|
|
5719 this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
|
|
|
5720 this;
|
|
|
5721 }
|
|
|
5722 },
|
|
|
5723
|
|
|
5724 detach: function( selector ) {
|
|
|
5725 return this.remove( selector, true );
|
|
|
5726 },
|
|
|
5727
|
|
|
5728 domManip: function( args, table, callback ) {
|
|
|
5729 var results, first, fragment, parent,
|
|
|
5730 value = args[0],
|
|
|
5731 scripts = [];
|
|
|
5732
|
|
|
5733 // We can't cloneNode fragments that contain checked, in WebKit
|
|
|
5734 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
|
|
|
5735 return this.each(function() {
|
|
|
5736 jQuery(this).domManip( args, table, callback, true );
|
|
|
5737 });
|
|
|
5738 }
|
|
|
5739
|
|
|
5740 if ( jQuery.isFunction(value) ) {
|
|
|
5741 return this.each(function(i) {
|
|
|
5742 var self = jQuery(this);
|
|
|
5743 args[0] = value.call(this, i, table ? self.html() : undefined);
|
|
|
5744 self.domManip( args, table, callback );
|
|
|
5745 });
|
|
|
5746 }
|
|
|
5747
|
|
|
5748 if ( this[0] ) {
|
|
|
5749 parent = value && value.parentNode;
|
|
|
5750
|
|
|
5751 // If we're in a fragment, just use that instead of building a new one
|
|
|
5752 if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
|
|
|
5753 results = { fragment: parent };
|
|
|
5754
|
|
|
5755 } else {
|
|
|
5756 results = jQuery.buildFragment( args, this, scripts );
|
|
|
5757 }
|
|
|
5758
|
|
|
5759 fragment = results.fragment;
|
|
|
5760
|
|
|
5761 if ( fragment.childNodes.length === 1 ) {
|
|
|
5762 first = fragment = fragment.firstChild;
|
|
|
5763 } else {
|
|
|
5764 first = fragment.firstChild;
|
|
|
5765 }
|
|
|
5766
|
|
|
5767 if ( first ) {
|
|
|
5768 table = table && jQuery.nodeName( first, "tr" );
|
|
|
5769
|
|
|
5770 for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
|
|
|
5771 callback.call(
|
|
|
5772 table ?
|
|
|
5773 root(this[i], first) :
|
|
|
5774 this[i],
|
|
|
5775 // Make sure that we do not leak memory by inadvertently discarding
|
|
|
5776 // the original fragment (which might have attached data) instead of
|
|
|
5777 // using it; in addition, use the original fragment object for the last
|
|
|
5778 // item instead of first because it can end up being emptied incorrectly
|
|
|
5779 // in certain situations (Bug #8070).
|
|
|
5780 // Fragments from the fragment cache must always be cloned and never used
|
|
|
5781 // in place.
|
|
|
5782 results.cacheable || (l > 1 && i < lastIndex) ?
|
|
|
5783 jQuery.clone( fragment, true, true ) :
|
|
|
5784 fragment
|
|
|
5785 );
|
|
|
5786 }
|
|
|
5787 }
|
|
|
5788
|
|
|
5789 if ( scripts.length ) {
|
|
|
5790 jQuery.each( scripts, evalScript );
|
|
|
5791 }
|
|
|
5792 }
|
|
|
5793
|
|
|
5794 return this;
|
|
|
5795 }
|
|
|
5796 });
|
|
|
5797
|
|
|
5798 function root( elem, cur ) {
|
|
|
5799 return jQuery.nodeName(elem, "table") ?
|
|
|
5800 (elem.getElementsByTagName("tbody")[0] ||
|
|
|
5801 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
|
|
|
5802 elem;
|
|
|
5803 }
|
|
|
5804
|
|
|
5805 function cloneCopyEvent( src, dest ) {
|
|
|
5806
|
|
|
5807 if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
|
|
|
5808 return;
|
|
|
5809 }
|
|
|
5810
|
|
|
5811 var internalKey = jQuery.expando,
|
|
|
5812 oldData = jQuery.data( src ),
|
|
|
5813 curData = jQuery.data( dest, oldData );
|
|
|
5814
|
|
|
5815 // Switch to use the internal data object, if it exists, for the next
|
|
|
5816 // stage of data copying
|
|
|
5817 if ( (oldData = oldData[ internalKey ]) ) {
|
|
|
5818 var events = oldData.events;
|
|
|
5819 curData = curData[ internalKey ] = jQuery.extend({}, oldData);
|
|
|
5820
|
|
|
5821 if ( events ) {
|
|
|
5822 delete curData.handle;
|
|
|
5823 curData.events = {};
|
|
|
5824
|
|
|
5825 for ( var type in events ) {
|
|
|
5826 for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
|
|
|
5827 jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
|
|
|
5828 }
|
|
|
5829 }
|
|
|
5830 }
|
|
|
5831 }
|
|
|
5832 }
|
|
|
5833
|
|
|
5834 function cloneFixAttributes( src, dest ) {
|
|
|
5835 var nodeName;
|
|
|
5836
|
|
|
5837 // We do not need to do anything for non-Elements
|
|
|
5838 if ( dest.nodeType !== 1 ) {
|
|
|
5839 return;
|
|
|
5840 }
|
|
|
5841
|
|
|
5842 // clearAttributes removes the attributes, which we don't want,
|
|
|
5843 // but also removes the attachEvent events, which we *do* want
|
|
|
5844 if ( dest.clearAttributes ) {
|
|
|
5845 dest.clearAttributes();
|
|
|
5846 }
|
|
|
5847
|
|
|
5848 // mergeAttributes, in contrast, only merges back on the
|
|
|
5849 // original attributes, not the events
|
|
|
5850 if ( dest.mergeAttributes ) {
|
|
|
5851 dest.mergeAttributes( src );
|
|
|
5852 }
|
|
|
5853
|
|
|
5854 nodeName = dest.nodeName.toLowerCase();
|
|
|
5855
|
|
|
5856 // IE6-8 fail to clone children inside object elements that use
|
|
|
5857 // the proprietary classid attribute value (rather than the type
|
|
|
5858 // attribute) to identify the type of content to display
|
|
|
5859 if ( nodeName === "object" ) {
|
|
|
5860 dest.outerHTML = src.outerHTML;
|
|
|
5861
|
|
|
5862 } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
|
|
|
5863 // IE6-8 fails to persist the checked state of a cloned checkbox
|
|
|
5864 // or radio button. Worse, IE6-7 fail to give the cloned element
|
|
|
5865 // a checked appearance if the defaultChecked value isn't also set
|
|
|
5866 if ( src.checked ) {
|
|
|
5867 dest.defaultChecked = dest.checked = src.checked;
|
|
|
5868 }
|
|
|
5869
|
|
|
5870 // IE6-7 get confused and end up setting the value of a cloned
|
|
|
5871 // checkbox/radio button to an empty string instead of "on"
|
|
|
5872 if ( dest.value !== src.value ) {
|
|
|
5873 dest.value = src.value;
|
|
|
5874 }
|
|
|
5875
|
|
|
5876 // IE6-8 fails to return the selected option to the default selected
|
|
|
5877 // state when cloning options
|
|
|
5878 } else if ( nodeName === "option" ) {
|
|
|
5879 dest.selected = src.defaultSelected;
|
|
|
5880
|
|
|
5881 // IE6-8 fails to set the defaultValue to the correct value when
|
|
|
5882 // cloning other types of input fields
|
|
|
5883 } else if ( nodeName === "input" || nodeName === "textarea" ) {
|
|
|
5884 dest.defaultValue = src.defaultValue;
|
|
|
5885 }
|
|
|
5886
|
|
|
5887 // Event data gets referenced instead of copied if the expando
|
|
|
5888 // gets copied too
|
|
|
5889 dest.removeAttribute( jQuery.expando );
|
|
|
5890 }
|
|
|
5891
|
|
|
5892 jQuery.buildFragment = function( args, nodes, scripts ) {
|
|
|
5893 var fragment, cacheable, cacheresults,
|
|
|
5894 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
|
|
|
5895
|
|
|
5896 // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
|
|
|
5897 // Cloning options loses the selected state, so don't cache them
|
|
|
5898 // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
|
|
|
5899 // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
|
|
|
5900 if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
|
|
|
5901 args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
|
|
|
5902
|
|
|
5903 cacheable = true;
|
|
|
5904
|
|
|
5905 cacheresults = jQuery.fragments[ args[0] ];
|
|
|
5906 if ( cacheresults && cacheresults !== 1 ) {
|
|
|
5907 fragment = cacheresults;
|
|
|
5908 }
|
|
|
5909 }
|
|
|
5910
|
|
|
5911 if ( !fragment ) {
|
|
|
5912 fragment = doc.createDocumentFragment();
|
|
|
5913 jQuery.clean( args, doc, fragment, scripts );
|
|
|
5914 }
|
|
|
5915
|
|
|
5916 if ( cacheable ) {
|
|
|
5917 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
|
|
|
5918 }
|
|
|
5919
|
|
|
5920 return { fragment: fragment, cacheable: cacheable };
|
|
|
5921 };
|
|
|
5922
|
|
|
5923 jQuery.fragments = {};
|
|
|
5924
|
|
|
5925 jQuery.each({
|
|
|
5926 appendTo: "append",
|
|
|
5927 prependTo: "prepend",
|
|
|
5928 insertBefore: "before",
|
|
|
5929 insertAfter: "after",
|
|
|
5930 replaceAll: "replaceWith"
|
|
|
5931 }, function( name, original ) {
|
|
|
5932 jQuery.fn[ name ] = function( selector ) {
|
|
|
5933 var ret = [],
|
|
|
5934 insert = jQuery( selector ),
|
|
|
5935 parent = this.length === 1 && this[0].parentNode;
|
|
|
5936
|
|
|
5937 if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
|
|
|
5938 insert[ original ]( this[0] );
|
|
|
5939 return this;
|
|
|
5940
|
|
|
5941 } else {
|
|
|
5942 for ( var i = 0, l = insert.length; i < l; i++ ) {
|
|
|
5943 var elems = (i > 0 ? this.clone(true) : this).get();
|
|
|
5944 jQuery( insert[i] )[ original ]( elems );
|
|
|
5945 ret = ret.concat( elems );
|
|
|
5946 }
|
|
|
5947
|
|
|
5948 return this.pushStack( ret, name, insert.selector );
|
|
|
5949 }
|
|
|
5950 };
|
|
|
5951 });
|
|
|
5952
|
|
|
5953 function getAll( elem ) {
|
|
|
5954 if ( "getElementsByTagName" in elem ) {
|
|
|
5955 return elem.getElementsByTagName( "*" );
|
|
|
5956
|
|
|
5957 } else if ( "querySelectorAll" in elem ) {
|
|
|
5958 return elem.querySelectorAll( "*" );
|
|
|
5959
|
|
|
5960 } else {
|
|
|
5961 return [];
|
|
|
5962 }
|
|
|
5963 }
|
|
|
5964
|
|
|
5965 // Used in clean, fixes the defaultChecked property
|
|
|
5966 function fixDefaultChecked( elem ) {
|
|
|
5967 if ( elem.type === "checkbox" || elem.type === "radio" ) {
|
|
|
5968 elem.defaultChecked = elem.checked;
|
|
|
5969 }
|
|
|
5970 }
|
|
|
5971 // Finds all inputs and passes them to fixDefaultChecked
|
|
|
5972 function findInputs( elem ) {
|
|
|
5973 if ( jQuery.nodeName( elem, "input" ) ) {
|
|
|
5974 fixDefaultChecked( elem );
|
|
|
5975 } else if ( elem.getElementsByTagName ) {
|
|
|
5976 jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
|
|
|
5977 }
|
|
|
5978 }
|
|
|
5979
|
|
|
5980 jQuery.extend({
|
|
|
5981 clone: function( elem, dataAndEvents, deepDataAndEvents ) {
|
|
|
5982 var clone = elem.cloneNode(true),
|
|
|
5983 srcElements,
|
|
|
5984 destElements,
|
|
|
5985 i;
|
|
|
5986
|
|
|
5987 if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
|
|
|
5988 (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
|
|
|
5989 // IE copies events bound via attachEvent when using cloneNode.
|
|
|
5990 // Calling detachEvent on the clone will also remove the events
|
|
|
5991 // from the original. In order to get around this, we use some
|
|
|
5992 // proprietary methods to clear the events. Thanks to MooTools
|
|
|
5993 // guys for this hotness.
|
|
|
5994
|
|
|
5995 cloneFixAttributes( elem, clone );
|
|
|
5996
|
|
|
5997 // Using Sizzle here is crazy slow, so we use getElementsByTagName
|
|
|
5998 // instead
|
|
|
5999 srcElements = getAll( elem );
|
|
|
6000 destElements = getAll( clone );
|
|
|
6001
|
|
|
6002 // Weird iteration because IE will replace the length property
|
|
|
6003 // with an element if you are cloning the body and one of the
|
|
|
6004 // elements on the page has a name or id of "length"
|
|
|
6005 for ( i = 0; srcElements[i]; ++i ) {
|
|
|
6006 cloneFixAttributes( srcElements[i], destElements[i] );
|
|
|
6007 }
|
|
|
6008 }
|
|
|
6009
|
|
|
6010 // Copy the events from the original to the clone
|
|
|
6011 if ( dataAndEvents ) {
|
|
|
6012 cloneCopyEvent( elem, clone );
|
|
|
6013
|
|
|
6014 if ( deepDataAndEvents ) {
|
|
|
6015 srcElements = getAll( elem );
|
|
|
6016 destElements = getAll( clone );
|
|
|
6017
|
|
|
6018 for ( i = 0; srcElements[i]; ++i ) {
|
|
|
6019 cloneCopyEvent( srcElements[i], destElements[i] );
|
|
|
6020 }
|
|
|
6021 }
|
|
|
6022 }
|
|
|
6023
|
|
|
6024 // Return the cloned set
|
|
|
6025 return clone;
|
|
|
6026 },
|
|
|
6027
|
|
|
6028 clean: function( elems, context, fragment, scripts ) {
|
|
|
6029 var checkScriptType;
|
|
|
6030
|
|
|
6031 context = context || document;
|
|
|
6032
|
|
|
6033 // !context.createElement fails in IE with an error but returns typeof 'object'
|
|
|
6034 if ( typeof context.createElement === "undefined" ) {
|
|
|
6035 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
|
|
|
6036 }
|
|
|
6037
|
|
|
6038 var ret = [], j;
|
|
|
6039
|
|
|
6040 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
|
|
|
6041 if ( typeof elem === "number" ) {
|
|
|
6042 elem += "";
|
|
|
6043 }
|
|
|
6044
|
|
|
6045 if ( !elem ) {
|
|
|
6046 continue;
|
|
|
6047 }
|
|
|
6048
|
|
|
6049 // Convert html string into DOM nodes
|
|
|
6050 if ( typeof elem === "string" ) {
|
|
|
6051 if ( !rhtml.test( elem ) ) {
|
|
|
6052 elem = context.createTextNode( elem );
|
|
|
6053 } else {
|
|
|
6054 // Fix "XHTML"-style tags in all browsers
|
|
|
6055 elem = elem.replace(rxhtmlTag, "<$1></$2>");
|
|
|
6056
|
|
|
6057 // Trim whitespace, otherwise indexOf won't work as expected
|
|
|
6058 var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
|
|
|
6059 wrap = wrapMap[ tag ] || wrapMap._default,
|
|
|
6060 depth = wrap[0],
|
|
|
6061 div = context.createElement("div");
|
|
|
6062
|
|
|
6063 // Go to html and back, then peel off extra wrappers
|
|
|
6064 div.innerHTML = wrap[1] + elem + wrap[2];
|
|
|
6065
|
|
|
6066 // Move to the right depth
|
|
|
6067 while ( depth-- ) {
|
|
|
6068 div = div.lastChild;
|
|
|
6069 }
|
|
|
6070
|
|
|
6071 // Remove IE's autoinserted <tbody> from table fragments
|
|
|
6072 if ( !jQuery.support.tbody ) {
|
|
|
6073
|
|
|
6074 // String was a <table>, *may* have spurious <tbody>
|
|
|
6075 var hasBody = rtbody.test(elem),
|
|
|
6076 tbody = tag === "table" && !hasBody ?
|
|
|
6077 div.firstChild && div.firstChild.childNodes :
|
|
|
6078
|
|
|
6079 // String was a bare <thead> or <tfoot>
|
|
|
6080 wrap[1] === "<table>" && !hasBody ?
|
|
|
6081 div.childNodes :
|
|
|
6082 [];
|
|
|
6083
|
|
|
6084 for ( j = tbody.length - 1; j >= 0 ; --j ) {
|
|
|
6085 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
|
|
|
6086 tbody[ j ].parentNode.removeChild( tbody[ j ] );
|
|
|
6087 }
|
|
|
6088 }
|
|
|
6089 }
|
|
|
6090
|
|
|
6091 // IE completely kills leading whitespace when innerHTML is used
|
|
|
6092 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
|
|
|
6093 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
|
|
|
6094 }
|
|
|
6095
|
|
|
6096 elem = div.childNodes;
|
|
|
6097 }
|
|
|
6098 }
|
|
|
6099
|
|
|
6100 // Resets defaultChecked for any radios and checkboxes
|
|
|
6101 // about to be appended to the DOM in IE 6/7 (#8060)
|
|
|
6102 var len;
|
|
|
6103 if ( !jQuery.support.appendChecked ) {
|
|
|
6104 if ( elem[0] && typeof (len = elem.length) === "number" ) {
|
|
|
6105 for ( j = 0; j < len; j++ ) {
|
|
|
6106 findInputs( elem[j] );
|
|
|
6107 }
|
|
|
6108 } else {
|
|
|
6109 findInputs( elem );
|
|
|
6110 }
|
|
|
6111 }
|
|
|
6112
|
|
|
6113 if ( elem.nodeType ) {
|
|
|
6114 ret.push( elem );
|
|
|
6115 } else {
|
|
|
6116 ret = jQuery.merge( ret, elem );
|
|
|
6117 }
|
|
|
6118 }
|
|
|
6119
|
|
|
6120 if ( fragment ) {
|
|
|
6121 checkScriptType = function( elem ) {
|
|
|
6122 return !elem.type || rscriptType.test( elem.type );
|
|
|
6123 };
|
|
|
6124 for ( i = 0; ret[i]; i++ ) {
|
|
|
6125 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
|
|
|
6126 scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
|
|
|
6127
|
|
|
6128 } else {
|
|
|
6129 if ( ret[i].nodeType === 1 ) {
|
|
|
6130 var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
|
|
|
6131
|
|
|
6132 ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
|
|
|
6133 }
|
|
|
6134 fragment.appendChild( ret[i] );
|
|
|
6135 }
|
|
|
6136 }
|
|
|
6137 }
|
|
|
6138
|
|
|
6139 return ret;
|
|
|
6140 },
|
|
|
6141
|
|
|
6142 cleanData: function( elems ) {
|
|
|
6143 var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
|
|
|
6144 deleteExpando = jQuery.support.deleteExpando;
|
|
|
6145
|
|
|
6146 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
|
|
|
6147 if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
|
|
|
6148 continue;
|
|
|
6149 }
|
|
|
6150
|
|
|
6151 id = elem[ jQuery.expando ];
|
|
|
6152
|
|
|
6153 if ( id ) {
|
|
|
6154 data = cache[ id ] && cache[ id ][ internalKey ];
|
|
|
6155
|
|
|
6156 if ( data && data.events ) {
|
|
|
6157 for ( var type in data.events ) {
|
|
|
6158 if ( special[ type ] ) {
|
|
|
6159 jQuery.event.remove( elem, type );
|
|
|
6160
|
|
|
6161 // This is a shortcut to avoid jQuery.event.remove's overhead
|
|
|
6162 } else {
|
|
|
6163 jQuery.removeEvent( elem, type, data.handle );
|
|
|
6164 }
|
|
|
6165 }
|
|
|
6166
|
|
|
6167 // Null the DOM reference to avoid IE6/7/8 leak (#7054)
|
|
|
6168 if ( data.handle ) {
|
|
|
6169 data.handle.elem = null;
|
|
|
6170 }
|
|
|
6171 }
|
|
|
6172
|
|
|
6173 if ( deleteExpando ) {
|
|
|
6174 delete elem[ jQuery.expando ];
|
|
|
6175
|
|
|
6176 } else if ( elem.removeAttribute ) {
|
|
|
6177 elem.removeAttribute( jQuery.expando );
|
|
|
6178 }
|
|
|
6179
|
|
|
6180 delete cache[ id ];
|
|
|
6181 }
|
|
|
6182 }
|
|
|
6183 }
|
|
|
6184 });
|
|
|
6185
|
|
|
6186 function evalScript( i, elem ) {
|
|
|
6187 if ( elem.src ) {
|
|
|
6188 jQuery.ajax({
|
|
|
6189 url: elem.src,
|
|
|
6190 async: false,
|
|
|
6191 dataType: "script"
|
|
|
6192 });
|
|
|
6193 } else {
|
|
|
6194 jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
|
|
|
6195 }
|
|
|
6196
|
|
|
6197 if ( elem.parentNode ) {
|
|
|
6198 elem.parentNode.removeChild( elem );
|
|
|
6199 }
|
|
|
6200 }
|
|
|
6201
|
|
|
6202
|
|
|
6203
|
|
|
6204
|
|
|
6205 var ralpha = /alpha\([^)]*\)/i,
|
|
|
6206 ropacity = /opacity=([^)]*)/,
|
|
|
6207 rdashAlpha = /-([a-z])/ig,
|
|
|
6208 // fixed for IE9, see #8346
|
|
|
6209 rupper = /([A-Z]|^ms)/g,
|
|
|
6210 rnumpx = /^-?\d+(?:px)?$/i,
|
|
|
6211 rnum = /^-?\d/,
|
|
|
6212 rrelNum = /^[+\-]=/,
|
|
|
6213 rrelNumFilter = /[^+\-\.\de]+/g,
|
|
|
6214
|
|
|
6215 cssShow = { position: "absolute", visibility: "hidden", display: "block" },
|
|
|
6216 cssWidth = [ "Left", "Right" ],
|
|
|
6217 cssHeight = [ "Top", "Bottom" ],
|
|
|
6218 curCSS,
|
|
|
6219
|
|
|
6220 getComputedStyle,
|
|
|
6221 currentStyle,
|
|
|
6222
|
|
|
6223 fcamelCase = function( all, letter ) {
|
|
|
6224 return letter.toUpperCase();
|
|
|
6225 };
|
|
|
6226
|
|
|
6227 jQuery.fn.css = function( name, value ) {
|
|
|
6228 // Setting 'undefined' is a no-op
|
|
|
6229 if ( arguments.length === 2 && value === undefined ) {
|
|
|
6230 return this;
|
|
|
6231 }
|
|
|
6232
|
|
|
6233 return jQuery.access( this, name, value, true, function( elem, name, value ) {
|
|
|
6234 return value !== undefined ?
|
|
|
6235 jQuery.style( elem, name, value ) :
|
|
|
6236 jQuery.css( elem, name );
|
|
|
6237 });
|
|
|
6238 };
|
|
|
6239
|
|
|
6240 jQuery.extend({
|
|
|
6241 // Add in style property hooks for overriding the default
|
|
|
6242 // behavior of getting and setting a style property
|
|
|
6243 cssHooks: {
|
|
|
6244 opacity: {
|
|
|
6245 get: function( elem, computed ) {
|
|
|
6246 if ( computed ) {
|
|
|
6247 // We should always get a number back from opacity
|
|
|
6248 var ret = curCSS( elem, "opacity", "opacity" );
|
|
|
6249 return ret === "" ? "1" : ret;
|
|
|
6250
|
|
|
6251 } else {
|
|
|
6252 return elem.style.opacity;
|
|
|
6253 }
|
|
|
6254 }
|
|
|
6255 }
|
|
|
6256 },
|
|
|
6257
|
|
|
6258 // Exclude the following css properties to add px
|
|
|
6259 cssNumber: {
|
|
|
6260 "zIndex": true,
|
|
|
6261 "fontWeight": true,
|
|
|
6262 "opacity": true,
|
|
|
6263 "zoom": true,
|
|
|
6264 "lineHeight": true,
|
|
|
6265 "widows": true,
|
|
|
6266 "orphans": true
|
|
|
6267 },
|
|
|
6268
|
|
|
6269 // Add in properties whose names you wish to fix before
|
|
|
6270 // setting or getting the value
|
|
|
6271 cssProps: {
|
|
|
6272 // normalize float css property
|
|
|
6273 "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
|
|
|
6274 },
|
|
|
6275
|
|
|
6276 // Get and set the style property on a DOM Node
|
|
|
6277 style: function( elem, name, value, extra ) {
|
|
|
6278 // Don't set styles on text and comment nodes
|
|
|
6279 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
|
|
|
6280 return;
|
|
|
6281 }
|
|
|
6282
|
|
|
6283 // Make sure that we're working with the right name
|
|
|
6284 var ret, type, origName = jQuery.camelCase( name ),
|
|
|
6285 style = elem.style, hooks = jQuery.cssHooks[ origName ];
|
|
|
6286
|
|
|
6287 name = jQuery.cssProps[ origName ] || origName;
|
|
|
6288
|
|
|
6289 // Check if we're setting a value
|
|
|
6290 if ( value !== undefined ) {
|
|
|
6291 type = typeof value;
|
|
|
6292
|
|
|
6293 // Make sure that NaN and null values aren't set. See: #7116
|
|
|
6294 if ( type === "number" && isNaN( value ) || value == null ) {
|
|
|
6295 return;
|
|
|
6296 }
|
|
|
6297
|
|
|
6298 // convert relative number strings (+= or -=) to relative numbers. #7345
|
|
|
6299 if ( type === "string" && rrelNum.test( value ) ) {
|
|
|
6300 value = +value.replace( rrelNumFilter, "" ) + parseFloat( jQuery.css( elem, name ) );
|
|
|
6301 }
|
|
|
6302
|
|
|
6303 // If a number was passed in, add 'px' to the (except for certain CSS properties)
|
|
|
6304 if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
|
|
|
6305 value += "px";
|
|
|
6306 }
|
|
|
6307
|
|
|
6308 // If a hook was provided, use that value, otherwise just set the specified value
|
|
|
6309 if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
|
|
|
6310 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
|
|
|
6311 // Fixes bug #5509
|
|
|
6312 try {
|
|
|
6313 style[ name ] = value;
|
|
|
6314 } catch(e) {}
|
|
|
6315 }
|
|
|
6316
|
|
|
6317 } else {
|
|
|
6318 // If a hook was provided get the non-computed value from there
|
|
|
6319 if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
|
|
|
6320 return ret;
|
|
|
6321 }
|
|
|
6322
|
|
|
6323 // Otherwise just get the value from the style object
|
|
|
6324 return style[ name ];
|
|
|
6325 }
|
|
|
6326 },
|
|
|
6327
|
|
|
6328 css: function( elem, name, extra ) {
|
|
|
6329 var ret, hooks;
|
|
|
6330
|
|
|
6331 // Make sure that we're working with the right name
|
|
|
6332 name = jQuery.camelCase( name );
|
|
|
6333 hooks = jQuery.cssHooks[ name ];
|
|
|
6334 name = jQuery.cssProps[ name ] || name;
|
|
|
6335
|
|
|
6336 // cssFloat needs a special treatment
|
|
|
6337 if ( name === "cssFloat" ) {
|
|
|
6338 name = "float";
|
|
|
6339 }
|
|
|
6340
|
|
|
6341 // If a hook was provided get the computed value from there
|
|
|
6342 if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
|
|
|
6343 return ret;
|
|
|
6344
|
|
|
6345 // Otherwise, if a way to get the computed value exists, use that
|
|
|
6346 } else if ( curCSS ) {
|
|
|
6347 return curCSS( elem, name );
|
|
|
6348 }
|
|
|
6349 },
|
|
|
6350
|
|
|
6351 // A method for quickly swapping in/out CSS properties to get correct calculations
|
|
|
6352 swap: function( elem, options, callback ) {
|
|
|
6353 var old = {};
|
|
|
6354
|
|
|
6355 // Remember the old values, and insert the new ones
|
|
|
6356 for ( var name in options ) {
|
|
|
6357 old[ name ] = elem.style[ name ];
|
|
|
6358 elem.style[ name ] = options[ name ];
|
|
|
6359 }
|
|
|
6360
|
|
|
6361 callback.call( elem );
|
|
|
6362
|
|
|
6363 // Revert the old values
|
|
|
6364 for ( name in options ) {
|
|
|
6365 elem.style[ name ] = old[ name ];
|
|
|
6366 }
|
|
|
6367 },
|
|
|
6368
|
|
|
6369 camelCase: function( string ) {
|
|
|
6370 return string.replace( rdashAlpha, fcamelCase );
|
|
|
6371 }
|
|
|
6372 });
|
|
|
6373
|
|
|
6374 // DEPRECATED, Use jQuery.css() instead
|
|
|
6375 jQuery.curCSS = jQuery.css;
|
|
|
6376
|
|
|
6377 jQuery.each(["height", "width"], function( i, name ) {
|
|
|
6378 jQuery.cssHooks[ name ] = {
|
|
|
6379 get: function( elem, computed, extra ) {
|
|
|
6380 var val;
|
|
|
6381
|
|
|
6382 if ( computed ) {
|
|
|
6383 if ( elem.offsetWidth !== 0 ) {
|
|
|
6384 val = getWH( elem, name, extra );
|
|
|
6385
|
|
|
6386 } else {
|
|
|
6387 jQuery.swap( elem, cssShow, function() {
|
|
|
6388 val = getWH( elem, name, extra );
|
|
|
6389 });
|
|
|
6390 }
|
|
|
6391
|
|
|
6392 if ( val <= 0 ) {
|
|
|
6393 val = curCSS( elem, name, name );
|
|
|
6394
|
|
|
6395 if ( val === "0px" && currentStyle ) {
|
|
|
6396 val = currentStyle( elem, name, name );
|
|
|
6397 }
|
|
|
6398
|
|
|
6399 if ( val != null ) {
|
|
|
6400 // Should return "auto" instead of 0, use 0 for
|
|
|
6401 // temporary backwards-compat
|
|
|
6402 return val === "" || val === "auto" ? "0px" : val;
|
|
|
6403 }
|
|
|
6404 }
|
|
|
6405
|
|
|
6406 if ( val < 0 || val == null ) {
|
|
|
6407 val = elem.style[ name ];
|
|
|
6408
|
|
|
6409 // Should return "auto" instead of 0, use 0 for
|
|
|
6410 // temporary backwards-compat
|
|
|
6411 return val === "" || val === "auto" ? "0px" : val;
|
|
|
6412 }
|
|
|
6413
|
|
|
6414 return typeof val === "string" ? val : val + "px";
|
|
|
6415 }
|
|
|
6416 },
|
|
|
6417
|
|
|
6418 set: function( elem, value ) {
|
|
|
6419 if ( rnumpx.test( value ) ) {
|
|
|
6420 // ignore negative width and height values #1599
|
|
|
6421 value = parseFloat(value);
|
|
|
6422
|
|
|
6423 if ( value >= 0 ) {
|
|
|
6424 return value + "px";
|
|
|
6425 }
|
|
|
6426
|
|
|
6427 } else {
|
|
|
6428 return value;
|
|
|
6429 }
|
|
|
6430 }
|
|
|
6431 };
|
|
|
6432 });
|
|
|
6433
|
|
|
6434 if ( !jQuery.support.opacity ) {
|
|
|
6435 jQuery.cssHooks.opacity = {
|
|
|
6436 get: function( elem, computed ) {
|
|
|
6437 // IE uses filters for opacity
|
|
|
6438 return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
|
|
|
6439 ( parseFloat( RegExp.$1 ) / 100 ) + "" :
|
|
|
6440 computed ? "1" : "";
|
|
|
6441 },
|
|
|
6442
|
|
|
6443 set: function( elem, value ) {
|
|
|
6444 var style = elem.style,
|
|
|
6445 currentStyle = elem.currentStyle;
|
|
|
6446
|
|
|
6447 // IE has trouble with opacity if it does not have layout
|
|
|
6448 // Force it by setting the zoom level
|
|
|
6449 style.zoom = 1;
|
|
|
6450
|
|
|
6451 // Set the alpha filter to set the opacity
|
|
|
6452 var opacity = jQuery.isNaN( value ) ?
|
|
|
6453 "" :
|
|
|
6454 "alpha(opacity=" + value * 100 + ")",
|
|
|
6455 filter = currentStyle && currentStyle.filter || style.filter || "";
|
|
|
6456
|
|
|
6457 style.filter = ralpha.test( filter ) ?
|
|
|
6458 filter.replace( ralpha, opacity ) :
|
|
|
6459 filter + " " + opacity;
|
|
|
6460 }
|
|
|
6461 };
|
|
|
6462 }
|
|
|
6463
|
|
|
6464 jQuery(function() {
|
|
|
6465 // This hook cannot be added until DOM ready because the support test
|
|
|
6466 // for it is not run until after DOM ready
|
|
|
6467 if ( !jQuery.support.reliableMarginRight ) {
|
|
|
6468 jQuery.cssHooks.marginRight = {
|
|
|
6469 get: function( elem, computed ) {
|
|
|
6470 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
|
|
|
6471 // Work around by temporarily setting element display to inline-block
|
|
|
6472 var ret;
|
|
|
6473 jQuery.swap( elem, { "display": "inline-block" }, function() {
|
|
|
6474 if ( computed ) {
|
|
|
6475 ret = curCSS( elem, "margin-right", "marginRight" );
|
|
|
6476 } else {
|
|
|
6477 ret = elem.style.marginRight;
|
|
|
6478 }
|
|
|
6479 });
|
|
|
6480 return ret;
|
|
|
6481 }
|
|
|
6482 };
|
|
|
6483 }
|
|
|
6484 });
|
|
|
6485
|
|
|
6486 if ( document.defaultView && document.defaultView.getComputedStyle ) {
|
|
|
6487 getComputedStyle = function( elem, name ) {
|
|
|
6488 var ret, defaultView, computedStyle;
|
|
|
6489
|
|
|
6490 name = name.replace( rupper, "-$1" ).toLowerCase();
|
|
|
6491
|
|
|
6492 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
|
|
|
6493 return undefined;
|
|
|
6494 }
|
|
|
6495
|
|
|
6496 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
|
|
|
6497 ret = computedStyle.getPropertyValue( name );
|
|
|
6498 if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
|
|
|
6499 ret = jQuery.style( elem, name );
|
|
|
6500 }
|
|
|
6501 }
|
|
|
6502
|
|
|
6503 return ret;
|
|
|
6504 };
|
|
|
6505 }
|
|
|
6506
|
|
|
6507 if ( document.documentElement.currentStyle ) {
|
|
|
6508 currentStyle = function( elem, name ) {
|
|
|
6509 var left,
|
|
|
6510 ret = elem.currentStyle && elem.currentStyle[ name ],
|
|
|
6511 rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
|
|
|
6512 style = elem.style;
|
|
|
6513
|
|
|
6514 // From the awesome hack by Dean Edwards
|
|
|
6515 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
|
|
|
6516
|
|
|
6517 // If we're not dealing with a regular pixel number
|
|
|
6518 // but a number that has a weird ending, we need to convert it to pixels
|
|
|
6519 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
|
|
|
6520 // Remember the original values
|
|
|
6521 left = style.left;
|
|
|
6522
|
|
|
6523 // Put in the new values to get a computed value out
|
|
|
6524 if ( rsLeft ) {
|
|
|
6525 elem.runtimeStyle.left = elem.currentStyle.left;
|
|
|
6526 }
|
|
|
6527 style.left = name === "fontSize" ? "1em" : (ret || 0);
|
|
|
6528 ret = style.pixelLeft + "px";
|
|
|
6529
|
|
|
6530 // Revert the changed values
|
|
|
6531 style.left = left;
|
|
|
6532 if ( rsLeft ) {
|
|
|
6533 elem.runtimeStyle.left = rsLeft;
|
|
|
6534 }
|
|
|
6535 }
|
|
|
6536
|
|
|
6537 return ret === "" ? "auto" : ret;
|
|
|
6538 };
|
|
|
6539 }
|
|
|
6540
|
|
|
6541 curCSS = getComputedStyle || currentStyle;
|
|
|
6542
|
|
|
6543 function getWH( elem, name, extra ) {
|
|
|
6544 var which = name === "width" ? cssWidth : cssHeight,
|
|
|
6545 val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
|
|
|
6546
|
|
|
6547 if ( extra === "border" ) {
|
|
|
6548 return val;
|
|
|
6549 }
|
|
|
6550
|
|
|
6551 jQuery.each( which, function() {
|
|
|
6552 if ( !extra ) {
|
|
|
6553 val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
|
|
|
6554 }
|
|
|
6555
|
|
|
6556 if ( extra === "margin" ) {
|
|
|
6557 val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
|
|
|
6558
|
|
|
6559 } else {
|
|
|
6560 val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
|
|
|
6561 }
|
|
|
6562 });
|
|
|
6563
|
|
|
6564 return val;
|
|
|
6565 }
|
|
|
6566
|
|
|
6567 if ( jQuery.expr && jQuery.expr.filters ) {
|
|
|
6568 jQuery.expr.filters.hidden = function( elem ) {
|
|
|
6569 var width = elem.offsetWidth,
|
|
|
6570 height = elem.offsetHeight;
|
|
|
6571
|
|
|
6572 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
|
|
|
6573 };
|
|
|
6574
|
|
|
6575 jQuery.expr.filters.visible = function( elem ) {
|
|
|
6576 return !jQuery.expr.filters.hidden( elem );
|
|
|
6577 };
|
|
|
6578 }
|
|
|
6579
|
|
|
6580
|
|
|
6581
|
|
|
6582
|
|
|
6583 var r20 = /%20/g,
|
|
|
6584 rbracket = /\[\]$/,
|
|
|
6585 rCRLF = /\r?\n/g,
|
|
|
6586 rhash = /#.*$/,
|
|
|
6587 rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
|
|
|
6588 rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
|
|
|
6589 // #7653, #8125, #8152: local protocol detection
|
|
|
6590 rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|widget):$/,
|
|
|
6591 rnoContent = /^(?:GET|HEAD)$/,
|
|
|
6592 rprotocol = /^\/\//,
|
|
|
6593 rquery = /\?/,
|
|
|
6594 rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
|
|
|
6595 rselectTextarea = /^(?:select|textarea)/i,
|
|
|
6596 rspacesAjax = /\s+/,
|
|
|
6597 rts = /([?&])_=[^&]*/,
|
|
|
6598 rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
|
|
|
6599
|
|
|
6600 // Keep a copy of the old load method
|
|
|
6601 _load = jQuery.fn.load,
|
|
|
6602
|
|
|
6603 /* Prefilters
|
|
|
6604 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
|
|
|
6605 * 2) These are called:
|
|
|
6606 * - BEFORE asking for a transport
|
|
|
6607 * - AFTER param serialization (s.data is a string if s.processData is true)
|
|
|
6608 * 3) key is the dataType
|
|
|
6609 * 4) the catchall symbol "*" can be used
|
|
|
6610 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
|
|
|
6611 */
|
|
|
6612 prefilters = {},
|
|
|
6613
|
|
|
6614 /* Transports bindings
|
|
|
6615 * 1) key is the dataType
|
|
|
6616 * 2) the catchall symbol "*" can be used
|
|
|
6617 * 3) selection will start with transport dataType and THEN go to "*" if needed
|
|
|
6618 */
|
|
|
6619 transports = {},
|
|
|
6620
|
|
|
6621 // Document location
|
|
|
6622 ajaxLocation,
|
|
|
6623
|
|
|
6624 // Document location segments
|
|
|
6625 ajaxLocParts;
|
|
|
6626
|
|
|
6627 // #8138, IE may throw an exception when accessing
|
|
|
6628 // a field from window.location if document.domain has been set
|
|
|
6629 try {
|
|
|
6630 ajaxLocation = location.href;
|
|
|
6631 } catch( e ) {
|
|
|
6632 // Use the href attribute of an A element
|
|
|
6633 // since IE will modify it given document.location
|
|
|
6634 ajaxLocation = document.createElement( "a" );
|
|
|
6635 ajaxLocation.href = "";
|
|
|
6636 ajaxLocation = ajaxLocation.href;
|
|
|
6637 }
|
|
|
6638
|
|
|
6639 // Segment location into parts
|
|
|
6640 ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
|
|
|
6641
|
|
|
6642 // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
|
|
|
6643 function addToPrefiltersOrTransports( structure ) {
|
|
|
6644
|
|
|
6645 // dataTypeExpression is optional and defaults to "*"
|
|
|
6646 return function( dataTypeExpression, func ) {
|
|
|
6647
|
|
|
6648 if ( typeof dataTypeExpression !== "string" ) {
|
|
|
6649 func = dataTypeExpression;
|
|
|
6650 dataTypeExpression = "*";
|
|
|
6651 }
|
|
|
6652
|
|
|
6653 if ( jQuery.isFunction( func ) ) {
|
|
|
6654 var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
|
|
|
6655 i = 0,
|
|
|
6656 length = dataTypes.length,
|
|
|
6657 dataType,
|
|
|
6658 list,
|
|
|
6659 placeBefore;
|
|
|
6660
|
|
|
6661 // For each dataType in the dataTypeExpression
|
|
|
6662 for(; i < length; i++ ) {
|
|
|
6663 dataType = dataTypes[ i ];
|
|
|
6664 // We control if we're asked to add before
|
|
|
6665 // any existing element
|
|
|
6666 placeBefore = /^\+/.test( dataType );
|
|
|
6667 if ( placeBefore ) {
|
|
|
6668 dataType = dataType.substr( 1 ) || "*";
|
|
|
6669 }
|
|
|
6670 list = structure[ dataType ] = structure[ dataType ] || [];
|
|
|
6671 // then we add to the structure accordingly
|
|
|
6672 list[ placeBefore ? "unshift" : "push" ]( func );
|
|
|
6673 }
|
|
|
6674 }
|
|
|
6675 };
|
|
|
6676 }
|
|
|
6677
|
|
|
6678 // Base inspection function for prefilters and transports
|
|
|
6679 function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
|
|
|
6680 dataType /* internal */, inspected /* internal */ ) {
|
|
|
6681
|
|
|
6682 dataType = dataType || options.dataTypes[ 0 ];
|
|
|
6683 inspected = inspected || {};
|
|
|
6684
|
|
|
6685 inspected[ dataType ] = true;
|
|
|
6686
|
|
|
6687 var list = structure[ dataType ],
|
|
|
6688 i = 0,
|
|
|
6689 length = list ? list.length : 0,
|
|
|
6690 executeOnly = ( structure === prefilters ),
|
|
|
6691 selection;
|
|
|
6692
|
|
|
6693 for(; i < length && ( executeOnly || !selection ); i++ ) {
|
|
|
6694 selection = list[ i ]( options, originalOptions, jqXHR );
|
|
|
6695 // If we got redirected to another dataType
|
|
|
6696 // we try there if executing only and not done already
|
|
|
6697 if ( typeof selection === "string" ) {
|
|
|
6698 if ( !executeOnly || inspected[ selection ] ) {
|
|
|
6699 selection = undefined;
|
|
|
6700 } else {
|
|
|
6701 options.dataTypes.unshift( selection );
|
|
|
6702 selection = inspectPrefiltersOrTransports(
|
|
|
6703 structure, options, originalOptions, jqXHR, selection, inspected );
|
|
|
6704 }
|
|
|
6705 }
|
|
|
6706 }
|
|
|
6707 // If we're only executing or nothing was selected
|
|
|
6708 // we try the catchall dataType if not done already
|
|
|
6709 if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
|
|
|
6710 selection = inspectPrefiltersOrTransports(
|
|
|
6711 structure, options, originalOptions, jqXHR, "*", inspected );
|
|
|
6712 }
|
|
|
6713 // unnecessary when only executing (prefilters)
|
|
|
6714 // but it'll be ignored by the caller in that case
|
|
|
6715 return selection;
|
|
|
6716 }
|
|
|
6717
|
|
|
6718 jQuery.fn.extend({
|
|
|
6719 load: function( url, params, callback ) {
|
|
|
6720 if ( typeof url !== "string" && _load ) {
|
|
|
6721 return _load.apply( this, arguments );
|
|
|
6722
|
|
|
6723 // Don't do a request if no elements are being requested
|
|
|
6724 } else if ( !this.length ) {
|
|
|
6725 return this;
|
|
|
6726 }
|
|
|
6727
|
|
|
6728 var off = url.indexOf( " " );
|
|
|
6729 if ( off >= 0 ) {
|
|
|
6730 var selector = url.slice( off, url.length );
|
|
|
6731 url = url.slice( 0, off );
|
|
|
6732 }
|
|
|
6733
|
|
|
6734 // Default to a GET request
|
|
|
6735 var type = "GET";
|
|
|
6736
|
|
|
6737 // If the second parameter was provided
|
|
|
6738 if ( params ) {
|
|
|
6739 // If it's a function
|
|
|
6740 if ( jQuery.isFunction( params ) ) {
|
|
|
6741 // We assume that it's the callback
|
|
|
6742 callback = params;
|
|
|
6743 params = undefined;
|
|
|
6744
|
|
|
6745 // Otherwise, build a param string
|
|
|
6746 } else if ( typeof params === "object" ) {
|
|
|
6747 params = jQuery.param( params, jQuery.ajaxSettings.traditional );
|
|
|
6748 type = "POST";
|
|
|
6749 }
|
|
|
6750 }
|
|
|
6751
|
|
|
6752 var self = this;
|
|
|
6753
|
|
|
6754 // Request the remote document
|
|
|
6755 jQuery.ajax({
|
|
|
6756 url: url,
|
|
|
6757 type: type,
|
|
|
6758 dataType: "html",
|
|
|
6759 data: params,
|
|
|
6760 // Complete callback (responseText is used internally)
|
|
|
6761 complete: function( jqXHR, status, responseText ) {
|
|
|
6762 // Store the response as specified by the jqXHR object
|
|
|
6763 responseText = jqXHR.responseText;
|
|
|
6764 // If successful, inject the HTML into all the matched elements
|
|
|
6765 if ( jqXHR.isResolved() ) {
|
|
|
6766 // #4825: Get the actual response in case
|
|
|
6767 // a dataFilter is present in ajaxSettings
|
|
|
6768 jqXHR.done(function( r ) {
|
|
|
6769 responseText = r;
|
|
|
6770 });
|
|
|
6771 // See if a selector was specified
|
|
|
6772 self.html( selector ?
|
|
|
6773 // Create a dummy div to hold the results
|
|
|
6774 jQuery("<div>")
|
|
|
6775 // inject the contents of the document in, removing the scripts
|
|
|
6776 // to avoid any 'Permission Denied' errors in IE
|
|
|
6777 .append(responseText.replace(rscript, ""))
|
|
|
6778
|
|
|
6779 // Locate the specified elements
|
|
|
6780 .find(selector) :
|
|
|
6781
|
|
|
6782 // If not, just inject the full result
|
|
|
6783 responseText );
|
|
|
6784 }
|
|
|
6785
|
|
|
6786 if ( callback ) {
|
|
|
6787 self.each( callback, [ responseText, status, jqXHR ] );
|
|
|
6788 }
|
|
|
6789 }
|
|
|
6790 });
|
|
|
6791
|
|
|
6792 return this;
|
|
|
6793 },
|
|
|
6794
|
|
|
6795 serialize: function() {
|
|
|
6796 return jQuery.param( this.serializeArray() );
|
|
|
6797 },
|
|
|
6798
|
|
|
6799 serializeArray: function() {
|
|
|
6800 return this.map(function(){
|
|
|
6801 return this.elements ? jQuery.makeArray( this.elements ) : this;
|
|
|
6802 })
|
|
|
6803 .filter(function(){
|
|
|
6804 return this.name && !this.disabled &&
|
|
|
6805 ( this.checked || rselectTextarea.test( this.nodeName ) ||
|
|
|
6806 rinput.test( this.type ) );
|
|
|
6807 })
|
|
|
6808 .map(function( i, elem ){
|
|
|
6809 var val = jQuery( this ).val();
|
|
|
6810
|
|
|
6811 return val == null ?
|
|
|
6812 null :
|
|
|
6813 jQuery.isArray( val ) ?
|
|
|
6814 jQuery.map( val, function( val, i ){
|
|
|
6815 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
|
|
|
6816 }) :
|
|
|
6817 { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
|
|
|
6818 }).get();
|
|
|
6819 }
|
|
|
6820 });
|
|
|
6821
|
|
|
6822 // Attach a bunch of functions for handling common AJAX events
|
|
|
6823 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
|
|
|
6824 jQuery.fn[ o ] = function( f ){
|
|
|
6825 return this.bind( o, f );
|
|
|
6826 };
|
|
|
6827 });
|
|
|
6828
|
|
|
6829 jQuery.each( [ "get", "post" ], function( i, method ) {
|
|
|
6830 jQuery[ method ] = function( url, data, callback, type ) {
|
|
|
6831 // shift arguments if data argument was omitted
|
|
|
6832 if ( jQuery.isFunction( data ) ) {
|
|
|
6833 type = type || callback;
|
|
|
6834 callback = data;
|
|
|
6835 data = undefined;
|
|
|
6836 }
|
|
|
6837
|
|
|
6838 return jQuery.ajax({
|
|
|
6839 type: method,
|
|
|
6840 url: url,
|
|
|
6841 data: data,
|
|
|
6842 success: callback,
|
|
|
6843 dataType: type
|
|
|
6844 });
|
|
|
6845 };
|
|
|
6846 });
|
|
|
6847
|
|
|
6848 jQuery.extend({
|
|
|
6849
|
|
|
6850 getScript: function( url, callback ) {
|
|
|
6851 return jQuery.get( url, undefined, callback, "script" );
|
|
|
6852 },
|
|
|
6853
|
|
|
6854 getJSON: function( url, data, callback ) {
|
|
|
6855 return jQuery.get( url, data, callback, "json" );
|
|
|
6856 },
|
|
|
6857
|
|
|
6858 // Creates a full fledged settings object into target
|
|
|
6859 // with both ajaxSettings and settings fields.
|
|
|
6860 // If target is omitted, writes into ajaxSettings.
|
|
|
6861 ajaxSetup: function ( target, settings ) {
|
|
|
6862 if ( !settings ) {
|
|
|
6863 // Only one parameter, we extend ajaxSettings
|
|
|
6864 settings = target;
|
|
|
6865 target = jQuery.extend( true, jQuery.ajaxSettings, settings );
|
|
|
6866 } else {
|
|
|
6867 // target was provided, we extend into it
|
|
|
6868 jQuery.extend( true, target, jQuery.ajaxSettings, settings );
|
|
|
6869 }
|
|
|
6870 // Flatten fields we don't want deep extended
|
|
|
6871 for( var field in { context: 1, url: 1 } ) {
|
|
|
6872 if ( field in settings ) {
|
|
|
6873 target[ field ] = settings[ field ];
|
|
|
6874 } else if( field in jQuery.ajaxSettings ) {
|
|
|
6875 target[ field ] = jQuery.ajaxSettings[ field ];
|
|
|
6876 }
|
|
|
6877 }
|
|
|
6878 return target;
|
|
|
6879 },
|
|
|
6880
|
|
|
6881 ajaxSettings: {
|
|
|
6882 url: ajaxLocation,
|
|
|
6883 isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
|
|
|
6884 global: true,
|
|
|
6885 type: "GET",
|
|
|
6886 contentType: "application/x-www-form-urlencoded",
|
|
|
6887 processData: true,
|
|
|
6888 async: true,
|
|
|
6889 /*
|
|
|
6890 timeout: 0,
|
|
|
6891 data: null,
|
|
|
6892 dataType: null,
|
|
|
6893 username: null,
|
|
|
6894 password: null,
|
|
|
6895 cache: null,
|
|
|
6896 traditional: false,
|
|
|
6897 headers: {},
|
|
|
6898 */
|
|
|
6899
|
|
|
6900 accepts: {
|
|
|
6901 xml: "application/xml, text/xml",
|
|
|
6902 html: "text/html",
|
|
|
6903 text: "text/plain",
|
|
|
6904 json: "application/json, text/javascript",
|
|
|
6905 "*": "*/*"
|
|
|
6906 },
|
|
|
6907
|
|
|
6908 contents: {
|
|
|
6909 xml: /xml/,
|
|
|
6910 html: /html/,
|
|
|
6911 json: /json/
|
|
|
6912 },
|
|
|
6913
|
|
|
6914 responseFields: {
|
|
|
6915 xml: "responseXML",
|
|
|
6916 text: "responseText"
|
|
|
6917 },
|
|
|
6918
|
|
|
6919 // List of data converters
|
|
|
6920 // 1) key format is "source_type destination_type" (a single space in-between)
|
|
|
6921 // 2) the catchall symbol "*" can be used for source_type
|
|
|
6922 converters: {
|
|
|
6923
|
|
|
6924 // Convert anything to text
|
|
|
6925 "* text": window.String,
|
|
|
6926
|
|
|
6927 // Text to html (true = no transformation)
|
|
|
6928 "text html": true,
|
|
|
6929
|
|
|
6930 // Evaluate text as a json expression
|
|
|
6931 "text json": jQuery.parseJSON,
|
|
|
6932
|
|
|
6933 // Parse text as xml
|
|
|
6934 "text xml": jQuery.parseXML
|
|
|
6935 }
|
|
|
6936 },
|
|
|
6937
|
|
|
6938 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
|
|
|
6939 ajaxTransport: addToPrefiltersOrTransports( transports ),
|
|
|
6940
|
|
|
6941 // Main method
|
|
|
6942 ajax: function( url, options ) {
|
|
|
6943
|
|
|
6944 // If url is an object, simulate pre-1.5 signature
|
|
|
6945 if ( typeof url === "object" ) {
|
|
|
6946 options = url;
|
|
|
6947 url = undefined;
|
|
|
6948 }
|
|
|
6949
|
|
|
6950 // Force options to be an object
|
|
|
6951 options = options || {};
|
|
|
6952
|
|
|
6953 var // Create the final options object
|
|
|
6954 s = jQuery.ajaxSetup( {}, options ),
|
|
|
6955 // Callbacks context
|
|
|
6956 callbackContext = s.context || s,
|
|
|
6957 // Context for global events
|
|
|
6958 // It's the callbackContext if one was provided in the options
|
|
|
6959 // and if it's a DOM node or a jQuery collection
|
|
|
6960 globalEventContext = callbackContext !== s &&
|
|
|
6961 ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
|
|
|
6962 jQuery( callbackContext ) : jQuery.event,
|
|
|
6963 // Deferreds
|
|
|
6964 deferred = jQuery.Deferred(),
|
|
|
6965 completeDeferred = jQuery._Deferred(),
|
|
|
6966 // Status-dependent callbacks
|
|
|
6967 statusCode = s.statusCode || {},
|
|
|
6968 // ifModified key
|
|
|
6969 ifModifiedKey,
|
|
|
6970 // Headers (they are sent all at once)
|
|
|
6971 requestHeaders = {},
|
|
|
6972 requestHeadersNames = {},
|
|
|
6973 // Response headers
|
|
|
6974 responseHeadersString,
|
|
|
6975 responseHeaders,
|
|
|
6976 // transport
|
|
|
6977 transport,
|
|
|
6978 // timeout handle
|
|
|
6979 timeoutTimer,
|
|
|
6980 // Cross-domain detection vars
|
|
|
6981 parts,
|
|
|
6982 // The jqXHR state
|
|
|
6983 state = 0,
|
|
|
6984 // To know if global events are to be dispatched
|
|
|
6985 fireGlobals,
|
|
|
6986 // Loop variable
|
|
|
6987 i,
|
|
|
6988 // Fake xhr
|
|
|
6989 jqXHR = {
|
|
|
6990
|
|
|
6991 readyState: 0,
|
|
|
6992
|
|
|
6993 // Caches the header
|
|
|
6994 setRequestHeader: function( name, value ) {
|
|
|
6995 if ( !state ) {
|
|
|
6996 var lname = name.toLowerCase();
|
|
|
6997 name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
|
|
|
6998 requestHeaders[ name ] = value;
|
|
|
6999 }
|
|
|
7000 return this;
|
|
|
7001 },
|
|
|
7002
|
|
|
7003 // Raw string
|
|
|
7004 getAllResponseHeaders: function() {
|
|
|
7005 return state === 2 ? responseHeadersString : null;
|
|
|
7006 },
|
|
|
7007
|
|
|
7008 // Builds headers hashtable if needed
|
|
|
7009 getResponseHeader: function( key ) {
|
|
|
7010 var match;
|
|
|
7011 if ( state === 2 ) {
|
|
|
7012 if ( !responseHeaders ) {
|
|
|
7013 responseHeaders = {};
|
|
|
7014 while( ( match = rheaders.exec( responseHeadersString ) ) ) {
|
|
|
7015 responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
|
|
|
7016 }
|
|
|
7017 }
|
|
|
7018 match = responseHeaders[ key.toLowerCase() ];
|
|
|
7019 }
|
|
|
7020 return match === undefined ? null : match;
|
|
|
7021 },
|
|
|
7022
|
|
|
7023 // Overrides response content-type header
|
|
|
7024 overrideMimeType: function( type ) {
|
|
|
7025 if ( !state ) {
|
|
|
7026 s.mimeType = type;
|
|
|
7027 }
|
|
|
7028 return this;
|
|
|
7029 },
|
|
|
7030
|
|
|
7031 // Cancel the request
|
|
|
7032 abort: function( statusText ) {
|
|
|
7033 statusText = statusText || "abort";
|
|
|
7034 if ( transport ) {
|
|
|
7035 transport.abort( statusText );
|
|
|
7036 }
|
|
|
7037 done( 0, statusText );
|
|
|
7038 return this;
|
|
|
7039 }
|
|
|
7040 };
|
|
|
7041
|
|
|
7042 // Callback for when everything is done
|
|
|
7043 // It is defined here because jslint complains if it is declared
|
|
|
7044 // at the end of the function (which would be more logical and readable)
|
|
|
7045 function done( status, statusText, responses, headers ) {
|
|
|
7046
|
|
|
7047 // Called once
|
|
|
7048 if ( state === 2 ) {
|
|
|
7049 return;
|
|
|
7050 }
|
|
|
7051
|
|
|
7052 // State is "done" now
|
|
|
7053 state = 2;
|
|
|
7054
|
|
|
7055 // Clear timeout if it exists
|
|
|
7056 if ( timeoutTimer ) {
|
|
|
7057 clearTimeout( timeoutTimer );
|
|
|
7058 }
|
|
|
7059
|
|
|
7060 // Dereference transport for early garbage collection
|
|
|
7061 // (no matter how long the jqXHR object will be used)
|
|
|
7062 transport = undefined;
|
|
|
7063
|
|
|
7064 // Cache response headers
|
|
|
7065 responseHeadersString = headers || "";
|
|
|
7066
|
|
|
7067 // Set readyState
|
|
|
7068 jqXHR.readyState = status ? 4 : 0;
|
|
|
7069
|
|
|
7070 var isSuccess,
|
|
|
7071 success,
|
|
|
7072 error,
|
|
|
7073 response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
|
|
|
7074 lastModified,
|
|
|
7075 etag;
|
|
|
7076
|
|
|
7077 // If successful, handle type chaining
|
|
|
7078 if ( status >= 200 && status < 300 || status === 304 ) {
|
|
|
7079
|
|
|
7080 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
|
|
7081 if ( s.ifModified ) {
|
|
|
7082
|
|
|
7083 if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
|
|
|
7084 jQuery.lastModified[ ifModifiedKey ] = lastModified;
|
|
|
7085 }
|
|
|
7086 if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
|
|
|
7087 jQuery.etag[ ifModifiedKey ] = etag;
|
|
|
7088 }
|
|
|
7089 }
|
|
|
7090
|
|
|
7091 // If not modified
|
|
|
7092 if ( status === 304 ) {
|
|
|
7093
|
|
|
7094 statusText = "notmodified";
|
|
|
7095 isSuccess = true;
|
|
|
7096
|
|
|
7097 // If we have data
|
|
|
7098 } else {
|
|
|
7099
|
|
|
7100 try {
|
|
|
7101 success = ajaxConvert( s, response );
|
|
|
7102 statusText = "success";
|
|
|
7103 isSuccess = true;
|
|
|
7104 } catch(e) {
|
|
|
7105 // We have a parsererror
|
|
|
7106 statusText = "parsererror";
|
|
|
7107 error = e;
|
|
|
7108 }
|
|
|
7109 }
|
|
|
7110 } else {
|
|
|
7111 // We extract error from statusText
|
|
|
7112 // then normalize statusText and status for non-aborts
|
|
|
7113 error = statusText;
|
|
|
7114 if( !statusText || status ) {
|
|
|
7115 statusText = "error";
|
|
|
7116 if ( status < 0 ) {
|
|
|
7117 status = 0;
|
|
|
7118 }
|
|
|
7119 }
|
|
|
7120 }
|
|
|
7121
|
|
|
7122 // Set data for the fake xhr object
|
|
|
7123 jqXHR.status = status;
|
|
|
7124 jqXHR.statusText = statusText;
|
|
|
7125
|
|
|
7126 // Success/Error
|
|
|
7127 if ( isSuccess ) {
|
|
|
7128 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
|
|
|
7129 } else {
|
|
|
7130 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
|
|
|
7131 }
|
|
|
7132
|
|
|
7133 // Status-dependent callbacks
|
|
|
7134 jqXHR.statusCode( statusCode );
|
|
|
7135 statusCode = undefined;
|
|
|
7136
|
|
|
7137 if ( fireGlobals ) {
|
|
|
7138 globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
|
|
|
7139 [ jqXHR, s, isSuccess ? success : error ] );
|
|
|
7140 }
|
|
|
7141
|
|
|
7142 // Complete
|
|
|
7143 completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
|
|
|
7144
|
|
|
7145 if ( fireGlobals ) {
|
|
|
7146 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s] );
|
|
|
7147 // Handle the global AJAX counter
|
|
|
7148 if ( !( --jQuery.active ) ) {
|
|
|
7149 jQuery.event.trigger( "ajaxStop" );
|
|
|
7150 }
|
|
|
7151 }
|
|
|
7152 }
|
|
|
7153
|
|
|
7154 // Attach deferreds
|
|
|
7155 deferred.promise( jqXHR );
|
|
|
7156 jqXHR.success = jqXHR.done;
|
|
|
7157 jqXHR.error = jqXHR.fail;
|
|
|
7158 jqXHR.complete = completeDeferred.done;
|
|
|
7159
|
|
|
7160 // Status-dependent callbacks
|
|
|
7161 jqXHR.statusCode = function( map ) {
|
|
|
7162 if ( map ) {
|
|
|
7163 var tmp;
|
|
|
7164 if ( state < 2 ) {
|
|
|
7165 for( tmp in map ) {
|
|
|
7166 statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
|
|
|
7167 }
|
|
|
7168 } else {
|
|
|
7169 tmp = map[ jqXHR.status ];
|
|
|
7170 jqXHR.then( tmp, tmp );
|
|
|
7171 }
|
|
|
7172 }
|
|
|
7173 return this;
|
|
|
7174 };
|
|
|
7175
|
|
|
7176 // Remove hash character (#7531: and string promotion)
|
|
|
7177 // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
|
|
|
7178 // We also use the url parameter if available
|
|
|
7179 s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
|
|
|
7180
|
|
|
7181 // Extract dataTypes list
|
|
|
7182 s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
|
|
|
7183
|
|
|
7184 // Determine if a cross-domain request is in order
|
|
|
7185 if ( s.crossDomain == null ) {
|
|
|
7186 parts = rurl.exec( s.url.toLowerCase() );
|
|
|
7187 s.crossDomain = !!( parts &&
|
|
|
7188 ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
|
|
|
7189 ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
|
|
|
7190 ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
|
|
|
7191 );
|
|
|
7192 }
|
|
|
7193
|
|
|
7194 // Convert data if not already a string
|
|
|
7195 if ( s.data && s.processData && typeof s.data !== "string" ) {
|
|
|
7196 s.data = jQuery.param( s.data, s.traditional );
|
|
|
7197 }
|
|
|
7198
|
|
|
7199 // Apply prefilters
|
|
|
7200 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
|
|
|
7201
|
|
|
7202 // If request was aborted inside a prefiler, stop there
|
|
|
7203 if ( state === 2 ) {
|
|
|
7204 return false;
|
|
|
7205 }
|
|
|
7206
|
|
|
7207 // We can fire global events as of now if asked to
|
|
|
7208 fireGlobals = s.global;
|
|
|
7209
|
|
|
7210 // Uppercase the type
|
|
|
7211 s.type = s.type.toUpperCase();
|
|
|
7212
|
|
|
7213 // Determine if request has content
|
|
|
7214 s.hasContent = !rnoContent.test( s.type );
|
|
|
7215
|
|
|
7216 // Watch for a new set of requests
|
|
|
7217 if ( fireGlobals && jQuery.active++ === 0 ) {
|
|
|
7218 jQuery.event.trigger( "ajaxStart" );
|
|
|
7219 }
|
|
|
7220
|
|
|
7221 // More options handling for requests with no content
|
|
|
7222 if ( !s.hasContent ) {
|
|
|
7223
|
|
|
7224 // If data is available, append data to url
|
|
|
7225 if ( s.data ) {
|
|
|
7226 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
|
|
|
7227 }
|
|
|
7228
|
|
|
7229 // Get ifModifiedKey before adding the anti-cache parameter
|
|
|
7230 ifModifiedKey = s.url;
|
|
|
7231
|
|
|
7232 // Add anti-cache in url if needed
|
|
|
7233 if ( s.cache === false ) {
|
|
|
7234
|
|
|
7235 var ts = jQuery.now(),
|
|
|
7236 // try replacing _= if it is there
|
|
|
7237 ret = s.url.replace( rts, "$1_=" + ts );
|
|
|
7238
|
|
|
7239 // if nothing was replaced, add timestamp to the end
|
|
|
7240 s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
|
|
|
7241 }
|
|
|
7242 }
|
|
|
7243
|
|
|
7244 // Set the correct header, if data is being sent
|
|
|
7245 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
|
|
|
7246 jqXHR.setRequestHeader( "Content-Type", s.contentType );
|
|
|
7247 }
|
|
|
7248
|
|
|
7249 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
|
|
7250 if ( s.ifModified ) {
|
|
|
7251 ifModifiedKey = ifModifiedKey || s.url;
|
|
|
7252 if ( jQuery.lastModified[ ifModifiedKey ] ) {
|
|
|
7253 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
|
|
|
7254 }
|
|
|
7255 if ( jQuery.etag[ ifModifiedKey ] ) {
|
|
|
7256 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
|
|
|
7257 }
|
|
|
7258 }
|
|
|
7259
|
|
|
7260 // Set the Accepts header for the server, depending on the dataType
|
|
|
7261 jqXHR.setRequestHeader(
|
|
|
7262 "Accept",
|
|
|
7263 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
|
|
|
7264 s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) :
|
|
|
7265 s.accepts[ "*" ]
|
|
|
7266 );
|
|
|
7267
|
|
|
7268 // Check for headers option
|
|
|
7269 for ( i in s.headers ) {
|
|
|
7270 jqXHR.setRequestHeader( i, s.headers[ i ] );
|
|
|
7271 }
|
|
|
7272
|
|
|
7273 // Allow custom headers/mimetypes and early abort
|
|
|
7274 if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
|
|
|
7275 // Abort if not done already
|
|
|
7276 jqXHR.abort();
|
|
|
7277 return false;
|
|
|
7278
|
|
|
7279 }
|
|
|
7280
|
|
|
7281 // Install callbacks on deferreds
|
|
|
7282 for ( i in { success: 1, error: 1, complete: 1 } ) {
|
|
|
7283 jqXHR[ i ]( s[ i ] );
|
|
|
7284 }
|
|
|
7285
|
|
|
7286 // Get transport
|
|
|
7287 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
|
|
|
7288
|
|
|
7289 // If no transport, we auto-abort
|
|
|
7290 if ( !transport ) {
|
|
|
7291 done( -1, "No Transport" );
|
|
|
7292 } else {
|
|
|
7293 jqXHR.readyState = 1;
|
|
|
7294 // Send global event
|
|
|
7295 if ( fireGlobals ) {
|
|
|
7296 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
|
|
|
7297 }
|
|
|
7298 // Timeout
|
|
|
7299 if ( s.async && s.timeout > 0 ) {
|
|
|
7300 timeoutTimer = setTimeout( function(){
|
|
|
7301 jqXHR.abort( "timeout" );
|
|
|
7302 }, s.timeout );
|
|
|
7303 }
|
|
|
7304
|
|
|
7305 try {
|
|
|
7306 state = 1;
|
|
|
7307 transport.send( requestHeaders, done );
|
|
|
7308 } catch (e) {
|
|
|
7309 // Propagate exception as error if not done
|
|
|
7310 if ( status < 2 ) {
|
|
|
7311 done( -1, e );
|
|
|
7312 // Simply rethrow otherwise
|
|
|
7313 } else {
|
|
|
7314 jQuery.error( e );
|
|
|
7315 }
|
|
|
7316 }
|
|
|
7317 }
|
|
|
7318
|
|
|
7319 return jqXHR;
|
|
|
7320 },
|
|
|
7321
|
|
|
7322 // Serialize an array of form elements or a set of
|
|
|
7323 // key/values into a query string
|
|
|
7324 param: function( a, traditional ) {
|
|
|
7325 var s = [],
|
|
|
7326 add = function( key, value ) {
|
|
|
7327 // If value is a function, invoke it and return its value
|
|
|
7328 value = jQuery.isFunction( value ) ? value() : value;
|
|
|
7329 s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
|
|
|
7330 };
|
|
|
7331
|
|
|
7332 // Set traditional to true for jQuery <= 1.3.2 behavior.
|
|
|
7333 if ( traditional === undefined ) {
|
|
|
7334 traditional = jQuery.ajaxSettings.traditional;
|
|
|
7335 }
|
|
|
7336
|
|
|
7337 // If an array was passed in, assume that it is an array of form elements.
|
|
|
7338 if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
|
|
|
7339 // Serialize the form elements
|
|
|
7340 jQuery.each( a, function() {
|
|
|
7341 add( this.name, this.value );
|
|
|
7342 });
|
|
|
7343
|
|
|
7344 } else {
|
|
|
7345 // If traditional, encode the "old" way (the way 1.3.2 or older
|
|
|
7346 // did it), otherwise encode params recursively.
|
|
|
7347 for ( var prefix in a ) {
|
|
|
7348 buildParams( prefix, a[ prefix ], traditional, add );
|
|
|
7349 }
|
|
|
7350 }
|
|
|
7351
|
|
|
7352 // Return the resulting serialization
|
|
|
7353 return s.join( "&" ).replace( r20, "+" );
|
|
|
7354 }
|
|
|
7355 });
|
|
|
7356
|
|
|
7357 function buildParams( prefix, obj, traditional, add ) {
|
|
|
7358 if ( jQuery.isArray( obj ) ) {
|
|
|
7359 // Serialize array item.
|
|
|
7360 jQuery.each( obj, function( i, v ) {
|
|
|
7361 if ( traditional || rbracket.test( prefix ) ) {
|
|
|
7362 // Treat each array item as a scalar.
|
|
|
7363 add( prefix, v );
|
|
|
7364
|
|
|
7365 } else {
|
|
|
7366 // If array item is non-scalar (array or object), encode its
|
|
|
7367 // numeric index to resolve deserialization ambiguity issues.
|
|
|
7368 // Note that rack (as of 1.0.0) can't currently deserialize
|
|
|
7369 // nested arrays properly, and attempting to do so may cause
|
|
|
7370 // a server error. Possible fixes are to modify rack's
|
|
|
7371 // deserialization algorithm or to provide an option or flag
|
|
|
7372 // to force array serialization to be shallow.
|
|
|
7373 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
|
|
|
7374 }
|
|
|
7375 });
|
|
|
7376
|
|
|
7377 } else if ( !traditional && obj != null && typeof obj === "object" ) {
|
|
|
7378 // Serialize object item.
|
|
|
7379 for ( var name in obj ) {
|
|
|
7380 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
|
|
|
7381 }
|
|
|
7382
|
|
|
7383 } else {
|
|
|
7384 // Serialize scalar item.
|
|
|
7385 add( prefix, obj );
|
|
|
7386 }
|
|
|
7387 }
|
|
|
7388
|
|
|
7389 // This is still on the jQuery object... for now
|
|
|
7390 // Want to move this to jQuery.ajax some day
|
|
|
7391 jQuery.extend({
|
|
|
7392
|
|
|
7393 // Counter for holding the number of active queries
|
|
|
7394 active: 0,
|
|
|
7395
|
|
|
7396 // Last-Modified header cache for next request
|
|
|
7397 lastModified: {},
|
|
|
7398 etag: {}
|
|
|
7399
|
|
|
7400 });
|
|
|
7401
|
|
|
7402 /* Handles responses to an ajax request:
|
|
|
7403 * - sets all responseXXX fields accordingly
|
|
|
7404 * - finds the right dataType (mediates between content-type and expected dataType)
|
|
|
7405 * - returns the corresponding response
|
|
|
7406 */
|
|
|
7407 function ajaxHandleResponses( s, jqXHR, responses ) {
|
|
|
7408
|
|
|
7409 var contents = s.contents,
|
|
|
7410 dataTypes = s.dataTypes,
|
|
|
7411 responseFields = s.responseFields,
|
|
|
7412 ct,
|
|
|
7413 type,
|
|
|
7414 finalDataType,
|
|
|
7415 firstDataType;
|
|
|
7416
|
|
|
7417 // Fill responseXXX fields
|
|
|
7418 for( type in responseFields ) {
|
|
|
7419 if ( type in responses ) {
|
|
|
7420 jqXHR[ responseFields[type] ] = responses[ type ];
|
|
|
7421 }
|
|
|
7422 }
|
|
|
7423
|
|
|
7424 // Remove auto dataType and get content-type in the process
|
|
|
7425 while( dataTypes[ 0 ] === "*" ) {
|
|
|
7426 dataTypes.shift();
|
|
|
7427 if ( ct === undefined ) {
|
|
|
7428 ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
|
|
|
7429 }
|
|
|
7430 }
|
|
|
7431
|
|
|
7432 // Check if we're dealing with a known content-type
|
|
|
7433 if ( ct ) {
|
|
|
7434 for ( type in contents ) {
|
|
|
7435 if ( contents[ type ] && contents[ type ].test( ct ) ) {
|
|
|
7436 dataTypes.unshift( type );
|
|
|
7437 break;
|
|
|
7438 }
|
|
|
7439 }
|
|
|
7440 }
|
|
|
7441
|
|
|
7442 // Check to see if we have a response for the expected dataType
|
|
|
7443 if ( dataTypes[ 0 ] in responses ) {
|
|
|
7444 finalDataType = dataTypes[ 0 ];
|
|
|
7445 } else {
|
|
|
7446 // Try convertible dataTypes
|
|
|
7447 for ( type in responses ) {
|
|
|
7448 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
|
|
|
7449 finalDataType = type;
|
|
|
7450 break;
|
|
|
7451 }
|
|
|
7452 if ( !firstDataType ) {
|
|
|
7453 firstDataType = type;
|
|
|
7454 }
|
|
|
7455 }
|
|
|
7456 // Or just use first one
|
|
|
7457 finalDataType = finalDataType || firstDataType;
|
|
|
7458 }
|
|
|
7459
|
|
|
7460 // If we found a dataType
|
|
|
7461 // We add the dataType to the list if needed
|
|
|
7462 // and return the corresponding response
|
|
|
7463 if ( finalDataType ) {
|
|
|
7464 if ( finalDataType !== dataTypes[ 0 ] ) {
|
|
|
7465 dataTypes.unshift( finalDataType );
|
|
|
7466 }
|
|
|
7467 return responses[ finalDataType ];
|
|
|
7468 }
|
|
|
7469 }
|
|
|
7470
|
|
|
7471 // Chain conversions given the request and the original response
|
|
|
7472 function ajaxConvert( s, response ) {
|
|
|
7473
|
|
|
7474 // Apply the dataFilter if provided
|
|
|
7475 if ( s.dataFilter ) {
|
|
|
7476 response = s.dataFilter( response, s.dataType );
|
|
|
7477 }
|
|
|
7478
|
|
|
7479 var dataTypes = s.dataTypes,
|
|
|
7480 converters = {},
|
|
|
7481 i,
|
|
|
7482 key,
|
|
|
7483 length = dataTypes.length,
|
|
|
7484 tmp,
|
|
|
7485 // Current and previous dataTypes
|
|
|
7486 current = dataTypes[ 0 ],
|
|
|
7487 prev,
|
|
|
7488 // Conversion expression
|
|
|
7489 conversion,
|
|
|
7490 // Conversion function
|
|
|
7491 conv,
|
|
|
7492 // Conversion functions (transitive conversion)
|
|
|
7493 conv1,
|
|
|
7494 conv2;
|
|
|
7495
|
|
|
7496 // For each dataType in the chain
|
|
|
7497 for( i = 1; i < length; i++ ) {
|
|
|
7498
|
|
|
7499 // Create converters map
|
|
|
7500 // with lowercased keys
|
|
|
7501 if ( i === 1 ) {
|
|
|
7502 for( key in s.converters ) {
|
|
|
7503 if( typeof key === "string" ) {
|
|
|
7504 converters[ key.toLowerCase() ] = s.converters[ key ];
|
|
|
7505 }
|
|
|
7506 }
|
|
|
7507 }
|
|
|
7508
|
|
|
7509 // Get the dataTypes
|
|
|
7510 prev = current;
|
|
|
7511 current = dataTypes[ i ];
|
|
|
7512
|
|
|
7513 // If current is auto dataType, update it to prev
|
|
|
7514 if( current === "*" ) {
|
|
|
7515 current = prev;
|
|
|
7516 // If no auto and dataTypes are actually different
|
|
|
7517 } else if ( prev !== "*" && prev !== current ) {
|
|
|
7518
|
|
|
7519 // Get the converter
|
|
|
7520 conversion = prev + " " + current;
|
|
|
7521 conv = converters[ conversion ] || converters[ "* " + current ];
|
|
|
7522
|
|
|
7523 // If there is no direct converter, search transitively
|
|
|
7524 if ( !conv ) {
|
|
|
7525 conv2 = undefined;
|
|
|
7526 for( conv1 in converters ) {
|
|
|
7527 tmp = conv1.split( " " );
|
|
|
7528 if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
|
|
|
7529 conv2 = converters[ tmp[1] + " " + current ];
|
|
|
7530 if ( conv2 ) {
|
|
|
7531 conv1 = converters[ conv1 ];
|
|
|
7532 if ( conv1 === true ) {
|
|
|
7533 conv = conv2;
|
|
|
7534 } else if ( conv2 === true ) {
|
|
|
7535 conv = conv1;
|
|
|
7536 }
|
|
|
7537 break;
|
|
|
7538 }
|
|
|
7539 }
|
|
|
7540 }
|
|
|
7541 }
|
|
|
7542 // If we found no converter, dispatch an error
|
|
|
7543 if ( !( conv || conv2 ) ) {
|
|
|
7544 jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
|
|
|
7545 }
|
|
|
7546 // If found converter is not an equivalence
|
|
|
7547 if ( conv !== true ) {
|
|
|
7548 // Convert with 1 or 2 converters accordingly
|
|
|
7549 response = conv ? conv( response ) : conv2( conv1(response) );
|
|
|
7550 }
|
|
|
7551 }
|
|
|
7552 }
|
|
|
7553 return response;
|
|
|
7554 }
|
|
|
7555
|
|
|
7556
|
|
|
7557
|
|
|
7558
|
|
|
7559 var jsc = jQuery.now(),
|
|
|
7560 jsre = /(\=)\?(&|$)|\?\?/i;
|
|
|
7561
|
|
|
7562 // Default jsonp settings
|
|
|
7563 jQuery.ajaxSetup({
|
|
|
7564 jsonp: "callback",
|
|
|
7565 jsonpCallback: function() {
|
|
|
7566 return jQuery.expando + "_" + ( jsc++ );
|
|
|
7567 }
|
|
|
7568 });
|
|
|
7569
|
|
|
7570 // Detect, normalize options and install callbacks for jsonp requests
|
|
|
7571 jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
|
|
|
7572
|
|
|
7573 var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
|
|
|
7574 ( typeof s.data === "string" );
|
|
|
7575
|
|
|
7576 if ( s.dataTypes[ 0 ] === "jsonp" ||
|
|
|
7577 s.jsonp !== false && ( jsre.test( s.url ) ||
|
|
|
7578 inspectData && jsre.test( s.data ) ) ) {
|
|
|
7579
|
|
|
7580 var responseContainer,
|
|
|
7581 jsonpCallback = s.jsonpCallback =
|
|
|
7582 jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
|
|
|
7583 previous = window[ jsonpCallback ],
|
|
|
7584 url = s.url,
|
|
|
7585 data = s.data,
|
|
|
7586 replace = "$1" + jsonpCallback + "$2";
|
|
|
7587
|
|
|
7588 if ( s.jsonp !== false ) {
|
|
|
7589 url = url.replace( jsre, replace );
|
|
|
7590 if ( s.url === url ) {
|
|
|
7591 if ( inspectData ) {
|
|
|
7592 data = data.replace( jsre, replace );
|
|
|
7593 }
|
|
|
7594 if ( s.data === data ) {
|
|
|
7595 // Add callback manually
|
|
|
7596 url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
|
|
|
7597 }
|
|
|
7598 }
|
|
|
7599 }
|
|
|
7600
|
|
|
7601 s.url = url;
|
|
|
7602 s.data = data;
|
|
|
7603
|
|
|
7604 // Install callback
|
|
|
7605 window[ jsonpCallback ] = function( response ) {
|
|
|
7606 responseContainer = [ response ];
|
|
|
7607 };
|
|
|
7608
|
|
|
7609 // Clean-up function
|
|
|
7610 jqXHR.always(function() {
|
|
|
7611 // Set callback back to previous value
|
|
|
7612 window[ jsonpCallback ] = previous;
|
|
|
7613 // Call if it was a function and we have a response
|
|
|
7614 if ( responseContainer && jQuery.isFunction( previous ) ) {
|
|
|
7615 window[ jsonpCallback ]( responseContainer[ 0 ] );
|
|
|
7616 }
|
|
|
7617 });
|
|
|
7618
|
|
|
7619 // Use data converter to retrieve json after script execution
|
|
|
7620 s.converters["script json"] = function() {
|
|
|
7621 if ( !responseContainer ) {
|
|
|
7622 jQuery.error( jsonpCallback + " was not called" );
|
|
|
7623 }
|
|
|
7624 return responseContainer[ 0 ];
|
|
|
7625 };
|
|
|
7626
|
|
|
7627 // force json dataType
|
|
|
7628 s.dataTypes[ 0 ] = "json";
|
|
|
7629
|
|
|
7630 // Delegate to script
|
|
|
7631 return "script";
|
|
|
7632 }
|
|
|
7633 });
|
|
|
7634
|
|
|
7635
|
|
|
7636
|
|
|
7637
|
|
|
7638 // Install script dataType
|
|
|
7639 jQuery.ajaxSetup({
|
|
|
7640 accepts: {
|
|
|
7641 script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
|
|
|
7642 },
|
|
|
7643 contents: {
|
|
|
7644 script: /javascript|ecmascript/
|
|
|
7645 },
|
|
|
7646 converters: {
|
|
|
7647 "text script": function( text ) {
|
|
|
7648 jQuery.globalEval( text );
|
|
|
7649 return text;
|
|
|
7650 }
|
|
|
7651 }
|
|
|
7652 });
|
|
|
7653
|
|
|
7654 // Handle cache's special case and global
|
|
|
7655 jQuery.ajaxPrefilter( "script", function( s ) {
|
|
|
7656 if ( s.cache === undefined ) {
|
|
|
7657 s.cache = false;
|
|
|
7658 }
|
|
|
7659 if ( s.crossDomain ) {
|
|
|
7660 s.type = "GET";
|
|
|
7661 s.global = false;
|
|
|
7662 }
|
|
|
7663 });
|
|
|
7664
|
|
|
7665 // Bind script tag hack transport
|
|
|
7666 jQuery.ajaxTransport( "script", function(s) {
|
|
|
7667
|
|
|
7668 // This transport only deals with cross domain requests
|
|
|
7669 if ( s.crossDomain ) {
|
|
|
7670
|
|
|
7671 var script,
|
|
|
7672 head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
|
|
|
7673
|
|
|
7674 return {
|
|
|
7675
|
|
|
7676 send: function( _, callback ) {
|
|
|
7677
|
|
|
7678 script = document.createElement( "script" );
|
|
|
7679
|
|
|
7680 script.async = "async";
|
|
|
7681
|
|
|
7682 if ( s.scriptCharset ) {
|
|
|
7683 script.charset = s.scriptCharset;
|
|
|
7684 }
|
|
|
7685
|
|
|
7686 script.src = s.url;
|
|
|
7687
|
|
|
7688 // Attach handlers for all browsers
|
|
|
7689 script.onload = script.onreadystatechange = function( _, isAbort ) {
|
|
|
7690
|
|
|
7691 if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
|
|
|
7692
|
|
|
7693 // Handle memory leak in IE
|
|
|
7694 script.onload = script.onreadystatechange = null;
|
|
|
7695
|
|
|
7696 // Remove the script
|
|
|
7697 if ( head && script.parentNode ) {
|
|
|
7698 head.removeChild( script );
|
|
|
7699 }
|
|
|
7700
|
|
|
7701 // Dereference the script
|
|
|
7702 script = undefined;
|
|
|
7703
|
|
|
7704 // Callback if not abort
|
|
|
7705 if ( !isAbort ) {
|
|
|
7706 callback( 200, "success" );
|
|
|
7707 }
|
|
|
7708 }
|
|
|
7709 };
|
|
|
7710 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
|
|
|
7711 // This arises when a base node is used (#2709 and #4378).
|
|
|
7712 head.insertBefore( script, head.firstChild );
|
|
|
7713 },
|
|
|
7714
|
|
|
7715 abort: function() {
|
|
|
7716 if ( script ) {
|
|
|
7717 script.onload( 0, 1 );
|
|
|
7718 }
|
|
|
7719 }
|
|
|
7720 };
|
|
|
7721 }
|
|
|
7722 });
|
|
|
7723
|
|
|
7724
|
|
|
7725
|
|
|
7726
|
|
|
7727 var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
|
|
|
7728 xhrOnUnloadAbort = window.ActiveXObject ? function() {
|
|
|
7729 // Abort all pending requests
|
|
|
7730 for ( var key in xhrCallbacks ) {
|
|
|
7731 xhrCallbacks[ key ]( 0, 1 );
|
|
|
7732 }
|
|
|
7733 } : false,
|
|
|
7734 xhrId = 0,
|
|
|
7735 xhrCallbacks;
|
|
|
7736
|
|
|
7737 // Functions to create xhrs
|
|
|
7738 function createStandardXHR() {
|
|
|
7739 try {
|
|
|
7740 return new window.XMLHttpRequest();
|
|
|
7741 } catch( e ) {}
|
|
|
7742 }
|
|
|
7743
|
|
|
7744 function createActiveXHR() {
|
|
|
7745 try {
|
|
|
7746 return new window.ActiveXObject( "Microsoft.XMLHTTP" );
|
|
|
7747 } catch( e ) {}
|
|
|
7748 }
|
|
|
7749
|
|
|
7750 // Create the request object
|
|
|
7751 // (This is still attached to ajaxSettings for backward compatibility)
|
|
|
7752 jQuery.ajaxSettings.xhr = window.ActiveXObject ?
|
|
|
7753 /* Microsoft failed to properly
|
|
|
7754 * implement the XMLHttpRequest in IE7 (can't request local files),
|
|
|
7755 * so we use the ActiveXObject when it is available
|
|
|
7756 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
|
|
|
7757 * we need a fallback.
|
|
|
7758 */
|
|
|
7759 function() {
|
|
|
7760 return !this.isLocal && createStandardXHR() || createActiveXHR();
|
|
|
7761 } :
|
|
|
7762 // For all other browsers, use the standard XMLHttpRequest object
|
|
|
7763 createStandardXHR;
|
|
|
7764
|
|
|
7765 // Determine support properties
|
|
|
7766 (function( xhr ) {
|
|
|
7767 jQuery.extend( jQuery.support, {
|
|
|
7768 ajax: !!xhr,
|
|
|
7769 cors: !!xhr && ( "withCredentials" in xhr )
|
|
|
7770 });
|
|
|
7771 })( jQuery.ajaxSettings.xhr() );
|
|
|
7772
|
|
|
7773 // Create transport if the browser can provide an xhr
|
|
|
7774 if ( jQuery.support.ajax ) {
|
|
|
7775
|
|
|
7776 jQuery.ajaxTransport(function( s ) {
|
|
|
7777 // Cross domain only allowed if supported through XMLHttpRequest
|
|
|
7778 if ( !s.crossDomain || jQuery.support.cors ) {
|
|
|
7779
|
|
|
7780 var callback;
|
|
|
7781
|
|
|
7782 return {
|
|
|
7783 send: function( headers, complete ) {
|
|
|
7784
|
|
|
7785 // Get a new xhr
|
|
|
7786 var xhr = s.xhr(),
|
|
|
7787 handle,
|
|
|
7788 i;
|
|
|
7789
|
|
|
7790 // Open the socket
|
|
|
7791 // Passing null username, generates a login popup on Opera (#2865)
|
|
|
7792 if ( s.username ) {
|
|
|
7793 xhr.open( s.type, s.url, s.async, s.username, s.password );
|
|
|
7794 } else {
|
|
|
7795 xhr.open( s.type, s.url, s.async );
|
|
|
7796 }
|
|
|
7797
|
|
|
7798 // Apply custom fields if provided
|
|
|
7799 if ( s.xhrFields ) {
|
|
|
7800 for ( i in s.xhrFields ) {
|
|
|
7801 xhr[ i ] = s.xhrFields[ i ];
|
|
|
7802 }
|
|
|
7803 }
|
|
|
7804
|
|
|
7805 // Override mime type if needed
|
|
|
7806 if ( s.mimeType && xhr.overrideMimeType ) {
|
|
|
7807 xhr.overrideMimeType( s.mimeType );
|
|
|
7808 }
|
|
|
7809
|
|
|
7810 // X-Requested-With header
|
|
|
7811 // For cross-domain requests, seeing as conditions for a preflight are
|
|
|
7812 // akin to a jigsaw puzzle, we simply never set it to be sure.
|
|
|
7813 // (it can always be set on a per-request basis or even using ajaxSetup)
|
|
|
7814 // For same-domain requests, won't change header if already provided.
|
|
|
7815 if ( !s.crossDomain && !headers["X-Requested-With"] ) {
|
|
|
7816 headers[ "X-Requested-With" ] = "XMLHttpRequest";
|
|
|
7817 }
|
|
|
7818
|
|
|
7819 // Need an extra try/catch for cross domain requests in Firefox 3
|
|
|
7820 try {
|
|
|
7821 for ( i in headers ) {
|
|
|
7822 xhr.setRequestHeader( i, headers[ i ] );
|
|
|
7823 }
|
|
|
7824 } catch( _ ) {}
|
|
|
7825
|
|
|
7826 // Do send the request
|
|
|
7827 // This may raise an exception which is actually
|
|
|
7828 // handled in jQuery.ajax (so no try/catch here)
|
|
|
7829 xhr.send( ( s.hasContent && s.data ) || null );
|
|
|
7830
|
|
|
7831 // Listener
|
|
|
7832 callback = function( _, isAbort ) {
|
|
|
7833
|
|
|
7834 var status,
|
|
|
7835 statusText,
|
|
|
7836 responseHeaders,
|
|
|
7837 responses,
|
|
|
7838 xml;
|
|
|
7839
|
|
|
7840 // Firefox throws exceptions when accessing properties
|
|
|
7841 // of an xhr when a network error occured
|
|
|
7842 // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
|
|
|
7843 try {
|
|
|
7844
|
|
|
7845 // Was never called and is aborted or complete
|
|
|
7846 if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
|
|
|
7847
|
|
|
7848 // Only called once
|
|
|
7849 callback = undefined;
|
|
|
7850
|
|
|
7851 // Do not keep as active anymore
|
|
|
7852 if ( handle ) {
|
|
|
7853 xhr.onreadystatechange = jQuery.noop;
|
|
|
7854 if ( xhrOnUnloadAbort ) {
|
|
|
7855 delete xhrCallbacks[ handle ];
|
|
|
7856 }
|
|
|
7857 }
|
|
|
7858
|
|
|
7859 // If it's an abort
|
|
|
7860 if ( isAbort ) {
|
|
|
7861 // Abort it manually if needed
|
|
|
7862 if ( xhr.readyState !== 4 ) {
|
|
|
7863 xhr.abort();
|
|
|
7864 }
|
|
|
7865 } else {
|
|
|
7866 status = xhr.status;
|
|
|
7867 responseHeaders = xhr.getAllResponseHeaders();
|
|
|
7868 responses = {};
|
|
|
7869 xml = xhr.responseXML;
|
|
|
7870
|
|
|
7871 // Construct response list
|
|
|
7872 if ( xml && xml.documentElement /* #4958 */ ) {
|
|
|
7873 responses.xml = xml;
|
|
|
7874 }
|
|
|
7875 responses.text = xhr.responseText;
|
|
|
7876
|
|
|
7877 // Firefox throws an exception when accessing
|
|
|
7878 // statusText for faulty cross-domain requests
|
|
|
7879 try {
|
|
|
7880 statusText = xhr.statusText;
|
|
|
7881 } catch( e ) {
|
|
|
7882 // We normalize with Webkit giving an empty statusText
|
|
|
7883 statusText = "";
|
|
|
7884 }
|
|
|
7885
|
|
|
7886 // Filter status for non standard behaviors
|
|
|
7887
|
|
|
7888 // If the request is local and we have data: assume a success
|
|
|
7889 // (success with no data won't get notified, that's the best we
|
|
|
7890 // can do given current implementations)
|
|
|
7891 if ( !status && s.isLocal && !s.crossDomain ) {
|
|
|
7892 status = responses.text ? 200 : 404;
|
|
|
7893 // IE - #1450: sometimes returns 1223 when it should be 204
|
|
|
7894 } else if ( status === 1223 ) {
|
|
|
7895 status = 204;
|
|
|
7896 }
|
|
|
7897 }
|
|
|
7898 }
|
|
|
7899 } catch( firefoxAccessException ) {
|
|
|
7900 if ( !isAbort ) {
|
|
|
7901 complete( -1, firefoxAccessException );
|
|
|
7902 }
|
|
|
7903 }
|
|
|
7904
|
|
|
7905 // Call complete if needed
|
|
|
7906 if ( responses ) {
|
|
|
7907 complete( status, statusText, responses, responseHeaders );
|
|
|
7908 }
|
|
|
7909 };
|
|
|
7910
|
|
|
7911 // if we're in sync mode or it's in cache
|
|
|
7912 // and has been retrieved directly (IE6 & IE7)
|
|
|
7913 // we need to manually fire the callback
|
|
|
7914 if ( !s.async || xhr.readyState === 4 ) {
|
|
|
7915 callback();
|
|
|
7916 } else {
|
|
|
7917 handle = ++xhrId;
|
|
|
7918 if ( xhrOnUnloadAbort ) {
|
|
|
7919 // Create the active xhrs callbacks list if needed
|
|
|
7920 // and attach the unload handler
|
|
|
7921 if ( !xhrCallbacks ) {
|
|
|
7922 xhrCallbacks = {};
|
|
|
7923 jQuery( window ).unload( xhrOnUnloadAbort );
|
|
|
7924 }
|
|
|
7925 // Add to list of active xhrs callbacks
|
|
|
7926 xhrCallbacks[ handle ] = callback;
|
|
|
7927 }
|
|
|
7928 xhr.onreadystatechange = callback;
|
|
|
7929 }
|
|
|
7930 },
|
|
|
7931
|
|
|
7932 abort: function() {
|
|
|
7933 if ( callback ) {
|
|
|
7934 callback(0,1);
|
|
|
7935 }
|
|
|
7936 }
|
|
|
7937 };
|
|
|
7938 }
|
|
|
7939 });
|
|
|
7940 }
|
|
|
7941
|
|
|
7942
|
|
|
7943
|
|
|
7944
|
|
|
7945 var elemdisplay = {},
|
|
|
7946 iframe, iframeDoc,
|
|
|
7947 rfxtypes = /^(?:toggle|show|hide)$/,
|
|
|
7948 rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
|
|
|
7949 timerId,
|
|
|
7950 fxAttrs = [
|
|
|
7951 // height animations
|
|
|
7952 [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
|
|
|
7953 // width animations
|
|
|
7954 [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
|
|
|
7955 // opacity animations
|
|
|
7956 [ "opacity" ]
|
|
|
7957 ],
|
|
|
7958 fxNow,
|
|
|
7959 requestAnimationFrame = window.webkitRequestAnimationFrame ||
|
|
|
7960 window.mozRequestAnimationFrame ||
|
|
|
7961 window.oRequestAnimationFrame;
|
|
|
7962
|
|
|
7963 jQuery.fn.extend({
|
|
|
7964 show: function( speed, easing, callback ) {
|
|
|
7965 var elem, display;
|
|
|
7966
|
|
|
7967 if ( speed || speed === 0 ) {
|
|
|
7968 return this.animate( genFx("show", 3), speed, easing, callback);
|
|
|
7969
|
|
|
7970 } else {
|
|
|
7971 for ( var i = 0, j = this.length; i < j; i++ ) {
|
|
|
7972 elem = this[i];
|
|
|
7973
|
|
|
7974 if ( elem.style ) {
|
|
|
7975 display = elem.style.display;
|
|
|
7976
|
|
|
7977 // Reset the inline display of this element to learn if it is
|
|
|
7978 // being hidden by cascaded rules or not
|
|
|
7979 if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
|
|
|
7980 display = elem.style.display = "";
|
|
|
7981 }
|
|
|
7982
|
|
|
7983 // Set elements which have been overridden with display: none
|
|
|
7984 // in a stylesheet to whatever the default browser style is
|
|
|
7985 // for such an element
|
|
|
7986 if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
|
|
|
7987 jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
|
|
|
7988 }
|
|
|
7989 }
|
|
|
7990 }
|
|
|
7991
|
|
|
7992 // Set the display of most of the elements in a second loop
|
|
|
7993 // to avoid the constant reflow
|
|
|
7994 for ( i = 0; i < j; i++ ) {
|
|
|
7995 elem = this[i];
|
|
|
7996
|
|
|
7997 if ( elem.style ) {
|
|
|
7998 display = elem.style.display;
|
|
|
7999
|
|
|
8000 if ( display === "" || display === "none" ) {
|
|
|
8001 elem.style.display = jQuery._data(elem, "olddisplay") || "";
|
|
|
8002 }
|
|
|
8003 }
|
|
|
8004 }
|
|
|
8005
|
|
|
8006 return this;
|
|
|
8007 }
|
|
|
8008 },
|
|
|
8009
|
|
|
8010 hide: function( speed, easing, callback ) {
|
|
|
8011 if ( speed || speed === 0 ) {
|
|
|
8012 return this.animate( genFx("hide", 3), speed, easing, callback);
|
|
|
8013
|
|
|
8014 } else {
|
|
|
8015 for ( var i = 0, j = this.length; i < j; i++ ) {
|
|
|
8016 if ( this[i].style ) {
|
|
|
8017 var display = jQuery.css( this[i], "display" );
|
|
|
8018
|
|
|
8019 if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
|
|
|
8020 jQuery._data( this[i], "olddisplay", display );
|
|
|
8021 }
|
|
|
8022 }
|
|
|
8023 }
|
|
|
8024
|
|
|
8025 // Set the display of the elements in a second loop
|
|
|
8026 // to avoid the constant reflow
|
|
|
8027 for ( i = 0; i < j; i++ ) {
|
|
|
8028 if ( this[i].style ) {
|
|
|
8029 this[i].style.display = "none";
|
|
|
8030 }
|
|
|
8031 }
|
|
|
8032
|
|
|
8033 return this;
|
|
|
8034 }
|
|
|
8035 },
|
|
|
8036
|
|
|
8037 // Save the old toggle function
|
|
|
8038 _toggle: jQuery.fn.toggle,
|
|
|
8039
|
|
|
8040 toggle: function( fn, fn2, callback ) {
|
|
|
8041 var bool = typeof fn === "boolean";
|
|
|
8042
|
|
|
8043 if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
|
|
|
8044 this._toggle.apply( this, arguments );
|
|
|
8045
|
|
|
8046 } else if ( fn == null || bool ) {
|
|
|
8047 this.each(function() {
|
|
|
8048 var state = bool ? fn : jQuery(this).is(":hidden");
|
|
|
8049 jQuery(this)[ state ? "show" : "hide" ]();
|
|
|
8050 });
|
|
|
8051
|
|
|
8052 } else {
|
|
|
8053 this.animate(genFx("toggle", 3), fn, fn2, callback);
|
|
|
8054 }
|
|
|
8055
|
|
|
8056 return this;
|
|
|
8057 },
|
|
|
8058
|
|
|
8059 fadeTo: function( speed, to, easing, callback ) {
|
|
|
8060 return this.filter(":hidden").css("opacity", 0).show().end()
|
|
|
8061 .animate({opacity: to}, speed, easing, callback);
|
|
|
8062 },
|
|
|
8063
|
|
|
8064 animate: function( prop, speed, easing, callback ) {
|
|
|
8065 var optall = jQuery.speed(speed, easing, callback);
|
|
|
8066
|
|
|
8067 if ( jQuery.isEmptyObject( prop ) ) {
|
|
|
8068 return this.each( optall.complete, [ false ] );
|
|
|
8069 }
|
|
|
8070
|
|
|
8071 // Do not change referenced properties as per-property easing will be lost
|
|
|
8072 prop = jQuery.extend( {}, prop );
|
|
|
8073
|
|
|
8074 return this[ optall.queue === false ? "each" : "queue" ](function() {
|
|
|
8075 // XXX 'this' does not always have a nodeName when running the
|
|
|
8076 // test suite
|
|
|
8077
|
|
|
8078 if ( optall.queue === false ) {
|
|
|
8079 jQuery._mark( this );
|
|
|
8080 }
|
|
|
8081
|
|
|
8082 var opt = jQuery.extend( {}, optall ),
|
|
|
8083 isElement = this.nodeType === 1,
|
|
|
8084 hidden = isElement && jQuery(this).is(":hidden"),
|
|
|
8085 name, val, p,
|
|
|
8086 display, e,
|
|
|
8087 parts, start, end, unit;
|
|
|
8088
|
|
|
8089 // will store per property easing and be used to determine when an animation is complete
|
|
|
8090 opt.animatedProperties = {};
|
|
|
8091
|
|
|
8092 for ( p in prop ) {
|
|
|
8093
|
|
|
8094 // property name normalization
|
|
|
8095 name = jQuery.camelCase( p );
|
|
|
8096 if ( p !== name ) {
|
|
|
8097 prop[ name ] = prop[ p ];
|
|
|
8098 delete prop[ p ];
|
|
|
8099 }
|
|
|
8100
|
|
|
8101 val = prop[ name ];
|
|
|
8102
|
|
|
8103 // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
|
|
|
8104 if ( jQuery.isArray( val ) ) {
|
|
|
8105 opt.animatedProperties[ name ] = val[ 1 ];
|
|
|
8106 val = prop[ name ] = val[ 0 ];
|
|
|
8107 } else {
|
|
|
8108 opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
|
|
|
8109 }
|
|
|
8110
|
|
|
8111 if ( val === "hide" && hidden || val === "show" && !hidden ) {
|
|
|
8112 return opt.complete.call( this );
|
|
|
8113 }
|
|
|
8114
|
|
|
8115 if ( isElement && ( name === "height" || name === "width" ) ) {
|
|
|
8116 // Make sure that nothing sneaks out
|
|
|
8117 // Record all 3 overflow attributes because IE does not
|
|
|
8118 // change the overflow attribute when overflowX and
|
|
|
8119 // overflowY are set to the same value
|
|
|
8120 opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
|
|
|
8121
|
|
|
8122 // Set display property to inline-block for height/width
|
|
|
8123 // animations on inline elements that are having width/height
|
|
|
8124 // animated
|
|
|
8125 if ( jQuery.css( this, "display" ) === "inline" &&
|
|
|
8126 jQuery.css( this, "float" ) === "none" ) {
|
|
|
8127 if ( !jQuery.support.inlineBlockNeedsLayout ) {
|
|
|
8128 this.style.display = "inline-block";
|
|
|
8129
|
|
|
8130 } else {
|
|
|
8131 display = defaultDisplay( this.nodeName );
|
|
|
8132
|
|
|
8133 // inline-level elements accept inline-block;
|
|
|
8134 // block-level elements need to be inline with layout
|
|
|
8135 if ( display === "inline" ) {
|
|
|
8136 this.style.display = "inline-block";
|
|
|
8137
|
|
|
8138 } else {
|
|
|
8139 this.style.display = "inline";
|
|
|
8140 this.style.zoom = 1;
|
|
|
8141 }
|
|
|
8142 }
|
|
|
8143 }
|
|
|
8144 }
|
|
|
8145 }
|
|
|
8146
|
|
|
8147 if ( opt.overflow != null ) {
|
|
|
8148 this.style.overflow = "hidden";
|
|
|
8149 }
|
|
|
8150
|
|
|
8151 for ( p in prop ) {
|
|
|
8152 e = new jQuery.fx( this, opt, p );
|
|
|
8153 val = prop[ p ];
|
|
|
8154
|
|
|
8155 if ( rfxtypes.test(val) ) {
|
|
|
8156 e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
|
|
|
8157
|
|
|
8158 } else {
|
|
|
8159 parts = rfxnum.exec( val );
|
|
|
8160 start = e.cur();
|
|
|
8161
|
|
|
8162 if ( parts ) {
|
|
|
8163 end = parseFloat( parts[2] );
|
|
|
8164 unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
|
|
|
8165
|
|
|
8166 // We need to compute starting value
|
|
|
8167 if ( unit !== "px" ) {
|
|
|
8168 jQuery.style( this, p, (end || 1) + unit);
|
|
|
8169 start = ((end || 1) / e.cur()) * start;
|
|
|
8170 jQuery.style( this, p, start + unit);
|
|
|
8171 }
|
|
|
8172
|
|
|
8173 // If a +=/-= token was provided, we're doing a relative animation
|
|
|
8174 if ( parts[1] ) {
|
|
|
8175 end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
|
|
|
8176 }
|
|
|
8177
|
|
|
8178 e.custom( start, end, unit );
|
|
|
8179
|
|
|
8180 } else {
|
|
|
8181 e.custom( start, val, "" );
|
|
|
8182 }
|
|
|
8183 }
|
|
|
8184 }
|
|
|
8185
|
|
|
8186 // For JS strict compliance
|
|
|
8187 return true;
|
|
|
8188 });
|
|
|
8189 },
|
|
|
8190
|
|
|
8191 stop: function( clearQueue, gotoEnd ) {
|
|
|
8192 if ( clearQueue ) {
|
|
|
8193 this.queue([]);
|
|
|
8194 }
|
|
|
8195
|
|
|
8196 this.each(function() {
|
|
|
8197 var timers = jQuery.timers,
|
|
|
8198 i = timers.length;
|
|
|
8199 // clear marker counters if we know they won't be
|
|
|
8200 if ( !gotoEnd ) {
|
|
|
8201 jQuery._unmark( true, this );
|
|
|
8202 }
|
|
|
8203 while ( i-- ) {
|
|
|
8204 if ( timers[i].elem === this ) {
|
|
|
8205 if (gotoEnd) {
|
|
|
8206 // force the next step to be the last
|
|
|
8207 timers[i](true);
|
|
|
8208 }
|
|
|
8209
|
|
|
8210 timers.splice(i, 1);
|
|
|
8211 }
|
|
|
8212 }
|
|
|
8213 });
|
|
|
8214
|
|
|
8215 // start the next in the queue if the last step wasn't forced
|
|
|
8216 if ( !gotoEnd ) {
|
|
|
8217 this.dequeue();
|
|
|
8218 }
|
|
|
8219
|
|
|
8220 return this;
|
|
|
8221 }
|
|
|
8222
|
|
|
8223 });
|
|
|
8224
|
|
|
8225 // Animations created synchronously will run synchronously
|
|
|
8226 function createFxNow() {
|
|
|
8227 setTimeout( clearFxNow, 0 );
|
|
|
8228 return ( fxNow = jQuery.now() );
|
|
|
8229 }
|
|
|
8230
|
|
|
8231 function clearFxNow() {
|
|
|
8232 fxNow = undefined;
|
|
|
8233 }
|
|
|
8234
|
|
|
8235 // Generate parameters to create a standard animation
|
|
|
8236 function genFx( type, num ) {
|
|
|
8237 var obj = {};
|
|
|
8238
|
|
|
8239 jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
|
|
|
8240 obj[ this ] = type;
|
|
|
8241 });
|
|
|
8242
|
|
|
8243 return obj;
|
|
|
8244 }
|
|
|
8245
|
|
|
8246 // Generate shortcuts for custom animations
|
|
|
8247 jQuery.each({
|
|
|
8248 slideDown: genFx("show", 1),
|
|
|
8249 slideUp: genFx("hide", 1),
|
|
|
8250 slideToggle: genFx("toggle", 1),
|
|
|
8251 fadeIn: { opacity: "show" },
|
|
|
8252 fadeOut: { opacity: "hide" },
|
|
|
8253 fadeToggle: { opacity: "toggle" }
|
|
|
8254 }, function( name, props ) {
|
|
|
8255 jQuery.fn[ name ] = function( speed, easing, callback ) {
|
|
|
8256 return this.animate( props, speed, easing, callback );
|
|
|
8257 };
|
|
|
8258 });
|
|
|
8259
|
|
|
8260 jQuery.extend({
|
|
|
8261 speed: function( speed, easing, fn ) {
|
|
|
8262 var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
|
|
|
8263 complete: fn || !fn && easing ||
|
|
|
8264 jQuery.isFunction( speed ) && speed,
|
|
|
8265 duration: speed,
|
|
|
8266 easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
|
|
|
8267 };
|
|
|
8268
|
|
|
8269 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
|
|
|
8270 opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
|
|
|
8271
|
|
|
8272 // Queueing
|
|
|
8273 opt.old = opt.complete;
|
|
|
8274 opt.complete = function( noUnmark ) {
|
|
|
8275 if ( opt.queue !== false ) {
|
|
|
8276 jQuery.dequeue( this );
|
|
|
8277 } else if ( noUnmark !== false ) {
|
|
|
8278 jQuery._unmark( this );
|
|
|
8279 }
|
|
|
8280
|
|
|
8281 if ( jQuery.isFunction( opt.old ) ) {
|
|
|
8282 opt.old.call( this );
|
|
|
8283 }
|
|
|
8284 };
|
|
|
8285
|
|
|
8286 return opt;
|
|
|
8287 },
|
|
|
8288
|
|
|
8289 easing: {
|
|
|
8290 linear: function( p, n, firstNum, diff ) {
|
|
|
8291 return firstNum + diff * p;
|
|
|
8292 },
|
|
|
8293 swing: function( p, n, firstNum, diff ) {
|
|
|
8294 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
|
|
|
8295 }
|
|
|
8296 },
|
|
|
8297
|
|
|
8298 timers: [],
|
|
|
8299
|
|
|
8300 fx: function( elem, options, prop ) {
|
|
|
8301 this.options = options;
|
|
|
8302 this.elem = elem;
|
|
|
8303 this.prop = prop;
|
|
|
8304
|
|
|
8305 options.orig = options.orig || {};
|
|
|
8306 }
|
|
|
8307
|
|
|
8308 });
|
|
|
8309
|
|
|
8310 jQuery.fx.prototype = {
|
|
|
8311 // Simple function for setting a style value
|
|
|
8312 update: function() {
|
|
|
8313 if ( this.options.step ) {
|
|
|
8314 this.options.step.call( this.elem, this.now, this );
|
|
|
8315 }
|
|
|
8316
|
|
|
8317 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
|
|
|
8318 },
|
|
|
8319
|
|
|
8320 // Get the current size
|
|
|
8321 cur: function() {
|
|
|
8322 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
|
|
|
8323 return this.elem[ this.prop ];
|
|
|
8324 }
|
|
|
8325
|
|
|
8326 var parsed,
|
|
|
8327 r = jQuery.css( this.elem, this.prop );
|
|
|
8328 // Empty strings, null, undefined and "auto" are converted to 0,
|
|
|
8329 // complex values such as "rotate(1rad)" are returned as is,
|
|
|
8330 // simple values such as "10px" are parsed to Float.
|
|
|
8331 return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
|
|
|
8332 },
|
|
|
8333
|
|
|
8334 // Start an animation from one number to another
|
|
|
8335 custom: function( from, to, unit ) {
|
|
|
8336 var self = this,
|
|
|
8337 fx = jQuery.fx,
|
|
|
8338 raf;
|
|
|
8339
|
|
|
8340 this.startTime = fxNow || createFxNow();
|
|
|
8341 this.start = from;
|
|
|
8342 this.end = to;
|
|
|
8343 this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
|
|
|
8344 this.now = this.start;
|
|
|
8345 this.pos = this.state = 0;
|
|
|
8346
|
|
|
8347 function t( gotoEnd ) {
|
|
|
8348 return self.step(gotoEnd);
|
|
|
8349 }
|
|
|
8350
|
|
|
8351 t.elem = this.elem;
|
|
|
8352
|
|
|
8353 if ( t() && jQuery.timers.push(t) && !timerId ) {
|
|
|
8354 // Use requestAnimationFrame instead of setInterval if available
|
|
|
8355 if ( requestAnimationFrame ) {
|
|
|
8356 timerId = 1;
|
|
|
8357 raf = function() {
|
|
|
8358 // When timerId gets set to null at any point, this stops
|
|
|
8359 if ( timerId ) {
|
|
|
8360 requestAnimationFrame( raf );
|
|
|
8361 fx.tick();
|
|
|
8362 }
|
|
|
8363 };
|
|
|
8364 requestAnimationFrame( raf );
|
|
|
8365 } else {
|
|
|
8366 timerId = setInterval( fx.tick, fx.interval );
|
|
|
8367 }
|
|
|
8368 }
|
|
|
8369 },
|
|
|
8370
|
|
|
8371 // Simple 'show' function
|
|
|
8372 show: function() {
|
|
|
8373 // Remember where we started, so that we can go back to it later
|
|
|
8374 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
|
|
|
8375 this.options.show = true;
|
|
|
8376
|
|
|
8377 // Begin the animation
|
|
|
8378 // Make sure that we start at a small width/height to avoid any
|
|
|
8379 // flash of content
|
|
|
8380 this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
|
|
|
8381
|
|
|
8382 // Start by showing the element
|
|
|
8383 jQuery( this.elem ).show();
|
|
|
8384 },
|
|
|
8385
|
|
|
8386 // Simple 'hide' function
|
|
|
8387 hide: function() {
|
|
|
8388 // Remember where we started, so that we can go back to it later
|
|
|
8389 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
|
|
|
8390 this.options.hide = true;
|
|
|
8391
|
|
|
8392 // Begin the animation
|
|
|
8393 this.custom(this.cur(), 0);
|
|
|
8394 },
|
|
|
8395
|
|
|
8396 // Each step of an animation
|
|
|
8397 step: function( gotoEnd ) {
|
|
|
8398 var t = fxNow || createFxNow(),
|
|
|
8399 done = true,
|
|
|
8400 elem = this.elem,
|
|
|
8401 options = this.options,
|
|
|
8402 i, n;
|
|
|
8403
|
|
|
8404 if ( gotoEnd || t >= options.duration + this.startTime ) {
|
|
|
8405 this.now = this.end;
|
|
|
8406 this.pos = this.state = 1;
|
|
|
8407 this.update();
|
|
|
8408
|
|
|
8409 options.animatedProperties[ this.prop ] = true;
|
|
|
8410
|
|
|
8411 for ( i in options.animatedProperties ) {
|
|
|
8412 if ( options.animatedProperties[i] !== true ) {
|
|
|
8413 done = false;
|
|
|
8414 }
|
|
|
8415 }
|
|
|
8416
|
|
|
8417 if ( done ) {
|
|
|
8418 // Reset the overflow
|
|
|
8419 if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
|
|
|
8420
|
|
|
8421 jQuery.each( [ "", "X", "Y" ], function (index, value) {
|
|
|
8422 elem.style[ "overflow" + value ] = options.overflow[index];
|
|
|
8423 });
|
|
|
8424 }
|
|
|
8425
|
|
|
8426 // Hide the element if the "hide" operation was done
|
|
|
8427 if ( options.hide ) {
|
|
|
8428 jQuery(elem).hide();
|
|
|
8429 }
|
|
|
8430
|
|
|
8431 // Reset the properties, if the item has been hidden or shown
|
|
|
8432 if ( options.hide || options.show ) {
|
|
|
8433 for ( var p in options.animatedProperties ) {
|
|
|
8434 jQuery.style( elem, p, options.orig[p] );
|
|
|
8435 }
|
|
|
8436 }
|
|
|
8437
|
|
|
8438 // Execute the complete function
|
|
|
8439 options.complete.call( elem );
|
|
|
8440 }
|
|
|
8441
|
|
|
8442 return false;
|
|
|
8443
|
|
|
8444 } else {
|
|
|
8445 // classical easing cannot be used with an Infinity duration
|
|
|
8446 if ( options.duration == Infinity ) {
|
|
|
8447 this.now = t;
|
|
|
8448 } else {
|
|
|
8449 n = t - this.startTime;
|
|
|
8450 this.state = n / options.duration;
|
|
|
8451
|
|
|
8452 // Perform the easing function, defaults to swing
|
|
|
8453 this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration );
|
|
|
8454 this.now = this.start + ((this.end - this.start) * this.pos);
|
|
|
8455 }
|
|
|
8456 // Perform the next step of the animation
|
|
|
8457 this.update();
|
|
|
8458 }
|
|
|
8459
|
|
|
8460 return true;
|
|
|
8461 }
|
|
|
8462 };
|
|
|
8463
|
|
|
8464 jQuery.extend( jQuery.fx, {
|
|
|
8465 tick: function() {
|
|
|
8466 for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) {
|
|
|
8467 if ( !timers[i]() ) {
|
|
|
8468 timers.splice(i--, 1);
|
|
|
8469 }
|
|
|
8470 }
|
|
|
8471
|
|
|
8472 if ( !timers.length ) {
|
|
|
8473 jQuery.fx.stop();
|
|
|
8474 }
|
|
|
8475 },
|
|
|
8476
|
|
|
8477 interval: 13,
|
|
|
8478
|
|
|
8479 stop: function() {
|
|
|
8480 clearInterval( timerId );
|
|
|
8481 timerId = null;
|
|
|
8482 },
|
|
|
8483
|
|
|
8484 speeds: {
|
|
|
8485 slow: 600,
|
|
|
8486 fast: 200,
|
|
|
8487 // Default speed
|
|
|
8488 _default: 400
|
|
|
8489 },
|
|
|
8490
|
|
|
8491 step: {
|
|
|
8492 opacity: function( fx ) {
|
|
|
8493 jQuery.style( fx.elem, "opacity", fx.now );
|
|
|
8494 },
|
|
|
8495
|
|
|
8496 _default: function( fx ) {
|
|
|
8497 if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
|
|
|
8498 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
|
|
|
8499 } else {
|
|
|
8500 fx.elem[ fx.prop ] = fx.now;
|
|
|
8501 }
|
|
|
8502 }
|
|
|
8503 }
|
|
|
8504 });
|
|
|
8505
|
|
|
8506 if ( jQuery.expr && jQuery.expr.filters ) {
|
|
|
8507 jQuery.expr.filters.animated = function( elem ) {
|
|
|
8508 return jQuery.grep(jQuery.timers, function( fn ) {
|
|
|
8509 return elem === fn.elem;
|
|
|
8510 }).length;
|
|
|
8511 };
|
|
|
8512 }
|
|
|
8513
|
|
|
8514 // Try to restore the default display value of an element
|
|
|
8515 function defaultDisplay( nodeName ) {
|
|
|
8516
|
|
|
8517 if ( !elemdisplay[ nodeName ] ) {
|
|
|
8518
|
|
|
8519 var elem = jQuery( "<" + nodeName + ">" ).appendTo( "body" ),
|
|
|
8520 display = elem.css( "display" );
|
|
|
8521
|
|
|
8522 elem.remove();
|
|
|
8523
|
|
|
8524 // If the simple way fails,
|
|
|
8525 // get element's real default display by attaching it to a temp iframe
|
|
|
8526 if ( display === "none" || display === "" ) {
|
|
|
8527 // No iframe to use yet, so create it
|
|
|
8528 if ( !iframe ) {
|
|
|
8529 iframe = document.createElement( "iframe" );
|
|
|
8530 iframe.frameBorder = iframe.width = iframe.height = 0;
|
|
|
8531 }
|
|
|
8532
|
|
|
8533 document.body.appendChild( iframe );
|
|
|
8534
|
|
|
8535 // Create a cacheable copy of the iframe document on first call.
|
|
|
8536 // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake html
|
|
|
8537 // document to it, Webkit & Firefox won't allow reusing the iframe document
|
|
|
8538 if ( !iframeDoc || !iframe.createElement ) {
|
|
|
8539 iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
|
|
|
8540 iframeDoc.write( "<!doctype><html><body></body></html>" );
|
|
|
8541 }
|
|
|
8542
|
|
|
8543 elem = iframeDoc.createElement( nodeName );
|
|
|
8544
|
|
|
8545 iframeDoc.body.appendChild( elem );
|
|
|
8546
|
|
|
8547 display = jQuery.css( elem, "display" );
|
|
|
8548
|
|
|
8549 document.body.removeChild( iframe );
|
|
|
8550 }
|
|
|
8551
|
|
|
8552 // Store the correct default display
|
|
|
8553 elemdisplay[ nodeName ] = display;
|
|
|
8554 }
|
|
|
8555
|
|
|
8556 return elemdisplay[ nodeName ];
|
|
|
8557 }
|
|
|
8558
|
|
|
8559
|
|
|
8560
|
|
|
8561
|
|
|
8562 var rtable = /^t(?:able|d|h)$/i,
|
|
|
8563 rroot = /^(?:body|html)$/i;
|
|
|
8564
|
|
|
8565 if ( "getBoundingClientRect" in document.documentElement ) {
|
|
|
8566 jQuery.fn.offset = function( options ) {
|
|
|
8567 var elem = this[0], box;
|
|
|
8568
|
|
|
8569 if ( options ) {
|
|
|
8570 return this.each(function( i ) {
|
|
|
8571 jQuery.offset.setOffset( this, options, i );
|
|
|
8572 });
|
|
|
8573 }
|
|
|
8574
|
|
|
8575 if ( !elem || !elem.ownerDocument ) {
|
|
|
8576 return null;
|
|
|
8577 }
|
|
|
8578
|
|
|
8579 if ( elem === elem.ownerDocument.body ) {
|
|
|
8580 return jQuery.offset.bodyOffset( elem );
|
|
|
8581 }
|
|
|
8582
|
|
|
8583 try {
|
|
|
8584 box = elem.getBoundingClientRect();
|
|
|
8585 } catch(e) {}
|
|
|
8586
|
|
|
8587 var doc = elem.ownerDocument,
|
|
|
8588 docElem = doc.documentElement;
|
|
|
8589
|
|
|
8590 // Make sure we're not dealing with a disconnected DOM node
|
|
|
8591 if ( !box || !jQuery.contains( docElem, elem ) ) {
|
|
|
8592 return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
|
|
|
8593 }
|
|
|
8594
|
|
|
8595 var body = doc.body,
|
|
|
8596 win = getWindow(doc),
|
|
|
8597 clientTop = docElem.clientTop || body.clientTop || 0,
|
|
|
8598 clientLeft = docElem.clientLeft || body.clientLeft || 0,
|
|
|
8599 scrollTop = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop,
|
|
|
8600 scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
|
|
|
8601 top = box.top + scrollTop - clientTop,
|
|
|
8602 left = box.left + scrollLeft - clientLeft;
|
|
|
8603
|
|
|
8604 return { top: top, left: left };
|
|
|
8605 };
|
|
|
8606
|
|
|
8607 } else {
|
|
|
8608 jQuery.fn.offset = function( options ) {
|
|
|
8609 var elem = this[0];
|
|
|
8610
|
|
|
8611 if ( options ) {
|
|
|
8612 return this.each(function( i ) {
|
|
|
8613 jQuery.offset.setOffset( this, options, i );
|
|
|
8614 });
|
|
|
8615 }
|
|
|
8616
|
|
|
8617 if ( !elem || !elem.ownerDocument ) {
|
|
|
8618 return null;
|
|
|
8619 }
|
|
|
8620
|
|
|
8621 if ( elem === elem.ownerDocument.body ) {
|
|
|
8622 return jQuery.offset.bodyOffset( elem );
|
|
|
8623 }
|
|
|
8624
|
|
|
8625 jQuery.offset.initialize();
|
|
|
8626
|
|
|
8627 var computedStyle,
|
|
|
8628 offsetParent = elem.offsetParent,
|
|
|
8629 prevOffsetParent = elem,
|
|
|
8630 doc = elem.ownerDocument,
|
|
|
8631 docElem = doc.documentElement,
|
|
|
8632 body = doc.body,
|
|
|
8633 defaultView = doc.defaultView,
|
|
|
8634 prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
|
|
|
8635 top = elem.offsetTop,
|
|
|
8636 left = elem.offsetLeft;
|
|
|
8637
|
|
|
8638 while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
|
|
|
8639 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
|
|
|
8640 break;
|
|
|
8641 }
|
|
|
8642
|
|
|
8643 computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
|
|
|
8644 top -= elem.scrollTop;
|
|
|
8645 left -= elem.scrollLeft;
|
|
|
8646
|
|
|
8647 if ( elem === offsetParent ) {
|
|
|
8648 top += elem.offsetTop;
|
|
|
8649 left += elem.offsetLeft;
|
|
|
8650
|
|
|
8651 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
|
|
|
8652 top += parseFloat( computedStyle.borderTopWidth ) || 0;
|
|
|
8653 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
|
|
|
8654 }
|
|
|
8655
|
|
|
8656 prevOffsetParent = offsetParent;
|
|
|
8657 offsetParent = elem.offsetParent;
|
|
|
8658 }
|
|
|
8659
|
|
|
8660 if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
|
|
|
8661 top += parseFloat( computedStyle.borderTopWidth ) || 0;
|
|
|
8662 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
|
|
|
8663 }
|
|
|
8664
|
|
|
8665 prevComputedStyle = computedStyle;
|
|
|
8666 }
|
|
|
8667
|
|
|
8668 if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
|
|
|
8669 top += body.offsetTop;
|
|
|
8670 left += body.offsetLeft;
|
|
|
8671 }
|
|
|
8672
|
|
|
8673 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
|
|
|
8674 top += Math.max( docElem.scrollTop, body.scrollTop );
|
|
|
8675 left += Math.max( docElem.scrollLeft, body.scrollLeft );
|
|
|
8676 }
|
|
|
8677
|
|
|
8678 return { top: top, left: left };
|
|
|
8679 };
|
|
|
8680 }
|
|
|
8681
|
|
|
8682 jQuery.offset = {
|
|
|
8683 initialize: function() {
|
|
|
8684 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
|
|
|
8685 html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
|
|
|
8686
|
|
|
8687 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
|
|
|
8688
|
|
|
8689 container.innerHTML = html;
|
|
|
8690 body.insertBefore( container, body.firstChild );
|
|
|
8691 innerDiv = container.firstChild;
|
|
|
8692 checkDiv = innerDiv.firstChild;
|
|
|
8693 td = innerDiv.nextSibling.firstChild.firstChild;
|
|
|
8694
|
|
|
8695 this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
|
|
|
8696 this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
|
|
|
8697
|
|
|
8698 checkDiv.style.position = "fixed";
|
|
|
8699 checkDiv.style.top = "20px";
|
|
|
8700
|
|
|
8701 // safari subtracts parent border width here which is 5px
|
|
|
8702 this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
|
|
|
8703 checkDiv.style.position = checkDiv.style.top = "";
|
|
|
8704
|
|
|
8705 innerDiv.style.overflow = "hidden";
|
|
|
8706 innerDiv.style.position = "relative";
|
|
|
8707
|
|
|
8708 this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
|
|
|
8709
|
|
|
8710 this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
|
|
|
8711
|
|
|
8712 body.removeChild( container );
|
|
|
8713 jQuery.offset.initialize = jQuery.noop;
|
|
|
8714 },
|
|
|
8715
|
|
|
8716 bodyOffset: function( body ) {
|
|
|
8717 var top = body.offsetTop,
|
|
|
8718 left = body.offsetLeft;
|
|
|
8719
|
|
|
8720 jQuery.offset.initialize();
|
|
|
8721
|
|
|
8722 if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
|
|
|
8723 top += parseFloat( jQuery.css(body, "marginTop") ) || 0;
|
|
|
8724 left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
|
|
|
8725 }
|
|
|
8726
|
|
|
8727 return { top: top, left: left };
|
|
|
8728 },
|
|
|
8729
|
|
|
8730 setOffset: function( elem, options, i ) {
|
|
|
8731 var position = jQuery.css( elem, "position" );
|
|
|
8732
|
|
|
8733 // set position first, in-case top/left are set even on static elem
|
|
|
8734 if ( position === "static" ) {
|
|
|
8735 elem.style.position = "relative";
|
|
|
8736 }
|
|
|
8737
|
|
|
8738 var curElem = jQuery( elem ),
|
|
|
8739 curOffset = curElem.offset(),
|
|
|
8740 curCSSTop = jQuery.css( elem, "top" ),
|
|
|
8741 curCSSLeft = jQuery.css( elem, "left" ),
|
|
|
8742 calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
|
|
|
8743 props = {}, curPosition = {}, curTop, curLeft;
|
|
|
8744
|
|
|
8745 // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
|
|
|
8746 if ( calculatePosition ) {
|
|
|
8747 curPosition = curElem.position();
|
|
|
8748 curTop = curPosition.top;
|
|
|
8749 curLeft = curPosition.left;
|
|
|
8750 } else {
|
|
|
8751 curTop = parseFloat( curCSSTop ) || 0;
|
|
|
8752 curLeft = parseFloat( curCSSLeft ) || 0;
|
|
|
8753 }
|
|
|
8754
|
|
|
8755 if ( jQuery.isFunction( options ) ) {
|
|
|
8756 options = options.call( elem, i, curOffset );
|
|
|
8757 }
|
|
|
8758
|
|
|
8759 if (options.top != null) {
|
|
|
8760 props.top = (options.top - curOffset.top) + curTop;
|
|
|
8761 }
|
|
|
8762 if (options.left != null) {
|
|
|
8763 props.left = (options.left - curOffset.left) + curLeft;
|
|
|
8764 }
|
|
|
8765
|
|
|
8766 if ( "using" in options ) {
|
|
|
8767 options.using.call( elem, props );
|
|
|
8768 } else {
|
|
|
8769 curElem.css( props );
|
|
|
8770 }
|
|
|
8771 }
|
|
|
8772 };
|
|
|
8773
|
|
|
8774
|
|
|
8775 jQuery.fn.extend({
|
|
|
8776 position: function() {
|
|
|
8777 if ( !this[0] ) {
|
|
|
8778 return null;
|
|
|
8779 }
|
|
|
8780
|
|
|
8781 var elem = this[0],
|
|
|
8782
|
|
|
8783 // Get *real* offsetParent
|
|
|
8784 offsetParent = this.offsetParent(),
|
|
|
8785
|
|
|
8786 // Get correct offsets
|
|
|
8787 offset = this.offset(),
|
|
|
8788 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
|
|
|
8789
|
|
|
8790 // Subtract element margins
|
|
|
8791 // note: when an element has margin: auto the offsetLeft and marginLeft
|
|
|
8792 // are the same in Safari causing offset.left to incorrectly be 0
|
|
|
8793 offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
|
|
|
8794 offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
|
|
|
8795
|
|
|
8796 // Add offsetParent borders
|
|
|
8797 parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
|
|
|
8798 parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
|
|
|
8799
|
|
|
8800 // Subtract the two offsets
|
|
|
8801 return {
|
|
|
8802 top: offset.top - parentOffset.top,
|
|
|
8803 left: offset.left - parentOffset.left
|
|
|
8804 };
|
|
|
8805 },
|
|
|
8806
|
|
|
8807 offsetParent: function() {
|
|
|
8808 return this.map(function() {
|
|
|
8809 var offsetParent = this.offsetParent || document.body;
|
|
|
8810 while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
|
|
|
8811 offsetParent = offsetParent.offsetParent;
|
|
|
8812 }
|
|
|
8813 return offsetParent;
|
|
|
8814 });
|
|
|
8815 }
|
|
|
8816 });
|
|
|
8817
|
|
|
8818
|
|
|
8819 // Create scrollLeft and scrollTop methods
|
|
|
8820 jQuery.each( ["Left", "Top"], function( i, name ) {
|
|
|
8821 var method = "scroll" + name;
|
|
|
8822
|
|
|
8823 jQuery.fn[ method ] = function( val ) {
|
|
|
8824 var elem, win;
|
|
|
8825
|
|
|
8826 if ( val === undefined ) {
|
|
|
8827 elem = this[ 0 ];
|
|
|
8828
|
|
|
8829 if ( !elem ) {
|
|
|
8830 return null;
|
|
|
8831 }
|
|
|
8832
|
|
|
8833 win = getWindow( elem );
|
|
|
8834
|
|
|
8835 // Return the scroll offset
|
|
|
8836 return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
|
|
|
8837 jQuery.support.boxModel && win.document.documentElement[ method ] ||
|
|
|
8838 win.document.body[ method ] :
|
|
|
8839 elem[ method ];
|
|
|
8840 }
|
|
|
8841
|
|
|
8842 // Set the scroll offset
|
|
|
8843 return this.each(function() {
|
|
|
8844 win = getWindow( this );
|
|
|
8845
|
|
|
8846 if ( win ) {
|
|
|
8847 win.scrollTo(
|
|
|
8848 !i ? val : jQuery( win ).scrollLeft(),
|
|
|
8849 i ? val : jQuery( win ).scrollTop()
|
|
|
8850 );
|
|
|
8851
|
|
|
8852 } else {
|
|
|
8853 this[ method ] = val;
|
|
|
8854 }
|
|
|
8855 });
|
|
|
8856 };
|
|
|
8857 });
|
|
|
8858
|
|
|
8859 function getWindow( elem ) {
|
|
|
8860 return jQuery.isWindow( elem ) ?
|
|
|
8861 elem :
|
|
|
8862 elem.nodeType === 9 ?
|
|
|
8863 elem.defaultView || elem.parentWindow :
|
|
|
8864 false;
|
|
|
8865 }
|
|
|
8866
|
|
|
8867
|
|
|
8868
|
|
|
8869
|
|
|
8870 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
|
|
|
8871 jQuery.each([ "Height", "Width" ], function( i, name ) {
|
|
|
8872
|
|
|
8873 var type = name.toLowerCase();
|
|
|
8874
|
|
|
8875 // innerHeight and innerWidth
|
|
|
8876 jQuery.fn["inner" + name] = function() {
|
|
|
8877 return this[0] ?
|
|
|
8878 parseFloat( jQuery.css( this[0], type, "padding" ) ) :
|
|
|
8879 null;
|
|
|
8880 };
|
|
|
8881
|
|
|
8882 // outerHeight and outerWidth
|
|
|
8883 jQuery.fn["outer" + name] = function( margin ) {
|
|
|
8884 return this[0] ?
|
|
|
8885 parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) :
|
|
|
8886 null;
|
|
|
8887 };
|
|
|
8888
|
|
|
8889 jQuery.fn[ type ] = function( size ) {
|
|
|
8890 // Get window width or height
|
|
|
8891 var elem = this[0];
|
|
|
8892 if ( !elem ) {
|
|
|
8893 return size == null ? null : this;
|
|
|
8894 }
|
|
|
8895
|
|
|
8896 if ( jQuery.isFunction( size ) ) {
|
|
|
8897 return this.each(function( i ) {
|
|
|
8898 var self = jQuery( this );
|
|
|
8899 self[ type ]( size.call( this, i, self[ type ]() ) );
|
|
|
8900 });
|
|
|
8901 }
|
|
|
8902
|
|
|
8903 if ( jQuery.isWindow( elem ) ) {
|
|
|
8904 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
|
|
|
8905 // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
|
|
|
8906 var docElemProp = elem.document.documentElement[ "client" + name ];
|
|
|
8907 return elem.document.compatMode === "CSS1Compat" && docElemProp ||
|
|
|
8908 elem.document.body[ "client" + name ] || docElemProp;
|
|
|
8909
|
|
|
8910 // Get document width or height
|
|
|
8911 } else if ( elem.nodeType === 9 ) {
|
|
|
8912 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
|
|
|
8913 return Math.max(
|
|
|
8914 elem.documentElement["client" + name],
|
|
|
8915 elem.body["scroll" + name], elem.documentElement["scroll" + name],
|
|
|
8916 elem.body["offset" + name], elem.documentElement["offset" + name]
|
|
|
8917 );
|
|
|
8918
|
|
|
8919 // Get or set width or height on the element
|
|
|
8920 } else if ( size === undefined ) {
|
|
|
8921 var orig = jQuery.css( elem, type ),
|
|
|
8922 ret = parseFloat( orig );
|
|
|
8923
|
|
|
8924 return jQuery.isNaN( ret ) ? orig : ret;
|
|
|
8925
|
|
|
8926 // Set the width or height on the element (default to pixels if value is unitless)
|
|
|
8927 } else {
|
|
|
8928 return this.css( type, typeof size === "string" ? size : size + "px" );
|
|
|
8929 }
|
|
|
8930 };
|
|
|
8931
|
|
|
8932 });
|
|
|
8933
|
|
|
8934
|
|
|
8935 window.jQuery = window.$ = jQuery;
|
|
|
8936 })(window);
|
