|
5
|
1 /*!
|
|
|
2 * jQuery JavaScript Library v1.4.3
|
|
|
3 * http://jquery.com/
|
|
|
4 *
|
|
|
5 * Copyright 2010, 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 2010, The Dojo Foundation
|
|
|
12 * Released under the MIT, BSD, and GPL Licenses.
|
|
|
13 *
|
|
|
14 * Date: Thu Oct 14 23:10:06 2010 -0400
|
|
|
15 */
|
|
|
16 (function( window, undefined ) {
|
|
|
17
|
|
|
18 // Use the correct document accordingly with window argument (sandbox)
|
|
|
19 var document = window.document;
|
|
|
20 var jQuery = (function() {
|
|
|
21
|
|
|
22 // Define a local copy of jQuery
|
|
|
23 var jQuery = function( selector, context ) {
|
|
|
24 // The jQuery object is actually just the init constructor 'enhanced'
|
|
|
25 return new jQuery.fn.init( selector, context );
|
|
|
26 },
|
|
|
27
|
|
|
28 // Map over jQuery in case of overwrite
|
|
|
29 _jQuery = window.jQuery,
|
|
|
30
|
|
|
31 // Map over the $ in case of overwrite
|
|
|
32 _$ = window.$,
|
|
|
33
|
|
|
34 // A central reference to the root jQuery(document)
|
|
|
35 rootjQuery,
|
|
|
36
|
|
|
37 // A simple way to check for HTML strings or ID strings
|
|
|
38 // (both of which we optimize for)
|
|
|
39 quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,
|
|
|
40
|
|
|
41 // Is it a simple selector
|
|
|
42 isSimple = /^.[^:#\[\.,]*$/,
|
|
|
43
|
|
|
44 // Check if a string has a non-whitespace character in it
|
|
|
45 rnotwhite = /\S/,
|
|
|
46 rwhite = /\s/,
|
|
|
47
|
|
|
48 // Used for trimming whitespace
|
|
|
49 trimLeft = /^\s+/,
|
|
|
50 trimRight = /\s+$/,
|
|
|
51
|
|
|
52 // Check for non-word characters
|
|
|
53 rnonword = /\W/,
|
|
|
54
|
|
|
55 // Check for digits
|
|
|
56 rdigit = /\d/,
|
|
|
57
|
|
|
58 // Match a standalone tag
|
|
|
59 rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
|
|
|
60
|
|
|
61 // JSON RegExp
|
|
|
62 rvalidchars = /^[\],:{}\s]*$/,
|
|
|
63 rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
|
|
|
64 rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
|
|
|
65 rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
|
|
|
66
|
|
|
67 // Useragent RegExp
|
|
|
68 rwebkit = /(webkit)[ \/]([\w.]+)/,
|
|
|
69 ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
|
|
|
70 rmsie = /(msie) ([\w.]+)/,
|
|
|
71 rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
|
|
|
72
|
|
|
73 // Keep a UserAgent string for use with jQuery.browser
|
|
|
74 userAgent = navigator.userAgent,
|
|
|
75
|
|
|
76 // For matching the engine and version of the browser
|
|
|
77 browserMatch,
|
|
|
78
|
|
|
79 // Has the ready events already been bound?
|
|
|
80 readyBound = false,
|
|
|
81
|
|
|
82 // The functions to execute on DOM ready
|
|
|
83 readyList = [],
|
|
|
84
|
|
|
85 // The ready event handler
|
|
|
86 DOMContentLoaded,
|
|
|
87
|
|
|
88 // Save a reference to some core methods
|
|
|
89 toString = Object.prototype.toString,
|
|
|
90 hasOwn = Object.prototype.hasOwnProperty,
|
|
|
91 push = Array.prototype.push,
|
|
|
92 slice = Array.prototype.slice,
|
|
|
93 trim = String.prototype.trim,
|
|
|
94 indexOf = Array.prototype.indexOf,
|
|
|
95
|
|
|
96 // [[Class]] -> type pairs
|
|
|
97 class2type = {};
|
|
|
98
|
|
|
99 jQuery.fn = jQuery.prototype = {
|
|
|
100 init: function( selector, context ) {
|
|
|
101 var match, elem, ret, doc;
|
|
|
102
|
|
|
103 // Handle $(""), $(null), or $(undefined)
|
|
|
104 if ( !selector ) {
|
|
|
105 return this;
|
|
|
106 }
|
|
|
107
|
|
|
108 // Handle $(DOMElement)
|
|
|
109 if ( selector.nodeType ) {
|
|
|
110 this.context = this[0] = selector;
|
|
|
111 this.length = 1;
|
|
|
112 return this;
|
|
|
113 }
|
|
|
114
|
|
|
115 // The body element only exists once, optimize finding it
|
|
|
116 if ( selector === "body" && !context && document.body ) {
|
|
|
117 this.context = document;
|
|
|
118 this[0] = document.body;
|
|
|
119 this.selector = "body";
|
|
|
120 this.length = 1;
|
|
|
121 return this;
|
|
|
122 }
|
|
|
123
|
|
|
124 // Handle HTML strings
|
|
|
125 if ( typeof selector === "string" ) {
|
|
|
126 // Are we dealing with HTML string or an ID?
|
|
|
127 match = quickExpr.exec( selector );
|
|
|
128
|
|
|
129 // Verify a match, and that no context was specified for #id
|
|
|
130 if ( match && (match[1] || !context) ) {
|
|
|
131
|
|
|
132 // HANDLE: $(html) -> $(array)
|
|
|
133 if ( match[1] ) {
|
|
|
134 doc = (context ? context.ownerDocument || context : document);
|
|
|
135
|
|
|
136 // If a single string is passed in and it's a single tag
|
|
|
137 // just do a createElement and skip the rest
|
|
|
138 ret = rsingleTag.exec( selector );
|
|
|
139
|
|
|
140 if ( ret ) {
|
|
|
141 if ( jQuery.isPlainObject( context ) ) {
|
|
|
142 selector = [ document.createElement( ret[1] ) ];
|
|
|
143 jQuery.fn.attr.call( selector, context, true );
|
|
|
144
|
|
|
145 } else {
|
|
|
146 selector = [ doc.createElement( ret[1] ) ];
|
|
|
147 }
|
|
|
148
|
|
|
149 } else {
|
|
|
150 ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
|
|
|
151 selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
|
|
|
152 }
|
|
|
153
|
|
|
154 return jQuery.merge( this, selector );
|
|
|
155
|
|
|
156 // HANDLE: $("#id")
|
|
|
157 } else {
|
|
|
158 elem = document.getElementById( match[2] );
|
|
|
159
|
|
|
160 // Check parentNode to catch when Blackberry 4.6 returns
|
|
|
161 // nodes that are no longer in the document #6963
|
|
|
162 if ( elem && elem.parentNode ) {
|
|
|
163 // Handle the case where IE and Opera return items
|
|
|
164 // by name instead of ID
|
|
|
165 if ( elem.id !== match[2] ) {
|
|
|
166 return rootjQuery.find( selector );
|
|
|
167 }
|
|
|
168
|
|
|
169 // Otherwise, we inject the element directly into the jQuery object
|
|
|
170 this.length = 1;
|
|
|
171 this[0] = elem;
|
|
|
172 }
|
|
|
173
|
|
|
174 this.context = document;
|
|
|
175 this.selector = selector;
|
|
|
176 return this;
|
|
|
177 }
|
|
|
178
|
|
|
179 // HANDLE: $("TAG")
|
|
|
180 } else if ( !context && !rnonword.test( selector ) ) {
|
|
|
181 this.selector = selector;
|
|
|
182 this.context = document;
|
|
|
183 selector = document.getElementsByTagName( selector );
|
|
|
184 return jQuery.merge( this, selector );
|
|
|
185
|
|
|
186 // HANDLE: $(expr, $(...))
|
|
|
187 } else if ( !context || context.jquery ) {
|
|
|
188 return (context || rootjQuery).find( selector );
|
|
|
189
|
|
|
190 // HANDLE: $(expr, context)
|
|
|
191 // (which is just equivalent to: $(context).find(expr)
|
|
|
192 } else {
|
|
|
193 return jQuery( context ).find( selector );
|
|
|
194 }
|
|
|
195
|
|
|
196 // HANDLE: $(function)
|
|
|
197 // Shortcut for document ready
|
|
|
198 } else if ( jQuery.isFunction( selector ) ) {
|
|
|
199 return rootjQuery.ready( selector );
|
|
|
200 }
|
|
|
201
|
|
|
202 if (selector.selector !== undefined) {
|
|
|
203 this.selector = selector.selector;
|
|
|
204 this.context = selector.context;
|
|
|
205 }
|
|
|
206
|
|
|
207 return jQuery.makeArray( selector, this );
|
|
|
208 },
|
|
|
209
|
|
|
210 // Start with an empty selector
|
|
|
211 selector: "",
|
|
|
212
|
|
|
213 // The current version of jQuery being used
|
|
|
214 jquery: "1.4.3",
|
|
|
215
|
|
|
216 // The default length of a jQuery object is 0
|
|
|
217 length: 0,
|
|
|
218
|
|
|
219 // The number of elements contained in the matched element set
|
|
|
220 size: function() {
|
|
|
221 return this.length;
|
|
|
222 },
|
|
|
223
|
|
|
224 toArray: function() {
|
|
|
225 return slice.call( this, 0 );
|
|
|
226 },
|
|
|
227
|
|
|
228 // Get the Nth element in the matched element set OR
|
|
|
229 // Get the whole matched element set as a clean array
|
|
|
230 get: function( num ) {
|
|
|
231 return num == null ?
|
|
|
232
|
|
|
233 // Return a 'clean' array
|
|
|
234 this.toArray() :
|
|
|
235
|
|
|
236 // Return just the object
|
|
|
237 ( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
|
|
|
238 },
|
|
|
239
|
|
|
240 // Take an array of elements and push it onto the stack
|
|
|
241 // (returning the new matched element set)
|
|
|
242 pushStack: function( elems, name, selector ) {
|
|
|
243 // Build a new jQuery matched element set
|
|
|
244 var ret = jQuery();
|
|
|
245
|
|
|
246 if ( jQuery.isArray( elems ) ) {
|
|
|
247 push.apply( ret, elems );
|
|
|
248
|
|
|
249 } else {
|
|
|
250 jQuery.merge( ret, elems );
|
|
|
251 }
|
|
|
252
|
|
|
253 // Add the old object onto the stack (as a reference)
|
|
|
254 ret.prevObject = this;
|
|
|
255
|
|
|
256 ret.context = this.context;
|
|
|
257
|
|
|
258 if ( name === "find" ) {
|
|
|
259 ret.selector = this.selector + (this.selector ? " " : "") + selector;
|
|
|
260 } else if ( name ) {
|
|
|
261 ret.selector = this.selector + "." + name + "(" + selector + ")";
|
|
|
262 }
|
|
|
263
|
|
|
264 // Return the newly-formed element set
|
|
|
265 return ret;
|
|
|
266 },
|
|
|
267
|
|
|
268 // Execute a callback for every element in the matched set.
|
|
|
269 // (You can seed the arguments with an array of args, but this is
|
|
|
270 // only used internally.)
|
|
|
271 each: function( callback, args ) {
|
|
|
272 return jQuery.each( this, callback, args );
|
|
|
273 },
|
|
|
274
|
|
|
275 ready: function( fn ) {
|
|
|
276 // Attach the listeners
|
|
|
277 jQuery.bindReady();
|
|
|
278
|
|
|
279 // If the DOM is already ready
|
|
|
280 if ( jQuery.isReady ) {
|
|
|
281 // Execute the function immediately
|
|
|
282 fn.call( document, jQuery );
|
|
|
283
|
|
|
284 // Otherwise, remember the function for later
|
|
|
285 } else if ( readyList ) {
|
|
|
286 // Add the function to the wait list
|
|
|
287 readyList.push( fn );
|
|
|
288 }
|
|
|
289
|
|
|
290 return this;
|
|
|
291 },
|
|
|
292
|
|
|
293 eq: function( i ) {
|
|
|
294 return i === -1 ?
|
|
|
295 this.slice( i ) :
|
|
|
296 this.slice( i, +i + 1 );
|
|
|
297 },
|
|
|
298
|
|
|
299 first: function() {
|
|
|
300 return this.eq( 0 );
|
|
|
301 },
|
|
|
302
|
|
|
303 last: function() {
|
|
|
304 return this.eq( -1 );
|
|
|
305 },
|
|
|
306
|
|
|
307 slice: function() {
|
|
|
308 return this.pushStack( slice.apply( this, arguments ),
|
|
|
309 "slice", slice.call(arguments).join(",") );
|
|
|
310 },
|
|
|
311
|
|
|
312 map: function( callback ) {
|
|
|
313 return this.pushStack( jQuery.map(this, function( elem, i ) {
|
|
|
314 return callback.call( elem, i, elem );
|
|
|
315 }));
|
|
|
316 },
|
|
|
317
|
|
|
318 end: function() {
|
|
|
319 return this.prevObject || jQuery(null);
|
|
|
320 },
|
|
|
321
|
|
|
322 // For internal use only.
|
|
|
323 // Behaves like an Array's method, not like a jQuery method.
|
|
|
324 push: push,
|
|
|
325 sort: [].sort,
|
|
|
326 splice: [].splice
|
|
|
327 };
|
|
|
328
|
|
|
329 // Give the init function the jQuery prototype for later instantiation
|
|
|
330 jQuery.fn.init.prototype = jQuery.fn;
|
|
|
331
|
|
|
332 jQuery.extend = jQuery.fn.extend = function() {
|
|
|
333 // copy reference to target object
|
|
|
334 var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy, copyIsArray;
|
|
|
335
|
|
|
336 // Handle a deep copy situation
|
|
|
337 if ( typeof target === "boolean" ) {
|
|
|
338 deep = target;
|
|
|
339 target = arguments[1] || {};
|
|
|
340 // skip the boolean and the target
|
|
|
341 i = 2;
|
|
|
342 }
|
|
|
343
|
|
|
344 // Handle case when target is a string or something (possible in deep copy)
|
|
|
345 if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
|
|
|
346 target = {};
|
|
|
347 }
|
|
|
348
|
|
|
349 // extend jQuery itself if only one argument is passed
|
|
|
350 if ( length === i ) {
|
|
|
351 target = this;
|
|
|
352 --i;
|
|
|
353 }
|
|
|
354
|
|
|
355 for ( ; i < length; i++ ) {
|
|
|
356 // Only deal with non-null/undefined values
|
|
|
357 if ( (options = arguments[ i ]) != null ) {
|
|
|
358 // Extend the base object
|
|
|
359 for ( name in options ) {
|
|
|
360 src = target[ name ];
|
|
|
361 copy = options[ name ];
|
|
|
362
|
|
|
363 // Prevent never-ending loop
|
|
|
364 if ( target === copy ) {
|
|
|
365 continue;
|
|
|
366 }
|
|
|
367
|
|
|
368 // Recurse if we're merging plain objects or arrays
|
|
|
369 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
|
|
|
370 if ( copyIsArray ) {
|
|
|
371 copyIsArray = false;
|
|
|
372 clone = src && jQuery.isArray(src) ? src : [];
|
|
|
373
|
|
|
374 } else {
|
|
|
375 clone = src && jQuery.isPlainObject(src) ? src : {};
|
|
|
376 }
|
|
|
377
|
|
|
378 // Never move original objects, clone them
|
|
|
379 target[ name ] = jQuery.extend( deep, clone, copy );
|
|
|
380
|
|
|
381 // Don't bring in undefined values
|
|
|
382 } else if ( copy !== undefined ) {
|
|
|
383 target[ name ] = copy;
|
|
|
384 }
|
|
|
385 }
|
|
|
386 }
|
|
|
387 }
|
|
|
388
|
|
|
389 // Return the modified object
|
|
|
390 return target;
|
|
|
391 };
|
|
|
392
|
|
|
393 jQuery.extend({
|
|
|
394 noConflict: function( deep ) {
|
|
|
395 window.$ = _$;
|
|
|
396
|
|
|
397 if ( deep ) {
|
|
|
398 window.jQuery = _jQuery;
|
|
|
399 }
|
|
|
400
|
|
|
401 return jQuery;
|
|
|
402 },
|
|
|
403
|
|
|
404 // Is the DOM ready to be used? Set to true once it occurs.
|
|
|
405 isReady: false,
|
|
|
406
|
|
|
407 // A counter to track how many items to wait for before
|
|
|
408 // the ready event fires. See #6781
|
|
|
409 readyWait: 1,
|
|
|
410
|
|
|
411 // Handle when the DOM is ready
|
|
|
412 ready: function( wait ) {
|
|
|
413 // A third-party is pushing the ready event forwards
|
|
|
414 if ( wait === true ) {
|
|
|
415 jQuery.readyWait--;
|
|
|
416 }
|
|
|
417
|
|
|
418 // Make sure that the DOM is not already loaded
|
|
|
419 if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) {
|
|
|
420 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
|
|
|
421 if ( !document.body ) {
|
|
|
422 return setTimeout( jQuery.ready, 1 );
|
|
|
423 }
|
|
|
424
|
|
|
425 // Remember that the DOM is ready
|
|
|
426 jQuery.isReady = true;
|
|
|
427
|
|
|
428 // If a normal DOM Ready event fired, decrement, and wait if need be
|
|
|
429 if ( wait !== true && --jQuery.readyWait > 0 ) {
|
|
|
430 return;
|
|
|
431 }
|
|
|
432
|
|
|
433 // If there are functions bound, to execute
|
|
|
434 if ( readyList ) {
|
|
|
435 // Execute all of them
|
|
|
436 var fn, i = 0;
|
|
|
437 while ( (fn = readyList[ i++ ]) ) {
|
|
|
438 fn.call( document, jQuery );
|
|
|
439 }
|
|
|
440
|
|
|
441 // Reset the list of functions
|
|
|
442 readyList = null;
|
|
|
443 }
|
|
|
444
|
|
|
445 // Trigger any bound ready events
|
|
|
446 if ( jQuery.fn.triggerHandler ) {
|
|
|
447 jQuery( document ).triggerHandler( "ready" );
|
|
|
448 }
|
|
|
449 }
|
|
|
450 },
|
|
|
451
|
|
|
452 bindReady: function() {
|
|
|
453 if ( readyBound ) {
|
|
|
454 return;
|
|
|
455 }
|
|
|
456
|
|
|
457 readyBound = true;
|
|
|
458
|
|
|
459 // Catch cases where $(document).ready() is called after the
|
|
|
460 // browser event has already occurred.
|
|
|
461 if ( document.readyState === "complete" ) {
|
|
|
462 // Handle it asynchronously to allow scripts the opportunity to delay ready
|
|
|
463 return setTimeout( jQuery.ready, 1 );
|
|
|
464 }
|
|
|
465
|
|
|
466 // Mozilla, Opera and webkit nightlies currently support this event
|
|
|
467 if ( document.addEventListener ) {
|
|
|
468 // Use the handy event callback
|
|
|
469 document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
|
|
|
470
|
|
|
471 // A fallback to window.onload, that will always work
|
|
|
472 window.addEventListener( "load", jQuery.ready, false );
|
|
|
473
|
|
|
474 // If IE event model is used
|
|
|
475 } else if ( document.attachEvent ) {
|
|
|
476 // ensure firing before onload,
|
|
|
477 // maybe late but safe also for iframes
|
|
|
478 document.attachEvent("onreadystatechange", DOMContentLoaded);
|
|
|
479
|
|
|
480 // A fallback to window.onload, that will always work
|
|
|
481 window.attachEvent( "onload", jQuery.ready );
|
|
|
482
|
|
|
483 // If IE and not a frame
|
|
|
484 // continually check to see if the document is ready
|
|
|
485 var toplevel = false;
|
|
|
486
|
|
|
487 try {
|
|
|
488 toplevel = window.frameElement == null;
|
|
|
489 } catch(e) {}
|
|
|
490
|
|
|
491 if ( document.documentElement.doScroll && toplevel ) {
|
|
|
492 doScrollCheck();
|
|
|
493 }
|
|
|
494 }
|
|
|
495 },
|
|
|
496
|
|
|
497 // See test/unit/core.js for details concerning isFunction.
|
|
|
498 // Since version 1.3, DOM methods and functions like alert
|
|
|
499 // aren't supported. They return false on IE (#2968).
|
|
|
500 isFunction: function( obj ) {
|
|
|
501 return jQuery.type(obj) === "function";
|
|
|
502 },
|
|
|
503
|
|
|
504 isArray: Array.isArray || function( obj ) {
|
|
|
505 return jQuery.type(obj) === "array";
|
|
|
506 },
|
|
|
507
|
|
|
508 // A crude way of determining if an object is a window
|
|
|
509 isWindow: function( obj ) {
|
|
|
510 return obj && typeof obj === "object" && "setInterval" in obj;
|
|
|
511 },
|
|
|
512
|
|
|
513 isNaN: function( obj ) {
|
|
|
514 return obj == null || !rdigit.test( obj ) || isNaN( obj );
|
|
|
515 },
|
|
|
516
|
|
|
517 type: function( obj ) {
|
|
|
518 return obj == null ?
|
|
|
519 String( obj ) :
|
|
|
520 class2type[ toString.call(obj) ] || "object";
|
|
|
521 },
|
|
|
522
|
|
|
523 isPlainObject: function( obj ) {
|
|
|
524 // Must be an Object.
|
|
|
525 // Because of IE, we also have to check the presence of the constructor property.
|
|
|
526 // Make sure that DOM nodes and window objects don't pass through, as well
|
|
|
527 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
|
|
|
528 return false;
|
|
|
529 }
|
|
|
530
|
|
|
531 // Not own constructor property must be Object
|
|
|
532 if ( obj.constructor &&
|
|
|
533 !hasOwn.call(obj, "constructor") &&
|
|
|
534 !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
|
|
|
535 return false;
|
|
|
536 }
|
|
|
537
|
|
|
538 // Own properties are enumerated firstly, so to speed up,
|
|
|
539 // if last one is own, then all properties are own.
|
|
|
540
|
|
|
541 var key;
|
|
|
542 for ( key in obj ) {}
|
|
|
543
|
|
|
544 return key === undefined || hasOwn.call( obj, key );
|
|
|
545 },
|
|
|
546
|
|
|
547 isEmptyObject: function( obj ) {
|
|
|
548 for ( var name in obj ) {
|
|
|
549 return false;
|
|
|
550 }
|
|
|
551 return true;
|
|
|
552 },
|
|
|
553
|
|
|
554 error: function( msg ) {
|
|
|
555 throw msg;
|
|
|
556 },
|
|
|
557
|
|
|
558 parseJSON: function( data ) {
|
|
|
559 if ( typeof data !== "string" || !data ) {
|
|
|
560 return null;
|
|
|
561 }
|
|
|
562
|
|
|
563 // Make sure leading/trailing whitespace is removed (IE can't handle it)
|
|
|
564 data = jQuery.trim( data );
|
|
|
565
|
|
|
566 // Make sure the incoming data is actual JSON
|
|
|
567 // Logic borrowed from http://json.org/json2.js
|
|
|
568 if ( rvalidchars.test(data.replace(rvalidescape, "@")
|
|
|
569 .replace(rvalidtokens, "]")
|
|
|
570 .replace(rvalidbraces, "")) ) {
|
|
|
571
|
|
|
572 // Try to use the native JSON parser first
|
|
|
573 return window.JSON && window.JSON.parse ?
|
|
|
574 window.JSON.parse( data ) :
|
|
|
575 (new Function("return " + data))();
|
|
|
576
|
|
|
577 } else {
|
|
|
578 jQuery.error( "Invalid JSON: " + data );
|
|
|
579 }
|
|
|
580 },
|
|
|
581
|
|
|
582 noop: function() {},
|
|
|
583
|
|
|
584 // Evalulates a script in a global context
|
|
|
585 globalEval: function( data ) {
|
|
|
586 if ( data && rnotwhite.test(data) ) {
|
|
|
587 // Inspired by code by Andrea Giammarchi
|
|
|
588 // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
|
|
|
589 var head = document.getElementsByTagName("head")[0] || document.documentElement,
|
|
|
590 script = document.createElement("script");
|
|
|
591
|
|
|
592 script.type = "text/javascript";
|
|
|
593
|
|
|
594 if ( jQuery.support.scriptEval ) {
|
|
|
595 script.appendChild( document.createTextNode( data ) );
|
|
|
596 } else {
|
|
|
597 script.text = data;
|
|
|
598 }
|
|
|
599
|
|
|
600 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
|
|
|
601 // This arises when a base node is used (#2709).
|
|
|
602 head.insertBefore( script, head.firstChild );
|
|
|
603 head.removeChild( script );
|
|
|
604 }
|
|
|
605 },
|
|
|
606
|
|
|
607 nodeName: function( elem, name ) {
|
|
|
608 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
|
|
|
609 },
|
|
|
610
|
|
|
611 // args is for internal usage only
|
|
|
612 each: function( object, callback, args ) {
|
|
|
613 var name, i = 0,
|
|
|
614 length = object.length,
|
|
|
615 isObj = length === undefined || jQuery.isFunction(object);
|
|
|
616
|
|
|
617 if ( args ) {
|
|
|
618 if ( isObj ) {
|
|
|
619 for ( name in object ) {
|
|
|
620 if ( callback.apply( object[ name ], args ) === false ) {
|
|
|
621 break;
|
|
|
622 }
|
|
|
623 }
|
|
|
624 } else {
|
|
|
625 for ( ; i < length; ) {
|
|
|
626 if ( callback.apply( object[ i++ ], args ) === false ) {
|
|
|
627 break;
|
|
|
628 }
|
|
|
629 }
|
|
|
630 }
|
|
|
631
|
|
|
632 // A special, fast, case for the most common use of each
|
|
|
633 } else {
|
|
|
634 if ( isObj ) {
|
|
|
635 for ( name in object ) {
|
|
|
636 if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
|
|
|
637 break;
|
|
|
638 }
|
|
|
639 }
|
|
|
640 } else {
|
|
|
641 for ( var value = object[0];
|
|
|
642 i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
|
|
|
643 }
|
|
|
644 }
|
|
|
645
|
|
|
646 return object;
|
|
|
647 },
|
|
|
648
|
|
|
649 // Use native String.trim function wherever possible
|
|
|
650 trim: trim ?
|
|
|
651 function( text ) {
|
|
|
652 return text == null ?
|
|
|
653 "" :
|
|
|
654 trim.call( text );
|
|
|
655 } :
|
|
|
656
|
|
|
657 // Otherwise use our own trimming functionality
|
|
|
658 function( text ) {
|
|
|
659 return text == null ?
|
|
|
660 "" :
|
|
|
661 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
|
|
|
662 },
|
|
|
663
|
|
|
664 // results is for internal usage only
|
|
|
665 makeArray: function( array, results ) {
|
|
|
666 var ret = results || [];
|
|
|
667
|
|
|
668 if ( array != null ) {
|
|
|
669 // The window, strings (and functions) also have 'length'
|
|
|
670 // The extra typeof function check is to prevent crashes
|
|
|
671 // in Safari 2 (See: #3039)
|
|
|
672 // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
|
|
|
673 var type = jQuery.type(array);
|
|
|
674
|
|
|
675 if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
|
|
|
676 push.call( ret, array );
|
|
|
677 } else {
|
|
|
678 jQuery.merge( ret, array );
|
|
|
679 }
|
|
|
680 }
|
|
|
681
|
|
|
682 return ret;
|
|
|
683 },
|
|
|
684
|
|
|
685 inArray: function( elem, array ) {
|
|
|
686 if ( array.indexOf ) {
|
|
|
687 return array.indexOf( elem );
|
|
|
688 }
|
|
|
689
|
|
|
690 for ( var i = 0, length = array.length; i < length; i++ ) {
|
|
|
691 if ( array[ i ] === elem ) {
|
|
|
692 return i;
|
|
|
693 }
|
|
|
694 }
|
|
|
695
|
|
|
696 return -1;
|
|
|
697 },
|
|
|
698
|
|
|
699 merge: function( first, second ) {
|
|
|
700 var i = first.length, j = 0;
|
|
|
701
|
|
|
702 if ( typeof second.length === "number" ) {
|
|
|
703 for ( var l = second.length; j < l; j++ ) {
|
|
|
704 first[ i++ ] = second[ j ];
|
|
|
705 }
|
|
|
706
|
|
|
707 } else {
|
|
|
708 while ( second[j] !== undefined ) {
|
|
|
709 first[ i++ ] = second[ j++ ];
|
|
|
710 }
|
|
|
711 }
|
|
|
712
|
|
|
713 first.length = i;
|
|
|
714
|
|
|
715 return first;
|
|
|
716 },
|
|
|
717
|
|
|
718 grep: function( elems, callback, inv ) {
|
|
|
719 var ret = [], retVal;
|
|
|
720 inv = !!inv;
|
|
|
721
|
|
|
722 // Go through the array, only saving the items
|
|
|
723 // that pass the validator function
|
|
|
724 for ( var i = 0, length = elems.length; i < length; i++ ) {
|
|
|
725 retVal = !!callback( elems[ i ], i );
|
|
|
726 if ( inv !== retVal ) {
|
|
|
727 ret.push( elems[ i ] );
|
|
|
728 }
|
|
|
729 }
|
|
|
730
|
|
|
731 return ret;
|
|
|
732 },
|
|
|
733
|
|
|
734 // arg is for internal usage only
|
|
|
735 map: function( elems, callback, arg ) {
|
|
|
736 var ret = [], value;
|
|
|
737
|
|
|
738 // Go through the array, translating each of the items to their
|
|
|
739 // new value (or values).
|
|
|
740 for ( var i = 0, length = elems.length; i < length; i++ ) {
|
|
|
741 value = callback( elems[ i ], i, arg );
|
|
|
742
|
|
|
743 if ( value != null ) {
|
|
|
744 ret[ ret.length ] = value;
|
|
|
745 }
|
|
|
746 }
|
|
|
747
|
|
|
748 return ret.concat.apply( [], ret );
|
|
|
749 },
|
|
|
750
|
|
|
751 // A global GUID counter for objects
|
|
|
752 guid: 1,
|
|
|
753
|
|
|
754 proxy: function( fn, proxy, thisObject ) {
|
|
|
755 if ( arguments.length === 2 ) {
|
|
|
756 if ( typeof proxy === "string" ) {
|
|
|
757 thisObject = fn;
|
|
|
758 fn = thisObject[ proxy ];
|
|
|
759 proxy = undefined;
|
|
|
760
|
|
|
761 } else if ( proxy && !jQuery.isFunction( proxy ) ) {
|
|
|
762 thisObject = proxy;
|
|
|
763 proxy = undefined;
|
|
|
764 }
|
|
|
765 }
|
|
|
766
|
|
|
767 if ( !proxy && fn ) {
|
|
|
768 proxy = function() {
|
|
|
769 return fn.apply( thisObject || this, arguments );
|
|
|
770 };
|
|
|
771 }
|
|
|
772
|
|
|
773 // Set the guid of unique handler to the same of original handler, so it can be removed
|
|
|
774 if ( fn ) {
|
|
|
775 proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
|
|
|
776 }
|
|
|
777
|
|
|
778 // So proxy can be declared as an argument
|
|
|
779 return proxy;
|
|
|
780 },
|
|
|
781
|
|
|
782 // Mutifunctional method to get and set values to a collection
|
|
|
783 // The value/s can be optionally by executed if its a function
|
|
|
784 access: function( elems, key, value, exec, fn, pass ) {
|
|
|
785 var length = elems.length;
|
|
|
786
|
|
|
787 // Setting many attributes
|
|
|
788 if ( typeof key === "object" ) {
|
|
|
789 for ( var k in key ) {
|
|
|
790 jQuery.access( elems, k, key[k], exec, fn, value );
|
|
|
791 }
|
|
|
792 return elems;
|
|
|
793 }
|
|
|
794
|
|
|
795 // Setting one attribute
|
|
|
796 if ( value !== undefined ) {
|
|
|
797 // Optionally, function values get executed if exec is true
|
|
|
798 exec = !pass && exec && jQuery.isFunction(value);
|
|
|
799
|
|
|
800 for ( var i = 0; i < length; i++ ) {
|
|
|
801 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
|
|
|
802 }
|
|
|
803
|
|
|
804 return elems;
|
|
|
805 }
|
|
|
806
|
|
|
807 // Getting an attribute
|
|
|
808 return length ? fn( elems[0], key ) : undefined;
|
|
|
809 },
|
|
|
810
|
|
|
811 now: function() {
|
|
|
812 return (new Date()).getTime();
|
|
|
813 },
|
|
|
814
|
|
|
815 // Use of jQuery.browser is frowned upon.
|
|
|
816 // More details: http://docs.jquery.com/Utilities/jQuery.browser
|
|
|
817 uaMatch: function( ua ) {
|
|
|
818 ua = ua.toLowerCase();
|
|
|
819
|
|
|
820 var match = rwebkit.exec( ua ) ||
|
|
|
821 ropera.exec( ua ) ||
|
|
|
822 rmsie.exec( ua ) ||
|
|
|
823 ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
|
|
|
824 [];
|
|
|
825
|
|
|
826 return { browser: match[1] || "", version: match[2] || "0" };
|
|
|
827 },
|
|
|
828
|
|
|
829 browser: {}
|
|
|
830 });
|
|
|
831
|
|
|
832 // Populate the class2type map
|
|
|
833 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
|
|
|
834 class2type[ "[object " + name + "]" ] = name.toLowerCase();
|
|
|
835 });
|
|
|
836
|
|
|
837 browserMatch = jQuery.uaMatch( userAgent );
|
|
|
838 if ( browserMatch.browser ) {
|
|
|
839 jQuery.browser[ browserMatch.browser ] = true;
|
|
|
840 jQuery.browser.version = browserMatch.version;
|
|
|
841 }
|
|
|
842
|
|
|
843 // Deprecated, use jQuery.browser.webkit instead
|
|
|
844 if ( jQuery.browser.webkit ) {
|
|
|
845 jQuery.browser.safari = true;
|
|
|
846 }
|
|
|
847
|
|
|
848 if ( indexOf ) {
|
|
|
849 jQuery.inArray = function( elem, array ) {
|
|
|
850 return indexOf.call( array, elem );
|
|
|
851 };
|
|
|
852 }
|
|
|
853
|
|
|
854 // Verify that \s matches non-breaking spaces
|
|
|
855 // (IE fails on this test)
|
|
|
856 if ( !rwhite.test( "\xA0" ) ) {
|
|
|
857 trimLeft = /^[\s\xA0]+/;
|
|
|
858 trimRight = /[\s\xA0]+$/;
|
|
|
859 }
|
|
|
860
|
|
|
861 // All jQuery objects should point back to these
|
|
|
862 rootjQuery = jQuery(document);
|
|
|
863
|
|
|
864 // Cleanup functions for the document ready method
|
|
|
865 if ( document.addEventListener ) {
|
|
|
866 DOMContentLoaded = function() {
|
|
|
867 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
|
|
|
868 jQuery.ready();
|
|
|
869 };
|
|
|
870
|
|
|
871 } else if ( document.attachEvent ) {
|
|
|
872 DOMContentLoaded = function() {
|
|
|
873 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
|
|
|
874 if ( document.readyState === "complete" ) {
|
|
|
875 document.detachEvent( "onreadystatechange", DOMContentLoaded );
|
|
|
876 jQuery.ready();
|
|
|
877 }
|
|
|
878 };
|
|
|
879 }
|
|
|
880
|
|
|
881 // The DOM ready check for Internet Explorer
|
|
|
882 function doScrollCheck() {
|
|
|
883 if ( jQuery.isReady ) {
|
|
|
884 return;
|
|
|
885 }
|
|
|
886
|
|
|
887 try {
|
|
|
888 // If IE is used, use the trick by Diego Perini
|
|
|
889 // http://javascript.nwbox.com/IEContentLoaded/
|
|
|
890 document.documentElement.doScroll("left");
|
|
|
891 } catch(e) {
|
|
|
892 setTimeout( doScrollCheck, 1 );
|
|
|
893 return;
|
|
|
894 }
|
|
|
895
|
|
|
896 // and execute any waiting functions
|
|
|
897 jQuery.ready();
|
|
|
898 }
|
|
|
899
|
|
|
900 // Expose jQuery to the global object
|
|
|
901 return (window.jQuery = window.$ = jQuery);
|
|
|
902
|
|
|
903 })();
|
|
|
904
|
|
|
905
|
|
|
906 (function() {
|
|
|
907
|
|
|
908 jQuery.support = {};
|
|
|
909
|
|
|
910 var root = document.documentElement,
|
|
|
911 script = document.createElement("script"),
|
|
|
912 div = document.createElement("div"),
|
|
|
913 id = "script" + jQuery.now();
|
|
|
914
|
|
|
915 div.style.display = "none";
|
|
|
916 div.innerHTML = " <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
|
|
|
917
|
|
|
918 var all = div.getElementsByTagName("*"),
|
|
|
919 a = div.getElementsByTagName("a")[0],
|
|
|
920 select = document.createElement("select"),
|
|
|
921 opt = select.appendChild( document.createElement("option") );
|
|
|
922
|
|
|
923 // Can't get basic test support
|
|
|
924 if ( !all || !all.length || !a ) {
|
|
|
925 return;
|
|
|
926 }
|
|
|
927
|
|
|
928 jQuery.support = {
|
|
|
929 // IE strips leading whitespace when .innerHTML is used
|
|
|
930 leadingWhitespace: div.firstChild.nodeType === 3,
|
|
|
931
|
|
|
932 // Make sure that tbody elements aren't automatically inserted
|
|
|
933 // IE will insert them into empty tables
|
|
|
934 tbody: !div.getElementsByTagName("tbody").length,
|
|
|
935
|
|
|
936 // Make sure that link elements get serialized correctly by innerHTML
|
|
|
937 // This requires a wrapper element in IE
|
|
|
938 htmlSerialize: !!div.getElementsByTagName("link").length,
|
|
|
939
|
|
|
940 // Get the style information from getAttribute
|
|
|
941 // (IE uses .cssText insted)
|
|
|
942 style: /red/.test( a.getAttribute("style") ),
|
|
|
943
|
|
|
944 // Make sure that URLs aren't manipulated
|
|
|
945 // (IE normalizes it by default)
|
|
|
946 hrefNormalized: a.getAttribute("href") === "/a",
|
|
|
947
|
|
|
948 // Make sure that element opacity exists
|
|
|
949 // (IE uses filter instead)
|
|
|
950 // Use a regex to work around a WebKit issue. See #5145
|
|
|
951 opacity: /^0.55$/.test( a.style.opacity ),
|
|
|
952
|
|
|
953 // Verify style float existence
|
|
|
954 // (IE uses styleFloat instead of cssFloat)
|
|
|
955 cssFloat: !!a.style.cssFloat,
|
|
|
956
|
|
|
957 // Make sure that if no value is specified for a checkbox
|
|
|
958 // that it defaults to "on".
|
|
|
959 // (WebKit defaults to "" instead)
|
|
|
960 checkOn: div.getElementsByTagName("input")[0].value === "on",
|
|
|
961
|
|
|
962 // Make sure that a selected-by-default option has a working selected property.
|
|
|
963 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
|
|
|
964 optSelected: opt.selected,
|
|
|
965
|
|
|
966 // Will be defined later
|
|
|
967 optDisabled: false,
|
|
|
968 checkClone: false,
|
|
|
969 scriptEval: false,
|
|
|
970 noCloneEvent: true,
|
|
|
971 boxModel: null,
|
|
|
972 inlineBlockNeedsLayout: false,
|
|
|
973 shrinkWrapBlocks: false,
|
|
|
974 reliableHiddenOffsets: true
|
|
|
975 };
|
|
|
976
|
|
|
977 // Make sure that the options inside disabled selects aren't marked as disabled
|
|
|
978 // (WebKit marks them as diabled)
|
|
|
979 select.disabled = true;
|
|
|
980 jQuery.support.optDisabled = !opt.disabled;
|
|
|
981
|
|
|
982 script.type = "text/javascript";
|
|
|
983 try {
|
|
|
984 script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
|
|
|
985 } catch(e) {}
|
|
|
986
|
|
|
987 root.insertBefore( script, root.firstChild );
|
|
|
988
|
|
|
989 // Make sure that the execution of code works by injecting a script
|
|
|
990 // tag with appendChild/createTextNode
|
|
|
991 // (IE doesn't support this, fails, and uses .text instead)
|
|
|
992 if ( window[ id ] ) {
|
|
|
993 jQuery.support.scriptEval = true;
|
|
|
994 delete window[ id ];
|
|
|
995 }
|
|
|
996
|
|
|
997 root.removeChild( script );
|
|
|
998
|
|
|
999 if ( div.attachEvent && div.fireEvent ) {
|
|
|
1000 div.attachEvent("onclick", function click() {
|
|
|
1001 // Cloning a node shouldn't copy over any
|
|
|
1002 // bound event handlers (IE does this)
|
|
|
1003 jQuery.support.noCloneEvent = false;
|
|
|
1004 div.detachEvent("onclick", click);
|
|
|
1005 });
|
|
|
1006 div.cloneNode(true).fireEvent("onclick");
|
|
|
1007 }
|
|
|
1008
|
|
|
1009 div = document.createElement("div");
|
|
|
1010 div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";
|
|
|
1011
|
|
|
1012 var fragment = document.createDocumentFragment();
|
|
|
1013 fragment.appendChild( div.firstChild );
|
|
|
1014
|
|
|
1015 // WebKit doesn't clone checked state correctly in fragments
|
|
|
1016 jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
|
|
|
1017
|
|
|
1018 // Figure out if the W3C box model works as expected
|
|
|
1019 // document.body must exist before we can do this
|
|
|
1020 jQuery(function() {
|
|
|
1021 var div = document.createElement("div");
|
|
|
1022 div.style.width = div.style.paddingLeft = "1px";
|
|
|
1023
|
|
|
1024 document.body.appendChild( div );
|
|
|
1025 jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
|
|
|
1026
|
|
|
1027 if ( "zoom" in div.style ) {
|
|
|
1028 // Check if natively block-level elements act like inline-block
|
|
|
1029 // elements when setting their display to 'inline' and giving
|
|
|
1030 // them layout
|
|
|
1031 // (IE < 8 does this)
|
|
|
1032 div.style.display = "inline";
|
|
|
1033 div.style.zoom = 1;
|
|
|
1034 jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2;
|
|
|
1035
|
|
|
1036 // Check if elements with layout shrink-wrap their children
|
|
|
1037 // (IE 6 does this)
|
|
|
1038 div.style.display = "";
|
|
|
1039 div.innerHTML = "<div style='width:4px;'></div>";
|
|
|
1040 jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2;
|
|
|
1041 }
|
|
|
1042
|
|
|
1043 div.innerHTML = "<table><tr><td style='padding:0;display:none'></td><td>t</td></tr></table>";
|
|
|
1044 var tds = div.getElementsByTagName("td");
|
|
|
1045
|
|
|
1046 // Check if table cells still have offsetWidth/Height when they are set
|
|
|
1047 // to display:none and there are still other visible table cells in a
|
|
|
1048 // table row; if so, offsetWidth/Height are not reliable for use when
|
|
|
1049 // determining if an element has been hidden directly using
|
|
|
1050 // display:none (it is still safe to use offsets if a parent element is
|
|
|
1051 // hidden; don safety goggles and see bug #4512 for more information).
|
|
|
1052 // (only IE 8 fails this test)
|
|
|
1053 jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0;
|
|
|
1054
|
|
|
1055 tds[0].style.display = "";
|
|
|
1056 tds[1].style.display = "none";
|
|
|
1057
|
|
|
1058 // Check if empty table cells still have offsetWidth/Height
|
|
|
1059 // (IE < 8 fail this test)
|
|
|
1060 jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0;
|
|
|
1061 div.innerHTML = "";
|
|
|
1062
|
|
|
1063 document.body.removeChild( div ).style.display = "none";
|
|
|
1064 div = tds = null;
|
|
|
1065 });
|
|
|
1066
|
|
|
1067 // Technique from Juriy Zaytsev
|
|
|
1068 // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
|
|
|
1069 var eventSupported = function( eventName ) {
|
|
|
1070 var el = document.createElement("div");
|
|
|
1071 eventName = "on" + eventName;
|
|
|
1072
|
|
|
1073 var isSupported = (eventName in el);
|
|
|
1074 if ( !isSupported ) {
|
|
|
1075 el.setAttribute(eventName, "return;");
|
|
|
1076 isSupported = typeof el[eventName] === "function";
|
|
|
1077 }
|
|
|
1078 el = null;
|
|
|
1079
|
|
|
1080 return isSupported;
|
|
|
1081 };
|
|
|
1082
|
|
|
1083 jQuery.support.submitBubbles = eventSupported("submit");
|
|
|
1084 jQuery.support.changeBubbles = eventSupported("change");
|
|
|
1085
|
|
|
1086 // release memory in IE
|
|
|
1087 root = script = div = all = a = null;
|
|
|
1088 })();
|
|
|
1089
|
|
|
1090 jQuery.props = {
|
|
|
1091 "for": "htmlFor",
|
|
|
1092 "class": "className",
|
|
|
1093 readonly: "readOnly",
|
|
|
1094 maxlength: "maxLength",
|
|
|
1095 cellspacing: "cellSpacing",
|
|
|
1096 rowspan: "rowSpan",
|
|
|
1097 colspan: "colSpan",
|
|
|
1098 tabindex: "tabIndex",
|
|
|
1099 usemap: "useMap",
|
|
|
1100 frameborder: "frameBorder"
|
|
|
1101 };
|
|
|
1102
|
|
|
1103
|
|
|
1104
|
|
|
1105
|
|
|
1106 var windowData = {},
|
|
|
1107 rbrace = /^(?:\{.*\}|\[.*\])$/;
|
|
|
1108
|
|
|
1109 jQuery.extend({
|
|
|
1110 cache: {},
|
|
|
1111
|
|
|
1112 // Please use with caution
|
|
|
1113 uuid: 0,
|
|
|
1114
|
|
|
1115 // Unique for each copy of jQuery on the page
|
|
|
1116 expando: "jQuery" + jQuery.now(),
|
|
|
1117
|
|
|
1118 // The following elements throw uncatchable exceptions if you
|
|
|
1119 // attempt to add expando properties to them.
|
|
|
1120 noData: {
|
|
|
1121 "embed": true,
|
|
|
1122 // Ban all objects except for Flash (which handle expandos)
|
|
|
1123 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
|
|
|
1124 "applet": true
|
|
|
1125 },
|
|
|
1126
|
|
|
1127 data: function( elem, name, data ) {
|
|
|
1128 if ( !jQuery.acceptData( elem ) ) {
|
|
|
1129 return;
|
|
|
1130 }
|
|
|
1131
|
|
|
1132 elem = elem == window ?
|
|
|
1133 windowData :
|
|
|
1134 elem;
|
|
|
1135
|
|
|
1136 var isNode = elem.nodeType,
|
|
|
1137 id = isNode ? elem[ jQuery.expando ] : null,
|
|
|
1138 cache = jQuery.cache, thisCache;
|
|
|
1139
|
|
|
1140 if ( isNode && !id && typeof name === "string" && data === undefined ) {
|
|
|
1141 return;
|
|
|
1142 }
|
|
|
1143
|
|
|
1144 // Get the data from the object directly
|
|
|
1145 if ( !isNode ) {
|
|
|
1146 cache = elem;
|
|
|
1147
|
|
|
1148 // Compute a unique ID for the element
|
|
|
1149 } else if ( !id ) {
|
|
|
1150 elem[ jQuery.expando ] = id = ++jQuery.uuid;
|
|
|
1151 }
|
|
|
1152
|
|
|
1153 // Avoid generating a new cache unless none exists and we
|
|
|
1154 // want to manipulate it.
|
|
|
1155 if ( typeof name === "object" ) {
|
|
|
1156 if ( isNode ) {
|
|
|
1157 cache[ id ] = jQuery.extend(cache[ id ], name);
|
|
|
1158
|
|
|
1159 } else {
|
|
|
1160 jQuery.extend( cache, name );
|
|
|
1161 }
|
|
|
1162
|
|
|
1163 } else if ( isNode && !cache[ id ] ) {
|
|
|
1164 cache[ id ] = {};
|
|
|
1165 }
|
|
|
1166
|
|
|
1167 thisCache = isNode ? cache[ id ] : cache;
|
|
|
1168
|
|
|
1169 // Prevent overriding the named cache with undefined values
|
|
|
1170 if ( data !== undefined ) {
|
|
|
1171 thisCache[ name ] = data;
|
|
|
1172 }
|
|
|
1173
|
|
|
1174 return typeof name === "string" ? thisCache[ name ] : thisCache;
|
|
|
1175 },
|
|
|
1176
|
|
|
1177 removeData: function( elem, name ) {
|
|
|
1178 if ( !jQuery.acceptData( elem ) ) {
|
|
|
1179 return;
|
|
|
1180 }
|
|
|
1181
|
|
|
1182 elem = elem == window ?
|
|
|
1183 windowData :
|
|
|
1184 elem;
|
|
|
1185
|
|
|
1186 var isNode = elem.nodeType,
|
|
|
1187 id = isNode ? elem[ jQuery.expando ] : elem,
|
|
|
1188 cache = jQuery.cache,
|
|
|
1189 thisCache = isNode ? cache[ id ] : id;
|
|
|
1190
|
|
|
1191 // If we want to remove a specific section of the element's data
|
|
|
1192 if ( name ) {
|
|
|
1193 if ( thisCache ) {
|
|
|
1194 // Remove the section of cache data
|
|
|
1195 delete thisCache[ name ];
|
|
|
1196
|
|
|
1197 // If we've removed all the data, remove the element's cache
|
|
|
1198 if ( isNode && jQuery.isEmptyObject(thisCache) ) {
|
|
|
1199 jQuery.removeData( elem );
|
|
|
1200 }
|
|
|
1201 }
|
|
|
1202
|
|
|
1203 // Otherwise, we want to remove all of the element's data
|
|
|
1204 } else {
|
|
|
1205 if ( isNode && jQuery.support.deleteExpando ) {
|
|
|
1206 delete elem[ jQuery.expando ];
|
|
|
1207
|
|
|
1208 } else if ( elem.removeAttribute ) {
|
|
|
1209 elem.removeAttribute( jQuery.expando );
|
|
|
1210
|
|
|
1211 // Completely remove the data cache
|
|
|
1212 } else if ( isNode ) {
|
|
|
1213 delete cache[ id ];
|
|
|
1214
|
|
|
1215 // Remove all fields from the object
|
|
|
1216 } else {
|
|
|
1217 for ( var n in elem ) {
|
|
|
1218 delete elem[ n ];
|
|
|
1219 }
|
|
|
1220 }
|
|
|
1221 }
|
|
|
1222 },
|
|
|
1223
|
|
|
1224 // A method for determining if a DOM node can handle the data expando
|
|
|
1225 acceptData: function( elem ) {
|
|
|
1226 if ( elem.nodeName ) {
|
|
|
1227 var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
|
|
|
1228
|
|
|
1229 if ( match ) {
|
|
|
1230 return !(match === true || elem.getAttribute("classid") !== match);
|
|
|
1231 }
|
|
|
1232 }
|
|
|
1233
|
|
|
1234 return true;
|
|
|
1235 }
|
|
|
1236 });
|
|
|
1237
|
|
|
1238 jQuery.fn.extend({
|
|
|
1239 data: function( key, value ) {
|
|
|
1240 if ( typeof key === "undefined" ) {
|
|
|
1241 return this.length ? jQuery.data( this[0] ) : null;
|
|
|
1242
|
|
|
1243 } else if ( typeof key === "object" ) {
|
|
|
1244 return this.each(function() {
|
|
|
1245 jQuery.data( this, key );
|
|
|
1246 });
|
|
|
1247 }
|
|
|
1248
|
|
|
1249 var parts = key.split(".");
|
|
|
1250 parts[1] = parts[1] ? "." + parts[1] : "";
|
|
|
1251
|
|
|
1252 if ( value === undefined ) {
|
|
|
1253 var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
|
|
|
1254
|
|
|
1255 // Try to fetch any internally stored data first
|
|
|
1256 if ( data === undefined && this.length ) {
|
|
|
1257 data = jQuery.data( this[0], key );
|
|
|
1258
|
|
|
1259 // If nothing was found internally, try to fetch any
|
|
|
1260 // data from the HTML5 data-* attribute
|
|
|
1261 if ( data === undefined && this[0].nodeType === 1 ) {
|
|
|
1262 data = this[0].getAttribute( "data-" + key );
|
|
|
1263
|
|
|
1264 if ( typeof data === "string" ) {
|
|
|
1265 try {
|
|
|
1266 data = data === "true" ? true :
|
|
|
1267 data === "false" ? false :
|
|
|
1268 data === "null" ? null :
|
|
|
1269 !jQuery.isNaN( data ) ? parseFloat( data ) :
|
|
|
1270 rbrace.test( data ) ? jQuery.parseJSON( data ) :
|
|
|
1271 data;
|
|
|
1272 } catch( e ) {}
|
|
|
1273
|
|
|
1274 } else {
|
|
|
1275 data = undefined;
|
|
|
1276 }
|
|
|
1277 }
|
|
|
1278 }
|
|
|
1279
|
|
|
1280 return data === undefined && parts[1] ?
|
|
|
1281 this.data( parts[0] ) :
|
|
|
1282 data;
|
|
|
1283
|
|
|
1284 } else {
|
|
|
1285 return this.each(function() {
|
|
|
1286 var $this = jQuery( this ), args = [ parts[0], value ];
|
|
|
1287
|
|
|
1288 $this.triggerHandler( "setData" + parts[1] + "!", args );
|
|
|
1289 jQuery.data( this, key, value );
|
|
|
1290 $this.triggerHandler( "changeData" + parts[1] + "!", args );
|
|
|
1291 });
|
|
|
1292 }
|
|
|
1293 },
|
|
|
1294
|
|
|
1295 removeData: function( key ) {
|
|
|
1296 return this.each(function() {
|
|
|
1297 jQuery.removeData( this, key );
|
|
|
1298 });
|
|
|
1299 }
|
|
|
1300 });
|
|
|
1301
|
|
|
1302
|
|
|
1303
|
|
|
1304
|
|
|
1305 jQuery.extend({
|
|
|
1306 queue: function( elem, type, data ) {
|
|
|
1307 if ( !elem ) {
|
|
|
1308 return;
|
|
|
1309 }
|
|
|
1310
|
|
|
1311 type = (type || "fx") + "queue";
|
|
|
1312 var q = jQuery.data( elem, type );
|
|
|
1313
|
|
|
1314 // Speed up dequeue by getting out quickly if this is just a lookup
|
|
|
1315 if ( !data ) {
|
|
|
1316 return q || [];
|
|
|
1317 }
|
|
|
1318
|
|
|
1319 if ( !q || jQuery.isArray(data) ) {
|
|
|
1320 q = jQuery.data( elem, type, jQuery.makeArray(data) );
|
|
|
1321
|
|
|
1322 } else {
|
|
|
1323 q.push( data );
|
|
|
1324 }
|
|
|
1325
|
|
|
1326 return q;
|
|
|
1327 },
|
|
|
1328
|
|
|
1329 dequeue: function( elem, type ) {
|
|
|
1330 type = type || "fx";
|
|
|
1331
|
|
|
1332 var queue = jQuery.queue( elem, type ), fn = queue.shift();
|
|
|
1333
|
|
|
1334 // If the fx queue is dequeued, always remove the progress sentinel
|
|
|
1335 if ( fn === "inprogress" ) {
|
|
|
1336 fn = queue.shift();
|
|
|
1337 }
|
|
|
1338
|
|
|
1339 if ( fn ) {
|
|
|
1340 // Add a progress sentinel to prevent the fx queue from being
|
|
|
1341 // automatically dequeued
|
|
|
1342 if ( type === "fx" ) {
|
|
|
1343 queue.unshift("inprogress");
|
|
|
1344 }
|
|
|
1345
|
|
|
1346 fn.call(elem, function() {
|
|
|
1347 jQuery.dequeue(elem, type);
|
|
|
1348 });
|
|
|
1349 }
|
|
|
1350 }
|
|
|
1351 });
|
|
|
1352
|
|
|
1353 jQuery.fn.extend({
|
|
|
1354 queue: function( type, data ) {
|
|
|
1355 if ( typeof type !== "string" ) {
|
|
|
1356 data = type;
|
|
|
1357 type = "fx";
|
|
|
1358 }
|
|
|
1359
|
|
|
1360 if ( data === undefined ) {
|
|
|
1361 return jQuery.queue( this[0], type );
|
|
|
1362 }
|
|
|
1363 return this.each(function( i ) {
|
|
|
1364 var queue = jQuery.queue( this, type, data );
|
|
|
1365
|
|
|
1366 if ( type === "fx" && queue[0] !== "inprogress" ) {
|
|
|
1367 jQuery.dequeue( this, type );
|
|
|
1368 }
|
|
|
1369 });
|
|
|
1370 },
|
|
|
1371 dequeue: function( type ) {
|
|
|
1372 return this.each(function() {
|
|
|
1373 jQuery.dequeue( this, type );
|
|
|
1374 });
|
|
|
1375 },
|
|
|
1376
|
|
|
1377 // Based off of the plugin by Clint Helfers, with permission.
|
|
|
1378 // http://blindsignals.com/index.php/2009/07/jquery-delay/
|
|
|
1379 delay: function( time, type ) {
|
|
|
1380 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
|
|
|
1381 type = type || "fx";
|
|
|
1382
|
|
|
1383 return this.queue( type, function() {
|
|
|
1384 var elem = this;
|
|
|
1385 setTimeout(function() {
|
|
|
1386 jQuery.dequeue( elem, type );
|
|
|
1387 }, time );
|
|
|
1388 });
|
|
|
1389 },
|
|
|
1390
|
|
|
1391 clearQueue: function( type ) {
|
|
|
1392 return this.queue( type || "fx", [] );
|
|
|
1393 }
|
|
|
1394 });
|
|
|
1395
|
|
|
1396
|
|
|
1397
|
|
|
1398
|
|
|
1399 var rclass = /[\n\t]/g,
|
|
|
1400 rspaces = /\s+/,
|
|
|
1401 rreturn = /\r/g,
|
|
|
1402 rspecialurl = /^(?:href|src|style)$/,
|
|
|
1403 rtype = /^(?:button|input)$/i,
|
|
|
1404 rfocusable = /^(?:button|input|object|select|textarea)$/i,
|
|
|
1405 rclickable = /^a(?:rea)?$/i,
|
|
|
1406 rradiocheck = /^(?:radio|checkbox)$/i;
|
|
|
1407
|
|
|
1408 jQuery.fn.extend({
|
|
|
1409 attr: function( name, value ) {
|
|
|
1410 return jQuery.access( this, name, value, true, jQuery.attr );
|
|
|
1411 },
|
|
|
1412
|
|
|
1413 removeAttr: function( name, fn ) {
|
|
|
1414 return this.each(function(){
|
|
|
1415 jQuery.attr( this, name, "" );
|
|
|
1416 if ( this.nodeType === 1 ) {
|
|
|
1417 this.removeAttribute( name );
|
|
|
1418 }
|
|
|
1419 });
|
|
|
1420 },
|
|
|
1421
|
|
|
1422 addClass: function( value ) {
|
|
|
1423 if ( jQuery.isFunction(value) ) {
|
|
|
1424 return this.each(function(i) {
|
|
|
1425 var self = jQuery(this);
|
|
|
1426 self.addClass( value.call(this, i, self.attr("class")) );
|
|
|
1427 });
|
|
|
1428 }
|
|
|
1429
|
|
|
1430 if ( value && typeof value === "string" ) {
|
|
|
1431 var classNames = (value || "").split( rspaces );
|
|
|
1432
|
|
|
1433 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
1434 var elem = this[i];
|
|
|
1435
|
|
|
1436 if ( elem.nodeType === 1 ) {
|
|
|
1437 if ( !elem.className ) {
|
|
|
1438 elem.className = value;
|
|
|
1439
|
|
|
1440 } else {
|
|
|
1441 var className = " " + elem.className + " ", setClass = elem.className;
|
|
|
1442 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
|
|
|
1443 if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
|
|
|
1444 setClass += " " + classNames[c];
|
|
|
1445 }
|
|
|
1446 }
|
|
|
1447 elem.className = jQuery.trim( setClass );
|
|
|
1448 }
|
|
|
1449 }
|
|
|
1450 }
|
|
|
1451 }
|
|
|
1452
|
|
|
1453 return this;
|
|
|
1454 },
|
|
|
1455
|
|
|
1456 removeClass: function( value ) {
|
|
|
1457 if ( jQuery.isFunction(value) ) {
|
|
|
1458 return this.each(function(i) {
|
|
|
1459 var self = jQuery(this);
|
|
|
1460 self.removeClass( value.call(this, i, self.attr("class")) );
|
|
|
1461 });
|
|
|
1462 }
|
|
|
1463
|
|
|
1464 if ( (value && typeof value === "string") || value === undefined ) {
|
|
|
1465 var classNames = (value || "").split( rspaces );
|
|
|
1466
|
|
|
1467 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
1468 var elem = this[i];
|
|
|
1469
|
|
|
1470 if ( elem.nodeType === 1 && elem.className ) {
|
|
|
1471 if ( value ) {
|
|
|
1472 var className = (" " + elem.className + " ").replace(rclass, " ");
|
|
|
1473 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
|
|
|
1474 className = className.replace(" " + classNames[c] + " ", " ");
|
|
|
1475 }
|
|
|
1476 elem.className = jQuery.trim( className );
|
|
|
1477
|
|
|
1478 } else {
|
|
|
1479 elem.className = "";
|
|
|
1480 }
|
|
|
1481 }
|
|
|
1482 }
|
|
|
1483 }
|
|
|
1484
|
|
|
1485 return this;
|
|
|
1486 },
|
|
|
1487
|
|
|
1488 toggleClass: function( value, stateVal ) {
|
|
|
1489 var type = typeof value, isBool = typeof stateVal === "boolean";
|
|
|
1490
|
|
|
1491 if ( jQuery.isFunction( value ) ) {
|
|
|
1492 return this.each(function(i) {
|
|
|
1493 var self = jQuery(this);
|
|
|
1494 self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
|
|
|
1495 });
|
|
|
1496 }
|
|
|
1497
|
|
|
1498 return this.each(function() {
|
|
|
1499 if ( type === "string" ) {
|
|
|
1500 // toggle individual class names
|
|
|
1501 var className, i = 0, self = jQuery(this),
|
|
|
1502 state = stateVal,
|
|
|
1503 classNames = value.split( rspaces );
|
|
|
1504
|
|
|
1505 while ( (className = classNames[ i++ ]) ) {
|
|
|
1506 // check each className given, space seperated list
|
|
|
1507 state = isBool ? state : !self.hasClass( className );
|
|
|
1508 self[ state ? "addClass" : "removeClass" ]( className );
|
|
|
1509 }
|
|
|
1510
|
|
|
1511 } else if ( type === "undefined" || type === "boolean" ) {
|
|
|
1512 if ( this.className ) {
|
|
|
1513 // store className if set
|
|
|
1514 jQuery.data( this, "__className__", this.className );
|
|
|
1515 }
|
|
|
1516
|
|
|
1517 // toggle whole className
|
|
|
1518 this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
|
|
|
1519 }
|
|
|
1520 });
|
|
|
1521 },
|
|
|
1522
|
|
|
1523 hasClass: function( selector ) {
|
|
|
1524 var className = " " + selector + " ";
|
|
|
1525 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
1526 if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
|
|
|
1527 return true;
|
|
|
1528 }
|
|
|
1529 }
|
|
|
1530
|
|
|
1531 return false;
|
|
|
1532 },
|
|
|
1533
|
|
|
1534 val: function( value ) {
|
|
|
1535 if ( !arguments.length ) {
|
|
|
1536 var elem = this[0];
|
|
|
1537
|
|
|
1538 if ( elem ) {
|
|
|
1539 if ( jQuery.nodeName( elem, "option" ) ) {
|
|
|
1540 // attributes.value is undefined in Blackberry 4.7 but
|
|
|
1541 // uses .value. See #6932
|
|
|
1542 var val = elem.attributes.value;
|
|
|
1543 return !val || val.specified ? elem.value : elem.text;
|
|
|
1544 }
|
|
|
1545
|
|
|
1546 // We need to handle select boxes special
|
|
|
1547 if ( jQuery.nodeName( elem, "select" ) ) {
|
|
|
1548 var index = elem.selectedIndex,
|
|
|
1549 values = [],
|
|
|
1550 options = elem.options,
|
|
|
1551 one = elem.type === "select-one";
|
|
|
1552
|
|
|
1553 // Nothing was selected
|
|
|
1554 if ( index < 0 ) {
|
|
|
1555 return null;
|
|
|
1556 }
|
|
|
1557
|
|
|
1558 // Loop through all the selected options
|
|
|
1559 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
|
|
|
1560 var option = options[ i ];
|
|
|
1561
|
|
|
1562 // Don't return options that are disabled or in a disabled optgroup
|
|
|
1563 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
|
|
|
1564 (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
|
|
|
1565
|
|
|
1566 // Get the specific value for the option
|
|
|
1567 value = jQuery(option).val();
|
|
|
1568
|
|
|
1569 // We don't need an array for one selects
|
|
|
1570 if ( one ) {
|
|
|
1571 return value;
|
|
|
1572 }
|
|
|
1573
|
|
|
1574 // Multi-Selects return an array
|
|
|
1575 values.push( value );
|
|
|
1576 }
|
|
|
1577 }
|
|
|
1578
|
|
|
1579 return values;
|
|
|
1580 }
|
|
|
1581
|
|
|
1582 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
|
|
|
1583 if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
|
|
|
1584 return elem.getAttribute("value") === null ? "on" : elem.value;
|
|
|
1585 }
|
|
|
1586
|
|
|
1587
|
|
|
1588 // Everything else, we just grab the value
|
|
|
1589 return (elem.value || "").replace(rreturn, "");
|
|
|
1590
|
|
|
1591 }
|
|
|
1592
|
|
|
1593 return undefined;
|
|
|
1594 }
|
|
|
1595
|
|
|
1596 var isFunction = jQuery.isFunction(value);
|
|
|
1597
|
|
|
1598 return this.each(function(i) {
|
|
|
1599 var self = jQuery(this), val = value;
|
|
|
1600
|
|
|
1601 if ( this.nodeType !== 1 ) {
|
|
|
1602 return;
|
|
|
1603 }
|
|
|
1604
|
|
|
1605 if ( isFunction ) {
|
|
|
1606 val = value.call(this, i, self.val());
|
|
|
1607 }
|
|
|
1608
|
|
|
1609 // Treat null/undefined as ""; convert numbers to string
|
|
|
1610 if ( val == null ) {
|
|
|
1611 val = "";
|
|
|
1612 } else if ( typeof val === "number" ) {
|
|
|
1613 val += "";
|
|
|
1614 } else if ( jQuery.isArray(val) ) {
|
|
|
1615 val = jQuery.map(val, function (value) {
|
|
|
1616 return value == null ? "" : value + "";
|
|
|
1617 });
|
|
|
1618 }
|
|
|
1619
|
|
|
1620 if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
|
|
|
1621 this.checked = jQuery.inArray( self.val(), val ) >= 0;
|
|
|
1622
|
|
|
1623 } else if ( jQuery.nodeName( this, "select" ) ) {
|
|
|
1624 var values = jQuery.makeArray(val);
|
|
|
1625
|
|
|
1626 jQuery( "option", this ).each(function() {
|
|
|
1627 this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
|
|
|
1628 });
|
|
|
1629
|
|
|
1630 if ( !values.length ) {
|
|
|
1631 this.selectedIndex = -1;
|
|
|
1632 }
|
|
|
1633
|
|
|
1634 } else {
|
|
|
1635 this.value = val;
|
|
|
1636 }
|
|
|
1637 });
|
|
|
1638 }
|
|
|
1639 });
|
|
|
1640
|
|
|
1641 jQuery.extend({
|
|
|
1642 attrFn: {
|
|
|
1643 val: true,
|
|
|
1644 css: true,
|
|
|
1645 html: true,
|
|
|
1646 text: true,
|
|
|
1647 data: true,
|
|
|
1648 width: true,
|
|
|
1649 height: true,
|
|
|
1650 offset: true
|
|
|
1651 },
|
|
|
1652
|
|
|
1653 attr: function( elem, name, value, pass ) {
|
|
|
1654 // don't set attributes on text and comment nodes
|
|
|
1655 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
|
1656 return undefined;
|
|
|
1657 }
|
|
|
1658
|
|
|
1659 if ( pass && name in jQuery.attrFn ) {
|
|
|
1660 return jQuery(elem)[name](value);
|
|
|
1661 }
|
|
|
1662
|
|
|
1663 var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
|
|
|
1664 // Whether we are setting (or getting)
|
|
|
1665 set = value !== undefined;
|
|
|
1666
|
|
|
1667 // Try to normalize/fix the name
|
|
|
1668 name = notxml && jQuery.props[ name ] || name;
|
|
|
1669
|
|
|
1670 // Only do all the following if this is a node (faster for style)
|
|
|
1671 if ( elem.nodeType === 1 ) {
|
|
|
1672 // These attributes require special treatment
|
|
|
1673 var special = rspecialurl.test( name );
|
|
|
1674
|
|
|
1675 // Safari mis-reports the default selected property of an option
|
|
|
1676 // Accessing the parent's selectedIndex property fixes it
|
|
|
1677 if ( name === "selected" && !jQuery.support.optSelected ) {
|
|
|
1678 var parent = elem.parentNode;
|
|
|
1679 if ( parent ) {
|
|
|
1680 parent.selectedIndex;
|
|
|
1681
|
|
|
1682 // Make sure that it also works with optgroups, see #5701
|
|
|
1683 if ( parent.parentNode ) {
|
|
|
1684 parent.parentNode.selectedIndex;
|
|
|
1685 }
|
|
|
1686 }
|
|
|
1687 }
|
|
|
1688
|
|
|
1689 // If applicable, access the attribute via the DOM 0 way
|
|
|
1690 // 'in' checks fail in Blackberry 4.7 #6931
|
|
|
1691 if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {
|
|
|
1692 if ( set ) {
|
|
|
1693 // We can't allow the type property to be changed (since it causes problems in IE)
|
|
|
1694 if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
|
|
|
1695 jQuery.error( "type property can't be changed" );
|
|
|
1696 }
|
|
|
1697
|
|
|
1698 if ( value === null ) {
|
|
|
1699 if ( elem.nodeType === 1 ) {
|
|
|
1700 elem.removeAttribute( name );
|
|
|
1701 }
|
|
|
1702
|
|
|
1703 } else {
|
|
|
1704 elem[ name ] = value;
|
|
|
1705 }
|
|
|
1706 }
|
|
|
1707
|
|
|
1708 // browsers index elements by id/name on forms, give priority to attributes.
|
|
|
1709 if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
|
|
|
1710 return elem.getAttributeNode( name ).nodeValue;
|
|
|
1711 }
|
|
|
1712
|
|
|
1713 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
|
|
|
1714 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
|
|
|
1715 if ( name === "tabIndex" ) {
|
|
|
1716 var attributeNode = elem.getAttributeNode( "tabIndex" );
|
|
|
1717
|
|
|
1718 return attributeNode && attributeNode.specified ?
|
|
|
1719 attributeNode.value :
|
|
|
1720 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
|
|
|
1721 0 :
|
|
|
1722 undefined;
|
|
|
1723 }
|
|
|
1724
|
|
|
1725 return elem[ name ];
|
|
|
1726 }
|
|
|
1727
|
|
|
1728 if ( !jQuery.support.style && notxml && name === "style" ) {
|
|
|
1729 if ( set ) {
|
|
|
1730 elem.style.cssText = "" + value;
|
|
|
1731 }
|
|
|
1732
|
|
|
1733 return elem.style.cssText;
|
|
|
1734 }
|
|
|
1735
|
|
|
1736 if ( set ) {
|
|
|
1737 // convert the value to a string (all browsers do this but IE) see #1070
|
|
|
1738 elem.setAttribute( name, "" + value );
|
|
|
1739 }
|
|
|
1740
|
|
|
1741 // Ensure that missing attributes return undefined
|
|
|
1742 // Blackberry 4.7 returns "" from getAttribute #6938
|
|
|
1743 if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
|
|
|
1744 return undefined;
|
|
|
1745 }
|
|
|
1746
|
|
|
1747 var attr = !jQuery.support.hrefNormalized && notxml && special ?
|
|
|
1748 // Some attributes require a special call on IE
|
|
|
1749 elem.getAttribute( name, 2 ) :
|
|
|
1750 elem.getAttribute( name );
|
|
|
1751
|
|
|
1752 // Non-existent attributes return null, we normalize to undefined
|
|
|
1753 return attr === null ? undefined : attr;
|
|
|
1754 }
|
|
|
1755 }
|
|
|
1756 });
|
|
|
1757
|
|
|
1758
|
|
|
1759
|
|
|
1760
|
|
|
1761 var rnamespaces = /\.(.*)$/,
|
|
|
1762 rformElems = /^(?:textarea|input|select)$/i,
|
|
|
1763 rperiod = /\./g,
|
|
|
1764 rspace = / /g,
|
|
|
1765 rescape = /[^\w\s.|`]/g,
|
|
|
1766 fcleanup = function( nm ) {
|
|
|
1767 return nm.replace(rescape, "\\$&");
|
|
|
1768 },
|
|
|
1769 focusCounts = { focusin: 0, focusout: 0 };
|
|
|
1770
|
|
|
1771 /*
|
|
|
1772 * A number of helper functions used for managing events.
|
|
|
1773 * Many of the ideas behind this code originated from
|
|
|
1774 * Dean Edwards' addEvent library.
|
|
|
1775 */
|
|
|
1776 jQuery.event = {
|
|
|
1777
|
|
|
1778 // Bind an event to an element
|
|
|
1779 // Original by Dean Edwards
|
|
|
1780 add: function( elem, types, handler, data ) {
|
|
|
1781 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
|
1782 return;
|
|
|
1783 }
|
|
|
1784
|
|
|
1785 // For whatever reason, IE has trouble passing the window object
|
|
|
1786 // around, causing it to be cloned in the process
|
|
|
1787 if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) {
|
|
|
1788 elem = window;
|
|
|
1789 }
|
|
|
1790
|
|
|
1791 if ( handler === false ) {
|
|
|
1792 handler = returnFalse;
|
|
|
1793 }
|
|
|
1794
|
|
|
1795 var handleObjIn, handleObj;
|
|
|
1796
|
|
|
1797 if ( handler.handler ) {
|
|
|
1798 handleObjIn = handler;
|
|
|
1799 handler = handleObjIn.handler;
|
|
|
1800 }
|
|
|
1801
|
|
|
1802 // Make sure that the function being executed has a unique ID
|
|
|
1803 if ( !handler.guid ) {
|
|
|
1804 handler.guid = jQuery.guid++;
|
|
|
1805 }
|
|
|
1806
|
|
|
1807 // Init the element's event structure
|
|
|
1808 var elemData = jQuery.data( elem );
|
|
|
1809
|
|
|
1810 // If no elemData is found then we must be trying to bind to one of the
|
|
|
1811 // banned noData elements
|
|
|
1812 if ( !elemData ) {
|
|
|
1813 return;
|
|
|
1814 }
|
|
|
1815
|
|
|
1816 // Use a key less likely to result in collisions for plain JS objects.
|
|
|
1817 // Fixes bug #7150.
|
|
|
1818 var eventKey = elem.nodeType ? "events" : "__events__",
|
|
|
1819 events = elemData[ eventKey ],
|
|
|
1820 eventHandle = elemData.handle;
|
|
|
1821
|
|
|
1822 if ( typeof events === "function" ) {
|
|
|
1823 // On plain objects events is a fn that holds the the data
|
|
|
1824 // which prevents this data from being JSON serialized
|
|
|
1825 // the function does not need to be called, it just contains the data
|
|
|
1826 eventHandle = events.handle;
|
|
|
1827 events = events.events;
|
|
|
1828
|
|
|
1829 } else if ( !events ) {
|
|
|
1830 if ( !elem.nodeType ) {
|
|
|
1831 // On plain objects, create a fn that acts as the holder
|
|
|
1832 // of the values to avoid JSON serialization of event data
|
|
|
1833 elemData[ eventKey ] = elemData = function(){};
|
|
|
1834 }
|
|
|
1835
|
|
|
1836 elemData.events = events = {};
|
|
|
1837 }
|
|
|
1838
|
|
|
1839 if ( !eventHandle ) {
|
|
|
1840 elemData.handle = eventHandle = function() {
|
|
|
1841 // Handle the second event of a trigger and when
|
|
|
1842 // an event is called after a page has unloaded
|
|
|
1843 return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
|
|
|
1844 jQuery.event.handle.apply( eventHandle.elem, arguments ) :
|
|
|
1845 undefined;
|
|
|
1846 };
|
|
|
1847 }
|
|
|
1848
|
|
|
1849 // Add elem as a property of the handle function
|
|
|
1850 // This is to prevent a memory leak with non-native events in IE.
|
|
|
1851 eventHandle.elem = elem;
|
|
|
1852
|
|
|
1853 // Handle multiple events separated by a space
|
|
|
1854 // jQuery(...).bind("mouseover mouseout", fn);
|
|
|
1855 types = types.split(" ");
|
|
|
1856
|
|
|
1857 var type, i = 0, namespaces;
|
|
|
1858
|
|
|
1859 while ( (type = types[ i++ ]) ) {
|
|
|
1860 handleObj = handleObjIn ?
|
|
|
1861 jQuery.extend({}, handleObjIn) :
|
|
|
1862 { handler: handler, data: data };
|
|
|
1863
|
|
|
1864 // Namespaced event handlers
|
|
|
1865 if ( type.indexOf(".") > -1 ) {
|
|
|
1866 namespaces = type.split(".");
|
|
|
1867 type = namespaces.shift();
|
|
|
1868 handleObj.namespace = namespaces.slice(0).sort().join(".");
|
|
|
1869
|
|
|
1870 } else {
|
|
|
1871 namespaces = [];
|
|
|
1872 handleObj.namespace = "";
|
|
|
1873 }
|
|
|
1874
|
|
|
1875 handleObj.type = type;
|
|
|
1876 if ( !handleObj.guid ) {
|
|
|
1877 handleObj.guid = handler.guid;
|
|
|
1878 }
|
|
|
1879
|
|
|
1880 // Get the current list of functions bound to this event
|
|
|
1881 var handlers = events[ type ],
|
|
|
1882 special = jQuery.event.special[ type ] || {};
|
|
|
1883
|
|
|
1884 // Init the event handler queue
|
|
|
1885 if ( !handlers ) {
|
|
|
1886 handlers = events[ type ] = [];
|
|
|
1887
|
|
|
1888 // Check for a special event handler
|
|
|
1889 // Only use addEventListener/attachEvent if the special
|
|
|
1890 // events handler returns false
|
|
|
1891 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
|
|
|
1892 // Bind the global event handler to the element
|
|
|
1893 if ( elem.addEventListener ) {
|
|
|
1894 elem.addEventListener( type, eventHandle, false );
|
|
|
1895
|
|
|
1896 } else if ( elem.attachEvent ) {
|
|
|
1897 elem.attachEvent( "on" + type, eventHandle );
|
|
|
1898 }
|
|
|
1899 }
|
|
|
1900 }
|
|
|
1901
|
|
|
1902 if ( special.add ) {
|
|
|
1903 special.add.call( elem, handleObj );
|
|
|
1904
|
|
|
1905 if ( !handleObj.handler.guid ) {
|
|
|
1906 handleObj.handler.guid = handler.guid;
|
|
|
1907 }
|
|
|
1908 }
|
|
|
1909
|
|
|
1910 // Add the function to the element's handler list
|
|
|
1911 handlers.push( handleObj );
|
|
|
1912
|
|
|
1913 // Keep track of which events have been used, for global triggering
|
|
|
1914 jQuery.event.global[ type ] = true;
|
|
|
1915 }
|
|
|
1916
|
|
|
1917 // Nullify elem to prevent memory leaks in IE
|
|
|
1918 elem = null;
|
|
|
1919 },
|
|
|
1920
|
|
|
1921 global: {},
|
|
|
1922
|
|
|
1923 // Detach an event or set of events from an element
|
|
|
1924 remove: function( elem, types, handler, pos ) {
|
|
|
1925 // don't do events on text and comment nodes
|
|
|
1926 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
|
1927 return;
|
|
|
1928 }
|
|
|
1929
|
|
|
1930 if ( handler === false ) {
|
|
|
1931 handler = returnFalse;
|
|
|
1932 }
|
|
|
1933
|
|
|
1934 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
|
|
|
1935 eventKey = elem.nodeType ? "events" : "__events__",
|
|
|
1936 elemData = jQuery.data( elem ),
|
|
|
1937 events = elemData && elemData[ eventKey ];
|
|
|
1938
|
|
|
1939 if ( !elemData || !events ) {
|
|
|
1940 return;
|
|
|
1941 }
|
|
|
1942
|
|
|
1943 if ( typeof events === "function" ) {
|
|
|
1944 elemData = events;
|
|
|
1945 events = events.events;
|
|
|
1946 }
|
|
|
1947
|
|
|
1948 // types is actually an event object here
|
|
|
1949 if ( types && types.type ) {
|
|
|
1950 handler = types.handler;
|
|
|
1951 types = types.type;
|
|
|
1952 }
|
|
|
1953
|
|
|
1954 // Unbind all events for the element
|
|
|
1955 if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
|
|
|
1956 types = types || "";
|
|
|
1957
|
|
|
1958 for ( type in events ) {
|
|
|
1959 jQuery.event.remove( elem, type + types );
|
|
|
1960 }
|
|
|
1961
|
|
|
1962 return;
|
|
|
1963 }
|
|
|
1964
|
|
|
1965 // Handle multiple events separated by a space
|
|
|
1966 // jQuery(...).unbind("mouseover mouseout", fn);
|
|
|
1967 types = types.split(" ");
|
|
|
1968
|
|
|
1969 while ( (type = types[ i++ ]) ) {
|
|
|
1970 origType = type;
|
|
|
1971 handleObj = null;
|
|
|
1972 all = type.indexOf(".") < 0;
|
|
|
1973 namespaces = [];
|
|
|
1974
|
|
|
1975 if ( !all ) {
|
|
|
1976 // Namespaced event handlers
|
|
|
1977 namespaces = type.split(".");
|
|
|
1978 type = namespaces.shift();
|
|
|
1979
|
|
|
1980 namespace = new RegExp("(^|\\.)" +
|
|
|
1981 jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
|
|
|
1982 }
|
|
|
1983
|
|
|
1984 eventType = events[ type ];
|
|
|
1985
|
|
|
1986 if ( !eventType ) {
|
|
|
1987 continue;
|
|
|
1988 }
|
|
|
1989
|
|
|
1990 if ( !handler ) {
|
|
|
1991 for ( j = 0; j < eventType.length; j++ ) {
|
|
|
1992 handleObj = eventType[ j ];
|
|
|
1993
|
|
|
1994 if ( all || namespace.test( handleObj.namespace ) ) {
|
|
|
1995 jQuery.event.remove( elem, origType, handleObj.handler, j );
|
|
|
1996 eventType.splice( j--, 1 );
|
|
|
1997 }
|
|
|
1998 }
|
|
|
1999
|
|
|
2000 continue;
|
|
|
2001 }
|
|
|
2002
|
|
|
2003 special = jQuery.event.special[ type ] || {};
|
|
|
2004
|
|
|
2005 for ( j = pos || 0; j < eventType.length; j++ ) {
|
|
|
2006 handleObj = eventType[ j ];
|
|
|
2007
|
|
|
2008 if ( handler.guid === handleObj.guid ) {
|
|
|
2009 // remove the given handler for the given type
|
|
|
2010 if ( all || namespace.test( handleObj.namespace ) ) {
|
|
|
2011 if ( pos == null ) {
|
|
|
2012 eventType.splice( j--, 1 );
|
|
|
2013 }
|
|
|
2014
|
|
|
2015 if ( special.remove ) {
|
|
|
2016 special.remove.call( elem, handleObj );
|
|
|
2017 }
|
|
|
2018 }
|
|
|
2019
|
|
|
2020 if ( pos != null ) {
|
|
|
2021 break;
|
|
|
2022 }
|
|
|
2023 }
|
|
|
2024 }
|
|
|
2025
|
|
|
2026 // remove generic event handler if no more handlers exist
|
|
|
2027 if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
|
|
|
2028 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
|
|
|
2029 jQuery.removeEvent( elem, type, elemData.handle );
|
|
|
2030 }
|
|
|
2031
|
|
|
2032 ret = null;
|
|
|
2033 delete events[ type ];
|
|
|
2034 }
|
|
|
2035 }
|
|
|
2036
|
|
|
2037 // Remove the expando if it's no longer used
|
|
|
2038 if ( jQuery.isEmptyObject( events ) ) {
|
|
|
2039 var handle = elemData.handle;
|
|
|
2040 if ( handle ) {
|
|
|
2041 handle.elem = null;
|
|
|
2042 }
|
|
|
2043
|
|
|
2044 delete elemData.events;
|
|
|
2045 delete elemData.handle;
|
|
|
2046
|
|
|
2047 if ( typeof elemData === "function" ) {
|
|
|
2048 jQuery.removeData( elem, eventKey );
|
|
|
2049
|
|
|
2050 } else if ( jQuery.isEmptyObject( elemData ) ) {
|
|
|
2051 jQuery.removeData( elem );
|
|
|
2052 }
|
|
|
2053 }
|
|
|
2054 },
|
|
|
2055
|
|
|
2056 // bubbling is internal
|
|
|
2057 trigger: function( event, data, elem /*, bubbling */ ) {
|
|
|
2058 // Event object or event type
|
|
|
2059 var type = event.type || event,
|
|
|
2060 bubbling = arguments[3];
|
|
|
2061
|
|
|
2062 if ( !bubbling ) {
|
|
|
2063 event = typeof event === "object" ?
|
|
|
2064 // jQuery.Event object
|
|
|
2065 event[ jQuery.expando ] ? event :
|
|
|
2066 // Object literal
|
|
|
2067 jQuery.extend( jQuery.Event(type), event ) :
|
|
|
2068 // Just the event type (string)
|
|
|
2069 jQuery.Event(type);
|
|
|
2070
|
|
|
2071 if ( type.indexOf("!") >= 0 ) {
|
|
|
2072 event.type = type = type.slice(0, -1);
|
|
|
2073 event.exclusive = true;
|
|
|
2074 }
|
|
|
2075
|
|
|
2076 // Handle a global trigger
|
|
|
2077 if ( !elem ) {
|
|
|
2078 // Don't bubble custom events when global (to avoid too much overhead)
|
|
|
2079 event.stopPropagation();
|
|
|
2080
|
|
|
2081 // Only trigger if we've ever bound an event for it
|
|
|
2082 if ( jQuery.event.global[ type ] ) {
|
|
|
2083 jQuery.each( jQuery.cache, function() {
|
|
|
2084 if ( this.events && this.events[type] ) {
|
|
|
2085 jQuery.event.trigger( event, data, this.handle.elem );
|
|
|
2086 }
|
|
|
2087 });
|
|
|
2088 }
|
|
|
2089 }
|
|
|
2090
|
|
|
2091 // Handle triggering a single element
|
|
|
2092
|
|
|
2093 // don't do events on text and comment nodes
|
|
|
2094 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
|
|
|
2095 return undefined;
|
|
|
2096 }
|
|
|
2097
|
|
|
2098 // Clean up in case it is reused
|
|
|
2099 event.result = undefined;
|
|
|
2100 event.target = elem;
|
|
|
2101
|
|
|
2102 // Clone the incoming data, if any
|
|
|
2103 data = jQuery.makeArray( data );
|
|
|
2104 data.unshift( event );
|
|
|
2105 }
|
|
|
2106
|
|
|
2107 event.currentTarget = elem;
|
|
|
2108
|
|
|
2109 // Trigger the event, it is assumed that "handle" is a function
|
|
|
2110 var handle = elem.nodeType ?
|
|
|
2111 jQuery.data( elem, "handle" ) :
|
|
|
2112 (jQuery.data( elem, "__events__" ) || {}).handle;
|
|
|
2113
|
|
|
2114 if ( handle ) {
|
|
|
2115 handle.apply( elem, data );
|
|
|
2116 }
|
|
|
2117
|
|
|
2118 var parent = elem.parentNode || elem.ownerDocument;
|
|
|
2119
|
|
|
2120 // Trigger an inline bound script
|
|
|
2121 try {
|
|
|
2122 if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
|
|
|
2123 if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
|
|
|
2124 event.result = false;
|
|
|
2125 event.preventDefault();
|
|
|
2126 }
|
|
|
2127 }
|
|
|
2128
|
|
|
2129 // prevent IE from throwing an error for some elements with some event types, see #3533
|
|
|
2130 } catch (inlineError) {}
|
|
|
2131
|
|
|
2132 if ( !event.isPropagationStopped() && parent ) {
|
|
|
2133 jQuery.event.trigger( event, data, parent, true );
|
|
|
2134
|
|
|
2135 } else if ( !event.isDefaultPrevented() ) {
|
|
|
2136 var target = event.target, old, targetType = type.replace(rnamespaces, ""),
|
|
|
2137 isClick = jQuery.nodeName(target, "a") && targetType === "click",
|
|
|
2138 special = jQuery.event.special[ targetType ] || {};
|
|
|
2139
|
|
|
2140 if ( (!special._default || special._default.call( elem, event ) === false) &&
|
|
|
2141 !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
|
|
|
2142
|
|
|
2143 try {
|
|
|
2144 if ( target[ targetType ] ) {
|
|
|
2145 // Make sure that we don't accidentally re-trigger the onFOO events
|
|
|
2146 old = target[ "on" + targetType ];
|
|
|
2147
|
|
|
2148 if ( old ) {
|
|
|
2149 target[ "on" + targetType ] = null;
|
|
|
2150 }
|
|
|
2151
|
|
|
2152 jQuery.event.triggered = true;
|
|
|
2153 target[ targetType ]();
|
|
|
2154 }
|
|
|
2155
|
|
|
2156 // prevent IE from throwing an error for some elements with some event types, see #3533
|
|
|
2157 } catch (triggerError) {}
|
|
|
2158
|
|
|
2159 if ( old ) {
|
|
|
2160 target[ "on" + targetType ] = old;
|
|
|
2161 }
|
|
|
2162
|
|
|
2163 jQuery.event.triggered = false;
|
|
|
2164 }
|
|
|
2165 }
|
|
|
2166 },
|
|
|
2167
|
|
|
2168 handle: function( event ) {
|
|
|
2169 var all, handlers, namespaces, namespace_sort = [], namespace_re, events, args = jQuery.makeArray( arguments );
|
|
|
2170
|
|
|
2171 event = args[0] = jQuery.event.fix( event || window.event );
|
|
|
2172 event.currentTarget = this;
|
|
|
2173
|
|
|
2174 // Namespaced event handlers
|
|
|
2175 all = event.type.indexOf(".") < 0 && !event.exclusive;
|
|
|
2176
|
|
|
2177 if ( !all ) {
|
|
|
2178 namespaces = event.type.split(".");
|
|
|
2179 event.type = namespaces.shift();
|
|
|
2180 namespace_sort = namespaces.slice(0).sort();
|
|
|
2181 namespace_re = new RegExp("(^|\\.)" + namespace_sort.join("\\.(?:.*\\.)?") + "(\\.|$)");
|
|
|
2182 }
|
|
|
2183
|
|
|
2184 event.namespace = event.namespace || namespace_sort.join(".");
|
|
|
2185
|
|
|
2186 events = jQuery.data(this, this.nodeType ? "events" : "__events__");
|
|
|
2187
|
|
|
2188 if ( typeof events === "function" ) {
|
|
|
2189 events = events.events;
|
|
|
2190 }
|
|
|
2191
|
|
|
2192 handlers = (events || {})[ event.type ];
|
|
|
2193
|
|
|
2194 if ( events && handlers ) {
|
|
|
2195 // Clone the handlers to prevent manipulation
|
|
|
2196 handlers = handlers.slice(0);
|
|
|
2197
|
|
|
2198 for ( var j = 0, l = handlers.length; j < l; j++ ) {
|
|
|
2199 var handleObj = handlers[ j ];
|
|
|
2200
|
|
|
2201 // Filter the functions by class
|
|
|
2202 if ( all || namespace_re.test( handleObj.namespace ) ) {
|
|
|
2203 // Pass in a reference to the handler function itself
|
|
|
2204 // So that we can later remove it
|
|
|
2205 event.handler = handleObj.handler;
|
|
|
2206 event.data = handleObj.data;
|
|
|
2207 event.handleObj = handleObj;
|
|
|
2208
|
|
|
2209 var ret = handleObj.handler.apply( this, args );
|
|
|
2210
|
|
|
2211 if ( ret !== undefined ) {
|
|
|
2212 event.result = ret;
|
|
|
2213 if ( ret === false ) {
|
|
|
2214 event.preventDefault();
|
|
|
2215 event.stopPropagation();
|
|
|
2216 }
|
|
|
2217 }
|
|
|
2218
|
|
|
2219 if ( event.isImmediatePropagationStopped() ) {
|
|
|
2220 break;
|
|
|
2221 }
|
|
|
2222 }
|
|
|
2223 }
|
|
|
2224 }
|
|
|
2225
|
|
|
2226 return event.result;
|
|
|
2227 },
|
|
|
2228
|
|
|
2229 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(" "),
|
|
|
2230
|
|
|
2231 fix: function( event ) {
|
|
|
2232 if ( event[ jQuery.expando ] ) {
|
|
|
2233 return event;
|
|
|
2234 }
|
|
|
2235
|
|
|
2236 // store a copy of the original event object
|
|
|
2237 // and "clone" to set read-only properties
|
|
|
2238 var originalEvent = event;
|
|
|
2239 event = jQuery.Event( originalEvent );
|
|
|
2240
|
|
|
2241 for ( var i = this.props.length, prop; i; ) {
|
|
|
2242 prop = this.props[ --i ];
|
|
|
2243 event[ prop ] = originalEvent[ prop ];
|
|
|
2244 }
|
|
|
2245
|
|
|
2246 // Fix target property, if necessary
|
|
|
2247 if ( !event.target ) {
|
|
|
2248 event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
|
|
|
2249 }
|
|
|
2250
|
|
|
2251 // check if target is a textnode (safari)
|
|
|
2252 if ( event.target.nodeType === 3 ) {
|
|
|
2253 event.target = event.target.parentNode;
|
|
|
2254 }
|
|
|
2255
|
|
|
2256 // Add relatedTarget, if necessary
|
|
|
2257 if ( !event.relatedTarget && event.fromElement ) {
|
|
|
2258 event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
|
|
|
2259 }
|
|
|
2260
|
|
|
2261 // Calculate pageX/Y if missing and clientX/Y available
|
|
|
2262 if ( event.pageX == null && event.clientX != null ) {
|
|
|
2263 var doc = document.documentElement, body = document.body;
|
|
|
2264 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
|
|
|
2265 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
|
|
|
2266 }
|
|
|
2267
|
|
|
2268 // Add which for key events
|
|
|
2269 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
|
|
|
2270 event.which = event.charCode != null ? event.charCode : event.keyCode;
|
|
|
2271 }
|
|
|
2272
|
|
|
2273 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
|
|
|
2274 if ( !event.metaKey && event.ctrlKey ) {
|
|
|
2275 event.metaKey = event.ctrlKey;
|
|
|
2276 }
|
|
|
2277
|
|
|
2278 // Add which for click: 1 === left; 2 === middle; 3 === right
|
|
|
2279 // Note: button is not normalized, so don't use it
|
|
|
2280 if ( !event.which && event.button !== undefined ) {
|
|
|
2281 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
|
|
|
2282 }
|
|
|
2283
|
|
|
2284 return event;
|
|
|
2285 },
|
|
|
2286
|
|
|
2287 // Deprecated, use jQuery.guid instead
|
|
|
2288 guid: 1E8,
|
|
|
2289
|
|
|
2290 // Deprecated, use jQuery.proxy instead
|
|
|
2291 proxy: jQuery.proxy,
|
|
|
2292
|
|
|
2293 special: {
|
|
|
2294 ready: {
|
|
|
2295 // Make sure the ready event is setup
|
|
|
2296 setup: jQuery.bindReady,
|
|
|
2297 teardown: jQuery.noop
|
|
|
2298 },
|
|
|
2299
|
|
|
2300 live: {
|
|
|
2301 add: function( handleObj ) {
|
|
|
2302 jQuery.event.add( this,
|
|
|
2303 liveConvert( handleObj.origType, handleObj.selector ),
|
|
|
2304 jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
|
|
|
2305 },
|
|
|
2306
|
|
|
2307 remove: function( handleObj ) {
|
|
|
2308 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
|
|
|
2309 }
|
|
|
2310 },
|
|
|
2311
|
|
|
2312 beforeunload: {
|
|
|
2313 setup: function( data, namespaces, eventHandle ) {
|
|
|
2314 // We only want to do this special case on windows
|
|
|
2315 if ( jQuery.isWindow( this ) ) {
|
|
|
2316 this.onbeforeunload = eventHandle;
|
|
|
2317 }
|
|
|
2318 },
|
|
|
2319
|
|
|
2320 teardown: function( namespaces, eventHandle ) {
|
|
|
2321 if ( this.onbeforeunload === eventHandle ) {
|
|
|
2322 this.onbeforeunload = null;
|
|
|
2323 }
|
|
|
2324 }
|
|
|
2325 }
|
|
|
2326 }
|
|
|
2327 };
|
|
|
2328
|
|
|
2329 jQuery.removeEvent = document.removeEventListener ?
|
|
|
2330 function( elem, type, handle ) {
|
|
|
2331 if ( elem.removeEventListener ) {
|
|
|
2332 elem.removeEventListener( type, handle, false );
|
|
|
2333 }
|
|
|
2334 } :
|
|
|
2335 function( elem, type, handle ) {
|
|
|
2336 if ( elem.detachEvent ) {
|
|
|
2337 elem.detachEvent( "on" + type, handle );
|
|
|
2338 }
|
|
|
2339 };
|
|
|
2340
|
|
|
2341 jQuery.Event = function( src ) {
|
|
|
2342 // Allow instantiation without the 'new' keyword
|
|
|
2343 if ( !this.preventDefault ) {
|
|
|
2344 return new jQuery.Event( src );
|
|
|
2345 }
|
|
|
2346
|
|
|
2347 // Event object
|
|
|
2348 if ( src && src.type ) {
|
|
|
2349 this.originalEvent = src;
|
|
|
2350 this.type = src.type;
|
|
|
2351 // Event type
|
|
|
2352 } else {
|
|
|
2353 this.type = src;
|
|
|
2354 }
|
|
|
2355
|
|
|
2356 // timeStamp is buggy for some events on Firefox(#3843)
|
|
|
2357 // So we won't rely on the native value
|
|
|
2358 this.timeStamp = jQuery.now();
|
|
|
2359
|
|
|
2360 // Mark it as fixed
|
|
|
2361 this[ jQuery.expando ] = true;
|
|
|
2362 };
|
|
|
2363
|
|
|
2364 function returnFalse() {
|
|
|
2365 return false;
|
|
|
2366 }
|
|
|
2367 function returnTrue() {
|
|
|
2368 return true;
|
|
|
2369 }
|
|
|
2370
|
|
|
2371 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
|
|
|
2372 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
|
|
|
2373 jQuery.Event.prototype = {
|
|
|
2374 preventDefault: function() {
|
|
|
2375 this.isDefaultPrevented = returnTrue;
|
|
|
2376
|
|
|
2377 var e = this.originalEvent;
|
|
|
2378 if ( !e ) {
|
|
|
2379 return;
|
|
|
2380 }
|
|
|
2381
|
|
|
2382 // if preventDefault exists run it on the original event
|
|
|
2383 if ( e.preventDefault ) {
|
|
|
2384 e.preventDefault();
|
|
|
2385
|
|
|
2386 // otherwise set the returnValue property of the original event to false (IE)
|
|
|
2387 } else {
|
|
|
2388 e.returnValue = false;
|
|
|
2389 }
|
|
|
2390 },
|
|
|
2391 stopPropagation: function() {
|
|
|
2392 this.isPropagationStopped = returnTrue;
|
|
|
2393
|
|
|
2394 var e = this.originalEvent;
|
|
|
2395 if ( !e ) {
|
|
|
2396 return;
|
|
|
2397 }
|
|
|
2398 // if stopPropagation exists run it on the original event
|
|
|
2399 if ( e.stopPropagation ) {
|
|
|
2400 e.stopPropagation();
|
|
|
2401 }
|
|
|
2402 // otherwise set the cancelBubble property of the original event to true (IE)
|
|
|
2403 e.cancelBubble = true;
|
|
|
2404 },
|
|
|
2405 stopImmediatePropagation: function() {
|
|
|
2406 this.isImmediatePropagationStopped = returnTrue;
|
|
|
2407 this.stopPropagation();
|
|
|
2408 },
|
|
|
2409 isDefaultPrevented: returnFalse,
|
|
|
2410 isPropagationStopped: returnFalse,
|
|
|
2411 isImmediatePropagationStopped: returnFalse
|
|
|
2412 };
|
|
|
2413
|
|
|
2414 // Checks if an event happened on an element within another element
|
|
|
2415 // Used in jQuery.event.special.mouseenter and mouseleave handlers
|
|
|
2416 var withinElement = function( event ) {
|
|
|
2417 // Check if mouse(over|out) are still within the same parent element
|
|
|
2418 var parent = event.relatedTarget;
|
|
|
2419
|
|
|
2420 // Firefox sometimes assigns relatedTarget a XUL element
|
|
|
2421 // which we cannot access the parentNode property of
|
|
|
2422 try {
|
|
|
2423 // Traverse up the tree
|
|
|
2424 while ( parent && parent !== this ) {
|
|
|
2425 parent = parent.parentNode;
|
|
|
2426 }
|
|
|
2427
|
|
|
2428 if ( parent !== this ) {
|
|
|
2429 // set the correct event type
|
|
|
2430 event.type = event.data;
|
|
|
2431
|
|
|
2432 // handle event if we actually just moused on to a non sub-element
|
|
|
2433 jQuery.event.handle.apply( this, arguments );
|
|
|
2434 }
|
|
|
2435
|
|
|
2436 // assuming we've left the element since we most likely mousedover a xul element
|
|
|
2437 } catch(e) { }
|
|
|
2438 },
|
|
|
2439
|
|
|
2440 // In case of event delegation, we only need to rename the event.type,
|
|
|
2441 // liveHandler will take care of the rest.
|
|
|
2442 delegate = function( event ) {
|
|
|
2443 event.type = event.data;
|
|
|
2444 jQuery.event.handle.apply( this, arguments );
|
|
|
2445 };
|
|
|
2446
|
|
|
2447 // Create mouseenter and mouseleave events
|
|
|
2448 jQuery.each({
|
|
|
2449 mouseenter: "mouseover",
|
|
|
2450 mouseleave: "mouseout"
|
|
|
2451 }, function( orig, fix ) {
|
|
|
2452 jQuery.event.special[ orig ] = {
|
|
|
2453 setup: function( data ) {
|
|
|
2454 jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
|
|
|
2455 },
|
|
|
2456 teardown: function( data ) {
|
|
|
2457 jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
|
|
|
2458 }
|
|
|
2459 };
|
|
|
2460 });
|
|
|
2461
|
|
|
2462 // submit delegation
|
|
|
2463 if ( !jQuery.support.submitBubbles ) {
|
|
|
2464
|
|
|
2465 jQuery.event.special.submit = {
|
|
|
2466 setup: function( data, namespaces ) {
|
|
|
2467 if ( this.nodeName.toLowerCase() !== "form" ) {
|
|
|
2468 jQuery.event.add(this, "click.specialSubmit", function( e ) {
|
|
|
2469 var elem = e.target, type = elem.type;
|
|
|
2470
|
|
|
2471 if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
|
|
|
2472 e.liveFired = undefined;
|
|
|
2473 return trigger( "submit", this, arguments );
|
|
|
2474 }
|
|
|
2475 });
|
|
|
2476
|
|
|
2477 jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
|
|
|
2478 var elem = e.target, type = elem.type;
|
|
|
2479
|
|
|
2480 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
|
|
|
2481 e.liveFired = undefined;
|
|
|
2482 return trigger( "submit", this, arguments );
|
|
|
2483 }
|
|
|
2484 });
|
|
|
2485
|
|
|
2486 } else {
|
|
|
2487 return false;
|
|
|
2488 }
|
|
|
2489 },
|
|
|
2490
|
|
|
2491 teardown: function( namespaces ) {
|
|
|
2492 jQuery.event.remove( this, ".specialSubmit" );
|
|
|
2493 }
|
|
|
2494 };
|
|
|
2495
|
|
|
2496 }
|
|
|
2497
|
|
|
2498 // change delegation, happens here so we have bind.
|
|
|
2499 if ( !jQuery.support.changeBubbles ) {
|
|
|
2500
|
|
|
2501 var changeFilters,
|
|
|
2502
|
|
|
2503 getVal = function( elem ) {
|
|
|
2504 var type = elem.type, val = elem.value;
|
|
|
2505
|
|
|
2506 if ( type === "radio" || type === "checkbox" ) {
|
|
|
2507 val = elem.checked;
|
|
|
2508
|
|
|
2509 } else if ( type === "select-multiple" ) {
|
|
|
2510 val = elem.selectedIndex > -1 ?
|
|
|
2511 jQuery.map( elem.options, function( elem ) {
|
|
|
2512 return elem.selected;
|
|
|
2513 }).join("-") :
|
|
|
2514 "";
|
|
|
2515
|
|
|
2516 } else if ( elem.nodeName.toLowerCase() === "select" ) {
|
|
|
2517 val = elem.selectedIndex;
|
|
|
2518 }
|
|
|
2519
|
|
|
2520 return val;
|
|
|
2521 },
|
|
|
2522
|
|
|
2523 testChange = function testChange( e ) {
|
|
|
2524 var elem = e.target, data, val;
|
|
|
2525
|
|
|
2526 if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
|
|
|
2527 return;
|
|
|
2528 }
|
|
|
2529
|
|
|
2530 data = jQuery.data( elem, "_change_data" );
|
|
|
2531 val = getVal(elem);
|
|
|
2532
|
|
|
2533 // the current data will be also retrieved by beforeactivate
|
|
|
2534 if ( e.type !== "focusout" || elem.type !== "radio" ) {
|
|
|
2535 jQuery.data( elem, "_change_data", val );
|
|
|
2536 }
|
|
|
2537
|
|
|
2538 if ( data === undefined || val === data ) {
|
|
|
2539 return;
|
|
|
2540 }
|
|
|
2541
|
|
|
2542 if ( data != null || val ) {
|
|
|
2543 e.type = "change";
|
|
|
2544 e.liveFired = undefined;
|
|
|
2545 return jQuery.event.trigger( e, arguments[1], elem );
|
|
|
2546 }
|
|
|
2547 };
|
|
|
2548
|
|
|
2549 jQuery.event.special.change = {
|
|
|
2550 filters: {
|
|
|
2551 focusout: testChange,
|
|
|
2552
|
|
|
2553 beforedeactivate: testChange,
|
|
|
2554
|
|
|
2555 click: function( e ) {
|
|
|
2556 var elem = e.target, type = elem.type;
|
|
|
2557
|
|
|
2558 if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
|
|
|
2559 return testChange.call( this, e );
|
|
|
2560 }
|
|
|
2561 },
|
|
|
2562
|
|
|
2563 // Change has to be called before submit
|
|
|
2564 // Keydown will be called before keypress, which is used in submit-event delegation
|
|
|
2565 keydown: function( e ) {
|
|
|
2566 var elem = e.target, type = elem.type;
|
|
|
2567
|
|
|
2568 if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
|
|
|
2569 (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
|
|
|
2570 type === "select-multiple" ) {
|
|
|
2571 return testChange.call( this, e );
|
|
|
2572 }
|
|
|
2573 },
|
|
|
2574
|
|
|
2575 // Beforeactivate happens also before the previous element is blurred
|
|
|
2576 // with this event you can't trigger a change event, but you can store
|
|
|
2577 // information
|
|
|
2578 beforeactivate: function( e ) {
|
|
|
2579 var elem = e.target;
|
|
|
2580 jQuery.data( elem, "_change_data", getVal(elem) );
|
|
|
2581 }
|
|
|
2582 },
|
|
|
2583
|
|
|
2584 setup: function( data, namespaces ) {
|
|
|
2585 if ( this.type === "file" ) {
|
|
|
2586 return false;
|
|
|
2587 }
|
|
|
2588
|
|
|
2589 for ( var type in changeFilters ) {
|
|
|
2590 jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
|
|
|
2591 }
|
|
|
2592
|
|
|
2593 return rformElems.test( this.nodeName );
|
|
|
2594 },
|
|
|
2595
|
|
|
2596 teardown: function( namespaces ) {
|
|
|
2597 jQuery.event.remove( this, ".specialChange" );
|
|
|
2598
|
|
|
2599 return rformElems.test( this.nodeName );
|
|
|
2600 }
|
|
|
2601 };
|
|
|
2602
|
|
|
2603 changeFilters = jQuery.event.special.change.filters;
|
|
|
2604
|
|
|
2605 // Handle when the input is .focus()'d
|
|
|
2606 changeFilters.focus = changeFilters.beforeactivate;
|
|
|
2607 }
|
|
|
2608
|
|
|
2609 function trigger( type, elem, args ) {
|
|
|
2610 args[0].type = type;
|
|
|
2611 return jQuery.event.handle.apply( elem, args );
|
|
|
2612 }
|
|
|
2613
|
|
|
2614 // Create "bubbling" focus and blur events
|
|
|
2615 if ( document.addEventListener ) {
|
|
|
2616 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
|
|
|
2617 jQuery.event.special[ fix ] = {
|
|
|
2618 setup: function() {
|
|
|
2619 if ( focusCounts[fix]++ === 0 ) {
|
|
|
2620 document.addEventListener( orig, handler, true );
|
|
|
2621 }
|
|
|
2622 },
|
|
|
2623 teardown: function() {
|
|
|
2624 if ( --focusCounts[fix] === 0 ) {
|
|
|
2625 document.removeEventListener( orig, handler, true );
|
|
|
2626 }
|
|
|
2627 }
|
|
|
2628 };
|
|
|
2629
|
|
|
2630 function handler( e ) {
|
|
|
2631 e = jQuery.event.fix( e );
|
|
|
2632 e.type = fix;
|
|
|
2633 return jQuery.event.trigger( e, null, e.target );
|
|
|
2634 }
|
|
|
2635 });
|
|
|
2636 }
|
|
|
2637
|
|
|
2638 jQuery.each(["bind", "one"], function( i, name ) {
|
|
|
2639 jQuery.fn[ name ] = function( type, data, fn ) {
|
|
|
2640 // Handle object literals
|
|
|
2641 if ( typeof type === "object" ) {
|
|
|
2642 for ( var key in type ) {
|
|
|
2643 this[ name ](key, data, type[key], fn);
|
|
|
2644 }
|
|
|
2645 return this;
|
|
|
2646 }
|
|
|
2647
|
|
|
2648 if ( jQuery.isFunction( data ) || data === false ) {
|
|
|
2649 fn = data;
|
|
|
2650 data = undefined;
|
|
|
2651 }
|
|
|
2652
|
|
|
2653 var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
|
|
|
2654 jQuery( this ).unbind( event, handler );
|
|
|
2655 return fn.apply( this, arguments );
|
|
|
2656 }) : fn;
|
|
|
2657
|
|
|
2658 if ( type === "unload" && name !== "one" ) {
|
|
|
2659 this.one( type, data, fn );
|
|
|
2660
|
|
|
2661 } else {
|
|
|
2662 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
2663 jQuery.event.add( this[i], type, handler, data );
|
|
|
2664 }
|
|
|
2665 }
|
|
|
2666
|
|
|
2667 return this;
|
|
|
2668 };
|
|
|
2669 });
|
|
|
2670
|
|
|
2671 jQuery.fn.extend({
|
|
|
2672 unbind: function( type, fn ) {
|
|
|
2673 // Handle object literals
|
|
|
2674 if ( typeof type === "object" && !type.preventDefault ) {
|
|
|
2675 for ( var key in type ) {
|
|
|
2676 this.unbind(key, type[key]);
|
|
|
2677 }
|
|
|
2678
|
|
|
2679 } else {
|
|
|
2680 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
2681 jQuery.event.remove( this[i], type, fn );
|
|
|
2682 }
|
|
|
2683 }
|
|
|
2684
|
|
|
2685 return this;
|
|
|
2686 },
|
|
|
2687
|
|
|
2688 delegate: function( selector, types, data, fn ) {
|
|
|
2689 return this.live( types, data, fn, selector );
|
|
|
2690 },
|
|
|
2691
|
|
|
2692 undelegate: function( selector, types, fn ) {
|
|
|
2693 if ( arguments.length === 0 ) {
|
|
|
2694 return this.unbind( "live" );
|
|
|
2695
|
|
|
2696 } else {
|
|
|
2697 return this.die( types, null, fn, selector );
|
|
|
2698 }
|
|
|
2699 },
|
|
|
2700
|
|
|
2701 trigger: function( type, data ) {
|
|
|
2702 return this.each(function() {
|
|
|
2703 jQuery.event.trigger( type, data, this );
|
|
|
2704 });
|
|
|
2705 },
|
|
|
2706
|
|
|
2707 triggerHandler: function( type, data ) {
|
|
|
2708 if ( this[0] ) {
|
|
|
2709 var event = jQuery.Event( type );
|
|
|
2710 event.preventDefault();
|
|
|
2711 event.stopPropagation();
|
|
|
2712 jQuery.event.trigger( event, data, this[0] );
|
|
|
2713 return event.result;
|
|
|
2714 }
|
|
|
2715 },
|
|
|
2716
|
|
|
2717 toggle: function( fn ) {
|
|
|
2718 // Save reference to arguments for access in closure
|
|
|
2719 var args = arguments, i = 1;
|
|
|
2720
|
|
|
2721 // link all the functions, so any of them can unbind this click handler
|
|
|
2722 while ( i < args.length ) {
|
|
|
2723 jQuery.proxy( fn, args[ i++ ] );
|
|
|
2724 }
|
|
|
2725
|
|
|
2726 return this.click( jQuery.proxy( fn, function( event ) {
|
|
|
2727 // Figure out which function to execute
|
|
|
2728 var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
|
|
|
2729 jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
|
|
|
2730
|
|
|
2731 // Make sure that clicks stop
|
|
|
2732 event.preventDefault();
|
|
|
2733
|
|
|
2734 // and execute the function
|
|
|
2735 return args[ lastToggle ].apply( this, arguments ) || false;
|
|
|
2736 }));
|
|
|
2737 },
|
|
|
2738
|
|
|
2739 hover: function( fnOver, fnOut ) {
|
|
|
2740 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
|
|
|
2741 }
|
|
|
2742 });
|
|
|
2743
|
|
|
2744 var liveMap = {
|
|
|
2745 focus: "focusin",
|
|
|
2746 blur: "focusout",
|
|
|
2747 mouseenter: "mouseover",
|
|
|
2748 mouseleave: "mouseout"
|
|
|
2749 };
|
|
|
2750
|
|
|
2751 jQuery.each(["live", "die"], function( i, name ) {
|
|
|
2752 jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
|
|
|
2753 var type, i = 0, match, namespaces, preType,
|
|
|
2754 selector = origSelector || this.selector,
|
|
|
2755 context = origSelector ? this : jQuery( this.context );
|
|
|
2756
|
|
|
2757 if ( typeof types === "object" && !types.preventDefault ) {
|
|
|
2758 for ( var key in types ) {
|
|
|
2759 context[ name ]( key, data, types[key], selector );
|
|
|
2760 }
|
|
|
2761
|
|
|
2762 return this;
|
|
|
2763 }
|
|
|
2764
|
|
|
2765 if ( jQuery.isFunction( data ) ) {
|
|
|
2766 fn = data;
|
|
|
2767 data = undefined;
|
|
|
2768 }
|
|
|
2769
|
|
|
2770 types = (types || "").split(" ");
|
|
|
2771
|
|
|
2772 while ( (type = types[ i++ ]) != null ) {
|
|
|
2773 match = rnamespaces.exec( type );
|
|
|
2774 namespaces = "";
|
|
|
2775
|
|
|
2776 if ( match ) {
|
|
|
2777 namespaces = match[0];
|
|
|
2778 type = type.replace( rnamespaces, "" );
|
|
|
2779 }
|
|
|
2780
|
|
|
2781 if ( type === "hover" ) {
|
|
|
2782 types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
|
|
|
2783 continue;
|
|
|
2784 }
|
|
|
2785
|
|
|
2786 preType = type;
|
|
|
2787
|
|
|
2788 if ( type === "focus" || type === "blur" ) {
|
|
|
2789 types.push( liveMap[ type ] + namespaces );
|
|
|
2790 type = type + namespaces;
|
|
|
2791
|
|
|
2792 } else {
|
|
|
2793 type = (liveMap[ type ] || type) + namespaces;
|
|
|
2794 }
|
|
|
2795
|
|
|
2796 if ( name === "live" ) {
|
|
|
2797 // bind live handler
|
|
|
2798 for ( var j = 0, l = context.length; j < l; j++ ) {
|
|
|
2799 jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
|
|
|
2800 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
|
|
|
2801 }
|
|
|
2802
|
|
|
2803 } else {
|
|
|
2804 // unbind live handler
|
|
|
2805 context.unbind( "live." + liveConvert( type, selector ), fn );
|
|
|
2806 }
|
|
|
2807 }
|
|
|
2808
|
|
|
2809 return this;
|
|
|
2810 };
|
|
|
2811 });
|
|
|
2812
|
|
|
2813 function liveHandler( event ) {
|
|
|
2814 var stop, maxLevel, elems = [], selectors = [],
|
|
|
2815 related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
|
|
|
2816 events = jQuery.data( this, this.nodeType ? "events" : "__events__" );
|
|
|
2817
|
|
|
2818 if ( typeof events === "function" ) {
|
|
|
2819 events = events.events;
|
|
|
2820 }
|
|
|
2821
|
|
|
2822 // Make sure we avoid non-left-click bubbling in Firefox (#3861)
|
|
|
2823 if ( event.liveFired === this || !events || !events.live || event.button && event.type === "click" ) {
|
|
|
2824 return;
|
|
|
2825 }
|
|
|
2826
|
|
|
2827 if ( event.namespace ) {
|
|
|
2828 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
|
|
|
2829 }
|
|
|
2830
|
|
|
2831 event.liveFired = this;
|
|
|
2832
|
|
|
2833 var live = events.live.slice(0);
|
|
|
2834
|
|
|
2835 for ( j = 0; j < live.length; j++ ) {
|
|
|
2836 handleObj = live[j];
|
|
|
2837
|
|
|
2838 if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
|
|
|
2839 selectors.push( handleObj.selector );
|
|
|
2840
|
|
|
2841 } else {
|
|
|
2842 live.splice( j--, 1 );
|
|
|
2843 }
|
|
|
2844 }
|
|
|
2845
|
|
|
2846 match = jQuery( event.target ).closest( selectors, event.currentTarget );
|
|
|
2847
|
|
|
2848 for ( i = 0, l = match.length; i < l; i++ ) {
|
|
|
2849 close = match[i];
|
|
|
2850
|
|
|
2851 for ( j = 0; j < live.length; j++ ) {
|
|
|
2852 handleObj = live[j];
|
|
|
2853
|
|
|
2854 if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) ) {
|
|
|
2855 elem = close.elem;
|
|
|
2856 related = null;
|
|
|
2857
|
|
|
2858 // Those two events require additional checking
|
|
|
2859 if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
|
|
|
2860 event.type = handleObj.preType;
|
|
|
2861 related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
|
|
|
2862 }
|
|
|
2863
|
|
|
2864 if ( !related || related !== elem ) {
|
|
|
2865 elems.push({ elem: elem, handleObj: handleObj, level: close.level });
|
|
|
2866 }
|
|
|
2867 }
|
|
|
2868 }
|
|
|
2869 }
|
|
|
2870
|
|
|
2871 for ( i = 0, l = elems.length; i < l; i++ ) {
|
|
|
2872 match = elems[i];
|
|
|
2873
|
|
|
2874 if ( maxLevel && match.level > maxLevel ) {
|
|
|
2875 break;
|
|
|
2876 }
|
|
|
2877
|
|
|
2878 event.currentTarget = match.elem;
|
|
|
2879 event.data = match.handleObj.data;
|
|
|
2880 event.handleObj = match.handleObj;
|
|
|
2881
|
|
|
2882 ret = match.handleObj.origHandler.apply( match.elem, arguments );
|
|
|
2883
|
|
|
2884 if ( ret === false || event.isPropagationStopped() ) {
|
|
|
2885 maxLevel = match.level;
|
|
|
2886
|
|
|
2887 if ( ret === false ) {
|
|
|
2888 stop = false;
|
|
|
2889 }
|
|
|
2890 }
|
|
|
2891 }
|
|
|
2892
|
|
|
2893 return stop;
|
|
|
2894 }
|
|
|
2895
|
|
|
2896 function liveConvert( type, selector ) {
|
|
|
2897 return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspace, "&");
|
|
|
2898 }
|
|
|
2899
|
|
|
2900 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
|
|
|
2901 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
|
|
|
2902 "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
|
|
|
2903
|
|
|
2904 // Handle event binding
|
|
|
2905 jQuery.fn[ name ] = function( data, fn ) {
|
|
|
2906 if ( fn == null ) {
|
|
|
2907 fn = data;
|
|
|
2908 data = null;
|
|
|
2909 }
|
|
|
2910
|
|
|
2911 return arguments.length > 0 ?
|
|
|
2912 this.bind( name, data, fn ) :
|
|
|
2913 this.trigger( name );
|
|
|
2914 };
|
|
|
2915
|
|
|
2916 if ( jQuery.attrFn ) {
|
|
|
2917 jQuery.attrFn[ name ] = true;
|
|
|
2918 }
|
|
|
2919 });
|
|
|
2920
|
|
|
2921 // Prevent memory leaks in IE
|
|
|
2922 // Window isn't included so as not to unbind existing unload events
|
|
|
2923 // More info:
|
|
|
2924 // - http://isaacschlueter.com/2006/10/msie-memory-leaks/
|
|
|
2925 if ( window.attachEvent && !window.addEventListener ) {
|
|
|
2926 jQuery(window).bind("unload", function() {
|
|
|
2927 for ( var id in jQuery.cache ) {
|
|
|
2928 if ( jQuery.cache[ id ].handle ) {
|
|
|
2929 // Try/Catch is to handle iframes being unloaded, see #4280
|
|
|
2930 try {
|
|
|
2931 jQuery.event.remove( jQuery.cache[ id ].handle.elem );
|
|
|
2932 } catch(e) {}
|
|
|
2933 }
|
|
|
2934 }
|
|
|
2935 });
|
|
|
2936 }
|
|
|
2937
|
|
|
2938
|
|
|
2939 /*!
|
|
|
2940 * Sizzle CSS Selector Engine - v1.0
|
|
|
2941 * Copyright 2009, The Dojo Foundation
|
|
|
2942 * Released under the MIT, BSD, and GPL Licenses.
|
|
|
2943 * More information: http://sizzlejs.com/
|
|
|
2944 */
|
|
|
2945 (function(){
|
|
|
2946
|
|
|
2947 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
|
|
|
2948 done = 0,
|
|
|
2949 toString = Object.prototype.toString,
|
|
|
2950 hasDuplicate = false,
|
|
|
2951 baseHasDuplicate = true;
|
|
|
2952
|
|
|
2953 // Here we check if the JavaScript engine is using some sort of
|
|
|
2954 // optimization where it does not always call our comparision
|
|
|
2955 // function. If that is the case, discard the hasDuplicate value.
|
|
|
2956 // Thus far that includes Google Chrome.
|
|
|
2957 [0, 0].sort(function(){
|
|
|
2958 baseHasDuplicate = false;
|
|
|
2959 return 0;
|
|
|
2960 });
|
|
|
2961
|
|
|
2962 var Sizzle = function(selector, context, results, seed) {
|
|
|
2963 results = results || [];
|
|
|
2964 context = context || document;
|
|
|
2965
|
|
|
2966 var origContext = context;
|
|
|
2967
|
|
|
2968 if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
|
|
|
2969 return [];
|
|
|
2970 }
|
|
|
2971
|
|
|
2972 if ( !selector || typeof selector !== "string" ) {
|
|
|
2973 return results;
|
|
|
2974 }
|
|
|
2975
|
|
|
2976 var parts = [], m, set, checkSet, extra, prune = true, contextXML = Sizzle.isXML(context),
|
|
|
2977 soFar = selector, ret, cur, pop, i;
|
|
|
2978
|
|
|
2979 // Reset the position of the chunker regexp (start from head)
|
|
|
2980 do {
|
|
|
2981 chunker.exec("");
|
|
|
2982 m = chunker.exec(soFar);
|
|
|
2983
|
|
|
2984 if ( m ) {
|
|
|
2985 soFar = m[3];
|
|
|
2986
|
|
|
2987 parts.push( m[1] );
|
|
|
2988
|
|
|
2989 if ( m[2] ) {
|
|
|
2990 extra = m[3];
|
|
|
2991 break;
|
|
|
2992 }
|
|
|
2993 }
|
|
|
2994 } while ( m );
|
|
|
2995
|
|
|
2996 if ( parts.length > 1 && origPOS.exec( selector ) ) {
|
|
|
2997 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
|
|
|
2998 set = posProcess( parts[0] + parts[1], context );
|
|
|
2999 } else {
|
|
|
3000 set = Expr.relative[ parts[0] ] ?
|
|
|
3001 [ context ] :
|
|
|
3002 Sizzle( parts.shift(), context );
|
|
|
3003
|
|
|
3004 while ( parts.length ) {
|
|
|
3005 selector = parts.shift();
|
|
|
3006
|
|
|
3007 if ( Expr.relative[ selector ] ) {
|
|
|
3008 selector += parts.shift();
|
|
|
3009 }
|
|
|
3010
|
|
|
3011 set = posProcess( selector, set );
|
|
|
3012 }
|
|
|
3013 }
|
|
|
3014 } else {
|
|
|
3015 // Take a shortcut and set the context if the root selector is an ID
|
|
|
3016 // (but not if it'll be faster if the inner selector is an ID)
|
|
|
3017 if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
|
|
|
3018 Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
|
|
|
3019 ret = Sizzle.find( parts.shift(), context, contextXML );
|
|
|
3020 context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
|
|
|
3021 }
|
|
|
3022
|
|
|
3023 if ( context ) {
|
|
|
3024 ret = seed ?
|
|
|
3025 { expr: parts.pop(), set: makeArray(seed) } :
|
|
|
3026 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
|
|
|
3027 set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
|
|
|
3028
|
|
|
3029 if ( parts.length > 0 ) {
|
|
|
3030 checkSet = makeArray(set);
|
|
|
3031 } else {
|
|
|
3032 prune = false;
|
|
|
3033 }
|
|
|
3034
|
|
|
3035 while ( parts.length ) {
|
|
|
3036 cur = parts.pop();
|
|
|
3037 pop = cur;
|
|
|
3038
|
|
|
3039 if ( !Expr.relative[ cur ] ) {
|
|
|
3040 cur = "";
|
|
|
3041 } else {
|
|
|
3042 pop = parts.pop();
|
|
|
3043 }
|
|
|
3044
|
|
|
3045 if ( pop == null ) {
|
|
|
3046 pop = context;
|
|
|
3047 }
|
|
|
3048
|
|
|
3049 Expr.relative[ cur ]( checkSet, pop, contextXML );
|
|
|
3050 }
|
|
|
3051 } else {
|
|
|
3052 checkSet = parts = [];
|
|
|
3053 }
|
|
|
3054 }
|
|
|
3055
|
|
|
3056 if ( !checkSet ) {
|
|
|
3057 checkSet = set;
|
|
|
3058 }
|
|
|
3059
|
|
|
3060 if ( !checkSet ) {
|
|
|
3061 Sizzle.error( cur || selector );
|
|
|
3062 }
|
|
|
3063
|
|
|
3064 if ( toString.call(checkSet) === "[object Array]" ) {
|
|
|
3065 if ( !prune ) {
|
|
|
3066 results.push.apply( results, checkSet );
|
|
|
3067 } else if ( context && context.nodeType === 1 ) {
|
|
|
3068 for ( i = 0; checkSet[i] != null; i++ ) {
|
|
|
3069 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
|
|
|
3070 results.push( set[i] );
|
|
|
3071 }
|
|
|
3072 }
|
|
|
3073 } else {
|
|
|
3074 for ( i = 0; checkSet[i] != null; i++ ) {
|
|
|
3075 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
|
|
|
3076 results.push( set[i] );
|
|
|
3077 }
|
|
|
3078 }
|
|
|
3079 }
|
|
|
3080 } else {
|
|
|
3081 makeArray( checkSet, results );
|
|
|
3082 }
|
|
|
3083
|
|
|
3084 if ( extra ) {
|
|
|
3085 Sizzle( extra, origContext, results, seed );
|
|
|
3086 Sizzle.uniqueSort( results );
|
|
|
3087 }
|
|
|
3088
|
|
|
3089 return results;
|
|
|
3090 };
|
|
|
3091
|
|
|
3092 Sizzle.uniqueSort = function(results){
|
|
|
3093 if ( sortOrder ) {
|
|
|
3094 hasDuplicate = baseHasDuplicate;
|
|
|
3095 results.sort(sortOrder);
|
|
|
3096
|
|
|
3097 if ( hasDuplicate ) {
|
|
|
3098 for ( var i = 1; i < results.length; i++ ) {
|
|
|
3099 if ( results[i] === results[i-1] ) {
|
|
|
3100 results.splice(i--, 1);
|
|
|
3101 }
|
|
|
3102 }
|
|
|
3103 }
|
|
|
3104 }
|
|
|
3105
|
|
|
3106 return results;
|
|
|
3107 };
|
|
|
3108
|
|
|
3109 Sizzle.matches = function(expr, set){
|
|
|
3110 return Sizzle(expr, null, null, set);
|
|
|
3111 };
|
|
|
3112
|
|
|
3113 Sizzle.matchesSelector = function(node, expr){
|
|
|
3114 return Sizzle(expr, null, null, [node]).length > 0;
|
|
|
3115 };
|
|
|
3116
|
|
|
3117 Sizzle.find = function(expr, context, isXML){
|
|
|
3118 var set;
|
|
|
3119
|
|
|
3120 if ( !expr ) {
|
|
|
3121 return [];
|
|
|
3122 }
|
|
|
3123
|
|
|
3124 for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
|
|
|
3125 var type = Expr.order[i], match;
|
|
|
3126
|
|
|
3127 if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
|
|
|
3128 var left = match[1];
|
|
|
3129 match.splice(1,1);
|
|
|
3130
|
|
|
3131 if ( left.substr( left.length - 1 ) !== "\\" ) {
|
|
|
3132 match[1] = (match[1] || "").replace(/\\/g, "");
|
|
|
3133 set = Expr.find[ type ]( match, context, isXML );
|
|
|
3134 if ( set != null ) {
|
|
|
3135 expr = expr.replace( Expr.match[ type ], "" );
|
|
|
3136 break;
|
|
|
3137 }
|
|
|
3138 }
|
|
|
3139 }
|
|
|
3140 }
|
|
|
3141
|
|
|
3142 if ( !set ) {
|
|
|
3143 set = context.getElementsByTagName("*");
|
|
|
3144 }
|
|
|
3145
|
|
|
3146 return {set: set, expr: expr};
|
|
|
3147 };
|
|
|
3148
|
|
|
3149 Sizzle.filter = function(expr, set, inplace, not){
|
|
|
3150 var old = expr, result = [], curLoop = set, match, anyFound,
|
|
|
3151 isXMLFilter = set && set[0] && Sizzle.isXML(set[0]);
|
|
|
3152
|
|
|
3153 while ( expr && set.length ) {
|
|
|
3154 for ( var type in Expr.filter ) {
|
|
|
3155 if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
|
|
|
3156 var filter = Expr.filter[ type ], found, item, left = match[1];
|
|
|
3157 anyFound = false;
|
|
|
3158
|
|
|
3159 match.splice(1,1);
|
|
|
3160
|
|
|
3161 if ( left.substr( left.length - 1 ) === "\\" ) {
|
|
|
3162 continue;
|
|
|
3163 }
|
|
|
3164
|
|
|
3165 if ( curLoop === result ) {
|
|
|
3166 result = [];
|
|
|
3167 }
|
|
|
3168
|
|
|
3169 if ( Expr.preFilter[ type ] ) {
|
|
|
3170 match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
|
|
|
3171
|
|
|
3172 if ( !match ) {
|
|
|
3173 anyFound = found = true;
|
|
|
3174 } else if ( match === true ) {
|
|
|
3175 continue;
|
|
|
3176 }
|
|
|
3177 }
|
|
|
3178
|
|
|
3179 if ( match ) {
|
|
|
3180 for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
|
|
|
3181 if ( item ) {
|
|
|
3182 found = filter( item, match, i, curLoop );
|
|
|
3183 var pass = not ^ !!found;
|
|
|
3184
|
|
|
3185 if ( inplace && found != null ) {
|
|
|
3186 if ( pass ) {
|
|
|
3187 anyFound = true;
|
|
|
3188 } else {
|
|
|
3189 curLoop[i] = false;
|
|
|
3190 }
|
|
|
3191 } else if ( pass ) {
|
|
|
3192 result.push( item );
|
|
|
3193 anyFound = true;
|
|
|
3194 }
|
|
|
3195 }
|
|
|
3196 }
|
|
|
3197 }
|
|
|
3198
|
|
|
3199 if ( found !== undefined ) {
|
|
|
3200 if ( !inplace ) {
|
|
|
3201 curLoop = result;
|
|
|
3202 }
|
|
|
3203
|
|
|
3204 expr = expr.replace( Expr.match[ type ], "" );
|
|
|
3205
|
|
|
3206 if ( !anyFound ) {
|
|
|
3207 return [];
|
|
|
3208 }
|
|
|
3209
|
|
|
3210 break;
|
|
|
3211 }
|
|
|
3212 }
|
|
|
3213 }
|
|
|
3214
|
|
|
3215 // Improper expression
|
|
|
3216 if ( expr === old ) {
|
|
|
3217 if ( anyFound == null ) {
|
|
|
3218 Sizzle.error( expr );
|
|
|
3219 } else {
|
|
|
3220 break;
|
|
|
3221 }
|
|
|
3222 }
|
|
|
3223
|
|
|
3224 old = expr;
|
|
|
3225 }
|
|
|
3226
|
|
|
3227 return curLoop;
|
|
|
3228 };
|
|
|
3229
|
|
|
3230 Sizzle.error = function( msg ) {
|
|
|
3231 throw "Syntax error, unrecognized expression: " + msg;
|
|
|
3232 };
|
|
|
3233
|
|
|
3234 var Expr = Sizzle.selectors = {
|
|
|
3235 order: [ "ID", "NAME", "TAG" ],
|
|
|
3236 match: {
|
|
|
3237 ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
|
|
|
3238 CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
|
|
|
3239 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
|
|
|
3240 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
|
|
|
3241 TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
|
|
|
3242 CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+\-]*)\))?/,
|
|
|
3243 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
|
|
|
3244 PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
|
|
|
3245 },
|
|
|
3246 leftMatch: {},
|
|
|
3247 attrMap: {
|
|
|
3248 "class": "className",
|
|
|
3249 "for": "htmlFor"
|
|
|
3250 },
|
|
|
3251 attrHandle: {
|
|
|
3252 href: function(elem){
|
|
|
3253 return elem.getAttribute("href");
|
|
|
3254 }
|
|
|
3255 },
|
|
|
3256 relative: {
|
|
|
3257 "+": function(checkSet, part){
|
|
|
3258 var isPartStr = typeof part === "string",
|
|
|
3259 isTag = isPartStr && !/\W/.test(part),
|
|
|
3260 isPartStrNotTag = isPartStr && !isTag;
|
|
|
3261
|
|
|
3262 if ( isTag ) {
|
|
|
3263 part = part.toLowerCase();
|
|
|
3264 }
|
|
|
3265
|
|
|
3266 for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
|
|
|
3267 if ( (elem = checkSet[i]) ) {
|
|
|
3268 while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
|
|
|
3269
|
|
|
3270 checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
|
|
|
3271 elem || false :
|
|
|
3272 elem === part;
|
|
|
3273 }
|
|
|
3274 }
|
|
|
3275
|
|
|
3276 if ( isPartStrNotTag ) {
|
|
|
3277 Sizzle.filter( part, checkSet, true );
|
|
|
3278 }
|
|
|
3279 },
|
|
|
3280 ">": function(checkSet, part){
|
|
|
3281 var isPartStr = typeof part === "string",
|
|
|
3282 elem, i = 0, l = checkSet.length;
|
|
|
3283
|
|
|
3284 if ( isPartStr && !/\W/.test(part) ) {
|
|
|
3285 part = part.toLowerCase();
|
|
|
3286
|
|
|
3287 for ( ; i < l; i++ ) {
|
|
|
3288 elem = checkSet[i];
|
|
|
3289 if ( elem ) {
|
|
|
3290 var parent = elem.parentNode;
|
|
|
3291 checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
|
|
|
3292 }
|
|
|
3293 }
|
|
|
3294 } else {
|
|
|
3295 for ( ; i < l; i++ ) {
|
|
|
3296 elem = checkSet[i];
|
|
|
3297 if ( elem ) {
|
|
|
3298 checkSet[i] = isPartStr ?
|
|
|
3299 elem.parentNode :
|
|
|
3300 elem.parentNode === part;
|
|
|
3301 }
|
|
|
3302 }
|
|
|
3303
|
|
|
3304 if ( isPartStr ) {
|
|
|
3305 Sizzle.filter( part, checkSet, true );
|
|
|
3306 }
|
|
|
3307 }
|
|
|
3308 },
|
|
|
3309 "": function(checkSet, part, isXML){
|
|
|
3310 var doneName = done++, checkFn = dirCheck, nodeCheck;
|
|
|
3311
|
|
|
3312 if ( typeof part === "string" && !/\W/.test(part) ) {
|
|
|
3313 part = part.toLowerCase();
|
|
|
3314 nodeCheck = part;
|
|
|
3315 checkFn = dirNodeCheck;
|
|
|
3316 }
|
|
|
3317
|
|
|
3318 checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
|
|
|
3319 },
|
|
|
3320 "~": function(checkSet, part, isXML){
|
|
|
3321 var doneName = done++, checkFn = dirCheck, nodeCheck;
|
|
|
3322
|
|
|
3323 if ( typeof part === "string" && !/\W/.test(part) ) {
|
|
|
3324 part = part.toLowerCase();
|
|
|
3325 nodeCheck = part;
|
|
|
3326 checkFn = dirNodeCheck;
|
|
|
3327 }
|
|
|
3328
|
|
|
3329 checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
|
|
|
3330 }
|
|
|
3331 },
|
|
|
3332 find: {
|
|
|
3333 ID: function(match, context, isXML){
|
|
|
3334 if ( typeof context.getElementById !== "undefined" && !isXML ) {
|
|
|
3335 var m = context.getElementById(match[1]);
|
|
|
3336 // Check parentNode to catch when Blackberry 4.6 returns
|
|
|
3337 // nodes that are no longer in the document #6963
|
|
|
3338 return m && m.parentNode ? [m] : [];
|
|
|
3339 }
|
|
|
3340 },
|
|
|
3341 NAME: function(match, context){
|
|
|
3342 if ( typeof context.getElementsByName !== "undefined" ) {
|
|
|
3343 var ret = [], results = context.getElementsByName(match[1]);
|
|
|
3344
|
|
|
3345 for ( var i = 0, l = results.length; i < l; i++ ) {
|
|
|
3346 if ( results[i].getAttribute("name") === match[1] ) {
|
|
|
3347 ret.push( results[i] );
|
|
|
3348 }
|
|
|
3349 }
|
|
|
3350
|
|
|
3351 return ret.length === 0 ? null : ret;
|
|
|
3352 }
|
|
|
3353 },
|
|
|
3354 TAG: function(match, context){
|
|
|
3355 return context.getElementsByTagName(match[1]);
|
|
|
3356 }
|
|
|
3357 },
|
|
|
3358 preFilter: {
|
|
|
3359 CLASS: function(match, curLoop, inplace, result, not, isXML){
|
|
|
3360 match = " " + match[1].replace(/\\/g, "") + " ";
|
|
|
3361
|
|
|
3362 if ( isXML ) {
|
|
|
3363 return match;
|
|
|
3364 }
|
|
|
3365
|
|
|
3366 for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
|
|
|
3367 if ( elem ) {
|
|
|
3368 if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
|
|
|
3369 if ( !inplace ) {
|
|
|
3370 result.push( elem );
|
|
|
3371 }
|
|
|
3372 } else if ( inplace ) {
|
|
|
3373 curLoop[i] = false;
|
|
|
3374 }
|
|
|
3375 }
|
|
|
3376 }
|
|
|
3377
|
|
|
3378 return false;
|
|
|
3379 },
|
|
|
3380 ID: function(match){
|
|
|
3381 return match[1].replace(/\\/g, "");
|
|
|
3382 },
|
|
|
3383 TAG: function(match, curLoop){
|
|
|
3384 return match[1].toLowerCase();
|
|
|
3385 },
|
|
|
3386 CHILD: function(match){
|
|
|
3387 if ( match[1] === "nth" ) {
|
|
|
3388 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
|
|
|
3389 var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
|
|
|
3390 match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
|
|
|
3391 !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
|
|
|
3392
|
|
|
3393 // calculate the numbers (first)n+(last) including if they are negative
|
|
|
3394 match[2] = (test[1] + (test[2] || 1)) - 0;
|
|
|
3395 match[3] = test[3] - 0;
|
|
|
3396 }
|
|
|
3397
|
|
|
3398 // TODO: Move to normal caching system
|
|
|
3399 match[0] = done++;
|
|
|
3400
|
|
|
3401 return match;
|
|
|
3402 },
|
|
|
3403 ATTR: function(match, curLoop, inplace, result, not, isXML){
|
|
|
3404 var name = match[1].replace(/\\/g, "");
|
|
|
3405
|
|
|
3406 if ( !isXML && Expr.attrMap[name] ) {
|
|
|
3407 match[1] = Expr.attrMap[name];
|
|
|
3408 }
|
|
|
3409
|
|
|
3410 if ( match[2] === "~=" ) {
|
|
|
3411 match[4] = " " + match[4] + " ";
|
|
|
3412 }
|
|
|
3413
|
|
|
3414 return match;
|
|
|
3415 },
|
|
|
3416 PSEUDO: function(match, curLoop, inplace, result, not){
|
|
|
3417 if ( match[1] === "not" ) {
|
|
|
3418 // If we're dealing with a complex expression, or a simple one
|
|
|
3419 if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
|
|
|
3420 match[3] = Sizzle(match[3], null, null, curLoop);
|
|
|
3421 } else {
|
|
|
3422 var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
|
|
|
3423 if ( !inplace ) {
|
|
|
3424 result.push.apply( result, ret );
|
|
|
3425 }
|
|
|
3426 return false;
|
|
|
3427 }
|
|
|
3428 } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
|
|
|
3429 return true;
|
|
|
3430 }
|
|
|
3431
|
|
|
3432 return match;
|
|
|
3433 },
|
|
|
3434 POS: function(match){
|
|
|
3435 match.unshift( true );
|
|
|
3436 return match;
|
|
|
3437 }
|
|
|
3438 },
|
|
|
3439 filters: {
|
|
|
3440 enabled: function(elem){
|
|
|
3441 return elem.disabled === false && elem.type !== "hidden";
|
|
|
3442 },
|
|
|
3443 disabled: function(elem){
|
|
|
3444 return elem.disabled === true;
|
|
|
3445 },
|
|
|
3446 checked: function(elem){
|
|
|
3447 return elem.checked === true;
|
|
|
3448 },
|
|
|
3449 selected: function(elem){
|
|
|
3450 // Accessing this property makes selected-by-default
|
|
|
3451 // options in Safari work properly
|
|
|
3452 elem.parentNode.selectedIndex;
|
|
|
3453 return elem.selected === true;
|
|
|
3454 },
|
|
|
3455 parent: function(elem){
|
|
|
3456 return !!elem.firstChild;
|
|
|
3457 },
|
|
|
3458 empty: function(elem){
|
|
|
3459 return !elem.firstChild;
|
|
|
3460 },
|
|
|
3461 has: function(elem, i, match){
|
|
|
3462 return !!Sizzle( match[3], elem ).length;
|
|
|
3463 },
|
|
|
3464 header: function(elem){
|
|
|
3465 return (/h\d/i).test( elem.nodeName );
|
|
|
3466 },
|
|
|
3467 text: function(elem){
|
|
|
3468 return "text" === elem.type;
|
|
|
3469 },
|
|
|
3470 radio: function(elem){
|
|
|
3471 return "radio" === elem.type;
|
|
|
3472 },
|
|
|
3473 checkbox: function(elem){
|
|
|
3474 return "checkbox" === elem.type;
|
|
|
3475 },
|
|
|
3476 file: function(elem){
|
|
|
3477 return "file" === elem.type;
|
|
|
3478 },
|
|
|
3479 password: function(elem){
|
|
|
3480 return "password" === elem.type;
|
|
|
3481 },
|
|
|
3482 submit: function(elem){
|
|
|
3483 return "submit" === elem.type;
|
|
|
3484 },
|
|
|
3485 image: function(elem){
|
|
|
3486 return "image" === elem.type;
|
|
|
3487 },
|
|
|
3488 reset: function(elem){
|
|
|
3489 return "reset" === elem.type;
|
|
|
3490 },
|
|
|
3491 button: function(elem){
|
|
|
3492 return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
|
|
|
3493 },
|
|
|
3494 input: function(elem){
|
|
|
3495 return (/input|select|textarea|button/i).test(elem.nodeName);
|
|
|
3496 }
|
|
|
3497 },
|
|
|
3498 setFilters: {
|
|
|
3499 first: function(elem, i){
|
|
|
3500 return i === 0;
|
|
|
3501 },
|
|
|
3502 last: function(elem, i, match, array){
|
|
|
3503 return i === array.length - 1;
|
|
|
3504 },
|
|
|
3505 even: function(elem, i){
|
|
|
3506 return i % 2 === 0;
|
|
|
3507 },
|
|
|
3508 odd: function(elem, i){
|
|
|
3509 return i % 2 === 1;
|
|
|
3510 },
|
|
|
3511 lt: function(elem, i, match){
|
|
|
3512 return i < match[3] - 0;
|
|
|
3513 },
|
|
|
3514 gt: function(elem, i, match){
|
|
|
3515 return i > match[3] - 0;
|
|
|
3516 },
|
|
|
3517 nth: function(elem, i, match){
|
|
|
3518 return match[3] - 0 === i;
|
|
|
3519 },
|
|
|
3520 eq: function(elem, i, match){
|
|
|
3521 return match[3] - 0 === i;
|
|
|
3522 }
|
|
|
3523 },
|
|
|
3524 filter: {
|
|
|
3525 PSEUDO: function(elem, match, i, array){
|
|
|
3526 var name = match[1], filter = Expr.filters[ name ];
|
|
|
3527
|
|
|
3528 if ( filter ) {
|
|
|
3529 return filter( elem, i, match, array );
|
|
|
3530 } else if ( name === "contains" ) {
|
|
|
3531 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
|
|
|
3532 } else if ( name === "not" ) {
|
|
|
3533 var not = match[3];
|
|
|
3534
|
|
|
3535 for ( var j = 0, l = not.length; j < l; j++ ) {
|
|
|
3536 if ( not[j] === elem ) {
|
|
|
3537 return false;
|
|
|
3538 }
|
|
|
3539 }
|
|
|
3540
|
|
|
3541 return true;
|
|
|
3542 } else {
|
|
|
3543 Sizzle.error( "Syntax error, unrecognized expression: " + name );
|
|
|
3544 }
|
|
|
3545 },
|
|
|
3546 CHILD: function(elem, match){
|
|
|
3547 var type = match[1], node = elem;
|
|
|
3548 switch (type) {
|
|
|
3549 case 'only':
|
|
|
3550 case 'first':
|
|
|
3551 while ( (node = node.previousSibling) ) {
|
|
|
3552 if ( node.nodeType === 1 ) {
|
|
|
3553 return false;
|
|
|
3554 }
|
|
|
3555 }
|
|
|
3556 if ( type === "first" ) {
|
|
|
3557 return true;
|
|
|
3558 }
|
|
|
3559 node = elem;
|
|
|
3560 case 'last':
|
|
|
3561 while ( (node = node.nextSibling) ) {
|
|
|
3562 if ( node.nodeType === 1 ) {
|
|
|
3563 return false;
|
|
|
3564 }
|
|
|
3565 }
|
|
|
3566 return true;
|
|
|
3567 case 'nth':
|
|
|
3568 var first = match[2], last = match[3];
|
|
|
3569
|
|
|
3570 if ( first === 1 && last === 0 ) {
|
|
|
3571 return true;
|
|
|
3572 }
|
|
|
3573
|
|
|
3574 var doneName = match[0],
|
|
|
3575 parent = elem.parentNode;
|
|
|
3576
|
|
|
3577 if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
|
|
|
3578 var count = 0;
|
|
|
3579 for ( node = parent.firstChild; node; node = node.nextSibling ) {
|
|
|
3580 if ( node.nodeType === 1 ) {
|
|
|
3581 node.nodeIndex = ++count;
|
|
|
3582 }
|
|
|
3583 }
|
|
|
3584 parent.sizcache = doneName;
|
|
|
3585 }
|
|
|
3586
|
|
|
3587 var diff = elem.nodeIndex - last;
|
|
|
3588 if ( first === 0 ) {
|
|
|
3589 return diff === 0;
|
|
|
3590 } else {
|
|
|
3591 return ( diff % first === 0 && diff / first >= 0 );
|
|
|
3592 }
|
|
|
3593 }
|
|
|
3594 },
|
|
|
3595 ID: function(elem, match){
|
|
|
3596 return elem.nodeType === 1 && elem.getAttribute("id") === match;
|
|
|
3597 },
|
|
|
3598 TAG: function(elem, match){
|
|
|
3599 return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
|
|
|
3600 },
|
|
|
3601 CLASS: function(elem, match){
|
|
|
3602 return (" " + (elem.className || elem.getAttribute("class")) + " ")
|
|
|
3603 .indexOf( match ) > -1;
|
|
|
3604 },
|
|
|
3605 ATTR: function(elem, match){
|
|
|
3606 var name = match[1],
|
|
|
3607 result = Expr.attrHandle[ name ] ?
|
|
|
3608 Expr.attrHandle[ name ]( elem ) :
|
|
|
3609 elem[ name ] != null ?
|
|
|
3610 elem[ name ] :
|
|
|
3611 elem.getAttribute( name ),
|
|
|
3612 value = result + "",
|
|
|
3613 type = match[2],
|
|
|
3614 check = match[4];
|
|
|
3615
|
|
|
3616 return result == null ?
|
|
|
3617 type === "!=" :
|
|
|
3618 type === "=" ?
|
|
|
3619 value === check :
|
|
|
3620 type === "*=" ?
|
|
|
3621 value.indexOf(check) >= 0 :
|
|
|
3622 type === "~=" ?
|
|
|
3623 (" " + value + " ").indexOf(check) >= 0 :
|
|
|
3624 !check ?
|
|
|
3625 value && result !== false :
|
|
|
3626 type === "!=" ?
|
|
|
3627 value !== check :
|
|
|
3628 type === "^=" ?
|
|
|
3629 value.indexOf(check) === 0 :
|
|
|
3630 type === "$=" ?
|
|
|
3631 value.substr(value.length - check.length) === check :
|
|
|
3632 type === "|=" ?
|
|
|
3633 value === check || value.substr(0, check.length + 1) === check + "-" :
|
|
|
3634 false;
|
|
|
3635 },
|
|
|
3636 POS: function(elem, match, i, array){
|
|
|
3637 var name = match[2], filter = Expr.setFilters[ name ];
|
|
|
3638
|
|
|
3639 if ( filter ) {
|
|
|
3640 return filter( elem, i, match, array );
|
|
|
3641 }
|
|
|
3642 }
|
|
|
3643 }
|
|
|
3644 };
|
|
|
3645
|
|
|
3646 var origPOS = Expr.match.POS,
|
|
|
3647 fescape = function(all, num){
|
|
|
3648 return "\\" + (num - 0 + 1);
|
|
|
3649 };
|
|
|
3650
|
|
|
3651 for ( var type in Expr.match ) {
|
|
|
3652 Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
|
|
|
3653 Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
|
|
|
3654 }
|
|
|
3655
|
|
|
3656 var makeArray = function(array, results) {
|
|
|
3657 array = Array.prototype.slice.call( array, 0 );
|
|
|
3658
|
|
|
3659 if ( results ) {
|
|
|
3660 results.push.apply( results, array );
|
|
|
3661 return results;
|
|
|
3662 }
|
|
|
3663
|
|
|
3664 return array;
|
|
|
3665 };
|
|
|
3666
|
|
|
3667 // Perform a simple check to determine if the browser is capable of
|
|
|
3668 // converting a NodeList to an array using builtin methods.
|
|
|
3669 // Also verifies that the returned array holds DOM nodes
|
|
|
3670 // (which is not the case in the Blackberry browser)
|
|
|
3671 try {
|
|
|
3672 Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
|
|
|
3673
|
|
|
3674 // Provide a fallback method if it does not work
|
|
|
3675 } catch(e){
|
|
|
3676 makeArray = function(array, results) {
|
|
|
3677 var ret = results || [], i = 0;
|
|
|
3678
|
|
|
3679 if ( toString.call(array) === "[object Array]" ) {
|
|
|
3680 Array.prototype.push.apply( ret, array );
|
|
|
3681 } else {
|
|
|
3682 if ( typeof array.length === "number" ) {
|
|
|
3683 for ( var l = array.length; i < l; i++ ) {
|
|
|
3684 ret.push( array[i] );
|
|
|
3685 }
|
|
|
3686 } else {
|
|
|
3687 for ( ; array[i]; i++ ) {
|
|
|
3688 ret.push( array[i] );
|
|
|
3689 }
|
|
|
3690 }
|
|
|
3691 }
|
|
|
3692
|
|
|
3693 return ret;
|
|
|
3694 };
|
|
|
3695 }
|
|
|
3696
|
|
|
3697 var sortOrder, siblingCheck;
|
|
|
3698
|
|
|
3699 if ( document.documentElement.compareDocumentPosition ) {
|
|
|
3700 sortOrder = function( a, b ) {
|
|
|
3701 if ( a === b ) {
|
|
|
3702 hasDuplicate = true;
|
|
|
3703 return 0;
|
|
|
3704 }
|
|
|
3705
|
|
|
3706 if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
|
|
|
3707 return a.compareDocumentPosition ? -1 : 1;
|
|
|
3708 }
|
|
|
3709
|
|
|
3710 return a.compareDocumentPosition(b) & 4 ? -1 : 1;
|
|
|
3711 };
|
|
|
3712 } else {
|
|
|
3713 sortOrder = function( a, b ) {
|
|
|
3714 var ap = [], bp = [], aup = a.parentNode, bup = b.parentNode,
|
|
|
3715 cur = aup, al, bl;
|
|
|
3716
|
|
|
3717 // The nodes are identical, we can exit early
|
|
|
3718 if ( a === b ) {
|
|
|
3719 hasDuplicate = true;
|
|
|
3720 return 0;
|
|
|
3721
|
|
|
3722 // If the nodes are siblings (or identical) we can do a quick check
|
|
|
3723 } else if ( aup === bup ) {
|
|
|
3724 return siblingCheck( a, b );
|
|
|
3725
|
|
|
3726 // If no parents were found then the nodes are disconnected
|
|
|
3727 } else if ( !aup ) {
|
|
|
3728 return -1;
|
|
|
3729
|
|
|
3730 } else if ( !bup ) {
|
|
|
3731 return 1;
|
|
|
3732 }
|
|
|
3733
|
|
|
3734 // Otherwise they're somewhere else in the tree so we need
|
|
|
3735 // to build up a full list of the parentNodes for comparison
|
|
|
3736 while ( cur ) {
|
|
|
3737 ap.unshift( cur );
|
|
|
3738 cur = cur.parentNode;
|
|
|
3739 }
|
|
|
3740
|
|
|
3741 cur = bup;
|
|
|
3742
|
|
|
3743 while ( cur ) {
|
|
|
3744 bp.unshift( cur );
|
|
|
3745 cur = cur.parentNode;
|
|
|
3746 }
|
|
|
3747
|
|
|
3748 al = ap.length;
|
|
|
3749 bl = bp.length;
|
|
|
3750
|
|
|
3751 // Start walking down the tree looking for a discrepancy
|
|
|
3752 for ( var i = 0; i < al && i < bl; i++ ) {
|
|
|
3753 if ( ap[i] !== bp[i] ) {
|
|
|
3754 return siblingCheck( ap[i], bp[i] );
|
|
|
3755 }
|
|
|
3756 }
|
|
|
3757
|
|
|
3758 // We ended someplace up the tree so do a sibling check
|
|
|
3759 return i === al ?
|
|
|
3760 siblingCheck( a, bp[i], -1 ) :
|
|
|
3761 siblingCheck( ap[i], b, 1 );
|
|
|
3762 };
|
|
|
3763
|
|
|
3764 siblingCheck = function( a, b, ret ) {
|
|
|
3765 if ( a === b ) {
|
|
|
3766 return ret;
|
|
|
3767 }
|
|
|
3768
|
|
|
3769 var cur = a.nextSibling;
|
|
|
3770
|
|
|
3771 while ( cur ) {
|
|
|
3772 if ( cur === b ) {
|
|
|
3773 return -1;
|
|
|
3774 }
|
|
|
3775
|
|
|
3776 cur = cur.nextSibling;
|
|
|
3777 }
|
|
|
3778
|
|
|
3779 return 1;
|
|
|
3780 };
|
|
|
3781 }
|
|
|
3782
|
|
|
3783 // Utility function for retreiving the text value of an array of DOM nodes
|
|
|
3784 Sizzle.getText = function( elems ) {
|
|
|
3785 var ret = "", elem;
|
|
|
3786
|
|
|
3787 for ( var i = 0; elems[i]; i++ ) {
|
|
|
3788 elem = elems[i];
|
|
|
3789
|
|
|
3790 // Get the text from text nodes and CDATA nodes
|
|
|
3791 if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
|
|
|
3792 ret += elem.nodeValue;
|
|
|
3793
|
|
|
3794 // Traverse everything else, except comment nodes
|
|
|
3795 } else if ( elem.nodeType !== 8 ) {
|
|
|
3796 ret += Sizzle.getText( elem.childNodes );
|
|
|
3797 }
|
|
|
3798 }
|
|
|
3799
|
|
|
3800 return ret;
|
|
|
3801 };
|
|
|
3802
|
|
|
3803 // Check to see if the browser returns elements by name when
|
|
|
3804 // querying by getElementById (and provide a workaround)
|
|
|
3805 (function(){
|
|
|
3806 // We're going to inject a fake input element with a specified name
|
|
|
3807 var form = document.createElement("div"),
|
|
|
3808 id = "script" + (new Date()).getTime();
|
|
|
3809 form.innerHTML = "<a name='" + id + "'/>";
|
|
|
3810
|
|
|
3811 // Inject it into the root element, check its status, and remove it quickly
|
|
|
3812 var root = document.documentElement;
|
|
|
3813 root.insertBefore( form, root.firstChild );
|
|
|
3814
|
|
|
3815 // The workaround has to do additional checks after a getElementById
|
|
|
3816 // Which slows things down for other browsers (hence the branching)
|
|
|
3817 if ( document.getElementById( id ) ) {
|
|
|
3818 Expr.find.ID = function(match, context, isXML){
|
|
|
3819 if ( typeof context.getElementById !== "undefined" && !isXML ) {
|
|
|
3820 var m = context.getElementById(match[1]);
|
|
|
3821 return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
|
|
|
3822 }
|
|
|
3823 };
|
|
|
3824
|
|
|
3825 Expr.filter.ID = function(elem, match){
|
|
|
3826 var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
|
|
|
3827 return elem.nodeType === 1 && node && node.nodeValue === match;
|
|
|
3828 };
|
|
|
3829 }
|
|
|
3830
|
|
|
3831 root.removeChild( form );
|
|
|
3832 root = form = null; // release memory in IE
|
|
|
3833 })();
|
|
|
3834
|
|
|
3835 (function(){
|
|
|
3836 // Check to see if the browser returns only elements
|
|
|
3837 // when doing getElementsByTagName("*")
|
|
|
3838
|
|
|
3839 // Create a fake element
|
|
|
3840 var div = document.createElement("div");
|
|
|
3841 div.appendChild( document.createComment("") );
|
|
|
3842
|
|
|
3843 // Make sure no comments are found
|
|
|
3844 if ( div.getElementsByTagName("*").length > 0 ) {
|
|
|
3845 Expr.find.TAG = function(match, context){
|
|
|
3846 var results = context.getElementsByTagName(match[1]);
|
|
|
3847
|
|
|
3848 // Filter out possible comments
|
|
|
3849 if ( match[1] === "*" ) {
|
|
|
3850 var tmp = [];
|
|
|
3851
|
|
|
3852 for ( var i = 0; results[i]; i++ ) {
|
|
|
3853 if ( results[i].nodeType === 1 ) {
|
|
|
3854 tmp.push( results[i] );
|
|
|
3855 }
|
|
|
3856 }
|
|
|
3857
|
|
|
3858 results = tmp;
|
|
|
3859 }
|
|
|
3860
|
|
|
3861 return results;
|
|
|
3862 };
|
|
|
3863 }
|
|
|
3864
|
|
|
3865 // Check to see if an attribute returns normalized href attributes
|
|
|
3866 div.innerHTML = "<a href='#'></a>";
|
|
|
3867 if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
|
|
|
3868 div.firstChild.getAttribute("href") !== "#" ) {
|
|
|
3869 Expr.attrHandle.href = function(elem){
|
|
|
3870 return elem.getAttribute("href", 2);
|
|
|
3871 };
|
|
|
3872 }
|
|
|
3873
|
|
|
3874 div = null; // release memory in IE
|
|
|
3875 })();
|
|
|
3876
|
|
|
3877 if ( document.querySelectorAll ) {
|
|
|
3878 (function(){
|
|
|
3879 var oldSizzle = Sizzle, div = document.createElement("div");
|
|
|
3880 div.innerHTML = "<p class='TEST'></p>";
|
|
|
3881
|
|
|
3882 // Safari can't handle uppercase or unicode characters when
|
|
|
3883 // in quirks mode.
|
|
|
3884 if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
|
|
|
3885 return;
|
|
|
3886 }
|
|
|
3887
|
|
|
3888 Sizzle = function(query, context, extra, seed){
|
|
|
3889 context = context || document;
|
|
|
3890
|
|
|
3891 // Only use querySelectorAll on non-XML documents
|
|
|
3892 // (ID selectors don't work in non-HTML documents)
|
|
|
3893 if ( !seed && !Sizzle.isXML(context) ) {
|
|
|
3894 if ( context.nodeType === 9 ) {
|
|
|
3895 try {
|
|
|
3896 return makeArray( context.querySelectorAll(query), extra );
|
|
|
3897 } catch(qsaError) {}
|
|
|
3898
|
|
|
3899 // qSA works strangely on Element-rooted queries
|
|
|
3900 // We can work around this by specifying an extra ID on the root
|
|
|
3901 // and working up from there (Thanks to Andrew Dupont for the technique)
|
|
|
3902 // IE 8 doesn't work on object elements
|
|
|
3903 } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
|
|
|
3904 var old = context.id, id = context.id = "__sizzle__";
|
|
|
3905
|
|
|
3906 try {
|
|
|
3907 return makeArray( context.querySelectorAll( "#" + id + " " + query ), extra );
|
|
|
3908
|
|
|
3909 } catch(pseudoError) {
|
|
|
3910 } finally {
|
|
|
3911 if ( old ) {
|
|
|
3912 context.id = old;
|
|
|
3913
|
|
|
3914 } else {
|
|
|
3915 context.removeAttribute( "id" );
|
|
|
3916 }
|
|
|
3917 }
|
|
|
3918 }
|
|
|
3919 }
|
|
|
3920
|
|
|
3921 return oldSizzle(query, context, extra, seed);
|
|
|
3922 };
|
|
|
3923
|
|
|
3924 for ( var prop in oldSizzle ) {
|
|
|
3925 Sizzle[ prop ] = oldSizzle[ prop ];
|
|
|
3926 }
|
|
|
3927
|
|
|
3928 div = null; // release memory in IE
|
|
|
3929 })();
|
|
|
3930 }
|
|
|
3931
|
|
|
3932 (function(){
|
|
|
3933 var html = document.documentElement,
|
|
|
3934 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector,
|
|
|
3935 pseudoWorks = false;
|
|
|
3936
|
|
|
3937 try {
|
|
|
3938 // This should fail with an exception
|
|
|
3939 // Gecko does not error, returns false instead
|
|
|
3940 matches.call( document.documentElement, ":sizzle" );
|
|
|
3941
|
|
|
3942 } catch( pseudoError ) {
|
|
|
3943 pseudoWorks = true;
|
|
|
3944 }
|
|
|
3945
|
|
|
3946 if ( matches ) {
|
|
|
3947 Sizzle.matchesSelector = function( node, expr ) {
|
|
|
3948 try {
|
|
|
3949 if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) ) {
|
|
|
3950 return matches.call( node, expr );
|
|
|
3951 }
|
|
|
3952 } catch(e) {}
|
|
|
3953
|
|
|
3954 return Sizzle(expr, null, null, [node]).length > 0;
|
|
|
3955 };
|
|
|
3956 }
|
|
|
3957 })();
|
|
|
3958
|
|
|
3959 (function(){
|
|
|
3960 var div = document.createElement("div");
|
|
|
3961
|
|
|
3962 div.innerHTML = "<div class='test e'></div><div class='test'></div>";
|
|
|
3963
|
|
|
3964 // Opera can't find a second classname (in 9.6)
|
|
|
3965 // Also, make sure that getElementsByClassName actually exists
|
|
|
3966 if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
|
|
|
3967 return;
|
|
|
3968 }
|
|
|
3969
|
|
|
3970 // Safari caches class attributes, doesn't catch changes (in 3.2)
|
|
|
3971 div.lastChild.className = "e";
|
|
|
3972
|
|
|
3973 if ( div.getElementsByClassName("e").length === 1 ) {
|
|
|
3974 return;
|
|
|
3975 }
|
|
|
3976
|
|
|
3977 Expr.order.splice(1, 0, "CLASS");
|
|
|
3978 Expr.find.CLASS = function(match, context, isXML) {
|
|
|
3979 if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
|
|
|
3980 return context.getElementsByClassName(match[1]);
|
|
|
3981 }
|
|
|
3982 };
|
|
|
3983
|
|
|
3984 div = null; // release memory in IE
|
|
|
3985 })();
|
|
|
3986
|
|
|
3987 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
|
|
|
3988 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
|
|
|
3989 var elem = checkSet[i];
|
|
|
3990 if ( elem ) {
|
|
|
3991 elem = elem[dir];
|
|
|
3992 var match = false;
|
|
|
3993
|
|
|
3994 while ( elem ) {
|
|
|
3995 if ( elem.sizcache === doneName ) {
|
|
|
3996 match = checkSet[elem.sizset];
|
|
|
3997 break;
|
|
|
3998 }
|
|
|
3999
|
|
|
4000 if ( elem.nodeType === 1 && !isXML ){
|
|
|
4001 elem.sizcache = doneName;
|
|
|
4002 elem.sizset = i;
|
|
|
4003 }
|
|
|
4004
|
|
|
4005 if ( elem.nodeName.toLowerCase() === cur ) {
|
|
|
4006 match = elem;
|
|
|
4007 break;
|
|
|
4008 }
|
|
|
4009
|
|
|
4010 elem = elem[dir];
|
|
|
4011 }
|
|
|
4012
|
|
|
4013 checkSet[i] = match;
|
|
|
4014 }
|
|
|
4015 }
|
|
|
4016 }
|
|
|
4017
|
|
|
4018 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
|
|
|
4019 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
|
|
|
4020 var elem = checkSet[i];
|
|
|
4021 if ( elem ) {
|
|
|
4022 elem = elem[dir];
|
|
|
4023 var match = false;
|
|
|
4024
|
|
|
4025 while ( elem ) {
|
|
|
4026 if ( elem.sizcache === doneName ) {
|
|
|
4027 match = checkSet[elem.sizset];
|
|
|
4028 break;
|
|
|
4029 }
|
|
|
4030
|
|
|
4031 if ( elem.nodeType === 1 ) {
|
|
|
4032 if ( !isXML ) {
|
|
|
4033 elem.sizcache = doneName;
|
|
|
4034 elem.sizset = i;
|
|
|
4035 }
|
|
|
4036 if ( typeof cur !== "string" ) {
|
|
|
4037 if ( elem === cur ) {
|
|
|
4038 match = true;
|
|
|
4039 break;
|
|
|
4040 }
|
|
|
4041
|
|
|
4042 } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
|
|
|
4043 match = elem;
|
|
|
4044 break;
|
|
|
4045 }
|
|
|
4046 }
|
|
|
4047
|
|
|
4048 elem = elem[dir];
|
|
|
4049 }
|
|
|
4050
|
|
|
4051 checkSet[i] = match;
|
|
|
4052 }
|
|
|
4053 }
|
|
|
4054 }
|
|
|
4055
|
|
|
4056 Sizzle.contains = document.documentElement.contains ? function(a, b){
|
|
|
4057 return a !== b && (a.contains ? a.contains(b) : true);
|
|
|
4058 } : function(a, b){
|
|
|
4059 return !!(a.compareDocumentPosition(b) & 16);
|
|
|
4060 };
|
|
|
4061
|
|
|
4062 Sizzle.isXML = function(elem){
|
|
|
4063 // documentElement is verified for cases where it doesn't yet exist
|
|
|
4064 // (such as loading iframes in IE - #4833)
|
|
|
4065 var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
|
|
|
4066 return documentElement ? documentElement.nodeName !== "HTML" : false;
|
|
|
4067 };
|
|
|
4068
|
|
|
4069 var posProcess = function(selector, context){
|
|
|
4070 var tmpSet = [], later = "", match,
|
|
|
4071 root = context.nodeType ? [context] : context;
|
|
|
4072
|
|
|
4073 // Position selectors must be done after the filter
|
|
|
4074 // And so must :not(positional) so we move all PSEUDOs to the end
|
|
|
4075 while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
|
|
|
4076 later += match[0];
|
|
|
4077 selector = selector.replace( Expr.match.PSEUDO, "" );
|
|
|
4078 }
|
|
|
4079
|
|
|
4080 selector = Expr.relative[selector] ? selector + "*" : selector;
|
|
|
4081
|
|
|
4082 for ( var i = 0, l = root.length; i < l; i++ ) {
|
|
|
4083 Sizzle( selector, root[i], tmpSet );
|
|
|
4084 }
|
|
|
4085
|
|
|
4086 return Sizzle.filter( later, tmpSet );
|
|
|
4087 };
|
|
|
4088
|
|
|
4089 // EXPOSE
|
|
|
4090 jQuery.find = Sizzle;
|
|
|
4091 jQuery.expr = Sizzle.selectors;
|
|
|
4092 jQuery.expr[":"] = jQuery.expr.filters;
|
|
|
4093 jQuery.unique = Sizzle.uniqueSort;
|
|
|
4094 jQuery.text = Sizzle.getText;
|
|
|
4095 jQuery.isXMLDoc = Sizzle.isXML;
|
|
|
4096 jQuery.contains = Sizzle.contains;
|
|
|
4097
|
|
|
4098
|
|
|
4099 })();
|
|
|
4100
|
|
|
4101
|
|
|
4102 var runtil = /Until$/,
|
|
|
4103 rparentsprev = /^(?:parents|prevUntil|prevAll)/,
|
|
|
4104 // Note: This RegExp should be improved, or likely pulled from Sizzle
|
|
|
4105 rmultiselector = /,/,
|
|
|
4106 isSimple = /^.[^:#\[\.,]*$/,
|
|
|
4107 slice = Array.prototype.slice,
|
|
|
4108 POS = jQuery.expr.match.POS;
|
|
|
4109
|
|
|
4110 jQuery.fn.extend({
|
|
|
4111 find: function( selector ) {
|
|
|
4112 var ret = this.pushStack( "", "find", selector ), length = 0;
|
|
|
4113
|
|
|
4114 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
4115 length = ret.length;
|
|
|
4116 jQuery.find( selector, this[i], ret );
|
|
|
4117
|
|
|
4118 if ( i > 0 ) {
|
|
|
4119 // Make sure that the results are unique
|
|
|
4120 for ( var n = length; n < ret.length; n++ ) {
|
|
|
4121 for ( var r = 0; r < length; r++ ) {
|
|
|
4122 if ( ret[r] === ret[n] ) {
|
|
|
4123 ret.splice(n--, 1);
|
|
|
4124 break;
|
|
|
4125 }
|
|
|
4126 }
|
|
|
4127 }
|
|
|
4128 }
|
|
|
4129 }
|
|
|
4130
|
|
|
4131 return ret;
|
|
|
4132 },
|
|
|
4133
|
|
|
4134 has: function( target ) {
|
|
|
4135 var targets = jQuery( target );
|
|
|
4136 return this.filter(function() {
|
|
|
4137 for ( var i = 0, l = targets.length; i < l; i++ ) {
|
|
|
4138 if ( jQuery.contains( this, targets[i] ) ) {
|
|
|
4139 return true;
|
|
|
4140 }
|
|
|
4141 }
|
|
|
4142 });
|
|
|
4143 },
|
|
|
4144
|
|
|
4145 not: function( selector ) {
|
|
|
4146 return this.pushStack( winnow(this, selector, false), "not", selector);
|
|
|
4147 },
|
|
|
4148
|
|
|
4149 filter: function( selector ) {
|
|
|
4150 return this.pushStack( winnow(this, selector, true), "filter", selector );
|
|
|
4151 },
|
|
|
4152
|
|
|
4153 is: function( selector ) {
|
|
|
4154 return !!selector && jQuery.filter( selector, this ).length > 0;
|
|
|
4155 },
|
|
|
4156
|
|
|
4157 closest: function( selectors, context ) {
|
|
|
4158 var ret = [], i, l, cur = this[0];
|
|
|
4159
|
|
|
4160 if ( jQuery.isArray( selectors ) ) {
|
|
|
4161 var match, matches = {}, selector, level = 1;
|
|
|
4162
|
|
|
4163 if ( cur && selectors.length ) {
|
|
|
4164 for ( i = 0, l = selectors.length; i < l; i++ ) {
|
|
|
4165 selector = selectors[i];
|
|
|
4166
|
|
|
4167 if ( !matches[selector] ) {
|
|
|
4168 matches[selector] = jQuery.expr.match.POS.test( selector ) ?
|
|
|
4169 jQuery( selector, context || this.context ) :
|
|
|
4170 selector;
|
|
|
4171 }
|
|
|
4172 }
|
|
|
4173
|
|
|
4174 while ( cur && cur.ownerDocument && cur !== context ) {
|
|
|
4175 for ( selector in matches ) {
|
|
|
4176 match = matches[selector];
|
|
|
4177
|
|
|
4178 if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
|
|
|
4179 ret.push({ selector: selector, elem: cur, level: level });
|
|
|
4180 }
|
|
|
4181 }
|
|
|
4182
|
|
|
4183 cur = cur.parentNode;
|
|
|
4184 level++;
|
|
|
4185 }
|
|
|
4186 }
|
|
|
4187
|
|
|
4188 return ret;
|
|
|
4189 }
|
|
|
4190
|
|
|
4191 var pos = POS.test( selectors ) ?
|
|
|
4192 jQuery( selectors, context || this.context ) : null;
|
|
|
4193
|
|
|
4194 for ( i = 0, l = this.length; i < l; i++ ) {
|
|
|
4195 cur = this[i];
|
|
|
4196
|
|
|
4197 while ( cur ) {
|
|
|
4198 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
|
|
|
4199 ret.push( cur );
|
|
|
4200 break;
|
|
|
4201
|
|
|
4202 } else {
|
|
|
4203 cur = cur.parentNode;
|
|
|
4204 if ( !cur || !cur.ownerDocument || cur === context ) {
|
|
|
4205 break;
|
|
|
4206 }
|
|
|
4207 }
|
|
|
4208 }
|
|
|
4209 }
|
|
|
4210
|
|
|
4211 ret = ret.length > 1 ? jQuery.unique(ret) : ret;
|
|
|
4212
|
|
|
4213 return this.pushStack( ret, "closest", selectors );
|
|
|
4214 },
|
|
|
4215
|
|
|
4216 // Determine the position of an element within
|
|
|
4217 // the matched set of elements
|
|
|
4218 index: function( elem ) {
|
|
|
4219 if ( !elem || typeof elem === "string" ) {
|
|
|
4220 return jQuery.inArray( this[0],
|
|
|
4221 // If it receives a string, the selector is used
|
|
|
4222 // If it receives nothing, the siblings are used
|
|
|
4223 elem ? jQuery( elem ) : this.parent().children() );
|
|
|
4224 }
|
|
|
4225 // Locate the position of the desired element
|
|
|
4226 return jQuery.inArray(
|
|
|
4227 // If it receives a jQuery object, the first element is used
|
|
|
4228 elem.jquery ? elem[0] : elem, this );
|
|
|
4229 },
|
|
|
4230
|
|
|
4231 add: function( selector, context ) {
|
|
|
4232 var set = typeof selector === "string" ?
|
|
|
4233 jQuery( selector, context || this.context ) :
|
|
|
4234 jQuery.makeArray( selector ),
|
|
|
4235 all = jQuery.merge( this.get(), set );
|
|
|
4236
|
|
|
4237 return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
|
|
|
4238 all :
|
|
|
4239 jQuery.unique( all ) );
|
|
|
4240 },
|
|
|
4241
|
|
|
4242 andSelf: function() {
|
|
|
4243 return this.add( this.prevObject );
|
|
|
4244 }
|
|
|
4245 });
|
|
|
4246
|
|
|
4247 // A painfully simple check to see if an element is disconnected
|
|
|
4248 // from a document (should be improved, where feasible).
|
|
|
4249 function isDisconnected( node ) {
|
|
|
4250 return !node || !node.parentNode || node.parentNode.nodeType === 11;
|
|
|
4251 }
|
|
|
4252
|
|
|
4253 jQuery.each({
|
|
|
4254 parent: function( elem ) {
|
|
|
4255 var parent = elem.parentNode;
|
|
|
4256 return parent && parent.nodeType !== 11 ? parent : null;
|
|
|
4257 },
|
|
|
4258 parents: function( elem ) {
|
|
|
4259 return jQuery.dir( elem, "parentNode" );
|
|
|
4260 },
|
|
|
4261 parentsUntil: function( elem, i, until ) {
|
|
|
4262 return jQuery.dir( elem, "parentNode", until );
|
|
|
4263 },
|
|
|
4264 next: function( elem ) {
|
|
|
4265 return jQuery.nth( elem, 2, "nextSibling" );
|
|
|
4266 },
|
|
|
4267 prev: function( elem ) {
|
|
|
4268 return jQuery.nth( elem, 2, "previousSibling" );
|
|
|
4269 },
|
|
|
4270 nextAll: function( elem ) {
|
|
|
4271 return jQuery.dir( elem, "nextSibling" );
|
|
|
4272 },
|
|
|
4273 prevAll: function( elem ) {
|
|
|
4274 return jQuery.dir( elem, "previousSibling" );
|
|
|
4275 },
|
|
|
4276 nextUntil: function( elem, i, until ) {
|
|
|
4277 return jQuery.dir( elem, "nextSibling", until );
|
|
|
4278 },
|
|
|
4279 prevUntil: function( elem, i, until ) {
|
|
|
4280 return jQuery.dir( elem, "previousSibling", until );
|
|
|
4281 },
|
|
|
4282 siblings: function( elem ) {
|
|
|
4283 return jQuery.sibling( elem.parentNode.firstChild, elem );
|
|
|
4284 },
|
|
|
4285 children: function( elem ) {
|
|
|
4286 return jQuery.sibling( elem.firstChild );
|
|
|
4287 },
|
|
|
4288 contents: function( elem ) {
|
|
|
4289 return jQuery.nodeName( elem, "iframe" ) ?
|
|
|
4290 elem.contentDocument || elem.contentWindow.document :
|
|
|
4291 jQuery.makeArray( elem.childNodes );
|
|
|
4292 }
|
|
|
4293 }, function( name, fn ) {
|
|
|
4294 jQuery.fn[ name ] = function( until, selector ) {
|
|
|
4295 var ret = jQuery.map( this, fn, until );
|
|
|
4296
|
|
|
4297 if ( !runtil.test( name ) ) {
|
|
|
4298 selector = until;
|
|
|
4299 }
|
|
|
4300
|
|
|
4301 if ( selector && typeof selector === "string" ) {
|
|
|
4302 ret = jQuery.filter( selector, ret );
|
|
|
4303 }
|
|
|
4304
|
|
|
4305 ret = this.length > 1 ? jQuery.unique( ret ) : ret;
|
|
|
4306
|
|
|
4307 if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
|
|
|
4308 ret = ret.reverse();
|
|
|
4309 }
|
|
|
4310
|
|
|
4311 return this.pushStack( ret, name, slice.call(arguments).join(",") );
|
|
|
4312 };
|
|
|
4313 });
|
|
|
4314
|
|
|
4315 jQuery.extend({
|
|
|
4316 filter: function( expr, elems, not ) {
|
|
|
4317 if ( not ) {
|
|
|
4318 expr = ":not(" + expr + ")";
|
|
|
4319 }
|
|
|
4320
|
|
|
4321 return elems.length === 1 ?
|
|
|
4322 jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
|
|
|
4323 jQuery.find.matches(expr, elems);
|
|
|
4324 },
|
|
|
4325
|
|
|
4326 dir: function( elem, dir, until ) {
|
|
|
4327 var matched = [], cur = elem[dir];
|
|
|
4328 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
|
|
|
4329 if ( cur.nodeType === 1 ) {
|
|
|
4330 matched.push( cur );
|
|
|
4331 }
|
|
|
4332 cur = cur[dir];
|
|
|
4333 }
|
|
|
4334 return matched;
|
|
|
4335 },
|
|
|
4336
|
|
|
4337 nth: function( cur, result, dir, elem ) {
|
|
|
4338 result = result || 1;
|
|
|
4339 var num = 0;
|
|
|
4340
|
|
|
4341 for ( ; cur; cur = cur[dir] ) {
|
|
|
4342 if ( cur.nodeType === 1 && ++num === result ) {
|
|
|
4343 break;
|
|
|
4344 }
|
|
|
4345 }
|
|
|
4346
|
|
|
4347 return cur;
|
|
|
4348 },
|
|
|
4349
|
|
|
4350 sibling: function( n, elem ) {
|
|
|
4351 var r = [];
|
|
|
4352
|
|
|
4353 for ( ; n; n = n.nextSibling ) {
|
|
|
4354 if ( n.nodeType === 1 && n !== elem ) {
|
|
|
4355 r.push( n );
|
|
|
4356 }
|
|
|
4357 }
|
|
|
4358
|
|
|
4359 return r;
|
|
|
4360 }
|
|
|
4361 });
|
|
|
4362
|
|
|
4363 // Implement the identical functionality for filter and not
|
|
|
4364 function winnow( elements, qualifier, keep ) {
|
|
|
4365 if ( jQuery.isFunction( qualifier ) ) {
|
|
|
4366 return jQuery.grep(elements, function( elem, i ) {
|
|
|
4367 var retVal = !!qualifier.call( elem, i, elem );
|
|
|
4368 return retVal === keep;
|
|
|
4369 });
|
|
|
4370
|
|
|
4371 } else if ( qualifier.nodeType ) {
|
|
|
4372 return jQuery.grep(elements, function( elem, i ) {
|
|
|
4373 return (elem === qualifier) === keep;
|
|
|
4374 });
|
|
|
4375
|
|
|
4376 } else if ( typeof qualifier === "string" ) {
|
|
|
4377 var filtered = jQuery.grep(elements, function( elem ) {
|
|
|
4378 return elem.nodeType === 1;
|
|
|
4379 });
|
|
|
4380
|
|
|
4381 if ( isSimple.test( qualifier ) ) {
|
|
|
4382 return jQuery.filter(qualifier, filtered, !keep);
|
|
|
4383 } else {
|
|
|
4384 qualifier = jQuery.filter( qualifier, filtered );
|
|
|
4385 }
|
|
|
4386 }
|
|
|
4387
|
|
|
4388 return jQuery.grep(elements, function( elem, i ) {
|
|
|
4389 return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
|
|
|
4390 });
|
|
|
4391 }
|
|
|
4392
|
|
|
4393
|
|
|
4394
|
|
|
4395
|
|
|
4396 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
|
|
|
4397 rleadingWhitespace = /^\s+/,
|
|
|
4398 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
|
|
|
4399 rtagName = /<([\w:]+)/,
|
|
|
4400 rtbody = /<tbody/i,
|
|
|
4401 rhtml = /<|&#?\w+;/,
|
|
|
4402 rnocache = /<(?:script|object|embed|option|style)/i,
|
|
|
4403 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, // checked="checked" or checked (html5)
|
|
|
4404 raction = /\=([^="'>\s]+\/)>/g,
|
|
|
4405 wrapMap = {
|
|
|
4406 option: [ 1, "<select multiple='multiple'>", "</select>" ],
|
|
|
4407 legend: [ 1, "<fieldset>", "</fieldset>" ],
|
|
|
4408 thead: [ 1, "<table>", "</table>" ],
|
|
|
4409 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
|
|
|
4410 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
|
|
|
4411 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
|
|
|
4412 area: [ 1, "<map>", "</map>" ],
|
|
|
4413 _default: [ 0, "", "" ]
|
|
|
4414 };
|
|
|
4415
|
|
|
4416 wrapMap.optgroup = wrapMap.option;
|
|
|
4417 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
|
|
|
4418 wrapMap.th = wrapMap.td;
|
|
|
4419
|
|
|
4420 // IE can't serialize <link> and <script> tags normally
|
|
|
4421 if ( !jQuery.support.htmlSerialize ) {
|
|
|
4422 wrapMap._default = [ 1, "div<div>", "</div>" ];
|
|
|
4423 }
|
|
|
4424
|
|
|
4425 jQuery.fn.extend({
|
|
|
4426 text: function( text ) {
|
|
|
4427 if ( jQuery.isFunction(text) ) {
|
|
|
4428 return this.each(function(i) {
|
|
|
4429 var self = jQuery(this);
|
|
|
4430 self.text( text.call(this, i, self.text()) );
|
|
|
4431 });
|
|
|
4432 }
|
|
|
4433
|
|
|
4434 if ( typeof text !== "object" && text !== undefined ) {
|
|
|
4435 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
|
|
|
4436 }
|
|
|
4437
|
|
|
4438 return jQuery.text( this );
|
|
|
4439 },
|
|
|
4440
|
|
|
4441 wrapAll: function( html ) {
|
|
|
4442 if ( jQuery.isFunction( html ) ) {
|
|
|
4443 return this.each(function(i) {
|
|
|
4444 jQuery(this).wrapAll( html.call(this, i) );
|
|
|
4445 });
|
|
|
4446 }
|
|
|
4447
|
|
|
4448 if ( this[0] ) {
|
|
|
4449 // The elements to wrap the target around
|
|
|
4450 var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
|
|
|
4451
|
|
|
4452 if ( this[0].parentNode ) {
|
|
|
4453 wrap.insertBefore( this[0] );
|
|
|
4454 }
|
|
|
4455
|
|
|
4456 wrap.map(function() {
|
|
|
4457 var elem = this;
|
|
|
4458
|
|
|
4459 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
|
|
|
4460 elem = elem.firstChild;
|
|
|
4461 }
|
|
|
4462
|
|
|
4463 return elem;
|
|
|
4464 }).append(this);
|
|
|
4465 }
|
|
|
4466
|
|
|
4467 return this;
|
|
|
4468 },
|
|
|
4469
|
|
|
4470 wrapInner: function( html ) {
|
|
|
4471 if ( jQuery.isFunction( html ) ) {
|
|
|
4472 return this.each(function(i) {
|
|
|
4473 jQuery(this).wrapInner( html.call(this, i) );
|
|
|
4474 });
|
|
|
4475 }
|
|
|
4476
|
|
|
4477 return this.each(function() {
|
|
|
4478 var self = jQuery( this ), contents = self.contents();
|
|
|
4479
|
|
|
4480 if ( contents.length ) {
|
|
|
4481 contents.wrapAll( html );
|
|
|
4482
|
|
|
4483 } else {
|
|
|
4484 self.append( html );
|
|
|
4485 }
|
|
|
4486 });
|
|
|
4487 },
|
|
|
4488
|
|
|
4489 wrap: function( html ) {
|
|
|
4490 return this.each(function() {
|
|
|
4491 jQuery( this ).wrapAll( html );
|
|
|
4492 });
|
|
|
4493 },
|
|
|
4494
|
|
|
4495 unwrap: function() {
|
|
|
4496 return this.parent().each(function() {
|
|
|
4497 if ( !jQuery.nodeName( this, "body" ) ) {
|
|
|
4498 jQuery( this ).replaceWith( this.childNodes );
|
|
|
4499 }
|
|
|
4500 }).end();
|
|
|
4501 },
|
|
|
4502
|
|
|
4503 append: function() {
|
|
|
4504 return this.domManip(arguments, true, function( elem ) {
|
|
|
4505 if ( this.nodeType === 1 ) {
|
|
|
4506 this.appendChild( elem );
|
|
|
4507 }
|
|
|
4508 });
|
|
|
4509 },
|
|
|
4510
|
|
|
4511 prepend: function() {
|
|
|
4512 return this.domManip(arguments, true, function( elem ) {
|
|
|
4513 if ( this.nodeType === 1 ) {
|
|
|
4514 this.insertBefore( elem, this.firstChild );
|
|
|
4515 }
|
|
|
4516 });
|
|
|
4517 },
|
|
|
4518
|
|
|
4519 before: function() {
|
|
|
4520 if ( this[0] && this[0].parentNode ) {
|
|
|
4521 return this.domManip(arguments, false, function( elem ) {
|
|
|
4522 this.parentNode.insertBefore( elem, this );
|
|
|
4523 });
|
|
|
4524 } else if ( arguments.length ) {
|
|
|
4525 var set = jQuery(arguments[0]);
|
|
|
4526 set.push.apply( set, this.toArray() );
|
|
|
4527 return this.pushStack( set, "before", arguments );
|
|
|
4528 }
|
|
|
4529 },
|
|
|
4530
|
|
|
4531 after: function() {
|
|
|
4532 if ( this[0] && this[0].parentNode ) {
|
|
|
4533 return this.domManip(arguments, false, function( elem ) {
|
|
|
4534 this.parentNode.insertBefore( elem, this.nextSibling );
|
|
|
4535 });
|
|
|
4536 } else if ( arguments.length ) {
|
|
|
4537 var set = this.pushStack( this, "after", arguments );
|
|
|
4538 set.push.apply( set, jQuery(arguments[0]).toArray() );
|
|
|
4539 return set;
|
|
|
4540 }
|
|
|
4541 },
|
|
|
4542
|
|
|
4543 // keepData is for internal use only--do not document
|
|
|
4544 remove: function( selector, keepData ) {
|
|
|
4545 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
|
|
|
4546 if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
|
|
|
4547 if ( !keepData && elem.nodeType === 1 ) {
|
|
|
4548 jQuery.cleanData( elem.getElementsByTagName("*") );
|
|
|
4549 jQuery.cleanData( [ elem ] );
|
|
|
4550 }
|
|
|
4551
|
|
|
4552 if ( elem.parentNode ) {
|
|
|
4553 elem.parentNode.removeChild( elem );
|
|
|
4554 }
|
|
|
4555 }
|
|
|
4556 }
|
|
|
4557
|
|
|
4558 return this;
|
|
|
4559 },
|
|
|
4560
|
|
|
4561 empty: function() {
|
|
|
4562 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
|
|
|
4563 // Remove element nodes and prevent memory leaks
|
|
|
4564 if ( elem.nodeType === 1 ) {
|
|
|
4565 jQuery.cleanData( elem.getElementsByTagName("*") );
|
|
|
4566 }
|
|
|
4567
|
|
|
4568 // Remove any remaining nodes
|
|
|
4569 while ( elem.firstChild ) {
|
|
|
4570 elem.removeChild( elem.firstChild );
|
|
|
4571 }
|
|
|
4572 }
|
|
|
4573
|
|
|
4574 return this;
|
|
|
4575 },
|
|
|
4576
|
|
|
4577 clone: function( events ) {
|
|
|
4578 // Do the clone
|
|
|
4579 var ret = this.map(function() {
|
|
|
4580 if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
|
|
|
4581 // IE copies events bound via attachEvent when
|
|
|
4582 // using cloneNode. Calling detachEvent on the
|
|
|
4583 // clone will also remove the events from the orignal
|
|
|
4584 // In order to get around this, we use innerHTML.
|
|
|
4585 // Unfortunately, this means some modifications to
|
|
|
4586 // attributes in IE that are actually only stored
|
|
|
4587 // as properties will not be copied (such as the
|
|
|
4588 // the name attribute on an input).
|
|
|
4589 var html = this.outerHTML, ownerDocument = this.ownerDocument;
|
|
|
4590 if ( !html ) {
|
|
|
4591 var div = ownerDocument.createElement("div");
|
|
|
4592 div.appendChild( this.cloneNode(true) );
|
|
|
4593 html = div.innerHTML;
|
|
|
4594 }
|
|
|
4595
|
|
|
4596 return jQuery.clean([html.replace(rinlinejQuery, "")
|
|
|
4597 // Handle the case in IE 8 where action=/test/> self-closes a tag
|
|
|
4598 .replace(raction, '="$1">')
|
|
|
4599 .replace(rleadingWhitespace, "")], ownerDocument)[0];
|
|
|
4600 } else {
|
|
|
4601 return this.cloneNode(true);
|
|
|
4602 }
|
|
|
4603 });
|
|
|
4604
|
|
|
4605 // Copy the events from the original to the clone
|
|
|
4606 if ( events === true ) {
|
|
|
4607 cloneCopyEvent( this, ret );
|
|
|
4608 cloneCopyEvent( this.find("*"), ret.find("*") );
|
|
|
4609 }
|
|
|
4610
|
|
|
4611 // Return the cloned set
|
|
|
4612 return ret;
|
|
|
4613 },
|
|
|
4614
|
|
|
4615 html: function( value ) {
|
|
|
4616 if ( value === undefined ) {
|
|
|
4617 return this[0] && this[0].nodeType === 1 ?
|
|
|
4618 this[0].innerHTML.replace(rinlinejQuery, "") :
|
|
|
4619 null;
|
|
|
4620
|
|
|
4621 // See if we can take a shortcut and just use innerHTML
|
|
|
4622 } else if ( typeof value === "string" && !rnocache.test( value ) &&
|
|
|
4623 (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
|
|
|
4624 !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
|
|
|
4625
|
|
|
4626 value = value.replace(rxhtmlTag, "<$1></$2>");
|
|
|
4627
|
|
|
4628 try {
|
|
|
4629 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
4630 // Remove element nodes and prevent memory leaks
|
|
|
4631 if ( this[i].nodeType === 1 ) {
|
|
|
4632 jQuery.cleanData( this[i].getElementsByTagName("*") );
|
|
|
4633 this[i].innerHTML = value;
|
|
|
4634 }
|
|
|
4635 }
|
|
|
4636
|
|
|
4637 // If using innerHTML throws an exception, use the fallback method
|
|
|
4638 } catch(e) {
|
|
|
4639 this.empty().append( value );
|
|
|
4640 }
|
|
|
4641
|
|
|
4642 } else if ( jQuery.isFunction( value ) ) {
|
|
|
4643 this.each(function(i){
|
|
|
4644 var self = jQuery(this);
|
|
|
4645 self.html( value.call(this, i, self.html()) );
|
|
|
4646 });
|
|
|
4647
|
|
|
4648 } else {
|
|
|
4649 this.empty().append( value );
|
|
|
4650 }
|
|
|
4651
|
|
|
4652 return this;
|
|
|
4653 },
|
|
|
4654
|
|
|
4655 replaceWith: function( value ) {
|
|
|
4656 if ( this[0] && this[0].parentNode ) {
|
|
|
4657 // Make sure that the elements are removed from the DOM before they are inserted
|
|
|
4658 // this can help fix replacing a parent with child elements
|
|
|
4659 if ( jQuery.isFunction( value ) ) {
|
|
|
4660 return this.each(function(i) {
|
|
|
4661 var self = jQuery(this), old = self.html();
|
|
|
4662 self.replaceWith( value.call( this, i, old ) );
|
|
|
4663 });
|
|
|
4664 }
|
|
|
4665
|
|
|
4666 if ( typeof value !== "string" ) {
|
|
|
4667 value = jQuery(value).detach();
|
|
|
4668 }
|
|
|
4669
|
|
|
4670 return this.each(function() {
|
|
|
4671 var next = this.nextSibling, parent = this.parentNode;
|
|
|
4672
|
|
|
4673 jQuery(this).remove();
|
|
|
4674
|
|
|
4675 if ( next ) {
|
|
|
4676 jQuery(next).before( value );
|
|
|
4677 } else {
|
|
|
4678 jQuery(parent).append( value );
|
|
|
4679 }
|
|
|
4680 });
|
|
|
4681 } else {
|
|
|
4682 return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
|
|
|
4683 }
|
|
|
4684 },
|
|
|
4685
|
|
|
4686 detach: function( selector ) {
|
|
|
4687 return this.remove( selector, true );
|
|
|
4688 },
|
|
|
4689
|
|
|
4690 domManip: function( args, table, callback ) {
|
|
|
4691 var results, first, value = args[0], scripts = [], fragment, parent;
|
|
|
4692
|
|
|
4693 // We can't cloneNode fragments that contain checked, in WebKit
|
|
|
4694 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
|
|
|
4695 return this.each(function() {
|
|
|
4696 jQuery(this).domManip( args, table, callback, true );
|
|
|
4697 });
|
|
|
4698 }
|
|
|
4699
|
|
|
4700 if ( jQuery.isFunction(value) ) {
|
|
|
4701 return this.each(function(i) {
|
|
|
4702 var self = jQuery(this);
|
|
|
4703 args[0] = value.call(this, i, table ? self.html() : undefined);
|
|
|
4704 self.domManip( args, table, callback );
|
|
|
4705 });
|
|
|
4706 }
|
|
|
4707
|
|
|
4708 if ( this[0] ) {
|
|
|
4709 parent = value && value.parentNode;
|
|
|
4710
|
|
|
4711 // If we're in a fragment, just use that instead of building a new one
|
|
|
4712 if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
|
|
|
4713 results = { fragment: parent };
|
|
|
4714
|
|
|
4715 } else {
|
|
|
4716 results = jQuery.buildFragment( args, this, scripts );
|
|
|
4717 }
|
|
|
4718
|
|
|
4719 fragment = results.fragment;
|
|
|
4720
|
|
|
4721 if ( fragment.childNodes.length === 1 ) {
|
|
|
4722 first = fragment = fragment.firstChild;
|
|
|
4723 } else {
|
|
|
4724 first = fragment.firstChild;
|
|
|
4725 }
|
|
|
4726
|
|
|
4727 if ( first ) {
|
|
|
4728 table = table && jQuery.nodeName( first, "tr" );
|
|
|
4729
|
|
|
4730 for ( var i = 0, l = this.length; i < l; i++ ) {
|
|
|
4731 callback.call(
|
|
|
4732 table ?
|
|
|
4733 root(this[i], first) :
|
|
|
4734 this[i],
|
|
|
4735 i > 0 || results.cacheable || this.length > 1 ?
|
|
|
4736 fragment.cloneNode(true) :
|
|
|
4737 fragment
|
|
|
4738 );
|
|
|
4739 }
|
|
|
4740 }
|
|
|
4741
|
|
|
4742 if ( scripts.length ) {
|
|
|
4743 jQuery.each( scripts, evalScript );
|
|
|
4744 }
|
|
|
4745 }
|
|
|
4746
|
|
|
4747 return this;
|
|
|
4748 }
|
|
|
4749 });
|
|
|
4750
|
|
|
4751 function root( elem, cur ) {
|
|
|
4752 return jQuery.nodeName(elem, "table") ?
|
|
|
4753 (elem.getElementsByTagName("tbody")[0] ||
|
|
|
4754 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
|
|
|
4755 elem;
|
|
|
4756 }
|
|
|
4757
|
|
|
4758 function cloneCopyEvent(orig, ret) {
|
|
|
4759 var i = 0;
|
|
|
4760
|
|
|
4761 ret.each(function() {
|
|
|
4762 if ( this.nodeName !== (orig[i] && orig[i].nodeName) ) {
|
|
|
4763 return;
|
|
|
4764 }
|
|
|
4765
|
|
|
4766 var oldData = jQuery.data( orig[i++] ), curData = jQuery.data( this, oldData ), events = oldData && oldData.events;
|
|
|
4767
|
|
|
4768 if ( events ) {
|
|
|
4769 delete curData.handle;
|
|
|
4770 curData.events = {};
|
|
|
4771
|
|
|
4772 for ( var type in events ) {
|
|
|
4773 for ( var handler in events[ type ] ) {
|
|
|
4774 jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
|
|
|
4775 }
|
|
|
4776 }
|
|
|
4777 }
|
|
|
4778 });
|
|
|
4779 }
|
|
|
4780
|
|
|
4781 jQuery.buildFragment = function( args, nodes, scripts ) {
|
|
|
4782 var fragment, cacheable, cacheresults,
|
|
|
4783 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
|
|
|
4784
|
|
|
4785 // Only cache "small" (1/2 KB) strings that are associated with the main document
|
|
|
4786 // Cloning options loses the selected state, so don't cache them
|
|
|
4787 // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
|
|
|
4788 // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
|
|
|
4789 if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
|
|
|
4790 !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
|
|
|
4791
|
|
|
4792 cacheable = true;
|
|
|
4793 cacheresults = jQuery.fragments[ args[0] ];
|
|
|
4794 if ( cacheresults ) {
|
|
|
4795 if ( cacheresults !== 1 ) {
|
|
|
4796 fragment = cacheresults;
|
|
|
4797 }
|
|
|
4798 }
|
|
|
4799 }
|
|
|
4800
|
|
|
4801 if ( !fragment ) {
|
|
|
4802 fragment = doc.createDocumentFragment();
|
|
|
4803 jQuery.clean( args, doc, fragment, scripts );
|
|
|
4804 }
|
|
|
4805
|
|
|
4806 if ( cacheable ) {
|
|
|
4807 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
|
|
|
4808 }
|
|
|
4809
|
|
|
4810 return { fragment: fragment, cacheable: cacheable };
|
|
|
4811 };
|
|
|
4812
|
|
|
4813 jQuery.fragments = {};
|
|
|
4814
|
|
|
4815 jQuery.each({
|
|
|
4816 appendTo: "append",
|
|
|
4817 prependTo: "prepend",
|
|
|
4818 insertBefore: "before",
|
|
|
4819 insertAfter: "after",
|
|
|
4820 replaceAll: "replaceWith"
|
|
|
4821 }, function( name, original ) {
|
|
|
4822 jQuery.fn[ name ] = function( selector ) {
|
|
|
4823 var ret = [], insert = jQuery( selector ),
|
|
|
4824 parent = this.length === 1 && this[0].parentNode;
|
|
|
4825
|
|
|
4826 if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
|
|
|
4827 insert[ original ]( this[0] );
|
|
|
4828 return this;
|
|
|
4829
|
|
|
4830 } else {
|
|
|
4831 for ( var i = 0, l = insert.length; i < l; i++ ) {
|
|
|
4832 var elems = (i > 0 ? this.clone(true) : this).get();
|
|
|
4833 jQuery( insert[i] )[ original ]( elems );
|
|
|
4834 ret = ret.concat( elems );
|
|
|
4835 }
|
|
|
4836
|
|
|
4837 return this.pushStack( ret, name, insert.selector );
|
|
|
4838 }
|
|
|
4839 };
|
|
|
4840 });
|
|
|
4841
|
|
|
4842 jQuery.extend({
|
|
|
4843 clean: function( elems, context, fragment, scripts ) {
|
|
|
4844 context = context || document;
|
|
|
4845
|
|
|
4846 // !context.createElement fails in IE with an error but returns typeof 'object'
|
|
|
4847 if ( typeof context.createElement === "undefined" ) {
|
|
|
4848 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
|
|
|
4849 }
|
|
|
4850
|
|
|
4851 var ret = [];
|
|
|
4852
|
|
|
4853 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
|
|
|
4854 if ( typeof elem === "number" ) {
|
|
|
4855 elem += "";
|
|
|
4856 }
|
|
|
4857
|
|
|
4858 if ( !elem ) {
|
|
|
4859 continue;
|
|
|
4860 }
|
|
|
4861
|
|
|
4862 // Convert html string into DOM nodes
|
|
|
4863 if ( typeof elem === "string" && !rhtml.test( elem ) ) {
|
|
|
4864 elem = context.createTextNode( elem );
|
|
|
4865
|
|
|
4866 } else if ( typeof elem === "string" ) {
|
|
|
4867 // Fix "XHTML"-style tags in all browsers
|
|
|
4868 elem = elem.replace(rxhtmlTag, "<$1></$2>");
|
|
|
4869
|
|
|
4870 // Trim whitespace, otherwise indexOf won't work as expected
|
|
|
4871 var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
|
|
|
4872 wrap = wrapMap[ tag ] || wrapMap._default,
|
|
|
4873 depth = wrap[0],
|
|
|
4874 div = context.createElement("div");
|
|
|
4875
|
|
|
4876 // Go to html and back, then peel off extra wrappers
|
|
|
4877 div.innerHTML = wrap[1] + elem + wrap[2];
|
|
|
4878
|
|
|
4879 // Move to the right depth
|
|
|
4880 while ( depth-- ) {
|
|
|
4881 div = div.lastChild;
|
|
|
4882 }
|
|
|
4883
|
|
|
4884 // Remove IE's autoinserted <tbody> from table fragments
|
|
|
4885 if ( !jQuery.support.tbody ) {
|
|
|
4886
|
|
|
4887 // String was a <table>, *may* have spurious <tbody>
|
|
|
4888 var hasBody = rtbody.test(elem),
|
|
|
4889 tbody = tag === "table" && !hasBody ?
|
|
|
4890 div.firstChild && div.firstChild.childNodes :
|
|
|
4891
|
|
|
4892 // String was a bare <thead> or <tfoot>
|
|
|
4893 wrap[1] === "<table>" && !hasBody ?
|
|
|
4894 div.childNodes :
|
|
|
4895 [];
|
|
|
4896
|
|
|
4897 for ( var j = tbody.length - 1; j >= 0 ; --j ) {
|
|
|
4898 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
|
|
|
4899 tbody[ j ].parentNode.removeChild( tbody[ j ] );
|
|
|
4900 }
|
|
|
4901 }
|
|
|
4902
|
|
|
4903 }
|
|
|
4904
|
|
|
4905 // IE completely kills leading whitespace when innerHTML is used
|
|
|
4906 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
|
|
|
4907 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
|
|
|
4908 }
|
|
|
4909
|
|
|
4910 elem = div.childNodes;
|
|
|
4911 }
|
|
|
4912
|
|
|
4913 if ( elem.nodeType ) {
|
|
|
4914 ret.push( elem );
|
|
|
4915 } else {
|
|
|
4916 ret = jQuery.merge( ret, elem );
|
|
|
4917 }
|
|
|
4918 }
|
|
|
4919
|
|
|
4920 if ( fragment ) {
|
|
|
4921 for ( i = 0; ret[i]; i++ ) {
|
|
|
4922 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
|
|
|
4923 scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
|
|
|
4924
|
|
|
4925 } else {
|
|
|
4926 if ( ret[i].nodeType === 1 ) {
|
|
|
4927 ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
|
|
|
4928 }
|
|
|
4929 fragment.appendChild( ret[i] );
|
|
|
4930 }
|
|
|
4931 }
|
|
|
4932 }
|
|
|
4933
|
|
|
4934 return ret;
|
|
|
4935 },
|
|
|
4936
|
|
|
4937 cleanData: function( elems ) {
|
|
|
4938 var data, id, cache = jQuery.cache,
|
|
|
4939 special = jQuery.event.special,
|
|
|
4940 deleteExpando = jQuery.support.deleteExpando;
|
|
|
4941
|
|
|
4942 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
|
|
|
4943 if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
|
|
|
4944 continue;
|
|
|
4945 }
|
|
|
4946
|
|
|
4947 id = elem[ jQuery.expando ];
|
|
|
4948
|
|
|
4949 if ( id ) {
|
|
|
4950 data = cache[ id ];
|
|
|
4951
|
|
|
4952 if ( data && data.events ) {
|
|
|
4953 for ( var type in data.events ) {
|
|
|
4954 if ( special[ type ] ) {
|
|
|
4955 jQuery.event.remove( elem, type );
|
|
|
4956
|
|
|
4957 } else {
|
|
|
4958 jQuery.removeEvent( elem, type, data.handle );
|
|
|
4959 }
|
|
|
4960 }
|
|
|
4961 }
|
|
|
4962
|
|
|
4963 if ( deleteExpando ) {
|
|
|
4964 delete elem[ jQuery.expando ];
|
|
|
4965
|
|
|
4966 } else if ( elem.removeAttribute ) {
|
|
|
4967 elem.removeAttribute( jQuery.expando );
|
|
|
4968 }
|
|
|
4969
|
|
|
4970 delete cache[ id ];
|
|
|
4971 }
|
|
|
4972 }
|
|
|
4973 }
|
|
|
4974 });
|
|
|
4975
|
|
|
4976 function evalScript( i, elem ) {
|
|
|
4977 if ( elem.src ) {
|
|
|
4978 jQuery.ajax({
|
|
|
4979 url: elem.src,
|
|
|
4980 async: false,
|
|
|
4981 dataType: "script"
|
|
|
4982 });
|
|
|
4983 } else {
|
|
|
4984 jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
|
|
|
4985 }
|
|
|
4986
|
|
|
4987 if ( elem.parentNode ) {
|
|
|
4988 elem.parentNode.removeChild( elem );
|
|
|
4989 }
|
|
|
4990 }
|
|
|
4991
|
|
|
4992
|
|
|
4993
|
|
|
4994
|
|
|
4995 var ralpha = /alpha\([^)]*\)/i,
|
|
|
4996 ropacity = /opacity=([^)]*)/,
|
|
|
4997 rdashAlpha = /-([a-z])/ig,
|
|
|
4998 rupper = /([A-Z])/g,
|
|
|
4999 rnumpx = /^-?\d+(?:px)?$/i,
|
|
|
5000 rnum = /^-?\d/,
|
|
|
5001
|
|
|
5002 cssShow = { position: "absolute", visibility: "hidden", display: "block" },
|
|
|
5003 cssWidth = [ "Left", "Right" ],
|
|
|
5004 cssHeight = [ "Top", "Bottom" ],
|
|
|
5005 curCSS,
|
|
|
5006
|
|
|
5007 // cache check for defaultView.getComputedStyle
|
|
|
5008 getComputedStyle = document.defaultView && document.defaultView.getComputedStyle,
|
|
|
5009
|
|
|
5010 fcamelCase = function( all, letter ) {
|
|
|
5011 return letter.toUpperCase();
|
|
|
5012 };
|
|
|
5013
|
|
|
5014 jQuery.fn.css = function( name, value ) {
|
|
|
5015 // Setting 'undefined' is a no-op
|
|
|
5016 if ( arguments.length === 2 && value === undefined ) {
|
|
|
5017 return this;
|
|
|
5018 }
|
|
|
5019
|
|
|
5020 return jQuery.access( this, name, value, true, function( elem, name, value ) {
|
|
|
5021 return value !== undefined ?
|
|
|
5022 jQuery.style( elem, name, value ) :
|
|
|
5023 jQuery.css( elem, name );
|
|
|
5024 });
|
|
|
5025 };
|
|
|
5026
|
|
|
5027 jQuery.extend({
|
|
|
5028 // Add in style property hooks for overriding the default
|
|
|
5029 // behavior of getting and setting a style property
|
|
|
5030 cssHooks: {
|
|
|
5031 opacity: {
|
|
|
5032 get: function( elem, computed ) {
|
|
|
5033 if ( computed ) {
|
|
|
5034 // We should always get a number back from opacity
|
|
|
5035 var ret = curCSS( elem, "opacity", "opacity" );
|
|
|
5036 return ret === "" ? "1" : ret;
|
|
|
5037
|
|
|
5038 } else {
|
|
|
5039 return elem.style.opacity;
|
|
|
5040 }
|
|
|
5041 }
|
|
|
5042 }
|
|
|
5043 },
|
|
|
5044
|
|
|
5045 // Exclude the following css properties to add px
|
|
|
5046 cssNumber: {
|
|
|
5047 "zIndex": true,
|
|
|
5048 "fontWeight": true,
|
|
|
5049 "opacity": true,
|
|
|
5050 "zoom": true,
|
|
|
5051 "lineHeight": true
|
|
|
5052 },
|
|
|
5053
|
|
|
5054 // Add in properties whose names you wish to fix before
|
|
|
5055 // setting or getting the value
|
|
|
5056 cssProps: {
|
|
|
5057 // normalize float css property
|
|
|
5058 "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
|
|
|
5059 },
|
|
|
5060
|
|
|
5061 // Get and set the style property on a DOM Node
|
|
|
5062 style: function( elem, name, value, extra ) {
|
|
|
5063 // Don't set styles on text and comment nodes
|
|
|
5064 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
|
|
|
5065 return;
|
|
|
5066 }
|
|
|
5067
|
|
|
5068 // Make sure that we're working with the right name
|
|
|
5069 var ret, origName = jQuery.camelCase( name ),
|
|
|
5070 style = elem.style, hooks = jQuery.cssHooks[ origName ];
|
|
|
5071
|
|
|
5072 name = jQuery.cssProps[ origName ] || origName;
|
|
|
5073
|
|
|
5074 // Check if we're setting a value
|
|
|
5075 if ( value !== undefined ) {
|
|
|
5076 // Make sure that NaN and null values aren't set. See: #7116
|
|
|
5077 if ( typeof value === "number" && isNaN( value ) || value == null ) {
|
|
|
5078 return;
|
|
|
5079 }
|
|
|
5080
|
|
|
5081 // If a number was passed in, add 'px' to the (except for certain CSS properties)
|
|
|
5082 if ( typeof value === "number" && !jQuery.cssNumber[ origName ] ) {
|
|
|
5083 value += "px";
|
|
|
5084 }
|
|
|
5085
|
|
|
5086 // If a hook was provided, use that value, otherwise just set the specified value
|
|
|
5087 if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
|
|
|
5088 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
|
|
|
5089 // Fixes bug #5509
|
|
|
5090 try {
|
|
|
5091 style[ name ] = value;
|
|
|
5092 } catch(e) {}
|
|
|
5093 }
|
|
|
5094
|
|
|
5095 } else {
|
|
|
5096 // If a hook was provided get the non-computed value from there
|
|
|
5097 if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
|
|
|
5098 return ret;
|
|
|
5099 }
|
|
|
5100
|
|
|
5101 // Otherwise just get the value from the style object
|
|
|
5102 return style[ name ];
|
|
|
5103 }
|
|
|
5104 },
|
|
|
5105
|
|
|
5106 css: function( elem, name, extra ) {
|
|
|
5107 // Make sure that we're working with the right name
|
|
|
5108 var ret, origName = jQuery.camelCase( name ),
|
|
|
5109 hooks = jQuery.cssHooks[ origName ];
|
|
|
5110
|
|
|
5111 name = jQuery.cssProps[ origName ] || origName;
|
|
|
5112
|
|
|
5113 // If a hook was provided get the computed value from there
|
|
|
5114 if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
|
|
|
5115 return ret;
|
|
|
5116
|
|
|
5117 // Otherwise, if a way to get the computed value exists, use that
|
|
|
5118 } else if ( curCSS ) {
|
|
|
5119 return curCSS( elem, name, origName );
|
|
|
5120 }
|
|
|
5121 },
|
|
|
5122
|
|
|
5123 // A method for quickly swapping in/out CSS properties to get correct calculations
|
|
|
5124 swap: function( elem, options, callback ) {
|
|
|
5125 var old = {};
|
|
|
5126
|
|
|
5127 // Remember the old values, and insert the new ones
|
|
|
5128 for ( var name in options ) {
|
|
|
5129 old[ name ] = elem.style[ name ];
|
|
|
5130 elem.style[ name ] = options[ name ];
|
|
|
5131 }
|
|
|
5132
|
|
|
5133 callback.call( elem );
|
|
|
5134
|
|
|
5135 // Revert the old values
|
|
|
5136 for ( name in options ) {
|
|
|
5137 elem.style[ name ] = old[ name ];
|
|
|
5138 }
|
|
|
5139 },
|
|
|
5140
|
|
|
5141 camelCase: function( string ) {
|
|
|
5142 return string.replace( rdashAlpha, fcamelCase );
|
|
|
5143 }
|
|
|
5144 });
|
|
|
5145
|
|
|
5146 // DEPRECATED, Use jQuery.css() instead
|
|
|
5147 jQuery.curCSS = jQuery.css;
|
|
|
5148
|
|
|
5149 jQuery.each(["height", "width"], function( i, name ) {
|
|
|
5150 jQuery.cssHooks[ name ] = {
|
|
|
5151 get: function( elem, computed, extra ) {
|
|
|
5152 var val;
|
|
|
5153
|
|
|
5154 if ( computed ) {
|
|
|
5155 if ( elem.offsetWidth !== 0 ) {
|
|
|
5156 val = getWH( elem, name, extra );
|
|
|
5157
|
|
|
5158 } else {
|
|
|
5159 jQuery.swap( elem, cssShow, function() {
|
|
|
5160 val = getWH( elem, name, extra );
|
|
|
5161 });
|
|
|
5162 }
|
|
|
5163
|
|
|
5164 return val + "px";
|
|
|
5165 }
|
|
|
5166 },
|
|
|
5167
|
|
|
5168 set: function( elem, value ) {
|
|
|
5169 if ( rnumpx.test( value ) ) {
|
|
|
5170 // ignore negative width and height values #1599
|
|
|
5171 value = parseFloat(value);
|
|
|
5172
|
|
|
5173 if ( value >= 0 ) {
|
|
|
5174 return value + "px";
|
|
|
5175 }
|
|
|
5176
|
|
|
5177 } else {
|
|
|
5178 return value;
|
|
|
5179 }
|
|
|
5180 }
|
|
|
5181 };
|
|
|
5182 });
|
|
|
5183
|
|
|
5184 if ( !jQuery.support.opacity ) {
|
|
|
5185 jQuery.cssHooks.opacity = {
|
|
|
5186 get: function( elem, computed ) {
|
|
|
5187 // IE uses filters for opacity
|
|
|
5188 return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ?
|
|
|
5189 (parseFloat(RegExp.$1) / 100) + "" :
|
|
|
5190 computed ? "1" : "";
|
|
|
5191 },
|
|
|
5192
|
|
|
5193 set: function( elem, value ) {
|
|
|
5194 var style = elem.style;
|
|
|
5195
|
|
|
5196 // IE has trouble with opacity if it does not have layout
|
|
|
5197 // Force it by setting the zoom level
|
|
|
5198 style.zoom = 1;
|
|
|
5199
|
|
|
5200 // Set the alpha filter to set the opacity
|
|
|
5201 var opacity = jQuery.isNaN(value) ?
|
|
|
5202 "" :
|
|
|
5203 "alpha(opacity=" + value * 100 + ")",
|
|
|
5204 filter = style.filter || "";
|
|
|
5205
|
|
|
5206 style.filter = ralpha.test(filter) ?
|
|
|
5207 filter.replace(ralpha, opacity) :
|
|
|
5208 style.filter + ' ' + opacity;
|
|
|
5209 }
|
|
|
5210 };
|
|
|
5211 }
|
|
|
5212
|
|
|
5213 if ( getComputedStyle ) {
|
|
|
5214 curCSS = function( elem, newName, name ) {
|
|
|
5215 var ret, defaultView, computedStyle;
|
|
|
5216
|
|
|
5217 name = name.replace( rupper, "-$1" ).toLowerCase();
|
|
|
5218
|
|
|
5219 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
|
|
|
5220 return undefined;
|
|
|
5221 }
|
|
|
5222
|
|
|
5223 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
|
|
|
5224 ret = computedStyle.getPropertyValue( name );
|
|
|
5225 if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
|
|
|
5226 ret = jQuery.style( elem, name );
|
|
|
5227 }
|
|
|
5228 }
|
|
|
5229
|
|
|
5230 return ret;
|
|
|
5231 };
|
|
|
5232
|
|
|
5233 } else if ( document.documentElement.currentStyle ) {
|
|
|
5234 curCSS = function( elem, name ) {
|
|
|
5235 var left, rsLeft, ret = elem.currentStyle && elem.currentStyle[ name ], style = elem.style;
|
|
|
5236
|
|
|
5237 // From the awesome hack by Dean Edwards
|
|
|
5238 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
|
|
|
5239
|
|
|
5240 // If we're not dealing with a regular pixel number
|
|
|
5241 // but a number that has a weird ending, we need to convert it to pixels
|
|
|
5242 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
|
|
|
5243 // Remember the original values
|
|
|
5244 left = style.left;
|
|
|
5245 rsLeft = elem.runtimeStyle.left;
|
|
|
5246
|
|
|
5247 // Put in the new values to get a computed value out
|
|
|
5248 elem.runtimeStyle.left = elem.currentStyle.left;
|
|
|
5249 style.left = name === "fontSize" ? "1em" : (ret || 0);
|
|
|
5250 ret = style.pixelLeft + "px";
|
|
|
5251
|
|
|
5252 // Revert the changed values
|
|
|
5253 style.left = left;
|
|
|
5254 elem.runtimeStyle.left = rsLeft;
|
|
|
5255 }
|
|
|
5256
|
|
|
5257 return ret;
|
|
|
5258 };
|
|
|
5259 }
|
|
|
5260
|
|
|
5261 function getWH( elem, name, extra ) {
|
|
|
5262 var which = name === "width" ? cssWidth : cssHeight,
|
|
|
5263 val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
|
|
|
5264
|
|
|
5265 if ( extra === "border" ) {
|
|
|
5266 return val;
|
|
|
5267 }
|
|
|
5268
|
|
|
5269 jQuery.each( which, function() {
|
|
|
5270 if ( !extra ) {
|
|
|
5271 val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
|
|
|
5272 }
|
|
|
5273
|
|
|
5274 if ( extra === "margin" ) {
|
|
|
5275 val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
|
|
|
5276
|
|
|
5277 } else {
|
|
|
5278 val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
|
|
|
5279 }
|
|
|
5280 });
|
|
|
5281
|
|
|
5282 return val;
|
|
|
5283 }
|
|
|
5284
|
|
|
5285 if ( jQuery.expr && jQuery.expr.filters ) {
|
|
|
5286 jQuery.expr.filters.hidden = function( elem ) {
|
|
|
5287 var width = elem.offsetWidth, height = elem.offsetHeight;
|
|
|
5288
|
|
|
5289 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
|
|
|
5290 };
|
|
|
5291
|
|
|
5292 jQuery.expr.filters.visible = function( elem ) {
|
|
|
5293 return !jQuery.expr.filters.hidden( elem );
|
|
|
5294 };
|
|
|
5295 }
|
|
|
5296
|
|
|
5297
|
|
|
5298
|
|
|
5299
|
|
|
5300 var jsc = jQuery.now(),
|
|
|
5301 rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
|
|
|
5302 rselectTextarea = /^(?:select|textarea)/i,
|
|
|
5303 rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
|
|
|
5304 rnoContent = /^(?:GET|HEAD|DELETE)$/,
|
|
|
5305 rbracket = /\[\]$/,
|
|
|
5306 jsre = /\=\?(&|$)/,
|
|
|
5307 rquery = /\?/,
|
|
|
5308 rts = /([?&])_=[^&]*/,
|
|
|
5309 rurl = /^(\w+:)?\/\/([^\/?#]+)/,
|
|
|
5310 r20 = /%20/g,
|
|
|
5311 rhash = /#.*$/,
|
|
|
5312
|
|
|
5313 // Keep a copy of the old load method
|
|
|
5314 _load = jQuery.fn.load;
|
|
|
5315
|
|
|
5316 jQuery.fn.extend({
|
|
|
5317 load: function( url, params, callback ) {
|
|
|
5318 if ( typeof url !== "string" && _load ) {
|
|
|
5319 return _load.apply( this, arguments );
|
|
|
5320
|
|
|
5321 // Don't do a request if no elements are being requested
|
|
|
5322 } else if ( !this.length ) {
|
|
|
5323 return this;
|
|
|
5324 }
|
|
|
5325
|
|
|
5326 var off = url.indexOf(" ");
|
|
|
5327 if ( off >= 0 ) {
|
|
|
5328 var selector = url.slice(off, url.length);
|
|
|
5329 url = url.slice(0, off);
|
|
|
5330 }
|
|
|
5331
|
|
|
5332 // Default to a GET request
|
|
|
5333 var type = "GET";
|
|
|
5334
|
|
|
5335 // If the second parameter was provided
|
|
|
5336 if ( params ) {
|
|
|
5337 // If it's a function
|
|
|
5338 if ( jQuery.isFunction( params ) ) {
|
|
|
5339 // We assume that it's the callback
|
|
|
5340 callback = params;
|
|
|
5341 params = null;
|
|
|
5342
|
|
|
5343 // Otherwise, build a param string
|
|
|
5344 } else if ( typeof params === "object" ) {
|
|
|
5345 params = jQuery.param( params, jQuery.ajaxSettings.traditional );
|
|
|
5346 type = "POST";
|
|
|
5347 }
|
|
|
5348 }
|
|
|
5349
|
|
|
5350 var self = this;
|
|
|
5351
|
|
|
5352 // Request the remote document
|
|
|
5353 jQuery.ajax({
|
|
|
5354 url: url,
|
|
|
5355 type: type,
|
|
|
5356 dataType: "html",
|
|
|
5357 data: params,
|
|
|
5358 complete: function( res, status ) {
|
|
|
5359 // If successful, inject the HTML into all the matched elements
|
|
|
5360 if ( status === "success" || status === "notmodified" ) {
|
|
|
5361 // See if a selector was specified
|
|
|
5362 self.html( selector ?
|
|
|
5363 // Create a dummy div to hold the results
|
|
|
5364 jQuery("<div>")
|
|
|
5365 // inject the contents of the document in, removing the scripts
|
|
|
5366 // to avoid any 'Permission Denied' errors in IE
|
|
|
5367 .append(res.responseText.replace(rscript, ""))
|
|
|
5368
|
|
|
5369 // Locate the specified elements
|
|
|
5370 .find(selector) :
|
|
|
5371
|
|
|
5372 // If not, just inject the full result
|
|
|
5373 res.responseText );
|
|
|
5374 }
|
|
|
5375
|
|
|
5376 if ( callback ) {
|
|
|
5377 self.each( callback, [res.responseText, status, res] );
|
|
|
5378 }
|
|
|
5379 }
|
|
|
5380 });
|
|
|
5381
|
|
|
5382 return this;
|
|
|
5383 },
|
|
|
5384
|
|
|
5385 serialize: function() {
|
|
|
5386 return jQuery.param(this.serializeArray());
|
|
|
5387 },
|
|
|
5388
|
|
|
5389 serializeArray: function() {
|
|
|
5390 return this.map(function() {
|
|
|
5391 return this.elements ? jQuery.makeArray(this.elements) : this;
|
|
|
5392 })
|
|
|
5393 .filter(function() {
|
|
|
5394 return this.name && !this.disabled &&
|
|
|
5395 (this.checked || rselectTextarea.test(this.nodeName) ||
|
|
|
5396 rinput.test(this.type));
|
|
|
5397 })
|
|
|
5398 .map(function( i, elem ) {
|
|
|
5399 var val = jQuery(this).val();
|
|
|
5400
|
|
|
5401 return val == null ?
|
|
|
5402 null :
|
|
|
5403 jQuery.isArray(val) ?
|
|
|
5404 jQuery.map( val, function( val, i ) {
|
|
|
5405 return { name: elem.name, value: val };
|
|
|
5406 }) :
|
|
|
5407 { name: elem.name, value: val };
|
|
|
5408 }).get();
|
|
|
5409 }
|
|
|
5410 });
|
|
|
5411
|
|
|
5412 // Attach a bunch of functions for handling common AJAX events
|
|
|
5413 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
|
|
|
5414 jQuery.fn[o] = function( f ) {
|
|
|
5415 return this.bind(o, f);
|
|
|
5416 };
|
|
|
5417 });
|
|
|
5418
|
|
|
5419 jQuery.extend({
|
|
|
5420 get: function( url, data, callback, type ) {
|
|
|
5421 // shift arguments if data argument was omited
|
|
|
5422 if ( jQuery.isFunction( data ) ) {
|
|
|
5423 type = type || callback;
|
|
|
5424 callback = data;
|
|
|
5425 data = null;
|
|
|
5426 }
|
|
|
5427
|
|
|
5428 return jQuery.ajax({
|
|
|
5429 type: "GET",
|
|
|
5430 url: url,
|
|
|
5431 data: data,
|
|
|
5432 success: callback,
|
|
|
5433 dataType: type
|
|
|
5434 });
|
|
|
5435 },
|
|
|
5436
|
|
|
5437 getScript: function( url, callback ) {
|
|
|
5438 return jQuery.get(url, null, callback, "script");
|
|
|
5439 },
|
|
|
5440
|
|
|
5441 getJSON: function( url, data, callback ) {
|
|
|
5442 return jQuery.get(url, data, callback, "json");
|
|
|
5443 },
|
|
|
5444
|
|
|
5445 post: function( url, data, callback, type ) {
|
|
|
5446 // shift arguments if data argument was omited
|
|
|
5447 if ( jQuery.isFunction( data ) ) {
|
|
|
5448 type = type || callback;
|
|
|
5449 callback = data;
|
|
|
5450 data = {};
|
|
|
5451 }
|
|
|
5452
|
|
|
5453 return jQuery.ajax({
|
|
|
5454 type: "POST",
|
|
|
5455 url: url,
|
|
|
5456 data: data,
|
|
|
5457 success: callback,
|
|
|
5458 dataType: type
|
|
|
5459 });
|
|
|
5460 },
|
|
|
5461
|
|
|
5462 ajaxSetup: function( settings ) {
|
|
|
5463 jQuery.extend( jQuery.ajaxSettings, settings );
|
|
|
5464 },
|
|
|
5465
|
|
|
5466 ajaxSettings: {
|
|
|
5467 url: location.href,
|
|
|
5468 global: true,
|
|
|
5469 type: "GET",
|
|
|
5470 contentType: "application/x-www-form-urlencoded",
|
|
|
5471 processData: true,
|
|
|
5472 async: true,
|
|
|
5473 /*
|
|
|
5474 timeout: 0,
|
|
|
5475 data: null,
|
|
|
5476 username: null,
|
|
|
5477 password: null,
|
|
|
5478 traditional: false,
|
|
|
5479 */
|
|
|
5480 // This function can be overriden by calling jQuery.ajaxSetup
|
|
|
5481 xhr: function() {
|
|
|
5482 return new window.XMLHttpRequest();
|
|
|
5483 },
|
|
|
5484 accepts: {
|
|
|
5485 xml: "application/xml, text/xml",
|
|
|
5486 html: "text/html",
|
|
|
5487 script: "text/javascript, application/javascript",
|
|
|
5488 json: "application/json, text/javascript",
|
|
|
5489 text: "text/plain",
|
|
|
5490 _default: "*/*"
|
|
|
5491 }
|
|
|
5492 },
|
|
|
5493
|
|
|
5494 ajax: function( origSettings ) {
|
|
|
5495 var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings),
|
|
|
5496 jsonp, status, data, type = s.type.toUpperCase(), noContent = rnoContent.test(type);
|
|
|
5497
|
|
|
5498 s.url = s.url.replace( rhash, "" );
|
|
|
5499
|
|
|
5500 // Use original (not extended) context object if it was provided
|
|
|
5501 s.context = origSettings && origSettings.context != null ? origSettings.context : s;
|
|
|
5502
|
|
|
5503 // convert data if not already a string
|
|
|
5504 if ( s.data && s.processData && typeof s.data !== "string" ) {
|
|
|
5505 s.data = jQuery.param( s.data, s.traditional );
|
|
|
5506 }
|
|
|
5507
|
|
|
5508 // Handle JSONP Parameter Callbacks
|
|
|
5509 if ( s.dataType === "jsonp" ) {
|
|
|
5510 if ( type === "GET" ) {
|
|
|
5511 if ( !jsre.test( s.url ) ) {
|
|
|
5512 s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";
|
|
|
5513 }
|
|
|
5514 } else if ( !s.data || !jsre.test(s.data) ) {
|
|
|
5515 s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
|
|
|
5516 }
|
|
|
5517 s.dataType = "json";
|
|
|
5518 }
|
|
|
5519
|
|
|
5520 // Build temporary JSONP function
|
|
|
5521 if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {
|
|
|
5522 jsonp = s.jsonpCallback || ("jsonp" + jsc++);
|
|
|
5523
|
|
|
5524 // Replace the =? sequence both in the query string and the data
|
|
|
5525 if ( s.data ) {
|
|
|
5526 s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
|
|
|
5527 }
|
|
|
5528
|
|
|
5529 s.url = s.url.replace(jsre, "=" + jsonp + "$1");
|
|
|
5530
|
|
|
5531 // We need to make sure
|
|
|
5532 // that a JSONP style response is executed properly
|
|
|
5533 s.dataType = "script";
|
|
|
5534
|
|
|
5535 // Handle JSONP-style loading
|
|
|
5536 var customJsonp = window[ jsonp ];
|
|
|
5537
|
|
|
5538 window[ jsonp ] = function( tmp ) {
|
|
|
5539 data = tmp;
|
|
|
5540 jQuery.handleSuccess( s, xhr, status, data );
|
|
|
5541 jQuery.handleComplete( s, xhr, status, data );
|
|
|
5542
|
|
|
5543 if ( jQuery.isFunction( customJsonp ) ) {
|
|
|
5544 customJsonp( tmp );
|
|
|
5545
|
|
|
5546 } else {
|
|
|
5547 // Garbage collect
|
|
|
5548 window[ jsonp ] = undefined;
|
|
|
5549
|
|
|
5550 try {
|
|
|
5551 delete window[ jsonp ];
|
|
|
5552 } catch( jsonpError ) {}
|
|
|
5553 }
|
|
|
5554
|
|
|
5555 if ( head ) {
|
|
|
5556 head.removeChild( script );
|
|
|
5557 }
|
|
|
5558 };
|
|
|
5559 }
|
|
|
5560
|
|
|
5561 if ( s.dataType === "script" && s.cache === null ) {
|
|
|
5562 s.cache = false;
|
|
|
5563 }
|
|
|
5564
|
|
|
5565 if ( s.cache === false && type === "GET" ) {
|
|
|
5566 var ts = jQuery.now();
|
|
|
5567
|
|
|
5568 // try replacing _= if it is there
|
|
|
5569 var ret = s.url.replace(rts, "$1_=" + ts);
|
|
|
5570
|
|
|
5571 // if nothing was replaced, add timestamp to the end
|
|
|
5572 s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
|
|
|
5573 }
|
|
|
5574
|
|
|
5575 // If data is available, append data to url for get requests
|
|
|
5576 if ( s.data && type === "GET" ) {
|
|
|
5577 s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
|
|
|
5578 }
|
|
|
5579
|
|
|
5580 // Watch for a new set of requests
|
|
|
5581 if ( s.global && jQuery.active++ === 0 ) {
|
|
|
5582 jQuery.event.trigger( "ajaxStart" );
|
|
|
5583 }
|
|
|
5584
|
|
|
5585 // Matches an absolute URL, and saves the domain
|
|
|
5586 var parts = rurl.exec( s.url ),
|
|
|
5587 remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);
|
|
|
5588
|
|
|
5589 // If we're requesting a remote document
|
|
|
5590 // and trying to load JSON or Script with a GET
|
|
|
5591 if ( s.dataType === "script" && type === "GET" && remote ) {
|
|
|
5592 var head = document.getElementsByTagName("head")[0] || document.documentElement;
|
|
|
5593 var script = document.createElement("script");
|
|
|
5594 if ( s.scriptCharset ) {
|
|
|
5595 script.charset = s.scriptCharset;
|
|
|
5596 }
|
|
|
5597 script.src = s.url;
|
|
|
5598
|
|
|
5599 // Handle Script loading
|
|
|
5600 if ( !jsonp ) {
|
|
|
5601 var done = false;
|
|
|
5602
|
|
|
5603 // Attach handlers for all browsers
|
|
|
5604 script.onload = script.onreadystatechange = function() {
|
|
|
5605 if ( !done && (!this.readyState ||
|
|
|
5606 this.readyState === "loaded" || this.readyState === "complete") ) {
|
|
|
5607 done = true;
|
|
|
5608 jQuery.handleSuccess( s, xhr, status, data );
|
|
|
5609 jQuery.handleComplete( s, xhr, status, data );
|
|
|
5610
|
|
|
5611 // Handle memory leak in IE
|
|
|
5612 script.onload = script.onreadystatechange = null;
|
|
|
5613 if ( head && script.parentNode ) {
|
|
|
5614 head.removeChild( script );
|
|
|
5615 }
|
|
|
5616 }
|
|
|
5617 };
|
|
|
5618 }
|
|
|
5619
|
|
|
5620 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
|
|
|
5621 // This arises when a base node is used (#2709 and #4378).
|
|
|
5622 head.insertBefore( script, head.firstChild );
|
|
|
5623
|
|
|
5624 // We handle everything using the script element injection
|
|
|
5625 return undefined;
|
|
|
5626 }
|
|
|
5627
|
|
|
5628 var requestDone = false;
|
|
|
5629
|
|
|
5630 // Create the request object
|
|
|
5631 var xhr = s.xhr();
|
|
|
5632
|
|
|
5633 if ( !xhr ) {
|
|
|
5634 return;
|
|
|
5635 }
|
|
|
5636
|
|
|
5637 // Open the socket
|
|
|
5638 // Passing null username, generates a login popup on Opera (#2865)
|
|
|
5639 if ( s.username ) {
|
|
|
5640 xhr.open(type, s.url, s.async, s.username, s.password);
|
|
|
5641 } else {
|
|
|
5642 xhr.open(type, s.url, s.async);
|
|
|
5643 }
|
|
|
5644
|
|
|
5645 // Need an extra try/catch for cross domain requests in Firefox 3
|
|
|
5646 try {
|
|
|
5647 // Set content-type if data specified and content-body is valid for this type
|
|
|
5648 if ( (s.data != null && !noContent) || (origSettings && origSettings.contentType) ) {
|
|
|
5649 xhr.setRequestHeader("Content-Type", s.contentType);
|
|
|
5650 }
|
|
|
5651
|
|
|
5652 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
|
|
5653 if ( s.ifModified ) {
|
|
|
5654 if ( jQuery.lastModified[s.url] ) {
|
|
|
5655 xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]);
|
|
|
5656 }
|
|
|
5657
|
|
|
5658 if ( jQuery.etag[s.url] ) {
|
|
|
5659 xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]);
|
|
|
5660 }
|
|
|
5661 }
|
|
|
5662
|
|
|
5663 // Set header so the called script knows that it's an XMLHttpRequest
|
|
|
5664 // Only send the header if it's not a remote XHR
|
|
|
5665 if ( !remote ) {
|
|
|
5666 xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
|
|
|
5667 }
|
|
|
5668
|
|
|
5669 // Set the Accepts header for the server, depending on the dataType
|
|
|
5670 xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
|
|
|
5671 s.accepts[ s.dataType ] + ", */*; q=0.01" :
|
|
|
5672 s.accepts._default );
|
|
|
5673 } catch( headerError ) {}
|
|
|
5674
|
|
|
5675 // Allow custom headers/mimetypes and early abort
|
|
|
5676 if ( s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false ) {
|
|
|
5677 // Handle the global AJAX counter
|
|
|
5678 if ( s.global && jQuery.active-- === 1 ) {
|
|
|
5679 jQuery.event.trigger( "ajaxStop" );
|
|
|
5680 }
|
|
|
5681
|
|
|
5682 // close opended socket
|
|
|
5683 xhr.abort();
|
|
|
5684 return false;
|
|
|
5685 }
|
|
|
5686
|
|
|
5687 if ( s.global ) {
|
|
|
5688 jQuery.triggerGlobal( s, "ajaxSend", [xhr, s] );
|
|
|
5689 }
|
|
|
5690
|
|
|
5691 // Wait for a response to come back
|
|
|
5692 var onreadystatechange = xhr.onreadystatechange = function( isTimeout ) {
|
|
|
5693 // The request was aborted
|
|
|
5694 if ( !xhr || xhr.readyState === 0 || isTimeout === "abort" ) {
|
|
|
5695 // Opera doesn't call onreadystatechange before this point
|
|
|
5696 // so we simulate the call
|
|
|
5697 if ( !requestDone ) {
|
|
|
5698 jQuery.handleComplete( s, xhr, status, data );
|
|
|
5699 }
|
|
|
5700
|
|
|
5701 requestDone = true;
|
|
|
5702 if ( xhr ) {
|
|
|
5703 xhr.onreadystatechange = jQuery.noop;
|
|
|
5704 }
|
|
|
5705
|
|
|
5706 // The transfer is complete and the data is available, or the request timed out
|
|
|
5707 } else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) {
|
|
|
5708 requestDone = true;
|
|
|
5709 xhr.onreadystatechange = jQuery.noop;
|
|
|
5710
|
|
|
5711 status = isTimeout === "timeout" ?
|
|
|
5712 "timeout" :
|
|
|
5713 !jQuery.httpSuccess( xhr ) ?
|
|
|
5714 "error" :
|
|
|
5715 s.ifModified && jQuery.httpNotModified( xhr, s.url ) ?
|
|
|
5716 "notmodified" :
|
|
|
5717 "success";
|
|
|
5718
|
|
|
5719 var errMsg;
|
|
|
5720
|
|
|
5721 if ( status === "success" ) {
|
|
|
5722 // Watch for, and catch, XML document parse errors
|
|
|
5723 try {
|
|
|
5724 // process the data (runs the xml through httpData regardless of callback)
|
|
|
5725 data = jQuery.httpData( xhr, s.dataType, s );
|
|
|
5726 } catch( parserError ) {
|
|
|
5727 status = "parsererror";
|
|
|
5728 errMsg = parserError;
|
|
|
5729 }
|
|
|
5730 }
|
|
|
5731
|
|
|
5732 // Make sure that the request was successful or notmodified
|
|
|
5733 if ( status === "success" || status === "notmodified" ) {
|
|
|
5734 // JSONP handles its own success callback
|
|
|
5735 if ( !jsonp ) {
|
|
|
5736 jQuery.handleSuccess( s, xhr, status, data );
|
|
|
5737 }
|
|
|
5738 } else {
|
|
|
5739 jQuery.handleError( s, xhr, status, errMsg );
|
|
|
5740 }
|
|
|
5741
|
|
|
5742 // Fire the complete handlers
|
|
|
5743 if ( !jsonp ) {
|
|
|
5744 jQuery.handleComplete( s, xhr, status, data );
|
|
|
5745 }
|
|
|
5746
|
|
|
5747 if ( isTimeout === "timeout" ) {
|
|
|
5748 xhr.abort();
|
|
|
5749 }
|
|
|
5750
|
|
|
5751 // Stop memory leaks
|
|
|
5752 if ( s.async ) {
|
|
|
5753 xhr = null;
|
|
|
5754 }
|
|
|
5755 }
|
|
|
5756 };
|
|
|
5757
|
|
|
5758 // Override the abort handler, if we can (IE 6 doesn't allow it, but that's OK)
|
|
|
5759 // Opera doesn't fire onreadystatechange at all on abort
|
|
|
5760 try {
|
|
|
5761 var oldAbort = xhr.abort;
|
|
|
5762 xhr.abort = function() {
|
|
|
5763 // xhr.abort in IE7 is not a native JS function
|
|
|
5764 // and does not have a call property
|
|
|
5765 if ( xhr && oldAbort.call ) {
|
|
|
5766 oldAbort.call( xhr );
|
|
|
5767 }
|
|
|
5768
|
|
|
5769 onreadystatechange( "abort" );
|
|
|
5770 };
|
|
|
5771 } catch( abortError ) {}
|
|
|
5772
|
|
|
5773 // Timeout checker
|
|
|
5774 if ( s.async && s.timeout > 0 ) {
|
|
|
5775 setTimeout(function() {
|
|
|
5776 // Check to see if the request is still happening
|
|
|
5777 if ( xhr && !requestDone ) {
|
|
|
5778 onreadystatechange( "timeout" );
|
|
|
5779 }
|
|
|
5780 }, s.timeout);
|
|
|
5781 }
|
|
|
5782
|
|
|
5783 // Send the data
|
|
|
5784 try {
|
|
|
5785 xhr.send( noContent || s.data == null ? null : s.data );
|
|
|
5786
|
|
|
5787 } catch( sendError ) {
|
|
|
5788 jQuery.handleError( s, xhr, null, sendError );
|
|
|
5789
|
|
|
5790 // Fire the complete handlers
|
|
|
5791 jQuery.handleComplete( s, xhr, status, data );
|
|
|
5792 }
|
|
|
5793
|
|
|
5794 // firefox 1.5 doesn't fire statechange for sync requests
|
|
|
5795 if ( !s.async ) {
|
|
|
5796 onreadystatechange();
|
|
|
5797 }
|
|
|
5798
|
|
|
5799 // return XMLHttpRequest to allow aborting the request etc.
|
|
|
5800 return xhr;
|
|
|
5801 },
|
|
|
5802
|
|
|
5803 // Serialize an array of form elements or a set of
|
|
|
5804 // key/values into a query string
|
|
|
5805 param: function( a, traditional ) {
|
|
|
5806 var s = [], add = function( key, value ) {
|
|
|
5807 // If value is a function, invoke it and return its value
|
|
|
5808 value = jQuery.isFunction(value) ? value() : value;
|
|
|
5809 s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
|
|
|
5810 };
|
|
|
5811
|
|
|
5812 // Set traditional to true for jQuery <= 1.3.2 behavior.
|
|
|
5813 if ( traditional === undefined ) {
|
|
|
5814 traditional = jQuery.ajaxSettings.traditional;
|
|
|
5815 }
|
|
|
5816
|
|
|
5817 // If an array was passed in, assume that it is an array of form elements.
|
|
|
5818 if ( jQuery.isArray(a) || a.jquery ) {
|
|
|
5819 // Serialize the form elements
|
|
|
5820 jQuery.each( a, function() {
|
|
|
5821 add( this.name, this.value );
|
|
|
5822 });
|
|
|
5823
|
|
|
5824 } else {
|
|
|
5825 // If traditional, encode the "old" way (the way 1.3.2 or older
|
|
|
5826 // did it), otherwise encode params recursively.
|
|
|
5827 for ( var prefix in a ) {
|
|
|
5828 buildParams( prefix, a[prefix], traditional, add );
|
|
|
5829 }
|
|
|
5830 }
|
|
|
5831
|
|
|
5832 // Return the resulting serialization
|
|
|
5833 return s.join("&").replace(r20, "+");
|
|
|
5834 }
|
|
|
5835 });
|
|
|
5836
|
|
|
5837 function buildParams( prefix, obj, traditional, add ) {
|
|
|
5838 if ( jQuery.isArray(obj) && obj.length ) {
|
|
|
5839 // Serialize array item.
|
|
|
5840 jQuery.each( obj, function( i, v ) {
|
|
|
5841 if ( traditional || rbracket.test( prefix ) ) {
|
|
|
5842 // Treat each array item as a scalar.
|
|
|
5843 add( prefix, v );
|
|
|
5844
|
|
|
5845 } else {
|
|
|
5846 // If array item is non-scalar (array or object), encode its
|
|
|
5847 // numeric index to resolve deserialization ambiguity issues.
|
|
|
5848 // Note that rack (as of 1.0.0) can't currently deserialize
|
|
|
5849 // nested arrays properly, and attempting to do so may cause
|
|
|
5850 // a server error. Possible fixes are to modify rack's
|
|
|
5851 // deserialization algorithm or to provide an option or flag
|
|
|
5852 // to force array serialization to be shallow.
|
|
|
5853 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
|
|
|
5854 }
|
|
|
5855 });
|
|
|
5856
|
|
|
5857 } else if ( !traditional && obj != null && typeof obj === "object" ) {
|
|
|
5858 if ( jQuery.isEmptyObject( obj ) ) {
|
|
|
5859 add( prefix, "" );
|
|
|
5860
|
|
|
5861 // Serialize object item.
|
|
|
5862 } else {
|
|
|
5863 jQuery.each( obj, function( k, v ) {
|
|
|
5864 buildParams( prefix + "[" + k + "]", v, traditional, add );
|
|
|
5865 });
|
|
|
5866 }
|
|
|
5867
|
|
|
5868 } else {
|
|
|
5869 // Serialize scalar item.
|
|
|
5870 add( prefix, obj );
|
|
|
5871 }
|
|
|
5872 }
|
|
|
5873
|
|
|
5874 // This is still on the jQuery object... for now
|
|
|
5875 // Want to move this to jQuery.ajax some day
|
|
|
5876 jQuery.extend({
|
|
|
5877
|
|
|
5878 // Counter for holding the number of active queries
|
|
|
5879 active: 0,
|
|
|
5880
|
|
|
5881 // Last-Modified header cache for next request
|
|
|
5882 lastModified: {},
|
|
|
5883 etag: {},
|
|
|
5884
|
|
|
5885 handleError: function( s, xhr, status, e ) {
|
|
|
5886 // If a local callback was specified, fire it
|
|
|
5887 if ( s.error ) {
|
|
|
5888 s.error.call( s.context, xhr, status, e );
|
|
|
5889 }
|
|
|
5890
|
|
|
5891 // Fire the global callback
|
|
|
5892 if ( s.global ) {
|
|
|
5893 jQuery.triggerGlobal( s, "ajaxError", [xhr, s, e] );
|
|
|
5894 }
|
|
|
5895 },
|
|
|
5896
|
|
|
5897 handleSuccess: function( s, xhr, status, data ) {
|
|
|
5898 // If a local callback was specified, fire it and pass it the data
|
|
|
5899 if ( s.success ) {
|
|
|
5900 s.success.call( s.context, data, status, xhr );
|
|
|
5901 }
|
|
|
5902
|
|
|
5903 // Fire the global callback
|
|
|
5904 if ( s.global ) {
|
|
|
5905 jQuery.triggerGlobal( s, "ajaxSuccess", [xhr, s] );
|
|
|
5906 }
|
|
|
5907 },
|
|
|
5908
|
|
|
5909 handleComplete: function( s, xhr, status ) {
|
|
|
5910 // Process result
|
|
|
5911 if ( s.complete ) {
|
|
|
5912 s.complete.call( s.context, xhr, status );
|
|
|
5913 }
|
|
|
5914
|
|
|
5915 // The request was completed
|
|
|
5916 if ( s.global ) {
|
|
|
5917 jQuery.triggerGlobal( s, "ajaxComplete", [xhr, s] );
|
|
|
5918 }
|
|
|
5919
|
|
|
5920 // Handle the global AJAX counter
|
|
|
5921 if ( s.global && jQuery.active-- === 1 ) {
|
|
|
5922 jQuery.event.trigger( "ajaxStop" );
|
|
|
5923 }
|
|
|
5924 },
|
|
|
5925
|
|
|
5926 triggerGlobal: function( s, type, args ) {
|
|
|
5927 (s.context && s.context.url == null ? jQuery(s.context) : jQuery.event).trigger(type, args);
|
|
|
5928 },
|
|
|
5929
|
|
|
5930 // Determines if an XMLHttpRequest was successful or not
|
|
|
5931 httpSuccess: function( xhr ) {
|
|
|
5932 try {
|
|
|
5933 // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
|
|
|
5934 return !xhr.status && location.protocol === "file:" ||
|
|
|
5935 xhr.status >= 200 && xhr.status < 300 ||
|
|
|
5936 xhr.status === 304 || xhr.status === 1223;
|
|
|
5937 } catch(e) {}
|
|
|
5938
|
|
|
5939 return false;
|
|
|
5940 },
|
|
|
5941
|
|
|
5942 // Determines if an XMLHttpRequest returns NotModified
|
|
|
5943 httpNotModified: function( xhr, url ) {
|
|
|
5944 var lastModified = xhr.getResponseHeader("Last-Modified"),
|
|
|
5945 etag = xhr.getResponseHeader("Etag");
|
|
|
5946
|
|
|
5947 if ( lastModified ) {
|
|
|
5948 jQuery.lastModified[url] = lastModified;
|
|
|
5949 }
|
|
|
5950
|
|
|
5951 if ( etag ) {
|
|
|
5952 jQuery.etag[url] = etag;
|
|
|
5953 }
|
|
|
5954
|
|
|
5955 return xhr.status === 304;
|
|
|
5956 },
|
|
|
5957
|
|
|
5958 httpData: function( xhr, type, s ) {
|
|
|
5959 var ct = xhr.getResponseHeader("content-type") || "",
|
|
|
5960 xml = type === "xml" || !type && ct.indexOf("xml") >= 0,
|
|
|
5961 data = xml ? xhr.responseXML : xhr.responseText;
|
|
|
5962
|
|
|
5963 if ( xml && data.documentElement.nodeName === "parsererror" ) {
|
|
|
5964 jQuery.error( "parsererror" );
|
|
|
5965 }
|
|
|
5966
|
|
|
5967 // Allow a pre-filtering function to sanitize the response
|
|
|
5968 // s is checked to keep backwards compatibility
|
|
|
5969 if ( s && s.dataFilter ) {
|
|
|
5970 data = s.dataFilter( data, type );
|
|
|
5971 }
|
|
|
5972
|
|
|
5973 // The filter can actually parse the response
|
|
|
5974 if ( typeof data === "string" ) {
|
|
|
5975 // Get the JavaScript object, if JSON is used.
|
|
|
5976 if ( type === "json" || !type && ct.indexOf("json") >= 0 ) {
|
|
|
5977 data = jQuery.parseJSON( data );
|
|
|
5978
|
|
|
5979 // If the type is "script", eval it in global context
|
|
|
5980 } else if ( type === "script" || !type && ct.indexOf("javascript") >= 0 ) {
|
|
|
5981 jQuery.globalEval( data );
|
|
|
5982 }
|
|
|
5983 }
|
|
|
5984
|
|
|
5985 return data;
|
|
|
5986 }
|
|
|
5987
|
|
|
5988 });
|
|
|
5989
|
|
|
5990 /*
|
|
|
5991 * Create the request object; Microsoft failed to properly
|
|
|
5992 * implement the XMLHttpRequest in IE7 (can't request local files),
|
|
|
5993 * so we use the ActiveXObject when it is available
|
|
|
5994 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
|
|
|
5995 * we need a fallback.
|
|
|
5996 */
|
|
|
5997 if ( window.ActiveXObject ) {
|
|
|
5998 jQuery.ajaxSettings.xhr = function() {
|
|
|
5999 if ( window.location.protocol !== "file:" ) {
|
|
|
6000 try {
|
|
|
6001 return new window.XMLHttpRequest();
|
|
|
6002 } catch(xhrError) {}
|
|
|
6003 }
|
|
|
6004
|
|
|
6005 try {
|
|
|
6006 return new window.ActiveXObject("Microsoft.XMLHTTP");
|
|
|
6007 } catch(activeError) {}
|
|
|
6008 };
|
|
|
6009 }
|
|
|
6010
|
|
|
6011 // Does this browser support XHR requests?
|
|
|
6012 jQuery.support.ajax = !!jQuery.ajaxSettings.xhr();
|
|
|
6013
|
|
|
6014
|
|
|
6015
|
|
|
6016
|
|
|
6017 var elemdisplay = {},
|
|
|
6018 rfxtypes = /^(?:toggle|show|hide)$/,
|
|
|
6019 rfxnum = /^([+\-]=)?([\d+.\-]+)(.*)$/,
|
|
|
6020 timerId,
|
|
|
6021 fxAttrs = [
|
|
|
6022 // height animations
|
|
|
6023 [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
|
|
|
6024 // width animations
|
|
|
6025 [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
|
|
|
6026 // opacity animations
|
|
|
6027 [ "opacity" ]
|
|
|
6028 ];
|
|
|
6029
|
|
|
6030 jQuery.fn.extend({
|
|
|
6031 show: function( speed, easing, callback ) {
|
|
|
6032 if ( speed || speed === 0 ) {
|
|
|
6033 return this.animate( genFx("show", 3), speed, easing, callback);
|
|
|
6034 } else {
|
|
|
6035 for ( var i = 0, j = this.length; i < j; i++ ) {
|
|
|
6036 // Reset the inline display of this element to learn if it is
|
|
|
6037 // being hidden by cascaded rules or not
|
|
|
6038 if ( !jQuery.data(this[i], "olddisplay") && this[i].style.display === "none" ) {
|
|
|
6039 this[i].style.display = "";
|
|
|
6040 }
|
|
|
6041
|
|
|
6042 // Set elements which have been overridden with display: none
|
|
|
6043 // in a stylesheet to whatever the default browser style is
|
|
|
6044 // for such an element
|
|
|
6045 if ( this[i].style.display === "" && jQuery.css( this[i], "display" ) === "none" ) {
|
|
|
6046 jQuery.data(this[i], "olddisplay", defaultDisplay(this[i].nodeName));
|
|
|
6047 }
|
|
|
6048 }
|
|
|
6049
|
|
|
6050 // Set the display of most of the elements in a second loop
|
|
|
6051 // to avoid the constant reflow
|
|
|
6052 for ( i = 0; i < j; i++ ) {
|
|
|
6053 this[i].style.display = jQuery.data(this[i], "olddisplay") || "";
|
|
|
6054 }
|
|
|
6055
|
|
|
6056 return this;
|
|
|
6057 }
|
|
|
6058 },
|
|
|
6059
|
|
|
6060 hide: function( speed, easing, callback ) {
|
|
|
6061 if ( speed || speed === 0 ) {
|
|
|
6062 return this.animate( genFx("hide", 3), speed, easing, callback);
|
|
|
6063
|
|
|
6064 } else {
|
|
|
6065 for ( var i = 0, j = this.length; i < j; i++ ) {
|
|
|
6066 var display = jQuery.css( this[i], "display" );
|
|
|
6067
|
|
|
6068 if ( display !== "none" ) {
|
|
|
6069 jQuery.data( this[i], "olddisplay", display );
|
|
|
6070 }
|
|
|
6071 }
|
|
|
6072
|
|
|
6073 // Set the display of the elements in a second loop
|
|
|
6074 // to avoid the constant reflow
|
|
|
6075 for ( i = 0; i < j; i++ ) {
|
|
|
6076 this[i].style.display = "none";
|
|
|
6077 }
|
|
|
6078
|
|
|
6079 return this;
|
|
|
6080 }
|
|
|
6081 },
|
|
|
6082
|
|
|
6083 // Save the old toggle function
|
|
|
6084 _toggle: jQuery.fn.toggle,
|
|
|
6085
|
|
|
6086 toggle: function( fn, fn2, callback ) {
|
|
|
6087 var bool = typeof fn === "boolean";
|
|
|
6088
|
|
|
6089 if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
|
|
|
6090 this._toggle.apply( this, arguments );
|
|
|
6091
|
|
|
6092 } else if ( fn == null || bool ) {
|
|
|
6093 this.each(function() {
|
|
|
6094 var state = bool ? fn : jQuery(this).is(":hidden");
|
|
|
6095 jQuery(this)[ state ? "show" : "hide" ]();
|
|
|
6096 });
|
|
|
6097
|
|
|
6098 } else {
|
|
|
6099 this.animate(genFx("toggle", 3), fn, fn2, callback);
|
|
|
6100 }
|
|
|
6101
|
|
|
6102 return this;
|
|
|
6103 },
|
|
|
6104
|
|
|
6105 fadeTo: function( speed, to, easing, callback ) {
|
|
|
6106 return this.filter(":hidden").css("opacity", 0).show().end()
|
|
|
6107 .animate({opacity: to}, speed, easing, callback);
|
|
|
6108 },
|
|
|
6109
|
|
|
6110 animate: function( prop, speed, easing, callback ) {
|
|
|
6111 var optall = jQuery.speed(speed, easing, callback);
|
|
|
6112
|
|
|
6113 if ( jQuery.isEmptyObject( prop ) ) {
|
|
|
6114 return this.each( optall.complete );
|
|
|
6115 }
|
|
|
6116
|
|
|
6117 return this[ optall.queue === false ? "each" : "queue" ](function() {
|
|
|
6118 // XXX ‘this’ does not always have a nodeName when running the
|
|
|
6119 // test suite
|
|
|
6120
|
|
|
6121 var opt = jQuery.extend({}, optall), p,
|
|
|
6122 isElement = this.nodeType === 1,
|
|
|
6123 hidden = isElement && jQuery(this).is(":hidden"),
|
|
|
6124 self = this;
|
|
|
6125
|
|
|
6126 for ( p in prop ) {
|
|
|
6127 var name = jQuery.camelCase( p );
|
|
|
6128
|
|
|
6129 if ( p !== name ) {
|
|
|
6130 prop[ name ] = prop[ p ];
|
|
|
6131 delete prop[ p ];
|
|
|
6132 p = name;
|
|
|
6133 }
|
|
|
6134
|
|
|
6135 if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) {
|
|
|
6136 return opt.complete.call(this);
|
|
|
6137 }
|
|
|
6138
|
|
|
6139 if ( isElement && ( p === "height" || p === "width" ) ) {
|
|
|
6140 // Make sure that nothing sneaks out
|
|
|
6141 // Record all 3 overflow attributes because IE does not
|
|
|
6142 // change the overflow attribute when overflowX and
|
|
|
6143 // overflowY are set to the same value
|
|
|
6144 opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
|
|
|
6145
|
|
|
6146 // Set display property to inline-block for height/width
|
|
|
6147 // animations on inline elements that are having width/height
|
|
|
6148 // animated
|
|
|
6149 if ( jQuery.css( this, "display" ) === "inline" &&
|
|
|
6150 jQuery.css( this, "float" ) === "none" ) {
|
|
|
6151 if ( !jQuery.support.inlineBlockNeedsLayout ) {
|
|
|
6152 this.style.display = "inline-block";
|
|
|
6153
|
|
|
6154 } else {
|
|
|
6155 var display = defaultDisplay(this.nodeName);
|
|
|
6156
|
|
|
6157 // inline-level elements accept inline-block;
|
|
|
6158 // block-level elements need to be inline with layout
|
|
|
6159 if ( display === "inline" ) {
|
|
|
6160 this.style.display = "inline-block";
|
|
|
6161
|
|
|
6162 } else {
|
|
|
6163 this.style.display = "inline";
|
|
|
6164 this.style.zoom = 1;
|
|
|
6165 }
|
|
|
6166 }
|
|
|
6167 }
|
|
|
6168 }
|
|
|
6169
|
|
|
6170 if ( jQuery.isArray( prop[p] ) ) {
|
|
|
6171 // Create (if needed) and add to specialEasing
|
|
|
6172 (opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1];
|
|
|
6173 prop[p] = prop[p][0];
|
|
|
6174 }
|
|
|
6175 }
|
|
|
6176
|
|
|
6177 if ( opt.overflow != null ) {
|
|
|
6178 this.style.overflow = "hidden";
|
|
|
6179 }
|
|
|
6180
|
|
|
6181 opt.curAnim = jQuery.extend({}, prop);
|
|
|
6182
|
|
|
6183 jQuery.each( prop, function( name, val ) {
|
|
|
6184 var e = new jQuery.fx( self, opt, name );
|
|
|
6185
|
|
|
6186 if ( rfxtypes.test(val) ) {
|
|
|
6187 e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop );
|
|
|
6188
|
|
|
6189 } else {
|
|
|
6190 var parts = rfxnum.exec(val),
|
|
|
6191 start = e.cur(true) || 0;
|
|
|
6192
|
|
|
6193 if ( parts ) {
|
|
|
6194 var end = parseFloat( parts[2] ),
|
|
|
6195 unit = parts[3] || "px";
|
|
|
6196
|
|
|
6197 // We need to compute starting value
|
|
|
6198 if ( unit !== "px" ) {
|
|
|
6199 jQuery.style( self, name, (end || 1) + unit);
|
|
|
6200 start = ((end || 1) / e.cur(true)) * start;
|
|
|
6201 jQuery.style( self, name, start + unit);
|
|
|
6202 }
|
|
|
6203
|
|
|
6204 // If a +=/-= token was provided, we're doing a relative animation
|
|
|
6205 if ( parts[1] ) {
|
|
|
6206 end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
|
|
|
6207 }
|
|
|
6208
|
|
|
6209 e.custom( start, end, unit );
|
|
|
6210
|
|
|
6211 } else {
|
|
|
6212 e.custom( start, val, "" );
|
|
|
6213 }
|
|
|
6214 }
|
|
|
6215 });
|
|
|
6216
|
|
|
6217 // For JS strict compliance
|
|
|
6218 return true;
|
|
|
6219 });
|
|
|
6220 },
|
|
|
6221
|
|
|
6222 stop: function( clearQueue, gotoEnd ) {
|
|
|
6223 var timers = jQuery.timers;
|
|
|
6224
|
|
|
6225 if ( clearQueue ) {
|
|
|
6226 this.queue([]);
|
|
|
6227 }
|
|
|
6228
|
|
|
6229 this.each(function() {
|
|
|
6230 // go in reverse order so anything added to the queue during the loop is ignored
|
|
|
6231 for ( var i = timers.length - 1; i >= 0; i-- ) {
|
|
|
6232 if ( timers[i].elem === this ) {
|
|
|
6233 if (gotoEnd) {
|
|
|
6234 // force the next step to be the last
|
|
|
6235 timers[i](true);
|
|
|
6236 }
|
|
|
6237
|
|
|
6238 timers.splice(i, 1);
|
|
|
6239 }
|
|
|
6240 }
|
|
|
6241 });
|
|
|
6242
|
|
|
6243 // start the next in the queue if the last step wasn't forced
|
|
|
6244 if ( !gotoEnd ) {
|
|
|
6245 this.dequeue();
|
|
|
6246 }
|
|
|
6247
|
|
|
6248 return this;
|
|
|
6249 }
|
|
|
6250
|
|
|
6251 });
|
|
|
6252
|
|
|
6253 function genFx( type, num ) {
|
|
|
6254 var obj = {};
|
|
|
6255
|
|
|
6256 jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
|
|
|
6257 obj[ this ] = type;
|
|
|
6258 });
|
|
|
6259
|
|
|
6260 return obj;
|
|
|
6261 }
|
|
|
6262
|
|
|
6263 // Generate shortcuts for custom animations
|
|
|
6264 jQuery.each({
|
|
|
6265 slideDown: genFx("show", 1),
|
|
|
6266 slideUp: genFx("hide", 1),
|
|
|
6267 slideToggle: genFx("toggle", 1),
|
|
|
6268 fadeIn: { opacity: "show" },
|
|
|
6269 fadeOut: { opacity: "hide" }
|
|
|
6270 }, function( name, props ) {
|
|
|
6271 jQuery.fn[ name ] = function( speed, easing, callback ) {
|
|
|
6272 return this.animate( props, speed, easing, callback );
|
|
|
6273 };
|
|
|
6274 });
|
|
|
6275
|
|
|
6276 jQuery.extend({
|
|
|
6277 speed: function( speed, easing, fn ) {
|
|
|
6278 var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
|
|
|
6279 complete: fn || !fn && easing ||
|
|
|
6280 jQuery.isFunction( speed ) && speed,
|
|
|
6281 duration: speed,
|
|
|
6282 easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
|
|
|
6283 };
|
|
|
6284
|
|
|
6285 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
|
|
|
6286 opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
|
|
|
6287
|
|
|
6288 // Queueing
|
|
|
6289 opt.old = opt.complete;
|
|
|
6290 opt.complete = function() {
|
|
|
6291 if ( opt.queue !== false ) {
|
|
|
6292 jQuery(this).dequeue();
|
|
|
6293 }
|
|
|
6294 if ( jQuery.isFunction( opt.old ) ) {
|
|
|
6295 opt.old.call( this );
|
|
|
6296 }
|
|
|
6297 };
|
|
|
6298
|
|
|
6299 return opt;
|
|
|
6300 },
|
|
|
6301
|
|
|
6302 easing: {
|
|
|
6303 linear: function( p, n, firstNum, diff ) {
|
|
|
6304 return firstNum + diff * p;
|
|
|
6305 },
|
|
|
6306 swing: function( p, n, firstNum, diff ) {
|
|
|
6307 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
|
|
|
6308 }
|
|
|
6309 },
|
|
|
6310
|
|
|
6311 timers: [],
|
|
|
6312
|
|
|
6313 fx: function( elem, options, prop ) {
|
|
|
6314 this.options = options;
|
|
|
6315 this.elem = elem;
|
|
|
6316 this.prop = prop;
|
|
|
6317
|
|
|
6318 if ( !options.orig ) {
|
|
|
6319 options.orig = {};
|
|
|
6320 }
|
|
|
6321 }
|
|
|
6322
|
|
|
6323 });
|
|
|
6324
|
|
|
6325 jQuery.fx.prototype = {
|
|
|
6326 // Simple function for setting a style value
|
|
|
6327 update: function() {
|
|
|
6328 if ( this.options.step ) {
|
|
|
6329 this.options.step.call( this.elem, this.now, this );
|
|
|
6330 }
|
|
|
6331
|
|
|
6332 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
|
|
|
6333 },
|
|
|
6334
|
|
|
6335 // Get the current size
|
|
|
6336 cur: function() {
|
|
|
6337 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
|
|
|
6338 return this.elem[ this.prop ];
|
|
|
6339 }
|
|
|
6340
|
|
|
6341 var r = parseFloat( jQuery.css( this.elem, this.prop ) );
|
|
|
6342 return r && r > -10000 ? r : 0;
|
|
|
6343 },
|
|
|
6344
|
|
|
6345 // Start an animation from one number to another
|
|
|
6346 custom: function( from, to, unit ) {
|
|
|
6347 this.startTime = jQuery.now();
|
|
|
6348 this.start = from;
|
|
|
6349 this.end = to;
|
|
|
6350 this.unit = unit || this.unit || "px";
|
|
|
6351 this.now = this.start;
|
|
|
6352 this.pos = this.state = 0;
|
|
|
6353
|
|
|
6354 var self = this, fx = jQuery.fx;
|
|
|
6355 function t( gotoEnd ) {
|
|
|
6356 return self.step(gotoEnd);
|
|
|
6357 }
|
|
|
6358
|
|
|
6359 t.elem = this.elem;
|
|
|
6360
|
|
|
6361 if ( t() && jQuery.timers.push(t) && !timerId ) {
|
|
|
6362 timerId = setInterval(fx.tick, fx.interval);
|
|
|
6363 }
|
|
|
6364 },
|
|
|
6365
|
|
|
6366 // Simple 'show' function
|
|
|
6367 show: function() {
|
|
|
6368 // Remember where we started, so that we can go back to it later
|
|
|
6369 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
|
|
|
6370 this.options.show = true;
|
|
|
6371
|
|
|
6372 // Begin the animation
|
|
|
6373 // Make sure that we start at a small width/height to avoid any
|
|
|
6374 // flash of content
|
|
|
6375 this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
|
|
|
6376
|
|
|
6377 // Start by showing the element
|
|
|
6378 jQuery( this.elem ).show();
|
|
|
6379 },
|
|
|
6380
|
|
|
6381 // Simple 'hide' function
|
|
|
6382 hide: function() {
|
|
|
6383 // Remember where we started, so that we can go back to it later
|
|
|
6384 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
|
|
|
6385 this.options.hide = true;
|
|
|
6386
|
|
|
6387 // Begin the animation
|
|
|
6388 this.custom(this.cur(), 0);
|
|
|
6389 },
|
|
|
6390
|
|
|
6391 // Each step of an animation
|
|
|
6392 step: function( gotoEnd ) {
|
|
|
6393 var t = jQuery.now(), done = true;
|
|
|
6394
|
|
|
6395 if ( gotoEnd || t >= this.options.duration + this.startTime ) {
|
|
|
6396 this.now = this.end;
|
|
|
6397 this.pos = this.state = 1;
|
|
|
6398 this.update();
|
|
|
6399
|
|
|
6400 this.options.curAnim[ this.prop ] = true;
|
|
|
6401
|
|
|
6402 for ( var i in this.options.curAnim ) {
|
|
|
6403 if ( this.options.curAnim[i] !== true ) {
|
|
|
6404 done = false;
|
|
|
6405 }
|
|
|
6406 }
|
|
|
6407
|
|
|
6408 if ( done ) {
|
|
|
6409 // Reset the overflow
|
|
|
6410 if ( this.options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
|
|
|
6411 var elem = this.elem, options = this.options;
|
|
|
6412 jQuery.each( [ "", "X", "Y" ], function (index, value) {
|
|
|
6413 elem.style[ "overflow" + value ] = options.overflow[index];
|
|
|
6414 } );
|
|
|
6415 }
|
|
|
6416
|
|
|
6417 // Hide the element if the "hide" operation was done
|
|
|
6418 if ( this.options.hide ) {
|
|
|
6419 jQuery(this.elem).hide();
|
|
|
6420 }
|
|
|
6421
|
|
|
6422 // Reset the properties, if the item has been hidden or shown
|
|
|
6423 if ( this.options.hide || this.options.show ) {
|
|
|
6424 for ( var p in this.options.curAnim ) {
|
|
|
6425 jQuery.style( this.elem, p, this.options.orig[p] );
|
|
|
6426 }
|
|
|
6427 }
|
|
|
6428
|
|
|
6429 // Execute the complete function
|
|
|
6430 this.options.complete.call( this.elem );
|
|
|
6431 }
|
|
|
6432
|
|
|
6433 return false;
|
|
|
6434
|
|
|
6435 } else {
|
|
|
6436 var n = t - this.startTime;
|
|
|
6437 this.state = n / this.options.duration;
|
|
|
6438
|
|
|
6439 // Perform the easing function, defaults to swing
|
|
|
6440 var specialEasing = this.options.specialEasing && this.options.specialEasing[this.prop];
|
|
|
6441 var defaultEasing = this.options.easing || (jQuery.easing.swing ? "swing" : "linear");
|
|
|
6442 this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
|
|
|
6443 this.now = this.start + ((this.end - this.start) * this.pos);
|
|
|
6444
|
|
|
6445 // Perform the next step of the animation
|
|
|
6446 this.update();
|
|
|
6447 }
|
|
|
6448
|
|
|
6449 return true;
|
|
|
6450 }
|
|
|
6451 };
|
|
|
6452
|
|
|
6453 jQuery.extend( jQuery.fx, {
|
|
|
6454 tick: function() {
|
|
|
6455 var timers = jQuery.timers;
|
|
|
6456
|
|
|
6457 for ( var i = 0; i < timers.length; i++ ) {
|
|
|
6458 if ( !timers[i]() ) {
|
|
|
6459 timers.splice(i--, 1);
|
|
|
6460 }
|
|
|
6461 }
|
|
|
6462
|
|
|
6463 if ( !timers.length ) {
|
|
|
6464 jQuery.fx.stop();
|
|
|
6465 }
|
|
|
6466 },
|
|
|
6467
|
|
|
6468 interval: 13,
|
|
|
6469
|
|
|
6470 stop: function() {
|
|
|
6471 clearInterval( timerId );
|
|
|
6472 timerId = null;
|
|
|
6473 },
|
|
|
6474
|
|
|
6475 speeds: {
|
|
|
6476 slow: 600,
|
|
|
6477 fast: 200,
|
|
|
6478 // Default speed
|
|
|
6479 _default: 400
|
|
|
6480 },
|
|
|
6481
|
|
|
6482 step: {
|
|
|
6483 opacity: function( fx ) {
|
|
|
6484 jQuery.style( fx.elem, "opacity", fx.now );
|
|
|
6485 },
|
|
|
6486
|
|
|
6487 _default: function( fx ) {
|
|
|
6488 if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
|
|
|
6489 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
|
|
|
6490 } else {
|
|
|
6491 fx.elem[ fx.prop ] = fx.now;
|
|
|
6492 }
|
|
|
6493 }
|
|
|
6494 }
|
|
|
6495 });
|
|
|
6496
|
|
|
6497 if ( jQuery.expr && jQuery.expr.filters ) {
|
|
|
6498 jQuery.expr.filters.animated = function( elem ) {
|
|
|
6499 return jQuery.grep(jQuery.timers, function( fn ) {
|
|
|
6500 return elem === fn.elem;
|
|
|
6501 }).length;
|
|
|
6502 };
|
|
|
6503 }
|
|
|
6504
|
|
|
6505 function defaultDisplay( nodeName ) {
|
|
|
6506 if ( !elemdisplay[ nodeName ] ) {
|
|
|
6507 var elem = jQuery("<" + nodeName + ">").appendTo("body"),
|
|
|
6508 display = elem.css("display");
|
|
|
6509
|
|
|
6510 elem.remove();
|
|
|
6511
|
|
|
6512 if ( display === "none" || display === "" ) {
|
|
|
6513 display = "block";
|
|
|
6514 }
|
|
|
6515
|
|
|
6516 elemdisplay[ nodeName ] = display;
|
|
|
6517 }
|
|
|
6518
|
|
|
6519 return elemdisplay[ nodeName ];
|
|
|
6520 }
|
|
|
6521
|
|
|
6522
|
|
|
6523
|
|
|
6524
|
|
|
6525 var rtable = /^t(?:able|d|h)$/i,
|
|
|
6526 rroot = /^(?:body|html)$/i;
|
|
|
6527
|
|
|
6528 if ( "getBoundingClientRect" in document.documentElement ) {
|
|
|
6529 jQuery.fn.offset = function( options ) {
|
|
|
6530 var elem = this[0], box;
|
|
|
6531
|
|
|
6532 if ( options ) {
|
|
|
6533 return this.each(function( i ) {
|
|
|
6534 jQuery.offset.setOffset( this, options, i );
|
|
|
6535 });
|
|
|
6536 }
|
|
|
6537
|
|
|
6538 if ( !elem || !elem.ownerDocument ) {
|
|
|
6539 return null;
|
|
|
6540 }
|
|
|
6541
|
|
|
6542 if ( elem === elem.ownerDocument.body ) {
|
|
|
6543 return jQuery.offset.bodyOffset( elem );
|
|
|
6544 }
|
|
|
6545
|
|
|
6546 try {
|
|
|
6547 box = elem.getBoundingClientRect();
|
|
|
6548 } catch(e) {}
|
|
|
6549
|
|
|
6550 var doc = elem.ownerDocument,
|
|
|
6551 docElem = doc.documentElement;
|
|
|
6552
|
|
|
6553 // Make sure we're not dealing with a disconnected DOM node
|
|
|
6554 if ( !box || !jQuery.contains( docElem, elem ) ) {
|
|
|
6555 return box || { top: 0, left: 0 };
|
|
|
6556 }
|
|
|
6557
|
|
|
6558 var body = doc.body,
|
|
|
6559 win = getWindow(doc),
|
|
|
6560 clientTop = docElem.clientTop || body.clientTop || 0,
|
|
|
6561 clientLeft = docElem.clientLeft || body.clientLeft || 0,
|
|
|
6562 scrollTop = (win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop ),
|
|
|
6563 scrollLeft = (win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft),
|
|
|
6564 top = box.top + scrollTop - clientTop,
|
|
|
6565 left = box.left + scrollLeft - clientLeft;
|
|
|
6566
|
|
|
6567 return { top: top, left: left };
|
|
|
6568 };
|
|
|
6569
|
|
|
6570 } else {
|
|
|
6571 jQuery.fn.offset = function( options ) {
|
|
|
6572 var elem = this[0];
|
|
|
6573
|
|
|
6574 if ( options ) {
|
|
|
6575 return this.each(function( i ) {
|
|
|
6576 jQuery.offset.setOffset( this, options, i );
|
|
|
6577 });
|
|
|
6578 }
|
|
|
6579
|
|
|
6580 if ( !elem || !elem.ownerDocument ) {
|
|
|
6581 return null;
|
|
|
6582 }
|
|
|
6583
|
|
|
6584 if ( elem === elem.ownerDocument.body ) {
|
|
|
6585 return jQuery.offset.bodyOffset( elem );
|
|
|
6586 }
|
|
|
6587
|
|
|
6588 jQuery.offset.initialize();
|
|
|
6589
|
|
|
6590 var offsetParent = elem.offsetParent, prevOffsetParent = elem,
|
|
|
6591 doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
|
|
|
6592 body = doc.body, defaultView = doc.defaultView,
|
|
|
6593 prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
|
|
|
6594 top = elem.offsetTop, left = elem.offsetLeft;
|
|
|
6595
|
|
|
6596 while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
|
|
|
6597 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
|
|
|
6598 break;
|
|
|
6599 }
|
|
|
6600
|
|
|
6601 computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
|
|
|
6602 top -= elem.scrollTop;
|
|
|
6603 left -= elem.scrollLeft;
|
|
|
6604
|
|
|
6605 if ( elem === offsetParent ) {
|
|
|
6606 top += elem.offsetTop;
|
|
|
6607 left += elem.offsetLeft;
|
|
|
6608
|
|
|
6609 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
|
|
|
6610 top += parseFloat( computedStyle.borderTopWidth ) || 0;
|
|
|
6611 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
|
|
|
6612 }
|
|
|
6613
|
|
|
6614 prevOffsetParent = offsetParent;
|
|
|
6615 offsetParent = elem.offsetParent;
|
|
|
6616 }
|
|
|
6617
|
|
|
6618 if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
|
|
|
6619 top += parseFloat( computedStyle.borderTopWidth ) || 0;
|
|
|
6620 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
|
|
|
6621 }
|
|
|
6622
|
|
|
6623 prevComputedStyle = computedStyle;
|
|
|
6624 }
|
|
|
6625
|
|
|
6626 if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
|
|
|
6627 top += body.offsetTop;
|
|
|
6628 left += body.offsetLeft;
|
|
|
6629 }
|
|
|
6630
|
|
|
6631 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
|
|
|
6632 top += Math.max( docElem.scrollTop, body.scrollTop );
|
|
|
6633 left += Math.max( docElem.scrollLeft, body.scrollLeft );
|
|
|
6634 }
|
|
|
6635
|
|
|
6636 return { top: top, left: left };
|
|
|
6637 };
|
|
|
6638 }
|
|
|
6639
|
|
|
6640 jQuery.offset = {
|
|
|
6641 initialize: function() {
|
|
|
6642 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
|
|
|
6643 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>";
|
|
|
6644
|
|
|
6645 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
|
|
|
6646
|
|
|
6647 container.innerHTML = html;
|
|
|
6648 body.insertBefore( container, body.firstChild );
|
|
|
6649 innerDiv = container.firstChild;
|
|
|
6650 checkDiv = innerDiv.firstChild;
|
|
|
6651 td = innerDiv.nextSibling.firstChild.firstChild;
|
|
|
6652
|
|
|
6653 this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
|
|
|
6654 this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
|
|
|
6655
|
|
|
6656 checkDiv.style.position = "fixed";
|
|
|
6657 checkDiv.style.top = "20px";
|
|
|
6658
|
|
|
6659 // safari subtracts parent border width here which is 5px
|
|
|
6660 this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
|
|
|
6661 checkDiv.style.position = checkDiv.style.top = "";
|
|
|
6662
|
|
|
6663 innerDiv.style.overflow = "hidden";
|
|
|
6664 innerDiv.style.position = "relative";
|
|
|
6665
|
|
|
6666 this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
|
|
|
6667
|
|
|
6668 this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
|
|
|
6669
|
|
|
6670 body.removeChild( container );
|
|
|
6671 body = container = innerDiv = checkDiv = table = td = null;
|
|
|
6672 jQuery.offset.initialize = jQuery.noop;
|
|
|
6673 },
|
|
|
6674
|
|
|
6675 bodyOffset: function( body ) {
|
|
|
6676 var top = body.offsetTop, left = body.offsetLeft;
|
|
|
6677
|
|
|
6678 jQuery.offset.initialize();
|
|
|
6679
|
|
|
6680 if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
|
|
|
6681 top += parseFloat( jQuery.css(body, "marginTop") ) || 0;
|
|
|
6682 left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
|
|
|
6683 }
|
|
|
6684
|
|
|
6685 return { top: top, left: left };
|
|
|
6686 },
|
|
|
6687
|
|
|
6688 setOffset: function( elem, options, i ) {
|
|
|
6689 var position = jQuery.css( elem, "position" );
|
|
|
6690
|
|
|
6691 // set position first, in-case top/left are set even on static elem
|
|
|
6692 if ( position === "static" ) {
|
|
|
6693 elem.style.position = "relative";
|
|
|
6694 }
|
|
|
6695
|
|
|
6696 var curElem = jQuery( elem ),
|
|
|
6697 curOffset = curElem.offset(),
|
|
|
6698 curCSSTop = jQuery.css( elem, "top" ),
|
|
|
6699 curCSSLeft = jQuery.css( elem, "left" ),
|
|
|
6700 calculatePosition = (position === "absolute" && jQuery.inArray('auto', [curCSSTop, curCSSLeft]) > -1),
|
|
|
6701 props = {}, curPosition = {}, curTop, curLeft;
|
|
|
6702
|
|
|
6703 // need to be able to calculate position if either top or left is auto and position is absolute
|
|
|
6704 if ( calculatePosition ) {
|
|
|
6705 curPosition = curElem.position();
|
|
|
6706 }
|
|
|
6707
|
|
|
6708 curTop = calculatePosition ? curPosition.top : parseInt( curCSSTop, 10 ) || 0;
|
|
|
6709 curLeft = calculatePosition ? curPosition.left : parseInt( curCSSLeft, 10 ) || 0;
|
|
|
6710
|
|
|
6711 if ( jQuery.isFunction( options ) ) {
|
|
|
6712 options = options.call( elem, i, curOffset );
|
|
|
6713 }
|
|
|
6714
|
|
|
6715 if (options.top != null) {
|
|
|
6716 props.top = (options.top - curOffset.top) + curTop;
|
|
|
6717 }
|
|
|
6718 if (options.left != null) {
|
|
|
6719 props.left = (options.left - curOffset.left) + curLeft;
|
|
|
6720 }
|
|
|
6721
|
|
|
6722 if ( "using" in options ) {
|
|
|
6723 options.using.call( elem, props );
|
|
|
6724 } else {
|
|
|
6725 curElem.css( props );
|
|
|
6726 }
|
|
|
6727 }
|
|
|
6728 };
|
|
|
6729
|
|
|
6730
|
|
|
6731 jQuery.fn.extend({
|
|
|
6732 position: function() {
|
|
|
6733 if ( !this[0] ) {
|
|
|
6734 return null;
|
|
|
6735 }
|
|
|
6736
|
|
|
6737 var elem = this[0],
|
|
|
6738
|
|
|
6739 // Get *real* offsetParent
|
|
|
6740 offsetParent = this.offsetParent(),
|
|
|
6741
|
|
|
6742 // Get correct offsets
|
|
|
6743 offset = this.offset(),
|
|
|
6744 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
|
|
|
6745
|
|
|
6746 // Subtract element margins
|
|
|
6747 // note: when an element has margin: auto the offsetLeft and marginLeft
|
|
|
6748 // are the same in Safari causing offset.left to incorrectly be 0
|
|
|
6749 offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
|
|
|
6750 offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
|
|
|
6751
|
|
|
6752 // Add offsetParent borders
|
|
|
6753 parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
|
|
|
6754 parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
|
|
|
6755
|
|
|
6756 // Subtract the two offsets
|
|
|
6757 return {
|
|
|
6758 top: offset.top - parentOffset.top,
|
|
|
6759 left: offset.left - parentOffset.left
|
|
|
6760 };
|
|
|
6761 },
|
|
|
6762
|
|
|
6763 offsetParent: function() {
|
|
|
6764 return this.map(function() {
|
|
|
6765 var offsetParent = this.offsetParent || document.body;
|
|
|
6766 while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
|
|
|
6767 offsetParent = offsetParent.offsetParent;
|
|
|
6768 }
|
|
|
6769 return offsetParent;
|
|
|
6770 });
|
|
|
6771 }
|
|
|
6772 });
|
|
|
6773
|
|
|
6774
|
|
|
6775 // Create scrollLeft and scrollTop methods
|
|
|
6776 jQuery.each( ["Left", "Top"], function( i, name ) {
|
|
|
6777 var method = "scroll" + name;
|
|
|
6778
|
|
|
6779 jQuery.fn[ method ] = function(val) {
|
|
|
6780 var elem = this[0], win;
|
|
|
6781
|
|
|
6782 if ( !elem ) {
|
|
|
6783 return null;
|
|
|
6784 }
|
|
|
6785
|
|
|
6786 if ( val !== undefined ) {
|
|
|
6787 // Set the scroll offset
|
|
|
6788 return this.each(function() {
|
|
|
6789 win = getWindow( this );
|
|
|
6790
|
|
|
6791 if ( win ) {
|
|
|
6792 win.scrollTo(
|
|
|
6793 !i ? val : jQuery(win).scrollLeft(),
|
|
|
6794 i ? val : jQuery(win).scrollTop()
|
|
|
6795 );
|
|
|
6796
|
|
|
6797 } else {
|
|
|
6798 this[ method ] = val;
|
|
|
6799 }
|
|
|
6800 });
|
|
|
6801 } else {
|
|
|
6802 win = getWindow( elem );
|
|
|
6803
|
|
|
6804 // Return the scroll offset
|
|
|
6805 return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
|
|
|
6806 jQuery.support.boxModel && win.document.documentElement[ method ] ||
|
|
|
6807 win.document.body[ method ] :
|
|
|
6808 elem[ method ];
|
|
|
6809 }
|
|
|
6810 };
|
|
|
6811 });
|
|
|
6812
|
|
|
6813 function getWindow( elem ) {
|
|
|
6814 return jQuery.isWindow( elem ) ?
|
|
|
6815 elem :
|
|
|
6816 elem.nodeType === 9 ?
|
|
|
6817 elem.defaultView || elem.parentWindow :
|
|
|
6818 false;
|
|
|
6819 }
|
|
|
6820
|
|
|
6821
|
|
|
6822
|
|
|
6823
|
|
|
6824 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
|
|
|
6825 jQuery.each([ "Height", "Width" ], function( i, name ) {
|
|
|
6826
|
|
|
6827 var type = name.toLowerCase();
|
|
|
6828
|
|
|
6829 // innerHeight and innerWidth
|
|
|
6830 jQuery.fn["inner" + name] = function() {
|
|
|
6831 return this[0] ?
|
|
|
6832 parseFloat( jQuery.css( this[0], type, "padding" ) ) :
|
|
|
6833 null;
|
|
|
6834 };
|
|
|
6835
|
|
|
6836 // outerHeight and outerWidth
|
|
|
6837 jQuery.fn["outer" + name] = function( margin ) {
|
|
|
6838 return this[0] ?
|
|
|
6839 parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) :
|
|
|
6840 null;
|
|
|
6841 };
|
|
|
6842
|
|
|
6843 jQuery.fn[ type ] = function( size ) {
|
|
|
6844 // Get window width or height
|
|
|
6845 var elem = this[0];
|
|
|
6846 if ( !elem ) {
|
|
|
6847 return size == null ? null : this;
|
|
|
6848 }
|
|
|
6849
|
|
|
6850 if ( jQuery.isFunction( size ) ) {
|
|
|
6851 return this.each(function( i ) {
|
|
|
6852 var self = jQuery( this );
|
|
|
6853 self[ type ]( size.call( this, i, self[ type ]() ) );
|
|
|
6854 });
|
|
|
6855 }
|
|
|
6856
|
|
|
6857 return jQuery.isWindow( elem ) ?
|
|
|
6858 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
|
|
|
6859 elem.document.compatMode === "CSS1Compat" && elem.document.documentElement[ "client" + name ] ||
|
|
|
6860 elem.document.body[ "client" + name ] :
|
|
|
6861
|
|
|
6862 // Get document width or height
|
|
|
6863 (elem.nodeType === 9) ? // is it a document
|
|
|
6864 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
|
|
|
6865 Math.max(
|
|
|
6866 elem.documentElement["client" + name],
|
|
|
6867 elem.body["scroll" + name], elem.documentElement["scroll" + name],
|
|
|
6868 elem.body["offset" + name], elem.documentElement["offset" + name]
|
|
|
6869 ) :
|
|
|
6870
|
|
|
6871 // Get or set width or height on the element
|
|
|
6872 size === undefined ?
|
|
|
6873 // Get width or height on the element
|
|
|
6874 parseFloat( jQuery.css( elem, type ) ) :
|
|
|
6875
|
|
|
6876 // Set the width or height on the element (default to pixels if value is unitless)
|
|
|
6877 this.css( type, typeof size === "string" ? size : size + "px" );
|
|
|
6878 };
|
|
|
6879
|
|
|
6880 });
|
|
|
6881
|
|
|
6882
|
|
|
6883 })(window);
|
