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