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