| OLD | NEW |
|---|
| (Empty) |
| 1 /*! | |
| 2 * jQuery JavaScript Library v1.3.2 | |
| 3 * http://jquery.com/ | |
| 4 * | |
| 5 * Copyright (c) 2009 John Resig | |
| 6 * Dual licensed under the MIT and GPL licenses. | |
| 7 * http://docs.jquery.com/License | |
| 8 * | |
| 9 * Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009) | |
| 10 * Revision: 6246 | |
| 11 */ | |
| 12 (function(){ | |
| 13 | |
| 14 var | |
| 15 // Will speed up references to window, and allows munging its name. | |
| 16 window = this, | |
| 17 // Will speed up references to undefined, and allows munging its name. | |
| 18 undefined, | |
| 19 // Map over jQuery in case of overwrite | |
| 20 _jQuery = window.jQuery, | |
| 21 // Map over the $ in case of overwrite | |
| 22 _$ = window.$, | |
| 23 | |
| 24 jQuery = window.jQuery = window.$ = function( selector, context ) { | |
| 25 // The jQuery object is actually just the init constructor 'enha
nced' | |
| 26 return new jQuery.fn.init( selector, context ); | |
| 27 }, | |
| 28 | |
| 29 // A simple way to check for HTML strings or ID strings | |
| 30 // (both of which we optimize for) | |
| 31 quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/, | |
| 32 // Is it a simple selector | |
| 33 isSimple = /^.[^:#\[\.,]*$/; | |
| 34 | |
| 35 jQuery.fn = jQuery.prototype = { | |
| 36 init: function( selector, context ) { | |
| 37 // Make sure that a selection was provided | |
| 38 selector = selector || document; | |
| 39 | |
| 40 // Handle $(DOMElement) | |
| 41 if ( selector.nodeType ) { | |
| 42 this[0] = selector; | |
| 43 this.length = 1; | |
| 44 this.context = selector; | |
| 45 return this; | |
| 46 } | |
| 47 // Handle HTML strings | |
| 48 if ( typeof selector === "string" ) { | |
| 49 // Are we dealing with HTML string or an ID? | |
| 50 var match = quickExpr.exec( selector ); | |
| 51 | |
| 52 // Verify a match, and that no context was specified for
#id | |
| 53 if ( match && (match[1] || !context) ) { | |
| 54 | |
| 55 // HANDLE: $(html) -> $(array) | |
| 56 if ( match[1] ) | |
| 57 selector = jQuery.clean( [ match[1] ], c
ontext ); | |
| 58 | |
| 59 // HANDLE: $("#id") | |
| 60 else { | |
| 61 var elem = document.getElementById( matc
h[3] ); | |
| 62 | |
| 63 // Handle the case where IE and Opera re
turn items | |
| 64 // by name instead of ID | |
| 65 if ( elem && elem.id != match[3] ) | |
| 66 return jQuery().find( selector )
; | |
| 67 | |
| 68 // Otherwise, we inject the element dire
ctly into the jQuery object | |
| 69 var ret = jQuery( elem || [] ); | |
| 70 ret.context = document; | |
| 71 ret.selector = selector; | |
| 72 return ret; | |
| 73 } | |
| 74 | |
| 75 // HANDLE: $(expr, [context]) | |
| 76 // (which is just equivalent to: $(content).find(expr) | |
| 77 } else | |
| 78 return jQuery( context ).find( selector ); | |
| 79 | |
| 80 // HANDLE: $(function) | |
| 81 // Shortcut for document ready | |
| 82 } else if ( jQuery.isFunction( selector ) ) | |
| 83 return jQuery( document ).ready( selector ); | |
| 84 | |
| 85 // Make sure that old selector state is passed along | |
| 86 if ( selector.selector && selector.context ) { | |
| 87 this.selector = selector.selector; | |
| 88 this.context = selector.context; | |
| 89 } | |
| 90 | |
| 91 return this.setArray(jQuery.isArray( selector ) ? | |
| 92 selector : | |
| 93 jQuery.makeArray(selector)); | |
| 94 }, | |
| 95 | |
| 96 // Start with an empty selector | |
| 97 selector: "", | |
| 98 | |
| 99 // The current version of jQuery being used | |
| 100 jquery: "1.3.2", | |
| 101 | |
| 102 // The number of elements contained in the matched element set | |
| 103 size: function() { | |
| 104 return this.length; | |
| 105 }, | |
| 106 | |
| 107 // Get the Nth element in the matched element set OR | |
| 108 // Get the whole matched element set as a clean array | |
| 109 get: function( num ) { | |
| 110 return num === undefined ? | |
| 111 | |
| 112 // Return a 'clean' array | |
| 113 Array.prototype.slice.call( this ) : | |
| 114 | |
| 115 // Return just the object | |
| 116 this[ num ]; | |
| 117 }, | |
| 118 | |
| 119 // Take an array of elements and push it onto the stack | |
| 120 // (returning the new matched element set) | |
| 121 pushStack: function( elems, name, selector ) { | |
| 122 // Build a new jQuery matched element set | |
| 123 var ret = jQuery( elems ); | |
| 124 | |
| 125 // Add the old object onto the stack (as a reference) | |
| 126 ret.prevObject = this; | |
| 127 | |
| 128 ret.context = this.context; | |
| 129 | |
| 130 if ( name === "find" ) | |
| 131 ret.selector = this.selector + (this.selector ? " " : ""
) + selector; | |
| 132 else if ( name ) | |
| 133 ret.selector = this.selector + "." + name + "(" + select
or + ")"; | |
| 134 | |
| 135 // Return the newly-formed element set | |
| 136 return ret; | |
| 137 }, | |
| 138 | |
| 139 // Force the current matched set of elements to become | |
| 140 // the specified array of elements (destroying the stack in the process) | |
| 141 // You should use pushStack() in order to do this, but maintain the stac
k | |
| 142 setArray: function( elems ) { | |
| 143 // Resetting the length to 0, then using the native Array push | |
| 144 // is a super-fast way to populate an object with array-like pro
perties | |
| 145 this.length = 0; | |
| 146 Array.prototype.push.apply( this, elems ); | |
| 147 | |
| 148 return this; | |
| 149 }, | |
| 150 | |
| 151 // Execute a callback for every element in the matched set. | |
| 152 // (You can seed the arguments with an array of args, but this is | |
| 153 // only used internally.) | |
| 154 each: function( callback, args ) { | |
| 155 return jQuery.each( this, callback, args ); | |
| 156 }, | |
| 157 | |
| 158 // Determine the position of an element within | |
| 159 // the matched set of elements | |
| 160 index: function( elem ) { | |
| 161 // Locate the position of the desired element | |
| 162 return jQuery.inArray( | |
| 163 // If it receives a jQuery object, the first element is
used | |
| 164 elem && elem.jquery ? elem[0] : elem | |
| 165 , this ); | |
| 166 }, | |
| 167 | |
| 168 attr: function( name, value, type ) { | |
| 169 var options = name; | |
| 170 | |
| 171 // Look for the case where we're accessing a style value | |
| 172 if ( typeof name === "string" ) | |
| 173 if ( value === undefined ) | |
| 174 return this[0] && jQuery[ type || "attr" ]( this
[0], name ); | |
| 175 | |
| 176 else { | |
| 177 options = {}; | |
| 178 options[ name ] = value; | |
| 179 } | |
| 180 | |
| 181 // Check to see if we're setting style values | |
| 182 return this.each(function(i){ | |
| 183 // Set all the styles | |
| 184 for ( name in options ) | |
| 185 jQuery.attr( | |
| 186 type ? | |
| 187 this.style : | |
| 188 this, | |
| 189 name, jQuery.prop( this, options[ name ]
, type, i, name ) | |
| 190 ); | |
| 191 }); | |
| 192 }, | |
| 193 | |
| 194 css: function( key, value ) { | |
| 195 // ignore negative width and height values | |
| 196 if ( (key == 'width' || key == 'height') && parseFloat(value) <
0 ) | |
| 197 value = undefined; | |
| 198 return this.attr( key, value, "curCSS" ); | |
| 199 }, | |
| 200 | |
| 201 text: function( text ) { | |
| 202 if ( typeof text !== "object" && text != null ) | |
| 203 return this.empty().append( (this[0] && this[0].ownerDoc
ument || document).createTextNode( text ) ); | |
| 204 | |
| 205 var ret = ""; | |
| 206 | |
| 207 jQuery.each( text || this, function(){ | |
| 208 jQuery.each( this.childNodes, function(){ | |
| 209 if ( this.nodeType != 8 ) | |
| 210 ret += this.nodeType != 1 ? | |
| 211 this.nodeValue : | |
| 212 jQuery.fn.text( [ this ] ); | |
| 213 }); | |
| 214 }); | |
| 215 | |
| 216 return ret; | |
| 217 }, | |
| 218 | |
| 219 wrapAll: function( html ) { | |
| 220 if ( this[0] ) { | |
| 221 // The elements to wrap the target around | |
| 222 var wrap = jQuery( html, this[0].ownerDocument ).clone()
; | |
| 223 | |
| 224 if ( this[0].parentNode ) | |
| 225 wrap.insertBefore( this[0] ); | |
| 226 | |
| 227 wrap.map(function(){ | |
| 228 var elem = this; | |
| 229 | |
| 230 while ( elem.firstChild ) | |
| 231 elem = elem.firstChild; | |
| 232 | |
| 233 return elem; | |
| 234 }).append(this); | |
| 235 } | |
| 236 | |
| 237 return this; | |
| 238 }, | |
| 239 | |
| 240 wrapInner: function( html ) { | |
| 241 return this.each(function(){ | |
| 242 jQuery( this ).contents().wrapAll( html ); | |
| 243 }); | |
| 244 }, | |
| 245 | |
| 246 wrap: function( html ) { | |
| 247 return this.each(function(){ | |
| 248 jQuery( this ).wrapAll( html ); | |
| 249 }); | |
| 250 }, | |
| 251 | |
| 252 append: function() { | |
| 253 return this.domManip(arguments, true, function(elem){ | |
| 254 if (this.nodeType == 1) | |
| 255 this.appendChild( elem ); | |
| 256 }); | |
| 257 }, | |
| 258 | |
| 259 prepend: function() { | |
| 260 return this.domManip(arguments, true, function(elem){ | |
| 261 if (this.nodeType == 1) | |
| 262 this.insertBefore( elem, this.firstChild ); | |
| 263 }); | |
| 264 }, | |
| 265 | |
| 266 before: function() { | |
| 267 return this.domManip(arguments, false, function(elem){ | |
| 268 this.parentNode.insertBefore( elem, this ); | |
| 269 }); | |
| 270 }, | |
| 271 | |
| 272 after: function() { | |
| 273 return this.domManip(arguments, false, function(elem){ | |
| 274 this.parentNode.insertBefore( elem, this.nextSibling ); | |
| 275 }); | |
| 276 }, | |
| 277 | |
| 278 end: function() { | |
| 279 return this.prevObject || jQuery( [] ); | |
| 280 }, | |
| 281 | |
| 282 // For internal use only. | |
| 283 // Behaves like an Array's method, not like a jQuery method. | |
| 284 push: [].push, | |
| 285 sort: [].sort, | |
| 286 splice: [].splice, | |
| 287 | |
| 288 find: function( selector ) { | |
| 289 if ( this.length === 1 ) { | |
| 290 var ret = this.pushStack( [], "find", selector ); | |
| 291 ret.length = 0; | |
| 292 jQuery.find( selector, this[0], ret ); | |
| 293 return ret; | |
| 294 } else { | |
| 295 return this.pushStack( jQuery.unique(jQuery.map(this, fu
nction(elem){ | |
| 296 return jQuery.find( selector, elem ); | |
| 297 })), "find", selector ); | |
| 298 } | |
| 299 }, | |
| 300 | |
| 301 clone: function( events ) { | |
| 302 // Do the clone | |
| 303 var ret = this.map(function(){ | |
| 304 if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(th
is) ) { | |
| 305 // IE copies events bound via attachEvent when | |
| 306 // using cloneNode. Calling detachEvent on the | |
| 307 // clone will also remove the events from the or
ignal | |
| 308 // In order to get around this, we use innerHTML
. | |
| 309 // Unfortunately, this means some modifications
to | |
| 310 // attributes in IE that are actually only store
d | |
| 311 // as properties will not be copied (such as the | |
| 312 // the name attribute on an input). | |
| 313 var html = this.outerHTML; | |
| 314 if ( !html ) { | |
| 315 var div = this.ownerDocument.createEleme
nt("div"); | |
| 316 div.appendChild( this.cloneNode(true) ); | |
| 317 html = div.innerHTML; | |
| 318 } | |
| 319 | |
| 320 return jQuery.clean([html.replace(/ jQuery\d+="(
?:\d+|null)"/g, "").replace(/^\s*/, "")])[0]; | |
| 321 } else | |
| 322 return this.cloneNode(true); | |
| 323 }); | |
| 324 | |
| 325 // Copy the events from the original to the clone | |
| 326 if ( events === true ) { | |
| 327 var orig = this.find("*").andSelf(), i = 0; | |
| 328 | |
| 329 ret.find("*").andSelf().each(function(){ | |
| 330 if ( this.nodeName !== orig[i].nodeName ) | |
| 331 return; | |
| 332 | |
| 333 var events = jQuery.data( orig[i], "events" ); | |
| 334 | |
| 335 for ( var type in events ) { | |
| 336 for ( var handler in events[ type ] ) { | |
| 337 jQuery.event.add( this, type, ev
ents[ type ][ handler ], events[ type ][ handler ].data ); | |
| 338 } | |
| 339 } | |
| 340 | |
| 341 i++; | |
| 342 }); | |
| 343 } | |
| 344 | |
| 345 // Return the cloned set | |
| 346 return ret; | |
| 347 }, | |
| 348 | |
| 349 filter: function( selector ) { | |
| 350 return this.pushStack( | |
| 351 jQuery.isFunction( selector ) && | |
| 352 jQuery.grep(this, function(elem, i){ | |
| 353 return selector.call( elem, i ); | |
| 354 }) || | |
| 355 | |
| 356 jQuery.multiFilter( selector, jQuery.grep(this, function
(elem){ | |
| 357 return elem.nodeType === 1; | |
| 358 }) ), "filter", selector ); | |
| 359 }, | |
| 360 | |
| 361 closest: function( selector ) { | |
| 362 var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(select
or) : null, | |
| 363 closer = 0; | |
| 364 | |
| 365 return this.map(function(){ | |
| 366 var cur = this; | |
| 367 while ( cur && cur.ownerDocument ) { | |
| 368 if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(
selector) ) { | |
| 369 jQuery.data(cur, "closest", closer); | |
| 370 return cur; | |
| 371 } | |
| 372 cur = cur.parentNode; | |
| 373 closer++; | |
| 374 } | |
| 375 }); | |
| 376 }, | |
| 377 | |
| 378 not: function( selector ) { | |
| 379 if ( typeof selector === "string" ) | |
| 380 // test special case where just one selector is passed i
n | |
| 381 if ( isSimple.test( selector ) ) | |
| 382 return this.pushStack( jQuery.multiFilter( selec
tor, this, true ), "not", selector ); | |
| 383 else | |
| 384 selector = jQuery.multiFilter( selector, this ); | |
| 385 | |
| 386 var isArrayLike = selector.length && selector[selector.length -
1] !== undefined && !selector.nodeType; | |
| 387 return this.filter(function() { | |
| 388 return isArrayLike ? jQuery.inArray( this, selector ) <
0 : this != selector; | |
| 389 }); | |
| 390 }, | |
| 391 | |
| 392 add: function( selector ) { | |
| 393 return this.pushStack( jQuery.unique( jQuery.merge( | |
| 394 this.get(), | |
| 395 typeof selector === "string" ? | |
| 396 jQuery( selector ) : | |
| 397 jQuery.makeArray( selector ) | |
| 398 ))); | |
| 399 }, | |
| 400 | |
| 401 is: function( selector ) { | |
| 402 return !!selector && jQuery.multiFilter( selector, this ).length
> 0; | |
| 403 }, | |
| 404 | |
| 405 hasClass: function( selector ) { | |
| 406 return !!selector && this.is( "." + selector ); | |
| 407 }, | |
| 408 | |
| 409 val: function( value ) { | |
| 410 if ( value === undefined ) { | |
| 411 var elem = this[0]; | |
| 412 | |
| 413 if ( elem ) { | |
| 414 if( jQuery.nodeName( elem, 'option' ) ) | |
| 415 return (elem.attributes.value || {}).spe
cified ? elem.value : elem.text; | |
| 416 | |
| 417 // We need to handle select boxes special | |
| 418 if ( jQuery.nodeName( elem, "select" ) ) { | |
| 419 var index = elem.selectedIndex, | |
| 420 values = [], | |
| 421 options = elem.options, | |
| 422 one = elem.type == "select-one"; | |
| 423 | |
| 424 // Nothing was selected | |
| 425 if ( index < 0 ) | |
| 426 return null; | |
| 427 | |
| 428 // Loop through all the selected options | |
| 429 for ( var i = one ? index : 0, max = one
? index + 1 : options.length; i < max; i++ ) { | |
| 430 var option = options[ i ]; | |
| 431 | |
| 432 if ( option.selected ) { | |
| 433 // Get the specifc value
for the option | |
| 434 value = jQuery(option).v
al(); | |
| 435 | |
| 436 // We don't need an arra
y for one selects | |
| 437 if ( one ) | |
| 438 return value; | |
| 439 | |
| 440 // Multi-Selects return
an array | |
| 441 values.push( value ); | |
| 442 } | |
| 443 } | |
| 444 | |
| 445 return values; | |
| 446 } | |
| 447 | |
| 448 // Everything else, we just grab the value | |
| 449 return (elem.value || "").replace(/\r/g, ""); | |
| 450 | |
| 451 } | |
| 452 | |
| 453 return undefined; | |
| 454 } | |
| 455 | |
| 456 if ( typeof value === "number" ) | |
| 457 value += ''; | |
| 458 | |
| 459 return this.each(function(){ | |
| 460 if ( this.nodeType != 1 ) | |
| 461 return; | |
| 462 | |
| 463 if ( jQuery.isArray(value) && /radio|checkbox/.test( thi
s.type ) ) | |
| 464 this.checked = (jQuery.inArray(this.value, value
) >= 0 || | |
| 465 jQuery.inArray(this.name, value) >= 0); | |
| 466 | |
| 467 else if ( jQuery.nodeName( this, "select" ) ) { | |
| 468 var values = jQuery.makeArray(value); | |
| 469 | |
| 470 jQuery( "option", this ).each(function(){ | |
| 471 this.selected = (jQuery.inArray( this.va
lue, values ) >= 0 || | |
| 472 jQuery.inArray( this.text, value
s ) >= 0); | |
| 473 }); | |
| 474 | |
| 475 if ( !values.length ) | |
| 476 this.selectedIndex = -1; | |
| 477 | |
| 478 } else | |
| 479 this.value = value; | |
| 480 }); | |
| 481 }, | |
| 482 | |
| 483 html: function( value ) { | |
| 484 return value === undefined ? | |
| 485 (this[0] ? | |
| 486 this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|nu
ll)"/g, "") : | |
| 487 null) : | |
| 488 this.empty().append( value ); | |
| 489 }, | |
| 490 | |
| 491 replaceWith: function( value ) { | |
| 492 return this.after( value ).remove(); | |
| 493 }, | |
| 494 | |
| 495 eq: function( i ) { | |
| 496 return this.slice( i, +i + 1 ); | |
| 497 }, | |
| 498 | |
| 499 slice: function() { | |
| 500 return this.pushStack( Array.prototype.slice.apply( this, argume
nts ), | |
| 501 "slice", Array.prototype.slice.call(arguments).join(",")
); | |
| 502 }, | |
| 503 | |
| 504 map: function( callback ) { | |
| 505 return this.pushStack( jQuery.map(this, function(elem, i){ | |
| 506 return callback.call( elem, i, elem ); | |
| 507 })); | |
| 508 }, | |
| 509 | |
| 510 andSelf: function() { | |
| 511 return this.add( this.prevObject ); | |
| 512 }, | |
| 513 | |
| 514 domManip: function( args, table, callback ) { | |
| 515 if ( this[0] ) { | |
| 516 var fragment = (this[0].ownerDocument || this[0]).create
DocumentFragment(), | |
| 517 scripts = jQuery.clean( args, (this[0].ownerDocu
ment || this[0]), fragment ), | |
| 518 first = fragment.firstChild; | |
| 519 | |
| 520 if ( first ) | |
| 521 for ( var i = 0, l = this.length; i < l; i++ ) | |
| 522 callback.call( root(this[i], first), thi
s.length > 1 || i > 0 ? | |
| 523 fragment.cloneNode(true)
: fragment ); | |
| 524 | |
| 525 if ( scripts ) | |
| 526 jQuery.each( scripts, evalScript ); | |
| 527 } | |
| 528 | |
| 529 return this; | |
| 530 | |
| 531 function root( elem, cur ) { | |
| 532 return table && jQuery.nodeName(elem, "table") && jQuery
.nodeName(cur, "tr") ? | |
| 533 (elem.getElementsByTagName("tbody")[0] || | |
| 534 elem.appendChild(elem.ownerDocument.createElemen
t("tbody"))) : | |
| 535 elem; | |
| 536 } | |
| 537 } | |
| 538 }; | |
| 539 | |
| 540 // Give the init function the jQuery prototype for later instantiation | |
| 541 jQuery.fn.init.prototype = jQuery.fn; | |
| 542 | |
| 543 function evalScript( i, elem ) { | |
| 544 if ( elem.src ) | |
| 545 jQuery.ajax({ | |
| 546 url: elem.src, | |
| 547 async: false, | |
| 548 dataType: "script" | |
| 549 }); | |
| 550 | |
| 551 else | |
| 552 jQuery.globalEval( elem.text || elem.textContent || elem.innerHT
ML || "" ); | |
| 553 | |
| 554 if ( elem.parentNode ) | |
| 555 elem.parentNode.removeChild( elem ); | |
| 556 } | |
| 557 | |
| 558 function now(){ | |
| 559 return +new Date; | |
| 560 } | |
| 561 | |
| 562 jQuery.extend = jQuery.fn.extend = function() { | |
| 563 // copy reference to target object | |
| 564 var target = arguments[0] || {}, i = 1, length = arguments.length, deep
= false, options; | |
| 565 | |
| 566 // Handle a deep copy situation | |
| 567 if ( typeof target === "boolean" ) { | |
| 568 deep = target; | |
| 569 target = arguments[1] || {}; | |
| 570 // skip the boolean and the target | |
| 571 i = 2; | |
| 572 } | |
| 573 | |
| 574 // Handle case when target is a string or something (possible in deep co
py) | |
| 575 if ( typeof target !== "object" && !jQuery.isFunction(target) ) | |
| 576 target = {}; | |
| 577 | |
| 578 // extend jQuery itself if only one argument is passed | |
| 579 if ( length == i ) { | |
| 580 target = this; | |
| 581 --i; | |
| 582 } | |
| 583 | |
| 584 for ( ; i < length; i++ ) | |
| 585 // Only deal with non-null/undefined values | |
| 586 if ( (options = arguments[ i ]) != null ) | |
| 587 // Extend the base object | |
| 588 for ( var name in options ) { | |
| 589 var src = target[ name ], copy = options[ name ]
; | |
| 590 | |
| 591 // Prevent never-ending loop | |
| 592 if ( target === copy ) | |
| 593 continue; | |
| 594 | |
| 595 // Recurse if we're merging object values | |
| 596 if ( deep && copy && typeof copy === "object" &&
!copy.nodeType ) | |
| 597 target[ name ] = jQuery.extend( deep, | |
| 598 // Never move original objects,
clone them | |
| 599 src || ( copy.length != null ? [
] : { } ) | |
| 600 , copy ); | |
| 601 | |
| 602 // Don't bring in undefined values | |
| 603 else if ( copy !== undefined ) | |
| 604 target[ name ] = copy; | |
| 605 | |
| 606 } | |
| 607 | |
| 608 // Return the modified object | |
| 609 return target; | |
| 610 }; | |
| 611 | |
| 612 // exclude the following css properties to add px | |
| 613 var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i, | |
| 614 // cache defaultView | |
| 615 defaultView = document.defaultView || {}, | |
| 616 toString = Object.prototype.toString; | |
| 617 | |
| 618 jQuery.extend({ | |
| 619 noConflict: function( deep ) { | |
| 620 window.$ = _$; | |
| 621 | |
| 622 if ( deep ) | |
| 623 window.jQuery = _jQuery; | |
| 624 | |
| 625 return jQuery; | |
| 626 }, | |
| 627 | |
| 628 // See test/unit/core.js for details concerning isFunction. | |
| 629 // Since version 1.3, DOM methods and functions like alert | |
| 630 // aren't supported. They return false on IE (#2968). | |
| 631 isFunction: function( obj ) { | |
| 632 return toString.call(obj) === "[object Function]"; | |
| 633 }, | |
| 634 | |
| 635 isArray: function( obj ) { | |
| 636 return toString.call(obj) === "[object Array]"; | |
| 637 }, | |
| 638 | |
| 639 // check if an element is in a (or is an) XML document | |
| 640 isXMLDoc: function( elem ) { | |
| 641 return elem.nodeType === 9 && elem.documentElement.nodeName !==
"HTML" || | |
| 642 !!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocum
ent ); | |
| 643 }, | |
| 644 | |
| 645 // Evalulates a script in a global context | |
| 646 globalEval: function( data ) { | |
| 647 if ( data && /\S/.test(data) ) { | |
| 648 // Inspired by code by Andrea Giammarchi | |
| 649 // http://webreflection.blogspot.com/2007/08/global-scop
e-evaluation-and-dom.html | |
| 650 var head = document.getElementsByTagName("head")[0] || d
ocument.documentElement, | |
| 651 script = document.createElement("script"); | |
| 652 | |
| 653 script.type = "text/javascript"; | |
| 654 if ( jQuery.support.scriptEval ) | |
| 655 script.appendChild( document.createTextNode( dat
a ) ); | |
| 656 else | |
| 657 script.text = data; | |
| 658 | |
| 659 // Use insertBefore instead of appendChild to circumven
t an IE6 bug. | |
| 660 // This arises when a base node is used (#2709). | |
| 661 head.insertBefore( script, head.firstChild ); | |
| 662 head.removeChild( script ); | |
| 663 } | |
| 664 }, | |
| 665 | |
| 666 nodeName: function( elem, name ) { | |
| 667 return elem.nodeName && elem.nodeName.toUpperCase() == name.toUp
perCase(); | |
| 668 }, | |
| 669 | |
| 670 // args is for internal usage only | |
| 671 each: function( object, callback, args ) { | |
| 672 var name, i = 0, length = object.length; | |
| 673 | |
| 674 if ( args ) { | |
| 675 if ( length === undefined ) { | |
| 676 for ( name in object ) | |
| 677 if ( callback.apply( object[ name ], arg
s ) === false ) | |
| 678 break; | |
| 679 } else | |
| 680 for ( ; i < length; ) | |
| 681 if ( callback.apply( object[ i++ ], args
) === false ) | |
| 682 break; | |
| 683 | |
| 684 // A special, fast, case for the most common use of each | |
| 685 } else { | |
| 686 if ( length === undefined ) { | |
| 687 for ( name in object ) | |
| 688 if ( callback.call( object[ name ], name
, object[ name ] ) === false ) | |
| 689 break; | |
| 690 } else | |
| 691 for ( var value = object[0]; | |
| 692 i < length && callback.call( value, i, v
alue ) !== false; value = object[++i] ){} | |
| 693 } | |
| 694 | |
| 695 return object; | |
| 696 }, | |
| 697 | |
| 698 prop: function( elem, value, type, i, name ) { | |
| 699 // Handle executable functions | |
| 700 if ( jQuery.isFunction( value ) ) | |
| 701 value = value.call( elem, i ); | |
| 702 | |
| 703 // Handle passing in a number to a CSS property | |
| 704 return typeof value === "number" && type == "curCSS" && !exclude
.test( name ) ? | |
| 705 value + "px" : | |
| 706 value; | |
| 707 }, | |
| 708 | |
| 709 className: { | |
| 710 // internal only, use addClass("class") | |
| 711 add: function( elem, classNames ) { | |
| 712 jQuery.each((classNames || "").split(/\s+/), function(i,
className){ | |
| 713 if ( elem.nodeType == 1 && !jQuery.className.has
( elem.className, className ) ) | |
| 714 elem.className += (elem.className ? " "
: "") + className; | |
| 715 }); | |
| 716 }, | |
| 717 | |
| 718 // internal only, use removeClass("class") | |
| 719 remove: function( elem, classNames ) { | |
| 720 if (elem.nodeType == 1) | |
| 721 elem.className = classNames !== undefined ? | |
| 722 jQuery.grep(elem.className.split(/\s+/),
function(className){ | |
| 723 return !jQuery.className.has( cl
assNames, className ); | |
| 724 }).join(" ") : | |
| 725 ""; | |
| 726 }, | |
| 727 | |
| 728 // internal only, use hasClass("class") | |
| 729 has: function( elem, className ) { | |
| 730 return elem && jQuery.inArray( className, (elem.classNam
e || elem).toString().split(/\s+/) ) > -1; | |
| 731 } | |
| 732 }, | |
| 733 | |
| 734 // A method for quickly swapping in/out CSS properties to get correct ca
lculations | |
| 735 swap: function( elem, options, callback ) { | |
| 736 var old = {}; | |
| 737 // Remember the old values, and insert the new ones | |
| 738 for ( var name in options ) { | |
| 739 old[ name ] = elem.style[ name ]; | |
| 740 elem.style[ name ] = options[ name ]; | |
| 741 } | |
| 742 | |
| 743 callback.call( elem ); | |
| 744 | |
| 745 // Revert the old values | |
| 746 for ( var name in options ) | |
| 747 elem.style[ name ] = old[ name ]; | |
| 748 }, | |
| 749 | |
| 750 css: function( elem, name, force, extra ) { | |
| 751 if ( name == "width" || name == "height" ) { | |
| 752 var val, props = { position: "absolute", visibility: "hi
dden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top
", "Bottom" ]; | |
| 753 | |
| 754 function getWH() { | |
| 755 val = name == "width" ? elem.offsetWidth : elem.
offsetHeight; | |
| 756 | |
| 757 if ( extra === "border" ) | |
| 758 return; | |
| 759 | |
| 760 jQuery.each( which, function() { | |
| 761 if ( !extra ) | |
| 762 val -= parseFloat(jQuery.curCSS(
elem, "padding" + this, true)) || 0; | |
| 763 if ( extra === "margin" ) | |
| 764 val += parseFloat(jQuery.curCSS(
elem, "margin" + this, true)) || 0; | |
| 765 else | |
| 766 val -= parseFloat(jQuery.curCSS(
elem, "border" + this + "Width", true)) || 0; | |
| 767 }); | |
| 768 } | |
| 769 | |
| 770 if ( elem.offsetWidth !== 0 ) | |
| 771 getWH(); | |
| 772 else | |
| 773 jQuery.swap( elem, props, getWH ); | |
| 774 | |
| 775 return Math.max(0, Math.round(val)); | |
| 776 } | |
| 777 | |
| 778 return jQuery.curCSS( elem, name, force ); | |
| 779 }, | |
| 780 | |
| 781 curCSS: function( elem, name, force ) { | |
| 782 var ret, style = elem.style; | |
| 783 | |
| 784 // We need to handle opacity special in IE | |
| 785 if ( name == "opacity" && !jQuery.support.opacity ) { | |
| 786 ret = jQuery.attr( style, "opacity" ); | |
| 787 | |
| 788 return ret == "" ? | |
| 789 "1" : | |
| 790 ret; | |
| 791 } | |
| 792 | |
| 793 // Make sure we're using the right name for getting the float va
lue | |
| 794 if ( name.match( /float/i ) ) | |
| 795 name = styleFloat; | |
| 796 | |
| 797 if ( !force && style && style[ name ] ) | |
| 798 ret = style[ name ]; | |
| 799 | |
| 800 else if ( defaultView.getComputedStyle ) { | |
| 801 | |
| 802 // Only "float" is needed here | |
| 803 if ( name.match( /float/i ) ) | |
| 804 name = "float"; | |
| 805 | |
| 806 name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase(); | |
| 807 | |
| 808 var computedStyle = defaultView.getComputedStyle( elem,
null ); | |
| 809 | |
| 810 if ( computedStyle ) | |
| 811 ret = computedStyle.getPropertyValue( name ); | |
| 812 | |
| 813 // We should always get a number back from opacity | |
| 814 if ( name == "opacity" && ret == "" ) | |
| 815 ret = "1"; | |
| 816 | |
| 817 } else if ( elem.currentStyle ) { | |
| 818 var camelCase = name.replace(/\-(\w)/g, function(all, le
tter){ | |
| 819 return letter.toUpperCase(); | |
| 820 }); | |
| 821 | |
| 822 ret = elem.currentStyle[ name ] || elem.currentStyle[ ca
melCase ]; | |
| 823 | |
| 824 // From the awesome hack by Dean Edwards | |
| 825 // http://erik.eae.net/archives/2007/07/27/18.54.15/#com
ment-102291 | |
| 826 | |
| 827 // If we're not dealing with a regular pixel number | |
| 828 // but a number that has a weird ending, we need to conv
ert it to pixels | |
| 829 if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) { | |
| 830 // Remember the original values | |
| 831 var left = style.left, rsLeft = elem.runtimeStyl
e.left; | |
| 832 | |
| 833 // Put in the new values to get a computed value
out | |
| 834 elem.runtimeStyle.left = elem.currentStyle.left; | |
| 835 style.left = ret || 0; | |
| 836 ret = style.pixelLeft + "px"; | |
| 837 | |
| 838 // Revert the changed values | |
| 839 style.left = left; | |
| 840 elem.runtimeStyle.left = rsLeft; | |
| 841 } | |
| 842 } | |
| 843 | |
| 844 return ret; | |
| 845 }, | |
| 846 | |
| 847 clean: function( elems, context, fragment ) { | |
| 848 context = context || document; | |
| 849 | |
| 850 // !context.createElement fails in IE with an error but returns
typeof 'object' | |
| 851 if ( typeof context.createElement === "undefined" ) | |
| 852 context = context.ownerDocument || context[0] && context
[0].ownerDocument || document; | |
| 853 | |
| 854 // If a single string is passed in and it's a single tag | |
| 855 // just do a createElement and skip the rest | |
| 856 if ( !fragment && elems.length === 1 && typeof elems[0] === "str
ing" ) { | |
| 857 var match = /^<(\w+)\s*\/?>$/.exec(elems[0]); | |
| 858 if ( match ) | |
| 859 return [ context.createElement( match[1] ) ]; | |
| 860 } | |
| 861 | |
| 862 var ret = [], scripts = [], div = context.createElement("div"); | |
| 863 | |
| 864 jQuery.each(elems, function(i, elem){ | |
| 865 if ( typeof elem === "number" ) | |
| 866 elem += ''; | |
| 867 | |
| 868 if ( !elem ) | |
| 869 return; | |
| 870 | |
| 871 // Convert html string into DOM nodes | |
| 872 if ( typeof elem === "string" ) { | |
| 873 // Fix "XHTML"-style tags in all browsers | |
| 874 elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, functi
on(all, front, tag){ | |
| 875 return tag.match(/^(abbr|br|col|img|inpu
t|link|meta|param|hr|area|embed)$/i) ? | |
| 876 all : | |
| 877 front + "></" + tag + ">"; | |
| 878 }); | |
| 879 | |
| 880 // Trim whitespace, otherwise indexOf won't work
as expected | |
| 881 var tags = elem.replace(/^\s+/, "").substring(0,
10).toLowerCase(); | |
| 882 | |
| 883 var wrap = | |
| 884 // option or optgroup | |
| 885 !tags.indexOf("<opt") && | |
| 886 [ 1, "<select multiple='multiple'>", "</
select>" ] || | |
| 887 | |
| 888 !tags.indexOf("<leg") && | |
| 889 [ 1, "<fieldset>", "</fieldset>" ] || | |
| 890 | |
| 891 tags.match(/^<(thead|tbody|tfoot|colg|ca
p)/) && | |
| 892 [ 1, "<table>", "</table>" ] || | |
| 893 | |
| 894 !tags.indexOf("<tr") && | |
| 895 [ 2, "<table><tbody>", "</tbody></table>
" ] || | |
| 896 | |
| 897 // <thead> matched above | |
| 898 (!tags.indexOf("<td") || !tags.indexOf("
<th")) && | |
| 899 [ 3, "<table><tbody><tr>", "</tr></tbody
></table>" ] || | |
| 900 | |
| 901 !tags.indexOf("<col") && | |
| 902 [ 2, "<table><tbody></tbody><colgroup>",
"</colgroup></table>" ] || | |
| 903 | |
| 904 // IE can't serialize <link> and <script
> tags normally | |
| 905 !jQuery.support.htmlSerialize && | |
| 906 [ 1, "div<div>", "</div>" ] || | |
| 907 | |
| 908 [ 0, "", "" ]; | |
| 909 | |
| 910 // Go to html and back, then peel off extra wrap
pers | |
| 911 div.innerHTML = wrap[1] + elem + wrap[2]; | |
| 912 | |
| 913 // Move to the right depth | |
| 914 while ( wrap[0]-- ) | |
| 915 div = div.lastChild; | |
| 916 | |
| 917 // Remove IE's autoinserted <tbody> from table f
ragments | |
| 918 if ( !jQuery.support.tbody ) { | |
| 919 | |
| 920 // String was a <table>, *may* have spur
ious <tbody> | |
| 921 var hasBody = /<tbody/i.test(elem), | |
| 922 tbody = !tags.indexOf("<table")
&& !hasBody ? | |
| 923 div.firstChild && div.fi
rstChild.childNodes : | |
| 924 | |
| 925 // String was a bare <thead> or
<tfoot> | |
| 926 wrap[1] == "<table>" && !hasBody
? | |
| 927 div.childNodes : | |
| 928 []; | |
| 929 | |
| 930 for ( var j = tbody.length - 1; j >= 0 ;
--j ) | |
| 931 if ( jQuery.nodeName( tbody[ j ]
, "tbody" ) && !tbody[ j ].childNodes.length ) | |
| 932 tbody[ j ].parentNode.re
moveChild( tbody[ j ] ); | |
| 933 | |
| 934 } | |
| 935 | |
| 936 // IE completely kills leading whitespace when i
nnerHTML is used | |
| 937 if ( !jQuery.support.leadingWhitespace && /^\s/.
test( elem ) ) | |
| 938 div.insertBefore( context.createTextNode
( elem.match(/^\s*/)[0] ), div.firstChild ); | |
| 939 | |
| 940 elem = jQuery.makeArray( div.childNodes ); | |
| 941 } | |
| 942 | |
| 943 if ( elem.nodeType ) | |
| 944 ret.push( elem ); | |
| 945 else | |
| 946 ret = jQuery.merge( ret, elem ); | |
| 947 | |
| 948 }); | |
| 949 | |
| 950 if ( fragment ) { | |
| 951 for ( var i = 0; ret[i]; i++ ) { | |
| 952 if ( jQuery.nodeName( ret[i], "script" ) && (!re
t[i].type || ret[i].type.toLowerCase() === "text/javascript") ) { | |
| 953 scripts.push( ret[i].parentNode ? ret[i]
.parentNode.removeChild( ret[i] ) : ret[i] ); | |
| 954 } else { | |
| 955 if ( ret[i].nodeType === 1 ) | |
| 956 ret.splice.apply( ret, [i + 1, 0
].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) ); | |
| 957 fragment.appendChild( ret[i] ); | |
| 958 } | |
| 959 } | |
| 960 | |
| 961 return scripts; | |
| 962 } | |
| 963 | |
| 964 return ret; | |
| 965 }, | |
| 966 | |
| 967 attr: function( elem, name, value ) { | |
| 968 // don't set attributes on text and comment nodes | |
| 969 if (!elem || elem.nodeType == 3 || elem.nodeType == 8) | |
| 970 return undefined; | |
| 971 | |
| 972 var notxml = !jQuery.isXMLDoc( elem ), | |
| 973 // Whether we are setting (or getting) | |
| 974 set = value !== undefined; | |
| 975 | |
| 976 // Try to normalize/fix the name | |
| 977 name = notxml && jQuery.props[ name ] || name; | |
| 978 | |
| 979 // Only do all the following if this is a node (faster for style
) | |
| 980 // IE elem.getAttribute passes even for style | |
| 981 if ( elem.tagName ) { | |
| 982 | |
| 983 // These attributes require special treatment | |
| 984 var special = /href|src|style/.test( name ); | |
| 985 | |
| 986 // Safari mis-reports the default selected property of a
hidden option | |
| 987 // Accessing the parent's selectedIndex property fixes i
t | |
| 988 if ( name == "selected" && elem.parentNode ) | |
| 989 elem.parentNode.selectedIndex; | |
| 990 | |
| 991 // If applicable, access the attribute via the DOM 0 way | |
| 992 if ( name in elem && notxml && !special ) { | |
| 993 if ( set ){ | |
| 994 // We can't allow the type property to b
e changed (since it causes problems in IE) | |
| 995 if ( name == "type" && jQuery.nodeName(
elem, "input" ) && elem.parentNode ) | |
| 996 throw "type property can't be ch
anged"; | |
| 997 | |
| 998 elem[ name ] = value; | |
| 999 } | |
| 1000 | |
| 1001 // browsers index elements by id/name on forms,
give priority to attributes. | |
| 1002 if( jQuery.nodeName( elem, "form" ) && elem.getA
ttributeNode(name) ) | |
| 1003 return elem.getAttributeNode( name ).nod
eValue; | |
| 1004 | |
| 1005 // elem.tabIndex doesn't always return the corre
ct value when it hasn't been explicitly set | |
| 1006 // http://fluidproject.org/blog/2008/01/09/getti
ng-setting-and-removing-tabindex-values-with-javascript/ | |
| 1007 if ( name == "tabIndex" ) { | |
| 1008 var attributeNode = elem.getAttributeNod
e( "tabIndex" ); | |
| 1009 return attributeNode && attributeNode.sp
ecified | |
| 1010 ? attributeNode.value | |
| 1011 : elem.nodeName.match(/(button|i
nput|object|select|textarea)/i) | |
| 1012 ? 0 | |
| 1013 : elem.nodeName.match(/^
(a|area)$/i) && elem.href | |
| 1014 ? 0 | |
| 1015 : undefined; | |
| 1016 } | |
| 1017 | |
| 1018 return elem[ name ]; | |
| 1019 } | |
| 1020 | |
| 1021 if ( !jQuery.support.style && notxml && name == "style"
) | |
| 1022 return jQuery.attr( elem.style, "cssText", value
); | |
| 1023 | |
| 1024 if ( set ) | |
| 1025 // convert the value to a string (all browsers d
o this but IE) see #1070 | |
| 1026 elem.setAttribute( name, "" + value ); | |
| 1027 | |
| 1028 var attr = !jQuery.support.hrefNormalized && notxml && s
pecial | |
| 1029 // Some attributes require a special cal
l on IE | |
| 1030 ? elem.getAttribute( name, 2 ) | |
| 1031 : elem.getAttribute( name ); | |
| 1032 | |
| 1033 // Non-existent attributes return null, we normalize to
undefined | |
| 1034 return attr === null ? undefined : attr; | |
| 1035 } | |
| 1036 | |
| 1037 // elem is actually elem.style ... set the style | |
| 1038 | |
| 1039 // IE uses filters for opacity | |
| 1040 if ( !jQuery.support.opacity && name == "opacity" ) { | |
| 1041 if ( set ) { | |
| 1042 // IE has trouble with opacity if it does not ha
ve layout | |
| 1043 // Force it by setting the zoom level | |
| 1044 elem.zoom = 1; | |
| 1045 | |
| 1046 // Set the alpha filter to set the opacity | |
| 1047 elem.filter = (elem.filter || "").replace( /alph
a\([^)]*\)/, "" ) + | |
| 1048 (parseInt( value ) + '' == "NaN" ? "" :
"alpha(opacity=" + value * 100 + ")"); | |
| 1049 } | |
| 1050 | |
| 1051 return elem.filter && elem.filter.indexOf("opacity=") >=
0 ? | |
| 1052 (parseFloat( elem.filter.match(/opacity=([^)]*)/
)[1] ) / 100) + '': | |
| 1053 ""; | |
| 1054 } | |
| 1055 | |
| 1056 name = name.replace(/-([a-z])/ig, function(all, letter){ | |
| 1057 return letter.toUpperCase(); | |
| 1058 }); | |
| 1059 | |
| 1060 if ( set ) | |
| 1061 elem[ name ] = value; | |
| 1062 | |
| 1063 return elem[ name ]; | |
| 1064 }, | |
| 1065 | |
| 1066 trim: function( text ) { | |
| 1067 return (text || "").replace( /^\s+|\s+$/g, "" ); | |
| 1068 }, | |
| 1069 | |
| 1070 makeArray: function( array ) { | |
| 1071 var ret = []; | |
| 1072 | |
| 1073 if( array != null ){ | |
| 1074 var i = array.length; | |
| 1075 // The window, strings (and functions) also have 'length
' | |
| 1076 if( i == null || typeof array === "string" || jQuery.isF
unction(array) || array.setInterval ) | |
| 1077 ret[0] = array; | |
| 1078 else | |
| 1079 while( i ) | |
| 1080 ret[--i] = array[i]; | |
| 1081 } | |
| 1082 | |
| 1083 return ret; | |
| 1084 }, | |
| 1085 | |
| 1086 inArray: function( elem, array ) { | |
| 1087 for ( var i = 0, length = array.length; i < length; i++ ) | |
| 1088 // Use === because on IE, window == document | |
| 1089 if ( array[ i ] === elem ) | |
| 1090 return i; | |
| 1091 | |
| 1092 return -1; | |
| 1093 }, | |
| 1094 | |
| 1095 merge: function( first, second ) { | |
| 1096 // We have to loop this way because IE & Opera overwrite the len
gth | |
| 1097 // expando of getElementsByTagName | |
| 1098 var i = 0, elem, pos = first.length; | |
| 1099 // Also, we need to make sure that the correct elements are bein
g returned | |
| 1100 // (IE returns comment nodes in a '*' query) | |
| 1101 if ( !jQuery.support.getAll ) { | |
| 1102 while ( (elem = second[ i++ ]) != null ) | |
| 1103 if ( elem.nodeType != 8 ) | |
| 1104 first[ pos++ ] = elem; | |
| 1105 | |
| 1106 } else | |
| 1107 while ( (elem = second[ i++ ]) != null ) | |
| 1108 first[ pos++ ] = elem; | |
| 1109 | |
| 1110 return first; | |
| 1111 }, | |
| 1112 | |
| 1113 unique: function( array ) { | |
| 1114 var ret = [], done = {}; | |
| 1115 | |
| 1116 try { | |
| 1117 | |
| 1118 for ( var i = 0, length = array.length; i < length; i++
) { | |
| 1119 var id = jQuery.data( array[ i ] ); | |
| 1120 | |
| 1121 if ( !done[ id ] ) { | |
| 1122 done[ id ] = true; | |
| 1123 ret.push( array[ i ] ); | |
| 1124 } | |
| 1125 } | |
| 1126 | |
| 1127 } catch( e ) { | |
| 1128 ret = array; | |
| 1129 } | |
| 1130 | |
| 1131 return ret; | |
| 1132 }, | |
| 1133 | |
| 1134 grep: function( elems, callback, inv ) { | |
| 1135 var ret = []; | |
| 1136 | |
| 1137 // Go through the array, only saving the items | |
| 1138 // that pass the validator function | |
| 1139 for ( var i = 0, length = elems.length; i < length; i++ ) | |
| 1140 if ( !inv != !callback( elems[ i ], i ) ) | |
| 1141 ret.push( elems[ i ] ); | |
| 1142 | |
| 1143 return ret; | |
| 1144 }, | |
| 1145 | |
| 1146 map: function( elems, callback ) { | |
| 1147 var ret = []; | |
| 1148 | |
| 1149 // Go through the array, translating each of the items to their | |
| 1150 // new value (or values). | |
| 1151 for ( var i = 0, length = elems.length; i < length; i++ ) { | |
| 1152 var value = callback( elems[ i ], i ); | |
| 1153 | |
| 1154 if ( value != null ) | |
| 1155 ret[ ret.length ] = value; | |
| 1156 } | |
| 1157 | |
| 1158 return ret.concat.apply( [], ret ); | |
| 1159 } | |
| 1160 }); | |
| 1161 | |
| 1162 // Use of jQuery.browser is deprecated. | |
| 1163 // It's included for backwards compatibility and plugins, | |
| 1164 // although they should work to migrate away. | |
| 1165 | |
| 1166 var userAgent = navigator.userAgent.toLowerCase(); | |
| 1167 | |
| 1168 // Figure out what browser is being used | |
| 1169 jQuery.browser = { | |
| 1170 version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'
])[1], | |
| 1171 safari: /webkit/.test( userAgent ), | |
| 1172 opera: /opera/.test( userAgent ), | |
| 1173 msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ), | |
| 1174 mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( use
rAgent ) | |
| 1175 }; | |
| 1176 | |
| 1177 jQuery.each({ | |
| 1178 parent: function(elem){return elem.parentNode;}, | |
| 1179 parents: function(elem){return jQuery.dir(elem,"parentNode");}, | |
| 1180 next: function(elem){return jQuery.nth(elem,2,"nextSibling");}, | |
| 1181 prev: function(elem){return jQuery.nth(elem,2,"previousSibling");}, | |
| 1182 nextAll: function(elem){return jQuery.dir(elem,"nextSibling");}, | |
| 1183 prevAll: function(elem){return jQuery.dir(elem,"previousSibling");}, | |
| 1184 siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChil
d,elem);}, | |
| 1185 children: function(elem){return jQuery.sibling(elem.firstChild);}, | |
| 1186 contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.cont
entDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);} | |
| 1187 }, function(name, fn){ | |
| 1188 jQuery.fn[ name ] = function( selector ) { | |
| 1189 var ret = jQuery.map( this, fn ); | |
| 1190 | |
| 1191 if ( selector && typeof selector == "string" ) | |
| 1192 ret = jQuery.multiFilter( selector, ret ); | |
| 1193 | |
| 1194 return this.pushStack( jQuery.unique( ret ), name, selector ); | |
| 1195 }; | |
| 1196 }); | |
| 1197 | |
| 1198 jQuery.each({ | |
| 1199 appendTo: "append", | |
| 1200 prependTo: "prepend", | |
| 1201 insertBefore: "before", | |
| 1202 insertAfter: "after", | |
| 1203 replaceAll: "replaceWith" | |
| 1204 }, function(name, original){ | |
| 1205 jQuery.fn[ name ] = function( selector ) { | |
| 1206 var ret = [], insert = jQuery( selector ); | |
| 1207 | |
| 1208 for ( var i = 0, l = insert.length; i < l; i++ ) { | |
| 1209 var elems = (i > 0 ? this.clone(true) : this).get(); | |
| 1210 jQuery.fn[ original ].apply( jQuery(insert[i]), elems ); | |
| 1211 ret = ret.concat( elems ); | |
| 1212 } | |
| 1213 | |
| 1214 return this.pushStack( ret, name, selector ); | |
| 1215 }; | |
| 1216 }); | |
| 1217 | |
| 1218 jQuery.each({ | |
| 1219 removeAttr: function( name ) { | |
| 1220 jQuery.attr( this, name, "" ); | |
| 1221 if (this.nodeType == 1) | |
| 1222 this.removeAttribute( name ); | |
| 1223 }, | |
| 1224 | |
| 1225 addClass: function( classNames ) { | |
| 1226 jQuery.className.add( this, classNames ); | |
| 1227 }, | |
| 1228 | |
| 1229 removeClass: function( classNames ) { | |
| 1230 jQuery.className.remove( this, classNames ); | |
| 1231 }, | |
| 1232 | |
| 1233 toggleClass: function( classNames, state ) { | |
| 1234 if( typeof state !== "boolean" ) | |
| 1235 state = !jQuery.className.has( this, classNames ); | |
| 1236 jQuery.className[ state ? "add" : "remove" ]( this, classNames )
; | |
| 1237 }, | |
| 1238 | |
| 1239 remove: function( selector ) { | |
| 1240 if ( !selector || jQuery.filter( selector, [ this ] ).length ) { | |
| 1241 // Prevent memory leaks | |
| 1242 jQuery( "*", this ).add([this]).each(function(){ | |
| 1243 jQuery.event.remove(this); | |
| 1244 jQuery.removeData(this); | |
| 1245 }); | |
| 1246 if (this.parentNode) | |
| 1247 this.parentNode.removeChild( this ); | |
| 1248 } | |
| 1249 }, | |
| 1250 | |
| 1251 empty: function() { | |
| 1252 // Remove element nodes and prevent memory leaks | |
| 1253 jQuery(this).children().remove(); | |
| 1254 | |
| 1255 // Remove any remaining nodes | |
| 1256 while ( this.firstChild ) | |
| 1257 this.removeChild( this.firstChild ); | |
| 1258 } | |
| 1259 }, function(name, fn){ | |
| 1260 jQuery.fn[ name ] = function(){ | |
| 1261 return this.each( fn, arguments ); | |
| 1262 }; | |
| 1263 }); | |
| 1264 | |
| 1265 // Helper function used by the dimensions and offset modules | |
| 1266 function num(elem, prop) { | |
| 1267 return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) ||
0; | |
| 1268 } | |
| 1269 var expando = "jQuery" + now(), uuid = 0, windowData = {}; | |
| 1270 | |
| 1271 jQuery.extend({ | |
| 1272 cache: {}, | |
| 1273 | |
| 1274 data: function( elem, name, data ) { | |
| 1275 elem = elem == window ? | |
| 1276 windowData : | |
| 1277 elem; | |
| 1278 | |
| 1279 var id = elem[ expando ]; | |
| 1280 | |
| 1281 // Compute a unique ID for the element | |
| 1282 if ( !id ) | |
| 1283 id = elem[ expando ] = ++uuid; | |
| 1284 | |
| 1285 // Only generate the data cache if we're | |
| 1286 // trying to access or manipulate it | |
| 1287 if ( name && !jQuery.cache[ id ] ) | |
| 1288 jQuery.cache[ id ] = {}; | |
| 1289 | |
| 1290 // Prevent overriding the named cache with undefined values | |
| 1291 if ( data !== undefined ) | |
| 1292 jQuery.cache[ id ][ name ] = data; | |
| 1293 | |
| 1294 // Return the named cache data, or the ID for the element | |
| 1295 return name ? | |
| 1296 jQuery.cache[ id ][ name ] : | |
| 1297 id; | |
| 1298 }, | |
| 1299 | |
| 1300 removeData: function( elem, name ) { | |
| 1301 elem = elem == window ? | |
| 1302 windowData : | |
| 1303 elem; | |
| 1304 | |
| 1305 var id = elem[ expando ]; | |
| 1306 | |
| 1307 // If we want to remove a specific section of the element's data | |
| 1308 if ( name ) { | |
| 1309 if ( jQuery.cache[ id ] ) { | |
| 1310 // Remove the section of cache data | |
| 1311 delete jQuery.cache[ id ][ name ]; | |
| 1312 | |
| 1313 // If we've removed all the data, remove the ele
ment's cache | |
| 1314 name = ""; | |
| 1315 | |
| 1316 for ( name in jQuery.cache[ id ] ) | |
| 1317 break; | |
| 1318 | |
| 1319 if ( !name ) | |
| 1320 jQuery.removeData( elem ); | |
| 1321 } | |
| 1322 | |
| 1323 // Otherwise, we want to remove all of the element's data | |
| 1324 } else { | |
| 1325 // Clean up the element expando | |
| 1326 try { | |
| 1327 delete elem[ expando ]; | |
| 1328 } catch(e){ | |
| 1329 // IE has trouble directly removing the expando | |
| 1330 // but it's ok with using removeAttribute | |
| 1331 if ( elem.removeAttribute ) | |
| 1332 elem.removeAttribute( expando ); | |
| 1333 } | |
| 1334 | |
| 1335 // Completely remove the data cache | |
| 1336 delete jQuery.cache[ id ]; | |
| 1337 } | |
| 1338 }, | |
| 1339 queue: function( elem, type, data ) { | |
| 1340 if ( elem ){ | |
| 1341 | |
| 1342 type = (type || "fx") + "queue"; | |
| 1343 | |
| 1344 var q = jQuery.data( elem, type ); | |
| 1345 | |
| 1346 if ( !q || jQuery.isArray(data) ) | |
| 1347 q = jQuery.data( elem, type, jQuery.makeArray(da
ta) ); | |
| 1348 else if( data ) | |
| 1349 q.push( data ); | |
| 1350 | |
| 1351 } | |
| 1352 return q; | |
| 1353 }, | |
| 1354 | |
| 1355 dequeue: function( elem, type ){ | |
| 1356 var queue = jQuery.queue( elem, type ), | |
| 1357 fn = queue.shift(); | |
| 1358 | |
| 1359 if( !type || type === "fx" ) | |
| 1360 fn = queue[0]; | |
| 1361 | |
| 1362 if( fn !== undefined ) | |
| 1363 fn.call(elem); | |
| 1364 } | |
| 1365 }); | |
| 1366 | |
| 1367 jQuery.fn.extend({ | |
| 1368 data: function( key, value ){ | |
| 1369 var parts = key.split("."); | |
| 1370 parts[1] = parts[1] ? "." + parts[1] : ""; | |
| 1371 | |
| 1372 if ( value === undefined ) { | |
| 1373 var data = this.triggerHandler("getData" + parts[1] + "!
", [parts[0]]); | |
| 1374 | |
| 1375 if ( data === undefined && this.length ) | |
| 1376 data = jQuery.data( this[0], key ); | |
| 1377 | |
| 1378 return data === undefined && parts[1] ? | |
| 1379 this.data( parts[0] ) : | |
| 1380 data; | |
| 1381 } else | |
| 1382 return this.trigger("setData" + parts[1] + "!", [parts[0
], value]).each(function(){ | |
| 1383 jQuery.data( this, key, value ); | |
| 1384 }); | |
| 1385 }, | |
| 1386 | |
| 1387 removeData: function( key ){ | |
| 1388 return this.each(function(){ | |
| 1389 jQuery.removeData( this, key ); | |
| 1390 }); | |
| 1391 }, | |
| 1392 queue: function(type, data){ | |
| 1393 if ( typeof type !== "string" ) { | |
| 1394 data = type; | |
| 1395 type = "fx"; | |
| 1396 } | |
| 1397 | |
| 1398 if ( data === undefined ) | |
| 1399 return jQuery.queue( this[0], type ); | |
| 1400 | |
| 1401 return this.each(function(){ | |
| 1402 var queue = jQuery.queue( this, type, data ); | |
| 1403 | |
| 1404 if( type == "fx" && queue.length == 1 ) | |
| 1405 queue[0].call(this); | |
| 1406 }); | |
| 1407 }, | |
| 1408 dequeue: function(type){ | |
| 1409 return this.each(function(){ | |
| 1410 jQuery.dequeue( this, type ); | |
| 1411 }); | |
| 1412 } | |
| 1413 });/*! | |
| 1414 * Sizzle CSS Selector Engine - v0.9.3 | |
| 1415 * Copyright 2009, The Dojo Foundation | |
| 1416 * Released under the MIT, BSD, and GPL Licenses. | |
| 1417 * More information: http://sizzlejs.com/ | |
| 1418 */ | |
| 1419 (function(){ | |
| 1420 | |
| 1421 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^
[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g, | |
| 1422 done = 0, | |
| 1423 toString = Object.prototype.toString; | |
| 1424 | |
| 1425 var Sizzle = function(selector, context, results, seed) { | |
| 1426 results = results || []; | |
| 1427 context = context || document; | |
| 1428 | |
| 1429 if ( context.nodeType !== 1 && context.nodeType !== 9 ) | |
| 1430 return []; | |
| 1431 | |
| 1432 if ( !selector || typeof selector !== "string" ) { | |
| 1433 return results; | |
| 1434 } | |
| 1435 | |
| 1436 var parts = [], m, set, checkSet, check, mode, extra, prune = true; | |
| 1437 | |
| 1438 // Reset the position of the chunker regexp (start from head) | |
| 1439 chunker.lastIndex = 0; | |
| 1440 | |
| 1441 while ( (m = chunker.exec(selector)) !== null ) { | |
| 1442 parts.push( m[1] ); | |
| 1443 | |
| 1444 if ( m[2] ) { | |
| 1445 extra = RegExp.rightContext; | |
| 1446 break; | |
| 1447 } | |
| 1448 } | |
| 1449 | |
| 1450 if ( parts.length > 1 && origPOS.exec( selector ) ) { | |
| 1451 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { | |
| 1452 set = posProcess( parts[0] + parts[1], context ); | |
| 1453 } else { | |
| 1454 set = Expr.relative[ parts[0] ] ? | |
| 1455 [ context ] : | |
| 1456 Sizzle( parts.shift(), context ); | |
| 1457 | |
| 1458 while ( parts.length ) { | |
| 1459 selector = parts.shift(); | |
| 1460 | |
| 1461 if ( Expr.relative[ selector ] ) | |
| 1462 selector += parts.shift(); | |
| 1463 | |
| 1464 set = posProcess( selector, set ); | |
| 1465 } | |
| 1466 } | |
| 1467 } else { | |
| 1468 var ret = seed ? | |
| 1469 { expr: parts.pop(), set: makeArray(seed) } : | |
| 1470 Sizzle.find( parts.pop(), parts.length === 1 && context.
parentNode ? context.parentNode : context, isXML(context) ); | |
| 1471 set = Sizzle.filter( ret.expr, ret.set ); | |
| 1472 | |
| 1473 if ( parts.length > 0 ) { | |
| 1474 checkSet = makeArray(set); | |
| 1475 } else { | |
| 1476 prune = false; | |
| 1477 } | |
| 1478 | |
| 1479 while ( parts.length ) { | |
| 1480 var cur = parts.pop(), pop = cur; | |
| 1481 | |
| 1482 if ( !Expr.relative[ cur ] ) { | |
| 1483 cur = ""; | |
| 1484 } else { | |
| 1485 pop = parts.pop(); | |
| 1486 } | |
| 1487 | |
| 1488 if ( pop == null ) { | |
| 1489 pop = context; | |
| 1490 } | |
| 1491 | |
| 1492 Expr.relative[ cur ]( checkSet, pop, isXML(context) ); | |
| 1493 } | |
| 1494 } | |
| 1495 | |
| 1496 if ( !checkSet ) { | |
| 1497 checkSet = set; | |
| 1498 } | |
| 1499 | |
| 1500 if ( !checkSet ) { | |
| 1501 throw "Syntax error, unrecognized expression: " + (cur || select
or); | |
| 1502 } | |
| 1503 | |
| 1504 if ( toString.call(checkSet) === "[object Array]" ) { | |
| 1505 if ( !prune ) { | |
| 1506 results.push.apply( results, checkSet ); | |
| 1507 } else if ( context.nodeType === 1 ) { | |
| 1508 for ( var i = 0; checkSet[i] != null; i++ ) { | |
| 1509 if ( checkSet[i] && (checkSet[i] === true || che
ckSet[i].nodeType === 1 && contains(context, checkSet[i])) ) { | |
| 1510 results.push( set[i] ); | |
| 1511 } | |
| 1512 } | |
| 1513 } else { | |
| 1514 for ( var i = 0; checkSet[i] != null; i++ ) { | |
| 1515 if ( checkSet[i] && checkSet[i].nodeType === 1 )
{ | |
| 1516 results.push( set[i] ); | |
| 1517 } | |
| 1518 } | |
| 1519 } | |
| 1520 } else { | |
| 1521 makeArray( checkSet, results ); | |
| 1522 } | |
| 1523 | |
| 1524 if ( extra ) { | |
| 1525 Sizzle( extra, context, results, seed ); | |
| 1526 | |
| 1527 if ( sortOrder ) { | |
| 1528 hasDuplicate = false; | |
| 1529 results.sort(sortOrder); | |
| 1530 | |
| 1531 if ( hasDuplicate ) { | |
| 1532 for ( var i = 1; i < results.length; i++ ) { | |
| 1533 if ( results[i] === results[i-1] ) { | |
| 1534 results.splice(i--, 1); | |
| 1535 } | |
| 1536 } | |
| 1537 } | |
| 1538 } | |
| 1539 } | |
| 1540 | |
| 1541 return results; | |
| 1542 }; | |
| 1543 | |
| 1544 Sizzle.matches = function(expr, set){ | |
| 1545 return Sizzle(expr, null, null, set); | |
| 1546 }; | |
| 1547 | |
| 1548 Sizzle.find = function(expr, context, isXML){ | |
| 1549 var set, match; | |
| 1550 | |
| 1551 if ( !expr ) { | |
| 1552 return []; | |
| 1553 } | |
| 1554 | |
| 1555 for ( var i = 0, l = Expr.order.length; i < l; i++ ) { | |
| 1556 var type = Expr.order[i], match; | |
| 1557 | |
| 1558 if ( (match = Expr.match[ type ].exec( expr )) ) { | |
| 1559 var left = RegExp.leftContext; | |
| 1560 | |
| 1561 if ( left.substr( left.length - 1 ) !== "\\" ) { | |
| 1562 match[1] = (match[1] || "").replace(/\\/g, ""); | |
| 1563 set = Expr.find[ type ]( match, context, isXML )
; | |
| 1564 if ( set != null ) { | |
| 1565 expr = expr.replace( Expr.match[ type ],
"" ); | |
| 1566 break; | |
| 1567 } | |
| 1568 } | |
| 1569 } | |
| 1570 } | |
| 1571 | |
| 1572 if ( !set ) { | |
| 1573 set = context.getElementsByTagName("*"); | |
| 1574 } | |
| 1575 | |
| 1576 return {set: set, expr: expr}; | |
| 1577 }; | |
| 1578 | |
| 1579 Sizzle.filter = function(expr, set, inplace, not){ | |
| 1580 var old = expr, result = [], curLoop = set, match, anyFound, | |
| 1581 isXMLFilter = set && set[0] && isXML(set[0]); | |
| 1582 | |
| 1583 while ( expr && set.length ) { | |
| 1584 for ( var type in Expr.filter ) { | |
| 1585 if ( (match = Expr.match[ type ].exec( expr )) != null )
{ | |
| 1586 var filter = Expr.filter[ type ], found, item; | |
| 1587 anyFound = false; | |
| 1588 | |
| 1589 if ( curLoop == result ) { | |
| 1590 result = []; | |
| 1591 } | |
| 1592 | |
| 1593 if ( Expr.preFilter[ type ] ) { | |
| 1594 match = Expr.preFilter[ type ]( match, c
urLoop, inplace, result, not, isXMLFilter ); | |
| 1595 | |
| 1596 if ( !match ) { | |
| 1597 anyFound = found = true; | |
| 1598 } else if ( match === true ) { | |
| 1599 continue; | |
| 1600 } | |
| 1601 } | |
| 1602 | |
| 1603 if ( match ) { | |
| 1604 for ( var i = 0; (item = curLoop[i]) !=
null; i++ ) { | |
| 1605 if ( item ) { | |
| 1606 found = filter( item, ma
tch, i, curLoop ); | |
| 1607 var pass = not ^ !!found
; | |
| 1608 | |
| 1609 if ( inplace && found !=
null ) { | |
| 1610 if ( pass ) { | |
| 1611 anyFound
= true; | |
| 1612 } else { | |
| 1613 curLoop[
i] = false; | |
| 1614 } | |
| 1615 } else if ( pass ) { | |
| 1616 result.push( ite
m ); | |
| 1617 anyFound = true; | |
| 1618 } | |
| 1619 } | |
| 1620 } | |
| 1621 } | |
| 1622 | |
| 1623 if ( found !== undefined ) { | |
| 1624 if ( !inplace ) { | |
| 1625 curLoop = result; | |
| 1626 } | |
| 1627 | |
| 1628 expr = expr.replace( Expr.match[ type ],
"" ); | |
| 1629 | |
| 1630 if ( !anyFound ) { | |
| 1631 return []; | |
| 1632 } | |
| 1633 | |
| 1634 break; | |
| 1635 } | |
| 1636 } | |
| 1637 } | |
| 1638 | |
| 1639 // Improper expression | |
| 1640 if ( expr == old ) { | |
| 1641 if ( anyFound == null ) { | |
| 1642 throw "Syntax error, unrecognized expression: "
+ expr; | |
| 1643 } else { | |
| 1644 break; | |
| 1645 } | |
| 1646 } | |
| 1647 | |
| 1648 old = expr; | |
| 1649 } | |
| 1650 | |
| 1651 return curLoop; | |
| 1652 }; | |
| 1653 | |
| 1654 var Expr = Sizzle.selectors = { | |
| 1655 order: [ "ID", "NAME", "TAG" ], | |
| 1656 match: { | |
| 1657 ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/, | |
| 1658 CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/, | |
| 1659 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/, | |
| 1660 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)
(.*?)\3|)\s*\]/, | |
| 1661 TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/, | |
| 1662 CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?
/, | |
| 1663 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$
)/, | |
| 1664 PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+
\)|[^\2\(\)]*)+)\2\))?/ | |
| 1665 }, | |
| 1666 attrMap: { | |
| 1667 "class": "className", | |
| 1668 "for": "htmlFor" | |
| 1669 }, | |
| 1670 attrHandle: { | |
| 1671 href: function(elem){ | |
| 1672 return elem.getAttribute("href"); | |
| 1673 } | |
| 1674 }, | |
| 1675 relative: { | |
| 1676 "+": function(checkSet, part, isXML){ | |
| 1677 var isPartStr = typeof part === "string", | |
| 1678 isTag = isPartStr && !/\W/.test(part), | |
| 1679 isPartStrNotTag = isPartStr && !isTag; | |
| 1680 | |
| 1681 if ( isTag && !isXML ) { | |
| 1682 part = part.toUpperCase(); | |
| 1683 } | |
| 1684 | |
| 1685 for ( var i = 0, l = checkSet.length, elem; i < l; i++ )
{ | |
| 1686 if ( (elem = checkSet[i]) ) { | |
| 1687 while ( (elem = elem.previousSibling) &&
elem.nodeType !== 1 ) {} | |
| 1688 | |
| 1689 checkSet[i] = isPartStrNotTag || elem &&
elem.nodeName === part ? | |
| 1690 elem || false : | |
| 1691 elem === part; | |
| 1692 } | |
| 1693 } | |
| 1694 | |
| 1695 if ( isPartStrNotTag ) { | |
| 1696 Sizzle.filter( part, checkSet, true ); | |
| 1697 } | |
| 1698 }, | |
| 1699 ">": function(checkSet, part, isXML){ | |
| 1700 var isPartStr = typeof part === "string"; | |
| 1701 | |
| 1702 if ( isPartStr && !/\W/.test(part) ) { | |
| 1703 part = isXML ? part : part.toUpperCase(); | |
| 1704 | |
| 1705 for ( var i = 0, l = checkSet.length; i < l; i++
) { | |
| 1706 var elem = checkSet[i]; | |
| 1707 if ( elem ) { | |
| 1708 var parent = elem.parentNode; | |
| 1709 checkSet[i] = parent.nodeName ==
= part ? parent : false; | |
| 1710 } | |
| 1711 } | |
| 1712 } else { | |
| 1713 for ( var i = 0, l = checkSet.length; i < l; i++
) { | |
| 1714 var elem = checkSet[i]; | |
| 1715 if ( elem ) { | |
| 1716 checkSet[i] = isPartStr ? | |
| 1717 elem.parentNode : | |
| 1718 elem.parentNode === part
; | |
| 1719 } | |
| 1720 } | |
| 1721 | |
| 1722 if ( isPartStr ) { | |
| 1723 Sizzle.filter( part, checkSet, true ); | |
| 1724 } | |
| 1725 } | |
| 1726 }, | |
| 1727 "": function(checkSet, part, isXML){ | |
| 1728 var doneName = done++, checkFn = dirCheck; | |
| 1729 | |
| 1730 if ( !part.match(/\W/) ) { | |
| 1731 var nodeCheck = part = isXML ? part : part.toUpp
erCase(); | |
| 1732 checkFn = dirNodeCheck; | |
| 1733 } | |
| 1734 | |
| 1735 checkFn("parentNode", part, doneName, checkSet, nodeChec
k, isXML); | |
| 1736 }, | |
| 1737 "~": function(checkSet, part, isXML){ | |
| 1738 var doneName = done++, checkFn = dirCheck; | |
| 1739 | |
| 1740 if ( typeof part === "string" && !part.match(/\W/) ) { | |
| 1741 var nodeCheck = part = isXML ? part : part.toUpp
erCase(); | |
| 1742 checkFn = dirNodeCheck; | |
| 1743 } | |
| 1744 | |
| 1745 checkFn("previousSibling", part, doneName, checkSet, nod
eCheck, isXML); | |
| 1746 } | |
| 1747 }, | |
| 1748 find: { | |
| 1749 ID: function(match, context, isXML){ | |
| 1750 if ( typeof context.getElementById !== "undefined" && !i
sXML ) { | |
| 1751 var m = context.getElementById(match[1]); | |
| 1752 return m ? [m] : []; | |
| 1753 } | |
| 1754 }, | |
| 1755 NAME: function(match, context, isXML){ | |
| 1756 if ( typeof context.getElementsByName !== "undefined" )
{ | |
| 1757 var ret = [], results = context.getElementsByNam
e(match[1]); | |
| 1758 | |
| 1759 for ( var i = 0, l = results.length; i < l; i++
) { | |
| 1760 if ( results[i].getAttribute("name") ===
match[1] ) { | |
| 1761 ret.push( results[i] ); | |
| 1762 } | |
| 1763 } | |
| 1764 | |
| 1765 return ret.length === 0 ? null : ret; | |
| 1766 } | |
| 1767 }, | |
| 1768 TAG: function(match, context){ | |
| 1769 return context.getElementsByTagName(match[1]); | |
| 1770 } | |
| 1771 }, | |
| 1772 preFilter: { | |
| 1773 CLASS: function(match, curLoop, inplace, result, not, isXML){ | |
| 1774 match = " " + match[1].replace(/\\/g, "") + " "; | |
| 1775 | |
| 1776 if ( isXML ) { | |
| 1777 return match; | |
| 1778 } | |
| 1779 | |
| 1780 for ( var i = 0, elem; (elem = curLoop[i]) != null; i++
) { | |
| 1781 if ( elem ) { | |
| 1782 if ( not ^ (elem.className && (" " + ele
m.className + " ").indexOf(match) >= 0) ) { | |
| 1783 if ( !inplace ) | |
| 1784 result.push( elem ); | |
| 1785 } else if ( inplace ) { | |
| 1786 curLoop[i] = false; | |
| 1787 } | |
| 1788 } | |
| 1789 } | |
| 1790 | |
| 1791 return false; | |
| 1792 }, | |
| 1793 ID: function(match){ | |
| 1794 return match[1].replace(/\\/g, ""); | |
| 1795 }, | |
| 1796 TAG: function(match, curLoop){ | |
| 1797 for ( var i = 0; curLoop[i] === false; i++ ){} | |
| 1798 return curLoop[i] && isXML(curLoop[i]) ? match[1] : matc
h[1].toUpperCase(); | |
| 1799 }, | |
| 1800 CHILD: function(match){ | |
| 1801 if ( match[1] == "nth" ) { | |
| 1802 // parse equations like 'even', 'odd', '5', '2n'
, '3n+2', '4n-1', '-n+6' | |
| 1803 var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec( | |
| 1804 match[2] == "even" && "2n" || match[2] =
= "odd" && "2n+1" || | |
| 1805 !/\D/.test( match[2] ) && "0n+" + match[
2] || match[2]); | |
| 1806 | |
| 1807 // calculate the numbers (first)n+(last) includi
ng if they are negative | |
| 1808 match[2] = (test[1] + (test[2] || 1)) - 0; | |
| 1809 match[3] = test[3] - 0; | |
| 1810 } | |
| 1811 | |
| 1812 // TODO: Move to normal caching system | |
| 1813 match[0] = done++; | |
| 1814 | |
| 1815 return match; | |
| 1816 }, | |
| 1817 ATTR: function(match, curLoop, inplace, result, not, isXML){ | |
| 1818 var name = match[1].replace(/\\/g, ""); | |
| 1819 | |
| 1820 if ( !isXML && Expr.attrMap[name] ) { | |
| 1821 match[1] = Expr.attrMap[name]; | |
| 1822 } | |
| 1823 | |
| 1824 if ( match[2] === "~=" ) { | |
| 1825 match[4] = " " + match[4] + " "; | |
| 1826 } | |
| 1827 | |
| 1828 return match; | |
| 1829 }, | |
| 1830 PSEUDO: function(match, curLoop, inplace, result, not){ | |
| 1831 if ( match[1] === "not" ) { | |
| 1832 // If we're dealing with a complex expression, o
r a simple one | |
| 1833 if ( match[3].match(chunker).length > 1 || /^\w/
.test(match[3]) ) { | |
| 1834 match[3] = Sizzle(match[3], null, null,
curLoop); | |
| 1835 } else { | |
| 1836 var ret = Sizzle.filter(match[3], curLoo
p, inplace, true ^ not); | |
| 1837 if ( !inplace ) { | |
| 1838 result.push.apply( result, ret )
; | |
| 1839 } | |
| 1840 return false; | |
| 1841 } | |
| 1842 } else if ( Expr.match.POS.test( match[0] ) || Expr.matc
h.CHILD.test( match[0] ) ) { | |
| 1843 return true; | |
| 1844 } | |
| 1845 | |
| 1846 return match; | |
| 1847 }, | |
| 1848 POS: function(match){ | |
| 1849 match.unshift( true ); | |
| 1850 return match; | |
| 1851 } | |
| 1852 }, | |
| 1853 filters: { | |
| 1854 enabled: function(elem){ | |
| 1855 return elem.disabled === false && elem.type !== "hidden"
; | |
| 1856 }, | |
| 1857 disabled: function(elem){ | |
| 1858 return elem.disabled === true; | |
| 1859 }, | |
| 1860 checked: function(elem){ | |
| 1861 return elem.checked === true; | |
| 1862 }, | |
| 1863 selected: function(elem){ | |
| 1864 // Accessing this property makes selected-by-default | |
| 1865 // options in Safari work properly | |
| 1866 elem.parentNode.selectedIndex; | |
| 1867 return elem.selected === true; | |
| 1868 }, | |
| 1869 parent: function(elem){ | |
| 1870 return !!elem.firstChild; | |
| 1871 }, | |
| 1872 empty: function(elem){ | |
| 1873 return !elem.firstChild; | |
| 1874 }, | |
| 1875 has: function(elem, i, match){ | |
| 1876 return !!Sizzle( match[3], elem ).length; | |
| 1877 }, | |
| 1878 header: function(elem){ | |
| 1879 return /h\d/i.test( elem.nodeName ); | |
| 1880 }, | |
| 1881 text: function(elem){ | |
| 1882 return "text" === elem.type; | |
| 1883 }, | |
| 1884 radio: function(elem){ | |
| 1885 return "radio" === elem.type; | |
| 1886 }, | |
| 1887 checkbox: function(elem){ | |
| 1888 return "checkbox" === elem.type; | |
| 1889 }, | |
| 1890 file: function(elem){ | |
| 1891 return "file" === elem.type; | |
| 1892 }, | |
| 1893 password: function(elem){ | |
| 1894 return "password" === elem.type; | |
| 1895 }, | |
| 1896 submit: function(elem){ | |
| 1897 return "submit" === elem.type; | |
| 1898 }, | |
| 1899 image: function(elem){ | |
| 1900 return "image" === elem.type; | |
| 1901 }, | |
| 1902 reset: function(elem){ | |
| 1903 return "reset" === elem.type; | |
| 1904 }, | |
| 1905 button: function(elem){ | |
| 1906 return "button" === elem.type || elem.nodeName.toUpperCa
se() === "BUTTON"; | |
| 1907 }, | |
| 1908 input: function(elem){ | |
| 1909 return /input|select|textarea|button/i.test(elem.nodeNam
e); | |
| 1910 } | |
| 1911 }, | |
| 1912 setFilters: { | |
| 1913 first: function(elem, i){ | |
| 1914 return i === 0; | |
| 1915 }, | |
| 1916 last: function(elem, i, match, array){ | |
| 1917 return i === array.length - 1; | |
| 1918 }, | |
| 1919 even: function(elem, i){ | |
| 1920 return i % 2 === 0; | |
| 1921 }, | |
| 1922 odd: function(elem, i){ | |
| 1923 return i % 2 === 1; | |
| 1924 }, | |
| 1925 lt: function(elem, i, match){ | |
| 1926 return i < match[3] - 0; | |
| 1927 }, | |
| 1928 gt: function(elem, i, match){ | |
| 1929 return i > match[3] - 0; | |
| 1930 }, | |
| 1931 nth: function(elem, i, match){ | |
| 1932 return match[3] - 0 == i; | |
| 1933 }, | |
| 1934 eq: function(elem, i, match){ | |
| 1935 return match[3] - 0 == i; | |
| 1936 } | |
| 1937 }, | |
| 1938 filter: { | |
| 1939 PSEUDO: function(elem, match, i, array){ | |
| 1940 var name = match[1], filter = Expr.filters[ name ]; | |
| 1941 | |
| 1942 if ( filter ) { | |
| 1943 return filter( elem, i, match, array ); | |
| 1944 } else if ( name === "contains" ) { | |
| 1945 return (elem.textContent || elem.innerText || ""
).indexOf(match[3]) >= 0; | |
| 1946 } else if ( name === "not" ) { | |
| 1947 var not = match[3]; | |
| 1948 | |
| 1949 for ( var i = 0, l = not.length; i < l; i++ ) { | |
| 1950 if ( not[i] === elem ) { | |
| 1951 return false; | |
| 1952 } | |
| 1953 } | |
| 1954 | |
| 1955 return true; | |
| 1956 } | |
| 1957 }, | |
| 1958 CHILD: function(elem, match){ | |
| 1959 var type = match[1], node = elem; | |
| 1960 switch (type) { | |
| 1961 case 'only': | |
| 1962 case 'first': | |
| 1963 while (node = node.previousSibling) { | |
| 1964 if ( node.nodeType === 1 ) retur
n false; | |
| 1965 } | |
| 1966 if ( type == 'first') return true; | |
| 1967 node = elem; | |
| 1968 case 'last': | |
| 1969 while (node = node.nextSibling) { | |
| 1970 if ( node.nodeType === 1 ) retur
n false; | |
| 1971 } | |
| 1972 return true; | |
| 1973 case 'nth': | |
| 1974 var first = match[2], last = match[3]; | |
| 1975 | |
| 1976 if ( first == 1 && last == 0 ) { | |
| 1977 return true; | |
| 1978 } | |
| 1979 | |
| 1980 var doneName = match[0], | |
| 1981 parent = elem.parentNode; | |
| 1982 | |
| 1983 if ( parent && (parent.sizcache !== done
Name || !elem.nodeIndex) ) { | |
| 1984 var count = 0; | |
| 1985 for ( node = parent.firstChild;
node; node = node.nextSibling ) { | |
| 1986 if ( node.nodeType === 1
) { | |
| 1987 node.nodeIndex =
++count; | |
| 1988 } | |
| 1989 } | |
| 1990 parent.sizcache = doneName; | |
| 1991 } | |
| 1992 | |
| 1993 var diff = elem.nodeIndex - last; | |
| 1994 if ( first == 0 ) { | |
| 1995 return diff == 0; | |
| 1996 } else { | |
| 1997 return ( diff % first == 0 && di
ff / first >= 0 ); | |
| 1998 } | |
| 1999 } | |
| 2000 }, | |
| 2001 ID: function(elem, match){ | |
| 2002 return elem.nodeType === 1 && elem.getAttribute("id") ==
= match; | |
| 2003 }, | |
| 2004 TAG: function(elem, match){ | |
| 2005 return (match === "*" && elem.nodeType === 1) || elem.no
deName === match; | |
| 2006 }, | |
| 2007 CLASS: function(elem, match){ | |
| 2008 return (" " + (elem.className || elem.getAttribute("clas
s")) + " ") | |
| 2009 .indexOf( match ) > -1; | |
| 2010 }, | |
| 2011 ATTR: function(elem, match){ | |
| 2012 var name = match[1], | |
| 2013 result = Expr.attrHandle[ name ] ? | |
| 2014 Expr.attrHandle[ name ]( elem ) : | |
| 2015 elem[ name ] != null ? | |
| 2016 elem[ name ] : | |
| 2017 elem.getAttribute( name ), | |
| 2018 value = result + "", | |
| 2019 type = match[2], | |
| 2020 check = match[4]; | |
| 2021 | |
| 2022 return result == null ? | |
| 2023 type === "!=" : | |
| 2024 type === "=" ? | |
| 2025 value === check : | |
| 2026 type === "*=" ? | |
| 2027 value.indexOf(check) >= 0 : | |
| 2028 type === "~=" ? | |
| 2029 (" " + value + " ").indexOf(check) >= 0 : | |
| 2030 !check ? | |
| 2031 value && result !== false : | |
| 2032 type === "!=" ? | |
| 2033 value != check : | |
| 2034 type === "^=" ? | |
| 2035 value.indexOf(check) === 0 : | |
| 2036 type === "$=" ? | |
| 2037 value.substr(value.length - check.length) === ch
eck : | |
| 2038 type === "|=" ? | |
| 2039 value === check || value.substr(0, check.length
+ 1) === check + "-" : | |
| 2040 false; | |
| 2041 }, | |
| 2042 POS: function(elem, match, i, array){ | |
| 2043 var name = match[2], filter = Expr.setFilters[ name ]; | |
| 2044 | |
| 2045 if ( filter ) { | |
| 2046 return filter( elem, i, match, array ); | |
| 2047 } | |
| 2048 } | |
| 2049 } | |
| 2050 }; | |
| 2051 | |
| 2052 var origPOS = Expr.match.POS; | |
| 2053 | |
| 2054 for ( var type in Expr.match ) { | |
| 2055 Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?
![^\(]*\))/.source ); | |
| 2056 } | |
| 2057 | |
| 2058 var makeArray = function(array, results) { | |
| 2059 array = Array.prototype.slice.call( array ); | |
| 2060 | |
| 2061 if ( results ) { | |
| 2062 results.push.apply( results, array ); | |
| 2063 return results; | |
| 2064 } | |
| 2065 | |
| 2066 return array; | |
| 2067 }; | |
| 2068 | |
| 2069 // Perform a simple check to determine if the browser is capable of | |
| 2070 // converting a NodeList to an array using builtin methods. | |
| 2071 try { | |
| 2072 Array.prototype.slice.call( document.documentElement.childNodes ); | |
| 2073 | |
| 2074 // Provide a fallback method if it does not work | |
| 2075 } catch(e){ | |
| 2076 makeArray = function(array, results) { | |
| 2077 var ret = results || []; | |
| 2078 | |
| 2079 if ( toString.call(array) === "[object Array]" ) { | |
| 2080 Array.prototype.push.apply( ret, array ); | |
| 2081 } else { | |
| 2082 if ( typeof array.length === "number" ) { | |
| 2083 for ( var i = 0, l = array.length; i < l; i++ )
{ | |
| 2084 ret.push( array[i] ); | |
| 2085 } | |
| 2086 } else { | |
| 2087 for ( var i = 0; array[i]; i++ ) { | |
| 2088 ret.push( array[i] ); | |
| 2089 } | |
| 2090 } | |
| 2091 } | |
| 2092 | |
| 2093 return ret; | |
| 2094 }; | |
| 2095 } | |
| 2096 | |
| 2097 var sortOrder; | |
| 2098 | |
| 2099 if ( document.documentElement.compareDocumentPosition ) { | |
| 2100 sortOrder = function( a, b ) { | |
| 2101 var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 :
1; | |
| 2102 if ( ret === 0 ) { | |
| 2103 hasDuplicate = true; | |
| 2104 } | |
| 2105 return ret; | |
| 2106 }; | |
| 2107 } else if ( "sourceIndex" in document.documentElement ) { | |
| 2108 sortOrder = function( a, b ) { | |
| 2109 var ret = a.sourceIndex - b.sourceIndex; | |
| 2110 if ( ret === 0 ) { | |
| 2111 hasDuplicate = true; | |
| 2112 } | |
| 2113 return ret; | |
| 2114 }; | |
| 2115 } else if ( document.createRange ) { | |
| 2116 sortOrder = function( a, b ) { | |
| 2117 var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocu
ment.createRange(); | |
| 2118 aRange.selectNode(a); | |
| 2119 aRange.collapse(true); | |
| 2120 bRange.selectNode(b); | |
| 2121 bRange.collapse(true); | |
| 2122 var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRang
e); | |
| 2123 if ( ret === 0 ) { | |
| 2124 hasDuplicate = true; | |
| 2125 } | |
| 2126 return ret; | |
| 2127 }; | |
| 2128 } | |
| 2129 | |
| 2130 // Check to see if the browser returns elements by name when | |
| 2131 // querying by getElementById (and provide a workaround) | |
| 2132 (function(){ | |
| 2133 // We're going to inject a fake input element with a specified name | |
| 2134 var form = document.createElement("form"), | |
| 2135 id = "script" + (new Date).getTime(); | |
| 2136 form.innerHTML = "<input name='" + id + "'/>"; | |
| 2137 | |
| 2138 // Inject it into the root element, check its status, and remove it quic
kly | |
| 2139 var root = document.documentElement; | |
| 2140 root.insertBefore( form, root.firstChild ); | |
| 2141 | |
| 2142 // The workaround has to do additional checks after a getElementById | |
| 2143 // Which slows things down for other browsers (hence the branching) | |
| 2144 if ( !!document.getElementById( id ) ) { | |
| 2145 Expr.find.ID = function(match, context, isXML){ | |
| 2146 if ( typeof context.getElementById !== "undefined" && !i
sXML ) { | |
| 2147 var m = context.getElementById(match[1]); | |
| 2148 return m ? m.id === match[1] || typeof m.getAttr
ibuteNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [
m] : undefined : []; | |
| 2149 } | |
| 2150 }; | |
| 2151 | |
| 2152 Expr.filter.ID = function(elem, match){ | |
| 2153 var node = typeof elem.getAttributeNode !== "undefined"
&& elem.getAttributeNode("id"); | |
| 2154 return elem.nodeType === 1 && node && node.nodeValue ===
match; | |
| 2155 }; | |
| 2156 } | |
| 2157 | |
| 2158 root.removeChild( form ); | |
| 2159 })(); | |
| 2160 | |
| 2161 (function(){ | |
| 2162 // Check to see if the browser returns only elements | |
| 2163 // when doing getElementsByTagName("*") | |
| 2164 | |
| 2165 // Create a fake element | |
| 2166 var div = document.createElement("div"); | |
| 2167 div.appendChild( document.createComment("") ); | |
| 2168 | |
| 2169 // Make sure no comments are found | |
| 2170 if ( div.getElementsByTagName("*").length > 0 ) { | |
| 2171 Expr.find.TAG = function(match, context){ | |
| 2172 var results = context.getElementsByTagName(match[1]); | |
| 2173 | |
| 2174 // Filter out possible comments | |
| 2175 if ( match[1] === "*" ) { | |
| 2176 var tmp = []; | |
| 2177 | |
| 2178 for ( var i = 0; results[i]; i++ ) { | |
| 2179 if ( results[i].nodeType === 1 ) { | |
| 2180 tmp.push( results[i] ); | |
| 2181 } | |
| 2182 } | |
| 2183 | |
| 2184 results = tmp; | |
| 2185 } | |
| 2186 | |
| 2187 return results; | |
| 2188 }; | |
| 2189 } | |
| 2190 | |
| 2191 // Check to see if an attribute returns normalized href attributes | |
| 2192 div.innerHTML = "<a href='#'></a>"; | |
| 2193 if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined
" && | |
| 2194 div.firstChild.getAttribute("href") !== "#" ) { | |
| 2195 Expr.attrHandle.href = function(elem){ | |
| 2196 return elem.getAttribute("href", 2); | |
| 2197 }; | |
| 2198 } | |
| 2199 })(); | |
| 2200 | |
| 2201 if ( document.querySelectorAll ) (function(){ | |
| 2202 var oldSizzle = Sizzle, div = document.createElement("div"); | |
| 2203 div.innerHTML = "<p class='TEST'></p>"; | |
| 2204 | |
| 2205 // Safari can't handle uppercase or unicode characters when | |
| 2206 // in quirks mode. | |
| 2207 if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0
) { | |
| 2208 return; | |
| 2209 } | |
| 2210 | |
| 2211 Sizzle = function(query, context, extra, seed){ | |
| 2212 context = context || document; | |
| 2213 | |
| 2214 // Only use querySelectorAll on non-XML documents | |
| 2215 // (ID selectors don't work in non-HTML documents) | |
| 2216 if ( !seed && context.nodeType === 9 && !isXML(context) ) { | |
| 2217 try { | |
| 2218 return makeArray( context.querySelectorAll(query
), extra ); | |
| 2219 } catch(e){} | |
| 2220 } | |
| 2221 | |
| 2222 return oldSizzle(query, context, extra, seed); | |
| 2223 }; | |
| 2224 | |
| 2225 Sizzle.find = oldSizzle.find; | |
| 2226 Sizzle.filter = oldSizzle.filter; | |
| 2227 Sizzle.selectors = oldSizzle.selectors; | |
| 2228 Sizzle.matches = oldSizzle.matches; | |
| 2229 })(); | |
| 2230 | |
| 2231 if ( document.getElementsByClassName && document.documentElement.getElementsByCl
assName ) (function(){ | |
| 2232 var div = document.createElement("div"); | |
| 2233 div.innerHTML = "<div class='test e'></div><div class='test'></div>"; | |
| 2234 | |
| 2235 // Opera can't find a second classname (in 9.6) | |
| 2236 if ( div.getElementsByClassName("e").length === 0 ) | |
| 2237 return; | |
| 2238 | |
| 2239 // Safari caches class attributes, doesn't catch changes (in 3.2) | |
| 2240 div.lastChild.className = "e"; | |
| 2241 | |
| 2242 if ( div.getElementsByClassName("e").length === 1 ) | |
| 2243 return; | |
| 2244 | |
| 2245 Expr.order.splice(1, 0, "CLASS"); | |
| 2246 Expr.find.CLASS = function(match, context, isXML) { | |
| 2247 if ( typeof context.getElementsByClassName !== "undefined" && !i
sXML ) { | |
| 2248 return context.getElementsByClassName(match[1]); | |
| 2249 } | |
| 2250 }; | |
| 2251 })(); | |
| 2252 | |
| 2253 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { | |
| 2254 var sibDir = dir == "previousSibling" && !isXML; | |
| 2255 for ( var i = 0, l = checkSet.length; i < l; i++ ) { | |
| 2256 var elem = checkSet[i]; | |
| 2257 if ( elem ) { | |
| 2258 if ( sibDir && elem.nodeType === 1 ){ | |
| 2259 elem.sizcache = doneName; | |
| 2260 elem.sizset = i; | |
| 2261 } | |
| 2262 elem = elem[dir]; | |
| 2263 var match = false; | |
| 2264 | |
| 2265 while ( elem ) { | |
| 2266 if ( elem.sizcache === doneName ) { | |
| 2267 match = checkSet[elem.sizset]; | |
| 2268 break; | |
| 2269 } | |
| 2270 | |
| 2271 if ( elem.nodeType === 1 && !isXML ){ | |
| 2272 elem.sizcache = doneName; | |
| 2273 elem.sizset = i; | |
| 2274 } | |
| 2275 | |
| 2276 if ( elem.nodeName === cur ) { | |
| 2277 match = elem; | |
| 2278 break; | |
| 2279 } | |
| 2280 | |
| 2281 elem = elem[dir]; | |
| 2282 } | |
| 2283 | |
| 2284 checkSet[i] = match; | |
| 2285 } | |
| 2286 } | |
| 2287 } | |
| 2288 | |
| 2289 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) { | |
| 2290 var sibDir = dir == "previousSibling" && !isXML; | |
| 2291 for ( var i = 0, l = checkSet.length; i < l; i++ ) { | |
| 2292 var elem = checkSet[i]; | |
| 2293 if ( elem ) { | |
| 2294 if ( sibDir && elem.nodeType === 1 ) { | |
| 2295 elem.sizcache = doneName; | |
| 2296 elem.sizset = i; | |
| 2297 } | |
| 2298 elem = elem[dir]; | |
| 2299 var match = false; | |
| 2300 | |
| 2301 while ( elem ) { | |
| 2302 if ( elem.sizcache === doneName ) { | |
| 2303 match = checkSet[elem.sizset]; | |
| 2304 break; | |
| 2305 } | |
| 2306 | |
| 2307 if ( elem.nodeType === 1 ) { | |
| 2308 if ( !isXML ) { | |
| 2309 elem.sizcache = doneName; | |
| 2310 elem.sizset = i; | |
| 2311 } | |
| 2312 if ( typeof cur !== "string" ) { | |
| 2313 if ( elem === cur ) { | |
| 2314 match = true; | |
| 2315 break; | |
| 2316 } | |
| 2317 | |
| 2318 } else if ( Sizzle.filter( cur, [elem] )
.length > 0 ) { | |
| 2319 match = elem; | |
| 2320 break; | |
| 2321 } | |
| 2322 } | |
| 2323 | |
| 2324 elem = elem[dir]; | |
| 2325 } | |
| 2326 | |
| 2327 checkSet[i] = match; | |
| 2328 } | |
| 2329 } | |
| 2330 } | |
| 2331 | |
| 2332 var contains = document.compareDocumentPosition ? function(a, b){ | |
| 2333 return a.compareDocumentPosition(b) & 16; | |
| 2334 } : function(a, b){ | |
| 2335 return a !== b && (a.contains ? a.contains(b) : true); | |
| 2336 }; | |
| 2337 | |
| 2338 var isXML = function(elem){ | |
| 2339 return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" |
| | |
| 2340 !!elem.ownerDocument && isXML( elem.ownerDocument ); | |
| 2341 }; | |
| 2342 | |
| 2343 var posProcess = function(selector, context){ | |
| 2344 var tmpSet = [], later = "", match, | |
| 2345 root = context.nodeType ? [context] : context; | |
| 2346 | |
| 2347 // Position selectors must be done after the filter | |
| 2348 // And so must :not(positional) so we move all PSEUDOs to the end | |
| 2349 while ( (match = Expr.match.PSEUDO.exec( selector )) ) { | |
| 2350 later += match[0]; | |
| 2351 selector = selector.replace( Expr.match.PSEUDO, "" ); | |
| 2352 } | |
| 2353 | |
| 2354 selector = Expr.relative[selector] ? selector + "*" : selector; | |
| 2355 | |
| 2356 for ( var i = 0, l = root.length; i < l; i++ ) { | |
| 2357 Sizzle( selector, root[i], tmpSet ); | |
| 2358 } | |
| 2359 | |
| 2360 return Sizzle.filter( later, tmpSet ); | |
| 2361 }; | |
| 2362 | |
| 2363 // EXPOSE | |
| 2364 jQuery.find = Sizzle; | |
| 2365 jQuery.filter = Sizzle.filter; | |
| 2366 jQuery.expr = Sizzle.selectors; | |
| 2367 jQuery.expr[":"] = jQuery.expr.filters; | |
| 2368 | |
| 2369 Sizzle.selectors.filters.hidden = function(elem){ | |
| 2370 return elem.offsetWidth === 0 || elem.offsetHeight === 0; | |
| 2371 }; | |
| 2372 | |
| 2373 Sizzle.selectors.filters.visible = function(elem){ | |
| 2374 return elem.offsetWidth > 0 || elem.offsetHeight > 0; | |
| 2375 }; | |
| 2376 | |
| 2377 Sizzle.selectors.filters.animated = function(elem){ | |
| 2378 return jQuery.grep(jQuery.timers, function(fn){ | |
| 2379 return elem === fn.elem; | |
| 2380 }).length; | |
| 2381 }; | |
| 2382 | |
| 2383 jQuery.multiFilter = function( expr, elems, not ) { | |
| 2384 if ( not ) { | |
| 2385 expr = ":not(" + expr + ")"; | |
| 2386 } | |
| 2387 | |
| 2388 return Sizzle.matches(expr, elems); | |
| 2389 }; | |
| 2390 | |
| 2391 jQuery.dir = function( elem, dir ){ | |
| 2392 var matched = [], cur = elem[dir]; | |
| 2393 while ( cur && cur != document ) { | |
| 2394 if ( cur.nodeType == 1 ) | |
| 2395 matched.push( cur ); | |
| 2396 cur = cur[dir]; | |
| 2397 } | |
| 2398 return matched; | |
| 2399 }; | |
| 2400 | |
| 2401 jQuery.nth = function(cur, result, dir, elem){ | |
| 2402 result = result || 1; | |
| 2403 var num = 0; | |
| 2404 | |
| 2405 for ( ; cur; cur = cur[dir] ) | |
| 2406 if ( cur.nodeType == 1 && ++num == result ) | |
| 2407 break; | |
| 2408 | |
| 2409 return cur; | |
| 2410 }; | |
| 2411 | |
| 2412 jQuery.sibling = function(n, elem){ | |
| 2413 var r = []; | |
| 2414 | |
| 2415 for ( ; n; n = n.nextSibling ) { | |
| 2416 if ( n.nodeType == 1 && n != elem ) | |
| 2417 r.push( n ); | |
| 2418 } | |
| 2419 | |
| 2420 return r; | |
| 2421 }; | |
| 2422 | |
| 2423 return; | |
| 2424 | |
| 2425 window.Sizzle = Sizzle; | |
| 2426 | |
| 2427 })(); | |
| 2428 /* | |
| 2429 * A number of helper functions used for managing events. | |
| 2430 * Many of the ideas behind this code originated from | |
| 2431 * Dean Edwards' addEvent library. | |
| 2432 */ | |
| 2433 jQuery.event = { | |
| 2434 | |
| 2435 // Bind an event to an element | |
| 2436 // Original by Dean Edwards | |
| 2437 add: function(elem, types, handler, data) { | |
| 2438 if ( elem.nodeType == 3 || elem.nodeType == 8 ) | |
| 2439 return; | |
| 2440 | |
| 2441 // For whatever reason, IE has trouble passing the window object | |
| 2442 // around, causing it to be cloned in the process | |
| 2443 if ( elem.setInterval && elem != window ) | |
| 2444 elem = window; | |
| 2445 | |
| 2446 // Make sure that the function being executed has a unique ID | |
| 2447 if ( !handler.guid ) | |
| 2448 handler.guid = this.guid++; | |
| 2449 | |
| 2450 // if data is passed, bind to handler | |
| 2451 if ( data !== undefined ) { | |
| 2452 // Create temporary function pointer to original handler | |
| 2453 var fn = handler; | |
| 2454 | |
| 2455 // Create unique handler function, wrapped around origin
al handler | |
| 2456 handler = this.proxy( fn ); | |
| 2457 | |
| 2458 // Store data in unique handler | |
| 2459 handler.data = data; | |
| 2460 } | |
| 2461 | |
| 2462 // Init the element's event structure | |
| 2463 var events = jQuery.data(elem, "events") || jQuery.data(elem, "e
vents", {}), | |
| 2464 handle = jQuery.data(elem, "handle") || jQuery.data(elem
, "handle", function(){ | |
| 2465 // Handle the second event of a trigger and when | |
| 2466 // an event is called after a page has unloaded | |
| 2467 return typeof jQuery !== "undefined" && !jQuery.
event.triggered ? | |
| 2468 jQuery.event.handle.apply(arguments.call
ee.elem, arguments) : | |
| 2469 undefined; | |
| 2470 }); | |
| 2471 // Add elem as a property of the handle function | |
| 2472 // This is to prevent a memory leak with non-native | |
| 2473 // event in IE. | |
| 2474 handle.elem = elem; | |
| 2475 | |
| 2476 // Handle multiple events separated by a space | |
| 2477 // jQuery(...).bind("mouseover mouseout", fn); | |
| 2478 jQuery.each(types.split(/\s+/), function(index, type) { | |
| 2479 // Namespaced event handlers | |
| 2480 var namespaces = type.split("."); | |
| 2481 type = namespaces.shift(); | |
| 2482 handler.type = namespaces.slice().sort().join("."); | |
| 2483 | |
| 2484 // Get the current list of functions bound to this event | |
| 2485 var handlers = events[type]; | |
| 2486 | |
| 2487 if ( jQuery.event.specialAll[type] ) | |
| 2488 jQuery.event.specialAll[type].setup.call(elem, d
ata, namespaces); | |
| 2489 | |
| 2490 // Init the event handler queue | |
| 2491 if (!handlers) { | |
| 2492 handlers = events[type] = {}; | |
| 2493 | |
| 2494 // Check for a special event handler | |
| 2495 // Only use addEventListener/attachEvent if the
special | |
| 2496 // events handler returns false | |
| 2497 if ( !jQuery.event.special[type] || jQuery.event
.special[type].setup.call(elem, data, namespaces) === false ) { | |
| 2498 // Bind the global event handler to the
element | |
| 2499 if (elem.addEventListener) | |
| 2500 elem.addEventListener(type, hand
le, false); | |
| 2501 else if (elem.attachEvent) | |
| 2502 elem.attachEvent("on" + type, ha
ndle); | |
| 2503 } | |
| 2504 } | |
| 2505 | |
| 2506 // Add the function to the element's handler list | |
| 2507 handlers[handler.guid] = handler; | |
| 2508 | |
| 2509 // Keep track of which events have been used, for global
triggering | |
| 2510 jQuery.event.global[type] = true; | |
| 2511 }); | |
| 2512 | |
| 2513 // Nullify elem to prevent memory leaks in IE | |
| 2514 elem = null; | |
| 2515 }, | |
| 2516 | |
| 2517 guid: 1, | |
| 2518 global: {}, | |
| 2519 | |
| 2520 // Detach an event or set of events from an element | |
| 2521 remove: function(elem, types, handler) { | |
| 2522 // don't do events on text and comment nodes | |
| 2523 if ( elem.nodeType == 3 || elem.nodeType == 8 ) | |
| 2524 return; | |
| 2525 | |
| 2526 var events = jQuery.data(elem, "events"), ret, index; | |
| 2527 | |
| 2528 if ( events ) { | |
| 2529 // Unbind all events for the element | |
| 2530 if ( types === undefined || (typeof types === "string" &
& types.charAt(0) == ".") ) | |
| 2531 for ( var type in events ) | |
| 2532 this.remove( elem, type + (types || "")
); | |
| 2533 else { | |
| 2534 // types is actually an event object here | |
| 2535 if ( types.type ) { | |
| 2536 handler = types.handler; | |
| 2537 types = types.type; | |
| 2538 } | |
| 2539 | |
| 2540 // Handle multiple events seperated by a space | |
| 2541 // jQuery(...).unbind("mouseover mouseout", fn); | |
| 2542 jQuery.each(types.split(/\s+/), function(index,
type){ | |
| 2543 // Namespaced event handlers | |
| 2544 var namespaces = type.split("."); | |
| 2545 type = namespaces.shift(); | |
| 2546 var namespace = RegExp("(^|\\.)" + names
paces.slice().sort().join(".*\\.") + "(\\.|$)"); | |
| 2547 | |
| 2548 if ( events[type] ) { | |
| 2549 // remove the given handler for
the given type | |
| 2550 if ( handler ) | |
| 2551 delete events[type][hand
ler.guid]; | |
| 2552 | |
| 2553 // remove all handlers for the g
iven type | |
| 2554 else | |
| 2555 for ( var handle in even
ts[type] ) | |
| 2556 // Handle the re
moval of namespaced events | |
| 2557 if ( namespace.t
est(events[type][handle].type) ) | |
| 2558 delete e
vents[type][handle]; | |
| 2559 | |
| 2560 if ( jQuery.event.specialAll[typ
e] ) | |
| 2561 jQuery.event.specialAll[
type].teardown.call(elem, namespaces); | |
| 2562 | |
| 2563 // remove generic event handler
if no more handlers exist | |
| 2564 for ( ret in events[type] ) brea
k; | |
| 2565 if ( !ret ) { | |
| 2566 if ( !jQuery.event.speci
al[type] || jQuery.event.special[type].teardown.call(elem, namespaces) === false
) { | |
| 2567 if (elem.removeE
ventListener) | |
| 2568 elem.rem
oveEventListener(type, jQuery.data(elem, "handle"), false); | |
| 2569 else if (elem.de
tachEvent) | |
| 2570 elem.det
achEvent("on" + type, jQuery.data(elem, "handle")); | |
| 2571 } | |
| 2572 ret = null; | |
| 2573 delete events[type]; | |
| 2574 } | |
| 2575 } | |
| 2576 }); | |
| 2577 } | |
| 2578 | |
| 2579 // Remove the expando if it's no longer used | |
| 2580 for ( ret in events ) break; | |
| 2581 if ( !ret ) { | |
| 2582 var handle = jQuery.data( elem, "handle" ); | |
| 2583 if ( handle ) handle.elem = null; | |
| 2584 jQuery.removeData( elem, "events" ); | |
| 2585 jQuery.removeData( elem, "handle" ); | |
| 2586 } | |
| 2587 } | |
| 2588 }, | |
| 2589 | |
| 2590 // bubbling is internal | |
| 2591 trigger: function( event, data, elem, bubbling ) { | |
| 2592 // Event object or event type | |
| 2593 var type = event.type || event; | |
| 2594 | |
| 2595 if( !bubbling ){ | |
| 2596 event = typeof event === "object" ? | |
| 2597 // jQuery.Event object | |
| 2598 event[expando] ? event : | |
| 2599 // Object literal | |
| 2600 jQuery.extend( jQuery.Event(type), event ) : | |
| 2601 // Just the event type (string) | |
| 2602 jQuery.Event(type); | |
| 2603 | |
| 2604 if ( type.indexOf("!") >= 0 ) { | |
| 2605 event.type = type = type.slice(0, -1); | |
| 2606 event.exclusive = true; | |
| 2607 } | |
| 2608 | |
| 2609 // Handle a global trigger | |
| 2610 if ( !elem ) { | |
| 2611 // Don't bubble custom events when global (to av
oid too much overhead) | |
| 2612 event.stopPropagation(); | |
| 2613 // Only trigger if we've ever bound an event for
it | |
| 2614 if ( this.global[type] ) | |
| 2615 jQuery.each( jQuery.cache, function(){ | |
| 2616 if ( this.events && this.events[
type] ) | |
| 2617 jQuery.event.trigger( ev
ent, data, this.handle.elem ); | |
| 2618 }); | |
| 2619 } | |
| 2620 | |
| 2621 // Handle triggering a single element | |
| 2622 | |
| 2623 // don't do events on text and comment nodes | |
| 2624 if ( !elem || elem.nodeType == 3 || elem.nodeType == 8 ) | |
| 2625 return undefined; | |
| 2626 | |
| 2627 // Clean up in case it is reused | |
| 2628 event.result = undefined; | |
| 2629 event.target = elem; | |
| 2630 | |
| 2631 // Clone the incoming data, if any | |
| 2632 data = jQuery.makeArray(data); | |
| 2633 data.unshift( event ); | |
| 2634 } | |
| 2635 | |
| 2636 event.currentTarget = elem; | |
| 2637 | |
| 2638 // Trigger the event, it is assumed that "handle" is a function | |
| 2639 var handle = jQuery.data(elem, "handle"); | |
| 2640 if ( handle ) | |
| 2641 handle.apply( elem, data ); | |
| 2642 | |
| 2643 // Handle triggering native .onfoo handlers (and on links since
we don't call .click() for links) | |
| 2644 if ( (!elem[type] || (jQuery.nodeName(elem, 'a') && type == "cli
ck")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false ) | |
| 2645 event.result = false; | |
| 2646 | |
| 2647 // Trigger the native events (except for clicks on links) | |
| 2648 if ( !bubbling && elem[type] && !event.isDefaultPrevented() && !
(jQuery.nodeName(elem, 'a') && type == "click") ) { | |
| 2649 this.triggered = true; | |
| 2650 try { | |
| 2651 elem[ type ](); | |
| 2652 // prevent IE from throwing an error for some hidden ele
ments | |
| 2653 } catch (e) {} | |
| 2654 } | |
| 2655 | |
| 2656 this.triggered = false; | |
| 2657 | |
| 2658 if ( !event.isPropagationStopped() ) { | |
| 2659 var parent = elem.parentNode || elem.ownerDocument; | |
| 2660 if ( parent ) | |
| 2661 jQuery.event.trigger(event, data, parent, true); | |
| 2662 } | |
| 2663 }, | |
| 2664 | |
| 2665 handle: function(event) { | |
| 2666 // returned undefined or false | |
| 2667 var all, handlers; | |
| 2668 | |
| 2669 event = arguments[0] = jQuery.event.fix( event || window.event )
; | |
| 2670 event.currentTarget = this; | |
| 2671 | |
| 2672 // Namespaced event handlers | |
| 2673 var namespaces = event.type.split("."); | |
| 2674 event.type = namespaces.shift(); | |
| 2675 | |
| 2676 // Cache this now, all = true means, any handler | |
| 2677 all = !namespaces.length && !event.exclusive; | |
| 2678 | |
| 2679 var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().joi
n(".*\\.") + "(\\.|$)"); | |
| 2680 | |
| 2681 handlers = ( jQuery.data(this, "events") || {} )[event.type]; | |
| 2682 | |
| 2683 for ( var j in handlers ) { | |
| 2684 var handler = handlers[j]; | |
| 2685 | |
| 2686 // Filter the functions by class | |
| 2687 if ( all || namespace.test(handler.type) ) { | |
| 2688 // Pass in a reference to the handler function i
tself | |
| 2689 // So that we can later remove it | |
| 2690 event.handler = handler; | |
| 2691 event.data = handler.data; | |
| 2692 | |
| 2693 var ret = handler.apply(this, arguments); | |
| 2694 | |
| 2695 if( ret !== undefined ){ | |
| 2696 event.result = ret; | |
| 2697 if ( ret === false ) { | |
| 2698 event.preventDefault(); | |
| 2699 event.stopPropagation(); | |
| 2700 } | |
| 2701 } | |
| 2702 | |
| 2703 if( event.isImmediatePropagationStopped() ) | |
| 2704 break; | |
| 2705 | |
| 2706 } | |
| 2707 } | |
| 2708 }, | |
| 2709 | |
| 2710 props: "altKey attrChange attrName bubbles button cancelable charCode cl
ientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler k
eyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode related
Target screenX screenY shiftKey srcElement target toElement view wheelDelta whic
h".split(" "), | |
| 2711 | |
| 2712 fix: function(event) { | |
| 2713 if ( event[expando] ) | |
| 2714 return event; | |
| 2715 | |
| 2716 // store a copy of the original event object | |
| 2717 // and "clone" to set read-only properties | |
| 2718 var originalEvent = event; | |
| 2719 event = jQuery.Event( originalEvent ); | |
| 2720 | |
| 2721 for ( var i = this.props.length, prop; i; ){ | |
| 2722 prop = this.props[ --i ]; | |
| 2723 event[ prop ] = originalEvent[ prop ]; | |
| 2724 } | |
| 2725 | |
| 2726 // Fix target property, if necessary | |
| 2727 if ( !event.target ) | |
| 2728 event.target = event.srcElement || document; // Fixes #1
925 where srcElement might not be defined either | |
| 2729 | |
| 2730 // check if target is a textnode (safari) | |
| 2731 if ( event.target.nodeType == 3 ) | |
| 2732 event.target = event.target.parentNode; | |
| 2733 | |
| 2734 // Add relatedTarget, if necessary | |
| 2735 if ( !event.relatedTarget && event.fromElement ) | |
| 2736 event.relatedTarget = event.fromElement == event.target
? event.toElement : event.fromElement; | |
| 2737 | |
| 2738 // Calculate pageX/Y if missing and clientX/Y available | |
| 2739 if ( event.pageX == null && event.clientX != null ) { | |
| 2740 var doc = document.documentElement, body = document.body
; | |
| 2741 event.pageX = event.clientX + (doc && doc.scrollLeft ||
body && body.scrollLeft || 0) - (doc.clientLeft || 0); | |
| 2742 event.pageY = event.clientY + (doc && doc.scrollTop || b
ody && body.scrollTop || 0) - (doc.clientTop || 0); | |
| 2743 } | |
| 2744 | |
| 2745 // Add which for key events | |
| 2746 if ( !event.which && ((event.charCode || event.charCode === 0) ?
event.charCode : event.keyCode) ) | |
| 2747 event.which = event.charCode || event.keyCode; | |
| 2748 | |
| 2749 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta f
or Macs) | |
| 2750 if ( !event.metaKey && event.ctrlKey ) | |
| 2751 event.metaKey = event.ctrlKey; | |
| 2752 | |
| 2753 // Add which for click: 1 == left; 2 == middle; 3 == right | |
| 2754 // Note: button is not normalized, so don't use it | |
| 2755 if ( !event.which && event.button ) | |
| 2756 event.which = (event.button & 1 ? 1 : ( event.button & 2
? 3 : ( event.button & 4 ? 2 : 0 ) )); | |
| 2757 | |
| 2758 return event; | |
| 2759 }, | |
| 2760 | |
| 2761 proxy: function( fn, proxy ){ | |
| 2762 proxy = proxy || function(){ return fn.apply(this, arguments); }
; | |
| 2763 // Set the guid of unique handler to the same of original handle
r, so it can be removed | |
| 2764 proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++; | |
| 2765 // So proxy can be declared as an argument | |
| 2766 return proxy; | |
| 2767 }, | |
| 2768 | |
| 2769 special: { | |
| 2770 ready: { | |
| 2771 // Make sure the ready event is setup | |
| 2772 setup: bindReady, | |
| 2773 teardown: function() {} | |
| 2774 } | |
| 2775 }, | |
| 2776 | |
| 2777 specialAll: { | |
| 2778 live: { | |
| 2779 setup: function( selector, namespaces ){ | |
| 2780 jQuery.event.add( this, namespaces[0], liveHandl
er ); | |
| 2781 }, | |
| 2782 teardown: function( namespaces ){ | |
| 2783 if ( namespaces.length ) { | |
| 2784 var remove = 0, name = RegExp("(^|\\.)"
+ namespaces[0] + "(\\.|$)"); | |
| 2785 | |
| 2786 jQuery.each( (jQuery.data(this, "events"
).live || {}), function(){ | |
| 2787 if ( name.test(this.type) ) | |
| 2788 remove++; | |
| 2789 }); | |
| 2790 | |
| 2791 if ( remove < 1 ) | |
| 2792 jQuery.event.remove( this, names
paces[0], liveHandler ); | |
| 2793 } | |
| 2794 } | |
| 2795 } | |
| 2796 } | |
| 2797 }; | |
| 2798 | |
| 2799 jQuery.Event = function( src ){ | |
| 2800 // Allow instantiation without the 'new' keyword | |
| 2801 if( !this.preventDefault ) | |
| 2802 return new jQuery.Event(src); | |
| 2803 | |
| 2804 // Event object | |
| 2805 if( src && src.type ){ | |
| 2806 this.originalEvent = src; | |
| 2807 this.type = src.type; | |
| 2808 // Event type | |
| 2809 }else | |
| 2810 this.type = src; | |
| 2811 | |
| 2812 // timeStamp is buggy for some events on Firefox(#3843) | |
| 2813 // So we won't rely on the native value | |
| 2814 this.timeStamp = now(); | |
| 2815 | |
| 2816 // Mark it as fixed | |
| 2817 this[expando] = true; | |
| 2818 }; | |
| 2819 | |
| 2820 function returnFalse(){ | |
| 2821 return false; | |
| 2822 } | |
| 2823 function returnTrue(){ | |
| 2824 return true; | |
| 2825 } | |
| 2826 | |
| 2827 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language
Binding | |
| 2828 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.
html | |
| 2829 jQuery.Event.prototype = { | |
| 2830 preventDefault: function() { | |
| 2831 this.isDefaultPrevented = returnTrue; | |
| 2832 | |
| 2833 var e = this.originalEvent; | |
| 2834 if( !e ) | |
| 2835 return; | |
| 2836 // if preventDefault exists run it on the original event | |
| 2837 if (e.preventDefault) | |
| 2838 e.preventDefault(); | |
| 2839 // otherwise set the returnValue property of the original event
to false (IE) | |
| 2840 e.returnValue = false; | |
| 2841 }, | |
| 2842 stopPropagation: function() { | |
| 2843 this.isPropagationStopped = returnTrue; | |
| 2844 | |
| 2845 var e = this.originalEvent; | |
| 2846 if( !e ) | |
| 2847 return; | |
| 2848 // if stopPropagation exists run it on the original event | |
| 2849 if (e.stopPropagation) | |
| 2850 e.stopPropagation(); | |
| 2851 // otherwise set the cancelBubble property of the original event
to true (IE) | |
| 2852 e.cancelBubble = true; | |
| 2853 }, | |
| 2854 stopImmediatePropagation:function(){ | |
| 2855 this.isImmediatePropagationStopped = returnTrue; | |
| 2856 this.stopPropagation(); | |
| 2857 }, | |
| 2858 isDefaultPrevented: returnFalse, | |
| 2859 isPropagationStopped: returnFalse, | |
| 2860 isImmediatePropagationStopped: returnFalse | |
| 2861 }; | |
| 2862 // Checks if an event happened on an element within another element | |
| 2863 // Used in jQuery.event.special.mouseenter and mouseleave handlers | |
| 2864 var withinElement = function(event) { | |
| 2865 // Check if mouse(over|out) are still within the same parent element | |
| 2866 var parent = event.relatedTarget; | |
| 2867 // Traverse up the tree | |
| 2868 while ( parent && parent != this ) | |
| 2869 try { parent = parent.parentNode; } | |
| 2870 catch(e) { parent = this; } | |
| 2871 | |
| 2872 if( parent != this ){ | |
| 2873 // set the correct event type | |
| 2874 event.type = event.data; | |
| 2875 // handle event if we actually just moused on to a non sub-eleme
nt | |
| 2876 jQuery.event.handle.apply( this, arguments ); | |
| 2877 } | |
| 2878 }; | |
| 2879 | |
| 2880 jQuery.each({ | |
| 2881 mouseover: 'mouseenter', | |
| 2882 mouseout: 'mouseleave' | |
| 2883 }, function( orig, fix ){ | |
| 2884 jQuery.event.special[ fix ] = { | |
| 2885 setup: function(){ | |
| 2886 jQuery.event.add( this, orig, withinElement, fix ); | |
| 2887 }, | |
| 2888 teardown: function(){ | |
| 2889 jQuery.event.remove( this, orig, withinElement ); | |
| 2890 } | |
| 2891 }; | |
| 2892 }); | |
| 2893 | |
| 2894 jQuery.fn.extend({ | |
| 2895 bind: function( type, data, fn ) { | |
| 2896 return type == "unload" ? this.one(type, data, fn) : this.each(f
unction(){ | |
| 2897 jQuery.event.add( this, type, fn || data, fn && data ); | |
| 2898 }); | |
| 2899 }, | |
| 2900 | |
| 2901 one: function( type, data, fn ) { | |
| 2902 var one = jQuery.event.proxy( fn || data, function(event) { | |
| 2903 jQuery(this).unbind(event, one); | |
| 2904 return (fn || data).apply( this, arguments ); | |
| 2905 }); | |
| 2906 return this.each(function(){ | |
| 2907 jQuery.event.add( this, type, one, fn && data); | |
| 2908 }); | |
| 2909 }, | |
| 2910 | |
| 2911 unbind: function( type, fn ) { | |
| 2912 return this.each(function(){ | |
| 2913 jQuery.event.remove( this, type, fn ); | |
| 2914 }); | |
| 2915 }, | |
| 2916 | |
| 2917 trigger: function( type, data ) { | |
| 2918 return this.each(function(){ | |
| 2919 jQuery.event.trigger( type, data, this ); | |
| 2920 }); | |
| 2921 }, | |
| 2922 | |
| 2923 triggerHandler: function( type, data ) { | |
| 2924 if( this[0] ){ | |
| 2925 var event = jQuery.Event(type); | |
| 2926 event.preventDefault(); | |
| 2927 event.stopPropagation(); | |
| 2928 jQuery.event.trigger( event, data, this[0] ); | |
| 2929 return event.result; | |
| 2930 } | |
| 2931 }, | |
| 2932 | |
| 2933 toggle: function( fn ) { | |
| 2934 // Save reference to arguments for access in closure | |
| 2935 var args = arguments, i = 1; | |
| 2936 | |
| 2937 // link all the functions, so any of them can unbind this click
handler | |
| 2938 while( i < args.length ) | |
| 2939 jQuery.event.proxy( fn, args[i++] ); | |
| 2940 | |
| 2941 return this.click( jQuery.event.proxy( fn, function(event) { | |
| 2942 // Figure out which function to execute | |
| 2943 this.lastToggle = ( this.lastToggle || 0 ) % i; | |
| 2944 | |
| 2945 // Make sure that clicks stop | |
| 2946 event.preventDefault(); | |
| 2947 | |
| 2948 // and execute the function | |
| 2949 return args[ this.lastToggle++ ].apply( this, arguments
) || false; | |
| 2950 })); | |
| 2951 }, | |
| 2952 | |
| 2953 hover: function(fnOver, fnOut) { | |
| 2954 return this.mouseenter(fnOver).mouseleave(fnOut); | |
| 2955 }, | |
| 2956 | |
| 2957 ready: function(fn) { | |
| 2958 // Attach the listeners | |
| 2959 bindReady(); | |
| 2960 | |
| 2961 // If the DOM is already ready | |
| 2962 if ( jQuery.isReady ) | |
| 2963 // Execute the function immediately | |
| 2964 fn.call( document, jQuery ); | |
| 2965 | |
| 2966 // Otherwise, remember the function for later | |
| 2967 else | |
| 2968 // Add the function to the wait list | |
| 2969 jQuery.readyList.push( fn ); | |
| 2970 | |
| 2971 return this; | |
| 2972 }, | |
| 2973 | |
| 2974 live: function( type, fn ){ | |
| 2975 var proxy = jQuery.event.proxy( fn ); | |
| 2976 proxy.guid += this.selector + type; | |
| 2977 | |
| 2978 jQuery(document).bind( liveConvert(type, this.selector), this.se
lector, proxy ); | |
| 2979 | |
| 2980 return this; | |
| 2981 }, | |
| 2982 | |
| 2983 die: function( type, fn ){ | |
| 2984 jQuery(document).unbind( liveConvert(type, this.selector), fn ?
{ guid: fn.guid + this.selector + type } : null ); | |
| 2985 return this; | |
| 2986 } | |
| 2987 }); | |
| 2988 | |
| 2989 function liveHandler( event ){ | |
| 2990 var check = RegExp("(^|\\.)" + event.type + "(\\.|$)"), | |
| 2991 stop = true, | |
| 2992 elems = []; | |
| 2993 | |
| 2994 jQuery.each(jQuery.data(this, "events").live || [], function(i, fn){ | |
| 2995 if ( check.test(fn.type) ) { | |
| 2996 var elem = jQuery(event.target).closest(fn.data)[0]; | |
| 2997 if ( elem ) | |
| 2998 elems.push({ elem: elem, fn: fn }); | |
| 2999 } | |
| 3000 }); | |
| 3001 | |
| 3002 elems.sort(function(a,b) { | |
| 3003 return jQuery.data(a.elem, "closest") - jQuery.data(b.elem, "clo
sest"); | |
| 3004 }); | |
| 3005 | |
| 3006 jQuery.each(elems, function(){ | |
| 3007 if ( this.fn.call(this.elem, event, this.fn.data) === false ) | |
| 3008 return (stop = false); | |
| 3009 }); | |
| 3010 | |
| 3011 return stop; | |
| 3012 } | |
| 3013 | |
| 3014 function liveConvert(type, selector){ | |
| 3015 return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "|")].j
oin("."); | |
| 3016 } | |
| 3017 | |
| 3018 jQuery.extend({ | |
| 3019 isReady: false, | |
| 3020 readyList: [], | |
| 3021 // Handle when the DOM is ready | |
| 3022 ready: function() { | |
| 3023 // Make sure that the DOM is not already loaded | |
| 3024 if ( !jQuery.isReady ) { | |
| 3025 // Remember that the DOM is ready | |
| 3026 jQuery.isReady = true; | |
| 3027 | |
| 3028 // If there are functions bound, to execute | |
| 3029 if ( jQuery.readyList ) { | |
| 3030 // Execute all of them | |
| 3031 jQuery.each( jQuery.readyList, function(){ | |
| 3032 this.call( document, jQuery ); | |
| 3033 }); | |
| 3034 | |
| 3035 // Reset the list of functions | |
| 3036 jQuery.readyList = null; | |
| 3037 } | |
| 3038 | |
| 3039 // Trigger any bound ready events | |
| 3040 jQuery(document).triggerHandler("ready"); | |
| 3041 } | |
| 3042 } | |
| 3043 }); | |
| 3044 | |
| 3045 var readyBound = false; | |
| 3046 | |
| 3047 function bindReady(){ | |
| 3048 if ( readyBound ) return; | |
| 3049 readyBound = true; | |
| 3050 | |
| 3051 // Mozilla, Opera and webkit nightlies currently support this event | |
| 3052 if ( document.addEventListener ) { | |
| 3053 // Use the handy event callback | |
| 3054 document.addEventListener( "DOMContentLoaded", function(){ | |
| 3055 document.removeEventListener( "DOMContentLoaded", argume
nts.callee, false ); | |
| 3056 jQuery.ready(); | |
| 3057 }, false ); | |
| 3058 | |
| 3059 // If IE event model is used | |
| 3060 } else if ( document.attachEvent ) { | |
| 3061 // ensure firing before onload, | |
| 3062 // maybe late but safe also for iframes | |
| 3063 document.attachEvent("onreadystatechange", function(){ | |
| 3064 if ( document.readyState === "complete" ) { | |
| 3065 document.detachEvent( "onreadystatechange", argu
ments.callee ); | |
| 3066 jQuery.ready(); | |
| 3067 } | |
| 3068 }); | |
| 3069 | |
| 3070 // If IE and not an iframe | |
| 3071 // continually check to see if the document is ready | |
| 3072 if ( document.documentElement.doScroll && window == window.top )
(function(){ | |
| 3073 if ( jQuery.isReady ) return; | |
| 3074 | |
| 3075 try { | |
| 3076 // If IE is used, use the trick by Diego Perini | |
| 3077 // http://javascript.nwbox.com/IEContentLoaded/ | |
| 3078 document.documentElement.doScroll("left"); | |
| 3079 } catch( error ) { | |
| 3080 setTimeout( arguments.callee, 0 ); | |
| 3081 return; | |
| 3082 } | |
| 3083 | |
| 3084 // and execute any waiting functions | |
| 3085 jQuery.ready(); | |
| 3086 })(); | |
| 3087 } | |
| 3088 | |
| 3089 // A fallback to window.onload, that will always work | |
| 3090 jQuery.event.add( window, "load", jQuery.ready ); | |
| 3091 } | |
| 3092 | |
| 3093 jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," + | |
| 3094 "mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave,"
+ | |
| 3095 "change,select,submit,keydown,keypress,keyup,error").split(","), functio
n(i, name){ | |
| 3096 | |
| 3097 // Handle event binding | |
| 3098 jQuery.fn[name] = function(fn){ | |
| 3099 return fn ? this.bind(name, fn) : this.trigger(name); | |
| 3100 }; | |
| 3101 }); | |
| 3102 | |
| 3103 // Prevent memory leaks in IE | |
| 3104 // And prevent errors on refresh with events like mouseover in other browsers | |
| 3105 // Window isn't included so as not to unbind existing unload events | |
| 3106 jQuery( window ).bind( 'unload', function(){ | |
| 3107 for ( var id in jQuery.cache ) | |
| 3108 // Skip the window | |
| 3109 if ( id != 1 && jQuery.cache[ id ].handle ) | |
| 3110 jQuery.event.remove( jQuery.cache[ id ].handle.elem ); | |
| 3111 }); | |
| 3112 (function(){ | |
| 3113 | |
| 3114 jQuery.support = {}; | |
| 3115 | |
| 3116 var root = document.documentElement, | |
| 3117 script = document.createElement("script"), | |
| 3118 div = document.createElement("div"), | |
| 3119 id = "script" + (new Date).getTime(); | |
| 3120 | |
| 3121 div.style.display = "none"; | |
| 3122 div.innerHTML = ' <link/><table></table><a href="/a" style="color:red;
float:left;opacity:.5;">a</a><select><option>text</option></select><object><para
m/></object>'; | |
| 3123 | |
| 3124 var all = div.getElementsByTagName("*"), | |
| 3125 a = div.getElementsByTagName("a")[0]; | |
| 3126 | |
| 3127 // Can't get basic test support | |
| 3128 if ( !all || !all.length || !a ) { | |
| 3129 return; | |
| 3130 } | |
| 3131 | |
| 3132 jQuery.support = { | |
| 3133 // IE strips leading whitespace when .innerHTML is used | |
| 3134 leadingWhitespace: div.firstChild.nodeType == 3, | |
| 3135 | |
| 3136 // Make sure that tbody elements aren't automatically inserted | |
| 3137 // IE will insert them into empty tables | |
| 3138 tbody: !div.getElementsByTagName("tbody").length, | |
| 3139 | |
| 3140 // Make sure that you can get all elements in an <object> elemen
t | |
| 3141 // IE 7 always returns no results | |
| 3142 objectAll: !!div.getElementsByTagName("object")[0] | |
| 3143 .getElementsByTagName("*").length, | |
| 3144 | |
| 3145 // Make sure that link elements get serialized correctly by inne
rHTML | |
| 3146 // This requires a wrapper element in IE | |
| 3147 htmlSerialize: !!div.getElementsByTagName("link").length, | |
| 3148 | |
| 3149 // Get the style information from getAttribute | |
| 3150 // (IE uses .cssText insted) | |
| 3151 style: /red/.test( a.getAttribute("style") ), | |
| 3152 | |
| 3153 // Make sure that URLs aren't manipulated | |
| 3154 // (IE normalizes it by default) | |
| 3155 hrefNormalized: a.getAttribute("href") === "/a", | |
| 3156 | |
| 3157 // Make sure that element opacity exists | |
| 3158 // (IE uses filter instead) | |
| 3159 opacity: a.style.opacity === "0.5", | |
| 3160 | |
| 3161 // Verify style float existence | |
| 3162 // (IE uses styleFloat instead of cssFloat) | |
| 3163 cssFloat: !!a.style.cssFloat, | |
| 3164 | |
| 3165 // Will be defined later | |
| 3166 scriptEval: false, | |
| 3167 noCloneEvent: true, | |
| 3168 boxModel: null | |
| 3169 }; | |
| 3170 | |
| 3171 script.type = "text/javascript"; | |
| 3172 try { | |
| 3173 script.appendChild( document.createTextNode( "window." + id + "=
1;" ) ); | |
| 3174 } catch(e){} | |
| 3175 | |
| 3176 root.insertBefore( script, root.firstChild ); | |
| 3177 | |
| 3178 // Make sure that the execution of code works by injecting a script | |
| 3179 // tag with appendChild/createTextNode | |
| 3180 // (IE doesn't support this, fails, and uses .text instead) | |
| 3181 if ( window[ id ] ) { | |
| 3182 jQuery.support.scriptEval = true; | |
| 3183 delete window[ id ]; | |
| 3184 } | |
| 3185 | |
| 3186 root.removeChild( script ); | |
| 3187 | |
| 3188 if ( div.attachEvent && div.fireEvent ) { | |
| 3189 div.attachEvent("onclick", function(){ | |
| 3190 // Cloning a node shouldn't copy over any | |
| 3191 // bound event handlers (IE does this) | |
| 3192 jQuery.support.noCloneEvent = false; | |
| 3193 div.detachEvent("onclick", arguments.callee); | |
| 3194 }); | |
| 3195 div.cloneNode(true).fireEvent("onclick"); | |
| 3196 } | |
| 3197 | |
| 3198 // Figure out if the W3C box model works as expected | |
| 3199 // document.body must exist before we can do this | |
| 3200 jQuery(function(){ | |
| 3201 var div = document.createElement("div"); | |
| 3202 div.style.width = div.style.paddingLeft = "1px"; | |
| 3203 | |
| 3204 document.body.appendChild( div ); | |
| 3205 jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth ===
2; | |
| 3206 document.body.removeChild( div ).style.display = 'none'; | |
| 3207 }); | |
| 3208 })(); | |
| 3209 | |
| 3210 var styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat"; | |
| 3211 | |
| 3212 jQuery.props = { | |
| 3213 "for": "htmlFor", | |
| 3214 "class": "className", | |
| 3215 "float": styleFloat, | |
| 3216 cssFloat: styleFloat, | |
| 3217 styleFloat: styleFloat, | |
| 3218 readonly: "readOnly", | |
| 3219 maxlength: "maxLength", | |
| 3220 cellspacing: "cellSpacing", | |
| 3221 rowspan: "rowSpan", | |
| 3222 tabindex: "tabIndex" | |
| 3223 }; | |
| 3224 jQuery.fn.extend({ | |
| 3225 // Keep a copy of the old load | |
| 3226 _load: jQuery.fn.load, | |
| 3227 | |
| 3228 load: function( url, params, callback ) { | |
| 3229 if ( typeof url !== "string" ) | |
| 3230 return this._load( url ); | |
| 3231 | |
| 3232 var off = url.indexOf(" "); | |
| 3233 if ( off >= 0 ) { | |
| 3234 var selector = url.slice(off, url.length); | |
| 3235 url = url.slice(0, off); | |
| 3236 } | |
| 3237 | |
| 3238 // Default to a GET request | |
| 3239 var type = "GET"; | |
| 3240 | |
| 3241 // If the second parameter was provided | |
| 3242 if ( params ) | |
| 3243 // If it's a function | |
| 3244 if ( jQuery.isFunction( params ) ) { | |
| 3245 // We assume that it's the callback | |
| 3246 callback = params; | |
| 3247 params = null; | |
| 3248 | |
| 3249 // Otherwise, build a param string | |
| 3250 } else if( typeof params === "object" ) { | |
| 3251 params = jQuery.param( params ); | |
| 3252 type = "POST"; | |
| 3253 } | |
| 3254 | |
| 3255 var self = this; | |
| 3256 | |
| 3257 // Request the remote document | |
| 3258 jQuery.ajax({ | |
| 3259 url: url, | |
| 3260 type: type, | |
| 3261 dataType: "html", | |
| 3262 data: params, | |
| 3263 complete: function(res, status){ | |
| 3264 // If successful, inject the HTML into all the m
atched elements | |
| 3265 if ( status == "success" || status == "notmodifi
ed" ) | |
| 3266 // See if a selector was specified | |
| 3267 self.html( selector ? | |
| 3268 // Create a dummy div to hold th
e results | |
| 3269 jQuery("<div/>") | |
| 3270 // inject the contents o
f the document in, removing the scripts | |
| 3271 // to avoid any 'Permiss
ion Denied' errors in IE | |
| 3272 .append(res.responseText
.replace(/<script(.|\s)*?\/script>/g, "")) | |
| 3273 | |
| 3274 // Locate the specified
elements | |
| 3275 .find(selector) : | |
| 3276 | |
| 3277 // If not, just inject the full
result | |
| 3278 res.responseText ); | |
| 3279 | |
| 3280 if( callback ) | |
| 3281 self.each( callback, [res.responseText,
status, res] ); | |
| 3282 } | |
| 3283 }); | |
| 3284 return this; | |
| 3285 }, | |
| 3286 | |
| 3287 serialize: function() { | |
| 3288 return jQuery.param(this.serializeArray()); | |
| 3289 }, | |
| 3290 serializeArray: function() { | |
| 3291 return this.map(function(){ | |
| 3292 return this.elements ? jQuery.makeArray(this.elements) :
this; | |
| 3293 }) | |
| 3294 .filter(function(){ | |
| 3295 return this.name && !this.disabled && | |
| 3296 (this.checked || /select|textarea/i.test(this.no
deName) || | |
| 3297 /text|hidden|password|search/i.test(this
.type)); | |
| 3298 }) | |
| 3299 .map(function(i, elem){ | |
| 3300 var val = jQuery(this).val(); | |
| 3301 return val == null ? null : | |
| 3302 jQuery.isArray(val) ? | |
| 3303 jQuery.map( val, function(val, i){ | |
| 3304 return {name: elem.name, value:
val}; | |
| 3305 }) : | |
| 3306 {name: elem.name, value: val}; | |
| 3307 }).get(); | |
| 3308 } | |
| 3309 }); | |
| 3310 | |
| 3311 // Attach a bunch of functions for handling common AJAX events | |
| 3312 jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".sp
lit(","), function(i,o){ | |
| 3313 jQuery.fn[o] = function(f){ | |
| 3314 return this.bind(o, f); | |
| 3315 }; | |
| 3316 }); | |
| 3317 | |
| 3318 var jsc = now(); | |
| 3319 | |
| 3320 jQuery.extend({ | |
| 3321 | |
| 3322 get: function( url, data, callback, type ) { | |
| 3323 // shift arguments if data argument was ommited | |
| 3324 if ( jQuery.isFunction( data ) ) { | |
| 3325 callback = data; | |
| 3326 data = null; | |
| 3327 } | |
| 3328 | |
| 3329 return jQuery.ajax({ | |
| 3330 type: "GET", | |
| 3331 url: url, | |
| 3332 data: data, | |
| 3333 success: callback, | |
| 3334 dataType: type | |
| 3335 }); | |
| 3336 }, | |
| 3337 | |
| 3338 getScript: function( url, callback ) { | |
| 3339 return jQuery.get(url, null, callback, "script"); | |
| 3340 }, | |
| 3341 | |
| 3342 getJSON: function( url, data, callback ) { | |
| 3343 return jQuery.get(url, data, callback, "json"); | |
| 3344 }, | |
| 3345 | |
| 3346 post: function( url, data, callback, type ) { | |
| 3347 if ( jQuery.isFunction( data ) ) { | |
| 3348 callback = data; | |
| 3349 data = {}; | |
| 3350 } | |
| 3351 | |
| 3352 return jQuery.ajax({ | |
| 3353 type: "POST", | |
| 3354 url: url, | |
| 3355 data: data, | |
| 3356 success: callback, | |
| 3357 dataType: type | |
| 3358 }); | |
| 3359 }, | |
| 3360 | |
| 3361 ajaxSetup: function( settings ) { | |
| 3362 jQuery.extend( jQuery.ajaxSettings, settings ); | |
| 3363 }, | |
| 3364 | |
| 3365 ajaxSettings: { | |
| 3366 url: location.href, | |
| 3367 global: true, | |
| 3368 type: "GET", | |
| 3369 contentType: "application/x-www-form-urlencoded", | |
| 3370 processData: true, | |
| 3371 async: true, | |
| 3372 /* | |
| 3373 timeout: 0, | |
| 3374 data: null, | |
| 3375 username: null, | |
| 3376 password: null, | |
| 3377 */ | |
| 3378 // Create the request object; Microsoft failed to properly | |
| 3379 // implement the XMLHttpRequest in IE7, so we use the ActiveXObj
ect when it is available | |
| 3380 // This function can be overriden by calling jQuery.ajaxSetup | |
| 3381 xhr:function(){ | |
| 3382 return window.ActiveXObject ? new ActiveXObject("Microso
ft.XMLHTTP") : new XMLHttpRequest(); | |
| 3383 }, | |
| 3384 accepts: { | |
| 3385 xml: "application/xml, text/xml", | |
| 3386 html: "text/html", | |
| 3387 script: "text/javascript, application/javascript", | |
| 3388 json: "application/json, text/javascript", | |
| 3389 text: "text/plain", | |
| 3390 _default: "*/*" | |
| 3391 } | |
| 3392 }, | |
| 3393 | |
| 3394 // Last-Modified header cache for next request | |
| 3395 lastModified: {}, | |
| 3396 | |
| 3397 ajax: function( s ) { | |
| 3398 // Extend the settings, but re-extend 's' so that it can be | |
| 3399 // checked again later (in the test suite, specifically) | |
| 3400 s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSe
ttings, s)); | |
| 3401 | |
| 3402 var jsonp, jsre = /=\?(&|$)/g, status, data, | |
| 3403 type = s.type.toUpperCase(); | |
| 3404 | |
| 3405 // convert data if not already a string | |
| 3406 if ( s.data && s.processData && typeof s.data !== "string" ) | |
| 3407 s.data = jQuery.param(s.data); | |
| 3408 | |
| 3409 // Handle JSONP Parameter Callbacks | |
| 3410 if ( s.dataType == "jsonp" ) { | |
| 3411 if ( type == "GET" ) { | |
| 3412 if ( !s.url.match(jsre) ) | |
| 3413 s.url += (s.url.match(/\?/) ? "&" : "?")
+ (s.jsonp || "callback") + "=?"; | |
| 3414 } else if ( !s.data || !s.data.match(jsre) ) | |
| 3415 s.data = (s.data ? s.data + "&" : "") + (s.jsonp
|| "callback") + "=?"; | |
| 3416 s.dataType = "json"; | |
| 3417 } | |
| 3418 | |
| 3419 // Build temporary JSONP function | |
| 3420 if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.
url.match(jsre)) ) { | |
| 3421 jsonp = "jsonp" + jsc++; | |
| 3422 | |
| 3423 // Replace the =? sequence both in the query string and
the data | |
| 3424 if ( s.data ) | |
| 3425 s.data = (s.data + "").replace(jsre, "=" + jsonp
+ "$1"); | |
| 3426 s.url = s.url.replace(jsre, "=" + jsonp + "$1"); | |
| 3427 | |
| 3428 // We need to make sure | |
| 3429 // that a JSONP style response is executed properly | |
| 3430 s.dataType = "script"; | |
| 3431 | |
| 3432 // Handle JSONP-style loading | |
| 3433 window[ jsonp ] = function(tmp){ | |
| 3434 data = tmp; | |
| 3435 success(); | |
| 3436 complete(); | |
| 3437 // Garbage collect | |
| 3438 window[ jsonp ] = undefined; | |
| 3439 try{ delete window[ jsonp ]; } catch(e){} | |
| 3440 if ( head ) | |
| 3441 head.removeChild( script ); | |
| 3442 }; | |
| 3443 } | |
| 3444 | |
| 3445 if ( s.dataType == "script" && s.cache == null ) | |
| 3446 s.cache = false; | |
| 3447 | |
| 3448 if ( s.cache === false && type == "GET" ) { | |
| 3449 var ts = now(); | |
| 3450 // try replacing _= if it is there | |
| 3451 var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts
+ "$2"); | |
| 3452 // if nothing was replaced, add timestamp to the end | |
| 3453 s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&"
: "?") + "_=" + ts : ""); | |
| 3454 } | |
| 3455 | |
| 3456 // If data is available, append data to url for get requests | |
| 3457 if ( s.data && type == "GET" ) { | |
| 3458 s.url += (s.url.match(/\?/) ? "&" : "?") + s.data; | |
| 3459 | |
| 3460 // IE likes to send both get and post data, prevent this | |
| 3461 s.data = null; | |
| 3462 } | |
| 3463 | |
| 3464 // Watch for a new set of requests | |
| 3465 if ( s.global && ! jQuery.active++ ) | |
| 3466 jQuery.event.trigger( "ajaxStart" ); | |
| 3467 | |
| 3468 // Matches an absolute URL, and saves the domain | |
| 3469 var parts = /^(\w+:)?\/\/([^\/?#]+)/.exec( s.url ); | |
| 3470 | |
| 3471 // If we're requesting a remote document | |
| 3472 // and trying to load JSON or Script with a GET | |
| 3473 if ( s.dataType == "script" && type == "GET" && parts | |
| 3474 && ( parts[1] && parts[1] != location.protocol || parts[
2] != location.host )){ | |
| 3475 | |
| 3476 var head = document.getElementsByTagName("head")[0]; | |
| 3477 var script = document.createElement("script"); | |
| 3478 script.src = s.url; | |
| 3479 if (s.scriptCharset) | |
| 3480 script.charset = s.scriptCharset; | |
| 3481 | |
| 3482 // Handle Script loading | |
| 3483 if ( !jsonp ) { | |
| 3484 var done = false; | |
| 3485 | |
| 3486 // Attach handlers for all browsers | |
| 3487 script.onload = script.onreadystatechange = func
tion(){ | |
| 3488 if ( !done && (!this.readyState || | |
| 3489 this.readyState == "load
ed" || this.readyState == "complete") ) { | |
| 3490 done = true; | |
| 3491 success(); | |
| 3492 complete(); | |
| 3493 | |
| 3494 // Handle memory leak in IE | |
| 3495 script.onload = script.onreadyst
atechange = null; | |
| 3496 head.removeChild( script ); | |
| 3497 } | |
| 3498 }; | |
| 3499 } | |
| 3500 | |
| 3501 head.appendChild(script); | |
| 3502 | |
| 3503 // We handle everything using the script element injecti
on | |
| 3504 return undefined; | |
| 3505 } | |
| 3506 | |
| 3507 var requestDone = false; | |
| 3508 | |
| 3509 // Create the request object | |
| 3510 var xhr = s.xhr(); | |
| 3511 | |
| 3512 // Open the socket | |
| 3513 // Passing null username, generates a login popup on Opera (#286
5) | |
| 3514 if( s.username ) | |
| 3515 xhr.open(type, s.url, s.async, s.username, s.password); | |
| 3516 else | |
| 3517 xhr.open(type, s.url, s.async); | |
| 3518 | |
| 3519 // Need an extra try/catch for cross domain requests in Firefox
3 | |
| 3520 try { | |
| 3521 // Set the correct header, if data is being sent | |
| 3522 if ( s.data ) | |
| 3523 xhr.setRequestHeader("Content-Type", s.contentTy
pe); | |
| 3524 | |
| 3525 // Set the If-Modified-Since header, if ifModified mode. | |
| 3526 if ( s.ifModified ) | |
| 3527 xhr.setRequestHeader("If-Modified-Since", | |
| 3528 jQuery.lastModified[s.url] || "Thu, 01 J
an 1970 00:00:00 GMT" ); | |
| 3529 | |
| 3530 // Set header so the called script knows that it's an XM
LHttpRequest | |
| 3531 xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest
"); | |
| 3532 | |
| 3533 // Set the Accepts header for the server, depending on t
he dataType | |
| 3534 xhr.setRequestHeader("Accept", s.dataType && s.accepts[
s.dataType ] ? | |
| 3535 s.accepts[ s.dataType ] + ", */*" : | |
| 3536 s.accepts._default ); | |
| 3537 } catch(e){} | |
| 3538 | |
| 3539 // Allow custom headers/mimetypes and early abort | |
| 3540 if ( s.beforeSend && s.beforeSend(xhr, s) === false ) { | |
| 3541 // Handle the global AJAX counter | |
| 3542 if ( s.global && ! --jQuery.active ) | |
| 3543 jQuery.event.trigger( "ajaxStop" ); | |
| 3544 // close opended socket | |
| 3545 xhr.abort(); | |
| 3546 return false; | |
| 3547 } | |
| 3548 | |
| 3549 if ( s.global ) | |
| 3550 jQuery.event.trigger("ajaxSend", [xhr, s]); | |
| 3551 | |
| 3552 // Wait for a response to come back | |
| 3553 var onreadystatechange = function(isTimeout){ | |
| 3554 // The request was aborted, clear the interval and decre
ment jQuery.active | |
| 3555 if (xhr.readyState == 0) { | |
| 3556 if (ival) { | |
| 3557 // clear poll interval | |
| 3558 clearInterval(ival); | |
| 3559 ival = null; | |
| 3560 // Handle the global AJAX counter | |
| 3561 if ( s.global && ! --jQuery.active ) | |
| 3562 jQuery.event.trigger( "ajaxStop"
); | |
| 3563 } | |
| 3564 // The transfer is complete and the data is available, o
r the request timed out | |
| 3565 } else if ( !requestDone && xhr && (xhr.readyState == 4
|| isTimeout == "timeout") ) { | |
| 3566 requestDone = true; | |
| 3567 | |
| 3568 // clear poll interval | |
| 3569 if (ival) { | |
| 3570 clearInterval(ival); | |
| 3571 ival = null; | |
| 3572 } | |
| 3573 | |
| 3574 status = isTimeout == "timeout" ? "timeout" : | |
| 3575 !jQuery.httpSuccess( xhr ) ? "error" : | |
| 3576 s.ifModified && jQuery.httpNotModified(
xhr, s.url ) ? "notmodified" : | |
| 3577 "success"; | |
| 3578 | |
| 3579 if ( status == "success" ) { | |
| 3580 // Watch for, and catch, XML document pa
rse errors | |
| 3581 try { | |
| 3582 // process the data (runs the xm
l through httpData regardless of callback) | |
| 3583 data = jQuery.httpData( xhr, s.d
ataType, s ); | |
| 3584 } catch(e) { | |
| 3585 status = "parsererror"; | |
| 3586 } | |
| 3587 } | |
| 3588 | |
| 3589 // Make sure that the request was successful or
notmodified | |
| 3590 if ( status == "success" ) { | |
| 3591 // Cache Last-Modified header, if ifModi
fied mode. | |
| 3592 var modRes; | |
| 3593 try { | |
| 3594 modRes = xhr.getResponseHeader("
Last-Modified"); | |
| 3595 } catch(e) {} // swallow exception throw
n by FF if header is not available | |
| 3596 | |
| 3597 if ( s.ifModified && modRes ) | |
| 3598 jQuery.lastModified[s.url] = mod
Res; | |
| 3599 | |
| 3600 // JSONP handles its own success callbac
k | |
| 3601 if ( !jsonp ) | |
| 3602 success(); | |
| 3603 } else | |
| 3604 jQuery.handleError(s, xhr, status); | |
| 3605 | |
| 3606 // Fire the complete handlers | |
| 3607 complete(); | |
| 3608 | |
| 3609 if ( isTimeout ) | |
| 3610 xhr.abort(); | |
| 3611 | |
| 3612 // Stop memory leaks | |
| 3613 if ( s.async ) | |
| 3614 xhr = null; | |
| 3615 } | |
| 3616 }; | |
| 3617 | |
| 3618 if ( s.async ) { | |
| 3619 // don't attach the handler to the request, just poll it
instead | |
| 3620 var ival = setInterval(onreadystatechange, 13); | |
| 3621 | |
| 3622 // Timeout checker | |
| 3623 if ( s.timeout > 0 ) | |
| 3624 setTimeout(function(){ | |
| 3625 // Check to see if the request is still
happening | |
| 3626 if ( xhr && !requestDone ) | |
| 3627 onreadystatechange( "timeout" ); | |
| 3628 }, s.timeout); | |
| 3629 } | |
| 3630 | |
| 3631 // Send the data | |
| 3632 try { | |
| 3633 xhr.send(s.data); | |
| 3634 } catch(e) { | |
| 3635 jQuery.handleError(s, xhr, null, e); | |
| 3636 } | |
| 3637 | |
| 3638 // firefox 1.5 doesn't fire statechange for sync requests | |
| 3639 if ( !s.async ) | |
| 3640 onreadystatechange(); | |
| 3641 | |
| 3642 function success(){ | |
| 3643 // If a local callback was specified, fire it and pass i
t the data | |
| 3644 if ( s.success ) | |
| 3645 s.success( data, status ); | |
| 3646 | |
| 3647 // Fire the global callback | |
| 3648 if ( s.global ) | |
| 3649 jQuery.event.trigger( "ajaxSuccess", [xhr, s] ); | |
| 3650 } | |
| 3651 | |
| 3652 function complete(){ | |
| 3653 // Process result | |
| 3654 if ( s.complete ) | |
| 3655 s.complete(xhr, status); | |
| 3656 | |
| 3657 // The request was completed | |
| 3658 if ( s.global ) | |
| 3659 jQuery.event.trigger( "ajaxComplete", [xhr, s] )
; | |
| 3660 | |
| 3661 // Handle the global AJAX counter | |
| 3662 if ( s.global && ! --jQuery.active ) | |
| 3663 jQuery.event.trigger( "ajaxStop" ); | |
| 3664 } | |
| 3665 | |
| 3666 // return XMLHttpRequest to allow aborting the request etc. | |
| 3667 return xhr; | |
| 3668 }, | |
| 3669 | |
| 3670 handleError: function( s, xhr, status, e ) { | |
| 3671 // If a local callback was specified, fire it | |
| 3672 if ( s.error ) s.error( xhr, status, e ); | |
| 3673 | |
| 3674 // Fire the global callback | |
| 3675 if ( s.global ) | |
| 3676 jQuery.event.trigger( "ajaxError", [xhr, s, e] ); | |
| 3677 }, | |
| 3678 | |
| 3679 // Counter for holding the number of active queries | |
| 3680 active: 0, | |
| 3681 | |
| 3682 // Determines if an XMLHttpRequest was successful or not | |
| 3683 httpSuccess: function( xhr ) { | |
| 3684 try { | |
| 3685 // IE error sometimes returns 1223 when it should be 204
so treat it as success, see #1450 | |
| 3686 return !xhr.status && location.protocol == "file:" || | |
| 3687 ( xhr.status >= 200 && xhr.status < 300 ) || xhr
.status == 304 || xhr.status == 1223; | |
| 3688 } catch(e){} | |
| 3689 return false; | |
| 3690 }, | |
| 3691 | |
| 3692 // Determines if an XMLHttpRequest returns NotModified | |
| 3693 httpNotModified: function( xhr, url ) { | |
| 3694 try { | |
| 3695 var xhrRes = xhr.getResponseHeader("Last-Modified"); | |
| 3696 | |
| 3697 // Firefox always returns 200. check Last-Modified date | |
| 3698 return xhr.status == 304 || xhrRes == jQuery.lastModifie
d[url]; | |
| 3699 } catch(e){} | |
| 3700 return false; | |
| 3701 }, | |
| 3702 | |
| 3703 httpData: function( xhr, type, s ) { | |
| 3704 var ct = xhr.getResponseHeader("content-type"), | |
| 3705 xml = type == "xml" || !type && ct && ct.indexOf("xml")
>= 0, | |
| 3706 data = xml ? xhr.responseXML : xhr.responseText; | |
| 3707 | |
| 3708 if ( xml && data.documentElement.tagName == "parsererror" ) | |
| 3709 throw "parsererror"; | |
| 3710 | |
| 3711 // Allow a pre-filtering function to sanitize the response | |
| 3712 // s != null is checked to keep backwards compatibility | |
| 3713 if( s && s.dataFilter ) | |
| 3714 data = s.dataFilter( data, type ); | |
| 3715 | |
| 3716 // The filter can actually parse the response | |
| 3717 if( typeof data === "string" ){ | |
| 3718 | |
| 3719 // If the type is "script", eval it in global context | |
| 3720 if ( type == "script" ) | |
| 3721 jQuery.globalEval( data ); | |
| 3722 | |
| 3723 // Get the JavaScript object, if JSON is used. | |
| 3724 if ( type == "json" ) | |
| 3725 data = window["eval"]("(" + data + ")"); | |
| 3726 } | |
| 3727 | |
| 3728 return data; | |
| 3729 }, | |
| 3730 | |
| 3731 // Serialize an array of form elements or a set of | |
| 3732 // key/values into a query string | |
| 3733 param: function( a ) { | |
| 3734 var s = [ ]; | |
| 3735 | |
| 3736 function add( key, value ){ | |
| 3737 s[ s.length ] = encodeURIComponent(key) + '=' + encodeUR
IComponent(value); | |
| 3738 }; | |
| 3739 | |
| 3740 // If an array was passed in, assume that it is an array | |
| 3741 // of form elements | |
| 3742 if ( jQuery.isArray(a) || a.jquery ) | |
| 3743 // Serialize the form elements | |
| 3744 jQuery.each( a, function(){ | |
| 3745 add( this.name, this.value ); | |
| 3746 }); | |
| 3747 | |
| 3748 // Otherwise, assume that it's an object of key/value pairs | |
| 3749 else | |
| 3750 // Serialize the key/values | |
| 3751 for ( var j in a ) | |
| 3752 // If the value is an array then the key names n
eed to be repeated | |
| 3753 if ( jQuery.isArray(a[j]) ) | |
| 3754 jQuery.each( a[j], function(){ | |
| 3755 add( j, this ); | |
| 3756 }); | |
| 3757 else | |
| 3758 add( j, jQuery.isFunction(a[j]) ? a[j]()
: a[j] ); | |
| 3759 | |
| 3760 // Return the resulting serialization | |
| 3761 return s.join("&").replace(/%20/g, "+"); | |
| 3762 } | |
| 3763 | |
| 3764 }); | |
| 3765 var elemdisplay = {}, | |
| 3766 timerId, | |
| 3767 fxAttrs = [ | |
| 3768 // height animations | |
| 3769 [ "height", "marginTop", "marginBottom", "paddingTop", "paddingB
ottom" ], | |
| 3770 // width animations | |
| 3771 [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingR
ight" ], | |
| 3772 // opacity animations | |
| 3773 [ "opacity" ] | |
| 3774 ]; | |
| 3775 | |
| 3776 function genFx( type, num ){ | |
| 3777 var obj = {}; | |
| 3778 jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function(){ | |
| 3779 obj[ this ] = type; | |
| 3780 }); | |
| 3781 return obj; | |
| 3782 } | |
| 3783 | |
| 3784 jQuery.fn.extend({ | |
| 3785 show: function(speed,callback){ | |
| 3786 if ( speed ) { | |
| 3787 return this.animate( genFx("show", 3), speed, callback); | |
| 3788 } else { | |
| 3789 for ( var i = 0, l = this.length; i < l; i++ ){ | |
| 3790 var old = jQuery.data(this[i], "olddisplay"); | |
| 3791 | |
| 3792 this[i].style.display = old || ""; | |
| 3793 | |
| 3794 if ( jQuery.css(this[i], "display") === "none" )
{ | |
| 3795 var tagName = this[i].tagName, display; | |
| 3796 | |
| 3797 if ( elemdisplay[ tagName ] ) { | |
| 3798 display = elemdisplay[ tagName ]
; | |
| 3799 } else { | |
| 3800 var elem = jQuery("<" + tagName
+ " />").appendTo("body"); | |
| 3801 | |
| 3802 display = elem.css("display"); | |
| 3803 if ( display === "none" ) | |
| 3804 display = "block"; | |
| 3805 | |
| 3806 elem.remove(); | |
| 3807 | |
| 3808 elemdisplay[ tagName ] = display
; | |
| 3809 } | |
| 3810 | |
| 3811 jQuery.data(this[i], "olddisplay", displ
ay); | |
| 3812 } | |
| 3813 } | |
| 3814 | |
| 3815 // Set the display of the elements in a second loop | |
| 3816 // to avoid the constant reflow | |
| 3817 for ( var i = 0, l = this.length; i < l; i++ ){ | |
| 3818 this[i].style.display = jQuery.data(this[i], "ol
ddisplay") || ""; | |
| 3819 } | |
| 3820 | |
| 3821 return this; | |
| 3822 } | |
| 3823 }, | |
| 3824 | |
| 3825 hide: function(speed,callback){ | |
| 3826 if ( speed ) { | |
| 3827 return this.animate( genFx("hide", 3), speed, callback); | |
| 3828 } else { | |
| 3829 for ( var i = 0, l = this.length; i < l; i++ ){ | |
| 3830 var old = jQuery.data(this[i], "olddisplay"); | |
| 3831 if ( !old && old !== "none" ) | |
| 3832 jQuery.data(this[i], "olddisplay", jQuer
y.css(this[i], "display")); | |
| 3833 } | |
| 3834 | |
| 3835 // Set the display of the elements in a second loop | |
| 3836 // to avoid the constant reflow | |
| 3837 for ( var i = 0, l = this.length; i < l; i++ ){ | |
| 3838 this[i].style.display = "none"; | |
| 3839 } | |
| 3840 | |
| 3841 return this; | |
| 3842 } | |
| 3843 }, | |
| 3844 | |
| 3845 // Save the old toggle function | |
| 3846 _toggle: jQuery.fn.toggle, | |
| 3847 | |
| 3848 toggle: function( fn, fn2 ){ | |
| 3849 var bool = typeof fn === "boolean"; | |
| 3850 | |
| 3851 return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ? | |
| 3852 this._toggle.apply( this, arguments ) : | |
| 3853 fn == null || bool ? | |
| 3854 this.each(function(){ | |
| 3855 var state = bool ? fn : jQuery(this).is(
":hidden"); | |
| 3856 jQuery(this)[ state ? "show" : "hide" ](
); | |
| 3857 }) : | |
| 3858 this.animate(genFx("toggle", 3), fn, fn2); | |
| 3859 }, | |
| 3860 | |
| 3861 fadeTo: function(speed,to,callback){ | |
| 3862 return this.animate({opacity: to}, speed, callback); | |
| 3863 }, | |
| 3864 | |
| 3865 animate: function( prop, speed, easing, callback ) { | |
| 3866 var optall = jQuery.speed(speed, easing, callback); | |
| 3867 | |
| 3868 return this[ optall.queue === false ? "each" : "queue" ](functio
n(){ | |
| 3869 | |
| 3870 var opt = jQuery.extend({}, optall), p, | |
| 3871 hidden = this.nodeType == 1 && jQuery(this).is("
:hidden"), | |
| 3872 self = this; | |
| 3873 | |
| 3874 for ( p in prop ) { | |
| 3875 if ( prop[p] == "hide" && hidden || prop[p] == "
show" && !hidden ) | |
| 3876 return opt.complete.call(this); | |
| 3877 | |
| 3878 if ( ( p == "height" || p == "width" ) && this.s
tyle ) { | |
| 3879 // Store display property | |
| 3880 opt.display = jQuery.css(this, "display"
); | |
| 3881 | |
| 3882 // Make sure that nothing sneaks out | |
| 3883 opt.overflow = this.style.overflow; | |
| 3884 } | |
| 3885 } | |
| 3886 | |
| 3887 if ( opt.overflow != null ) | |
| 3888 this.style.overflow = "hidden"; | |
| 3889 | |
| 3890 opt.curAnim = jQuery.extend({}, prop); | |
| 3891 | |
| 3892 jQuery.each( prop, function(name, val){ | |
| 3893 var e = new jQuery.fx( self, opt, name ); | |
| 3894 | |
| 3895 if ( /toggle|show|hide/.test(val) ) | |
| 3896 e[ val == "toggle" ? hidden ? "show" : "
hide" : val ]( prop ); | |
| 3897 else { | |
| 3898 var parts = val.toString().match(/^([+-]
=)?([\d+-.]+)(.*)$/), | |
| 3899 start = e.cur(true) || 0; | |
| 3900 | |
| 3901 if ( parts ) { | |
| 3902 var end = parseFloat(parts[2]), | |
| 3903 unit = parts[3] || "px"; | |
| 3904 | |
| 3905 // We need to compute starting v
alue | |
| 3906 if ( unit != "px" ) { | |
| 3907 self.style[ name ] = (en
d || 1) + unit; | |
| 3908 start = ((end || 1) / e.
cur(true)) * start; | |
| 3909 self.style[ name ] = sta
rt + unit; | |
| 3910 } | |
| 3911 | |
| 3912 // If a +=/-= token was provided
, we're doing a relative animation | |
| 3913 if ( parts[1] ) | |
| 3914 end = ((parts[1] == "-="
? -1 : 1) * end) + start; | |
| 3915 | |
| 3916 e.custom( start, end, unit ); | |
| 3917 } else | |
| 3918 e.custom( start, val, "" ); | |
| 3919 } | |
| 3920 }); | |
| 3921 | |
| 3922 // For JS strict compliance | |
| 3923 return true; | |
| 3924 }); | |
| 3925 }, | |
| 3926 | |
| 3927 stop: function(clearQueue, gotoEnd){ | |
| 3928 var timers = jQuery.timers; | |
| 3929 | |
| 3930 if (clearQueue) | |
| 3931 this.queue([]); | |
| 3932 | |
| 3933 this.each(function(){ | |
| 3934 // go in reverse order so anything added to the queue du
ring the loop is ignored | |
| 3935 for ( var i = timers.length - 1; i >= 0; i-- ) | |
| 3936 if ( timers[i].elem == this ) { | |
| 3937 if (gotoEnd) | |
| 3938 // force the next step to be the
last | |
| 3939 timers[i](true); | |
| 3940 timers.splice(i, 1); | |
| 3941 } | |
| 3942 }); | |
| 3943 | |
| 3944 // start the next in the queue if the last step wasn't forced | |
| 3945 if (!gotoEnd) | |
| 3946 this.dequeue(); | |
| 3947 | |
| 3948 return this; | |
| 3949 } | |
| 3950 | |
| 3951 }); | |
| 3952 | |
| 3953 // Generate shortcuts for custom animations | |
| 3954 jQuery.each({ | |
| 3955 slideDown: genFx("show", 1), | |
| 3956 slideUp: genFx("hide", 1), | |
| 3957 slideToggle: genFx("toggle", 1), | |
| 3958 fadeIn: { opacity: "show" }, | |
| 3959 fadeOut: { opacity: "hide" } | |
| 3960 }, function( name, props ){ | |
| 3961 jQuery.fn[ name ] = function( speed, callback ){ | |
| 3962 return this.animate( props, speed, callback ); | |
| 3963 }; | |
| 3964 }); | |
| 3965 | |
| 3966 jQuery.extend({ | |
| 3967 | |
| 3968 speed: function(speed, easing, fn) { | |
| 3969 var opt = typeof speed === "object" ? speed : { | |
| 3970 complete: fn || !fn && easing || | |
| 3971 jQuery.isFunction( speed ) && speed, | |
| 3972 duration: speed, | |
| 3973 easing: fn && easing || easing && !jQuery.isFunction(eas
ing) && easing | |
| 3974 }; | |
| 3975 | |
| 3976 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "numb
er" ? opt.duration : | |
| 3977 jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._defa
ult; | |
| 3978 | |
| 3979 // Queueing | |
| 3980 opt.old = opt.complete; | |
| 3981 opt.complete = function(){ | |
| 3982 if ( opt.queue !== false ) | |
| 3983 jQuery(this).dequeue(); | |
| 3984 if ( jQuery.isFunction( opt.old ) ) | |
| 3985 opt.old.call( this ); | |
| 3986 }; | |
| 3987 | |
| 3988 return opt; | |
| 3989 }, | |
| 3990 | |
| 3991 easing: { | |
| 3992 linear: function( p, n, firstNum, diff ) { | |
| 3993 return firstNum + diff * p; | |
| 3994 }, | |
| 3995 swing: function( p, n, firstNum, diff ) { | |
| 3996 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNu
m; | |
| 3997 } | |
| 3998 }, | |
| 3999 | |
| 4000 timers: [], | |
| 4001 | |
| 4002 fx: function( elem, options, prop ){ | |
| 4003 this.options = options; | |
| 4004 this.elem = elem; | |
| 4005 this.prop = prop; | |
| 4006 | |
| 4007 if ( !options.orig ) | |
| 4008 options.orig = {}; | |
| 4009 } | |
| 4010 | |
| 4011 }); | |
| 4012 | |
| 4013 jQuery.fx.prototype = { | |
| 4014 | |
| 4015 // Simple function for setting a style value | |
| 4016 update: function(){ | |
| 4017 if ( this.options.step ) | |
| 4018 this.options.step.call( this.elem, this.now, this ); | |
| 4019 | |
| 4020 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this ); | |
| 4021 | |
| 4022 // Set display property to block for height/width animations | |
| 4023 if ( ( this.prop == "height" || this.prop == "width" ) && this.e
lem.style ) | |
| 4024 this.elem.style.display = "block"; | |
| 4025 }, | |
| 4026 | |
| 4027 // Get the current size | |
| 4028 cur: function(force){ | |
| 4029 if ( this.elem[this.prop] != null && (!this.elem.style || this.e
lem.style[this.prop] == null) ) | |
| 4030 return this.elem[ this.prop ]; | |
| 4031 | |
| 4032 var r = parseFloat(jQuery.css(this.elem, this.prop, force)); | |
| 4033 return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem,
this.prop)) || 0; | |
| 4034 }, | |
| 4035 | |
| 4036 // Start an animation from one number to another | |
| 4037 custom: function(from, to, unit){ | |
| 4038 this.startTime = now(); | |
| 4039 this.start = from; | |
| 4040 this.end = to; | |
| 4041 this.unit = unit || this.unit || "px"; | |
| 4042 this.now = this.start; | |
| 4043 this.pos = this.state = 0; | |
| 4044 | |
| 4045 var self = this; | |
| 4046 function t(gotoEnd){ | |
| 4047 return self.step(gotoEnd); | |
| 4048 } | |
| 4049 | |
| 4050 t.elem = this.elem; | |
| 4051 | |
| 4052 if ( t() && jQuery.timers.push(t) && !timerId ) { | |
| 4053 timerId = setInterval(function(){ | |
| 4054 var timers = jQuery.timers; | |
| 4055 | |
| 4056 for ( var i = 0; i < timers.length; i++ ) | |
| 4057 if ( !timers[i]() ) | |
| 4058 timers.splice(i--, 1); | |
| 4059 | |
| 4060 if ( !timers.length ) { | |
| 4061 clearInterval( timerId ); | |
| 4062 timerId = undefined; | |
| 4063 } | |
| 4064 }, 13); | |
| 4065 } | |
| 4066 }, | |
| 4067 | |
| 4068 // Simple 'show' function | |
| 4069 show: function(){ | |
| 4070 // Remember where we started, so that we can go back to it later | |
| 4071 this.options.orig[this.prop] = jQuery.attr( this.elem.style, thi
s.prop ); | |
| 4072 this.options.show = true; | |
| 4073 | |
| 4074 // Begin the animation | |
| 4075 // Make sure that we start at a small width/height to avoid any | |
| 4076 // flash of content | |
| 4077 this.custom(this.prop == "width" || this.prop == "height" ? 1 :
0, this.cur()); | |
| 4078 | |
| 4079 // Start by showing the element | |
| 4080 jQuery(this.elem).show(); | |
| 4081 }, | |
| 4082 | |
| 4083 // Simple 'hide' function | |
| 4084 hide: function(){ | |
| 4085 // Remember where we started, so that we can go back to it later | |
| 4086 this.options.orig[this.prop] = jQuery.attr( this.elem.style, thi
s.prop ); | |
| 4087 this.options.hide = true; | |
| 4088 | |
| 4089 // Begin the animation | |
| 4090 this.custom(this.cur(), 0); | |
| 4091 }, | |
| 4092 | |
| 4093 // Each step of an animation | |
| 4094 step: function(gotoEnd){ | |
| 4095 var t = now(); | |
| 4096 | |
| 4097 if ( gotoEnd || t >= this.options.duration + this.startTime ) { | |
| 4098 this.now = this.end; | |
| 4099 this.pos = this.state = 1; | |
| 4100 this.update(); | |
| 4101 | |
| 4102 this.options.curAnim[ this.prop ] = true; | |
| 4103 | |
| 4104 var done = true; | |
| 4105 for ( var i in this.options.curAnim ) | |
| 4106 if ( this.options.curAnim[i] !== true ) | |
| 4107 done = false; | |
| 4108 | |
| 4109 if ( done ) { | |
| 4110 if ( this.options.display != null ) { | |
| 4111 // Reset the overflow | |
| 4112 this.elem.style.overflow = this.options.
overflow; | |
| 4113 | |
| 4114 // Reset the display | |
| 4115 this.elem.style.display = this.options.d
isplay; | |
| 4116 if ( jQuery.css(this.elem, "display") ==
"none" ) | |
| 4117 this.elem.style.display = "block
"; | |
| 4118 } | |
| 4119 | |
| 4120 // Hide the element if the "hide" operation was
done | |
| 4121 if ( this.options.hide ) | |
| 4122 jQuery(this.elem).hide(); | |
| 4123 | |
| 4124 // Reset the properties, if the item has been hi
dden or shown | |
| 4125 if ( this.options.hide || this.options.show ) | |
| 4126 for ( var p in this.options.curAnim ) | |
| 4127 jQuery.attr(this.elem.style, p,
this.options.orig[p]); | |
| 4128 | |
| 4129 // Execute the complete function | |
| 4130 this.options.complete.call( this.elem ); | |
| 4131 } | |
| 4132 | |
| 4133 return false; | |
| 4134 } else { | |
| 4135 var n = t - this.startTime; | |
| 4136 this.state = n / this.options.duration; | |
| 4137 | |
| 4138 // Perform the easing function, defaults to swing | |
| 4139 this.pos = jQuery.easing[this.options.easing || (jQuery.
easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration); | |
| 4140 this.now = this.start + ((this.end - this.start) * this.
pos); | |
| 4141 | |
| 4142 // Perform the next step of the animation | |
| 4143 this.update(); | |
| 4144 } | |
| 4145 | |
| 4146 return true; | |
| 4147 } | |
| 4148 | |
| 4149 }; | |
| 4150 | |
| 4151 jQuery.extend( jQuery.fx, { | |
| 4152 speeds:{ | |
| 4153 slow: 600, | |
| 4154 fast: 200, | |
| 4155 // Default speed | |
| 4156 _default: 400 | |
| 4157 }, | |
| 4158 step: { | |
| 4159 | |
| 4160 opacity: function(fx){ | |
| 4161 jQuery.attr(fx.elem.style, "opacity", fx.now); | |
| 4162 }, | |
| 4163 | |
| 4164 _default: function(fx){ | |
| 4165 if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) | |
| 4166 fx.elem.style[ fx.prop ] = fx.now + fx.unit; | |
| 4167 else | |
| 4168 fx.elem[ fx.prop ] = fx.now; | |
| 4169 } | |
| 4170 } | |
| 4171 }); | |
| 4172 if ( document.documentElement["getBoundingClientRect"] ) | |
| 4173 jQuery.fn.offset = function() { | |
| 4174 if ( !this[0] ) return { top: 0, left: 0 }; | |
| 4175 if ( this[0] === this[0].ownerDocument.body ) return jQuery.offs
et.bodyOffset( this[0] ); | |
| 4176 var box = this[0].getBoundingClientRect(), doc = this[0].ownerD
ocument, body = doc.body, docElem = doc.documentElement, | |
| 4177 clientTop = docElem.clientTop || body.clientTop || 0, cl
ientLeft = docElem.clientLeft || body.clientLeft || 0, | |
| 4178 top = box.top + (self.pageYOffset || jQuery.boxModel &
& docElem.scrollTop || body.scrollTop ) - clientTop, | |
| 4179 left = box.left + (self.pageXOffset || jQuery.boxModel &
& docElem.scrollLeft || body.scrollLeft) - clientLeft; | |
| 4180 return { top: top, left: left }; | |
| 4181 }; | |
| 4182 else | |
| 4183 jQuery.fn.offset = function() { | |
| 4184 if ( !this[0] ) return { top: 0, left: 0 }; | |
| 4185 if ( this[0] === this[0].ownerDocument.body ) return jQuery.offs
et.bodyOffset( this[0] ); | |
| 4186 jQuery.offset.initialized || jQuery.offset.initialize(); | |
| 4187 | |
| 4188 var elem = this[0], offsetParent = elem.offsetParent, prevOffset
Parent = elem, | |
| 4189 doc = elem.ownerDocument, computedStyle, docElem = doc.d
ocumentElement, | |
| 4190 body = doc.body, defaultView = doc.defaultView, | |
| 4191 prevComputedStyle = defaultView.getComputedStyle(elem, n
ull), | |
| 4192 top = elem.offsetTop, left = elem.offsetLeft; | |
| 4193 | |
| 4194 while ( (elem = elem.parentNode) && elem !== body && elem !== do
cElem ) { | |
| 4195 computedStyle = defaultView.getComputedStyle(elem, null)
; | |
| 4196 top -= elem.scrollTop, left -= elem.scrollLeft; | |
| 4197 if ( elem === offsetParent ) { | |
| 4198 top += elem.offsetTop, left += elem.offsetLeft; | |
| 4199 if ( jQuery.offset.doesNotAddBorder && !(jQuery.
offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.tagName)) ) | |
| 4200 top += parseInt( computedStyle.borderTo
pWidth, 10) || 0, | |
| 4201 left += parseInt( computedStyle.borderLe
ftWidth, 10) || 0; | |
| 4202 prevOffsetParent = offsetParent, offsetParent =
elem.offsetParent; | |
| 4203 } | |
| 4204 if ( jQuery.offset.subtractsBorderForOverflowNotVisible
&& computedStyle.overflow !== "visible" ) | |
| 4205 top += parseInt( computedStyle.borderTopWidth,
10) || 0, | |
| 4206 left += parseInt( computedStyle.borderLeftWidth,
10) || 0; | |
| 4207 prevComputedStyle = computedStyle; | |
| 4208 } | |
| 4209 | |
| 4210 if ( prevComputedStyle.position === "relative" || prevComputedSt
yle.position === "static" ) | |
| 4211 top += body.offsetTop, | |
| 4212 left += body.offsetLeft; | |
| 4213 | |
| 4214 if ( prevComputedStyle.position === "fixed" ) | |
| 4215 top += Math.max(docElem.scrollTop, body.scrollTop), | |
| 4216 left += Math.max(docElem.scrollLeft, body.scrollLeft); | |
| 4217 | |
| 4218 return { top: top, left: left }; | |
| 4219 }; | |
| 4220 | |
| 4221 jQuery.offset = { | |
| 4222 initialize: function() { | |
| 4223 if ( this.initialized ) return; | |
| 4224 var body = document.body, container = document.createElement('di
v'), innerDiv, checkDiv, table, td, rules, prop, bodyMarginTop = body.style.marg
inTop, | |
| 4225 html = '<div style="position:absolute;top:0;left:0;margi
n:0;border:5px solid #000;padding:0;width:1px;height:1px;"><div></div></div><tab
le 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></tab
le>'; | |
| 4226 | |
| 4227 rules = { position: 'absolute', top: 0, left: 0, margin: 0, bord
er: 0, width: '1px', height: '1px', visibility: 'hidden' }; | |
| 4228 for ( prop in rules ) container.style[prop] = rules[prop]; | |
| 4229 | |
| 4230 container.innerHTML = html; | |
| 4231 body.insertBefore(container, body.firstChild); | |
| 4232 innerDiv = container.firstChild, checkDiv = innerDiv.firstChild,
td = innerDiv.nextSibling.firstChild.firstChild; | |
| 4233 | |
| 4234 this.doesNotAddBorder = (checkDiv.offsetTop !== 5); | |
| 4235 this.doesAddBorderForTableAndCells = (td.offsetTop === 5); | |
| 4236 | |
| 4237 innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'r
elative'; | |
| 4238 this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop
=== -5); | |
| 4239 | |
| 4240 body.style.marginTop = '1px'; | |
| 4241 this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0); | |
| 4242 body.style.marginTop = bodyMarginTop; | |
| 4243 | |
| 4244 body.removeChild(container); | |
| 4245 this.initialized = true; | |
| 4246 }, | |
| 4247 | |
| 4248 bodyOffset: function(body) { | |
| 4249 jQuery.offset.initialized || jQuery.offset.initialize(); | |
| 4250 var top = body.offsetTop, left = body.offsetLeft; | |
| 4251 if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) | |
| 4252 top += parseInt( jQuery.curCSS(body, 'marginTop', true
), 10 ) || 0, | |
| 4253 left += parseInt( jQuery.curCSS(body, 'marginLeft', true
), 10 ) || 0; | |
| 4254 return { top: top, left: left }; | |
| 4255 } | |
| 4256 }; | |
| 4257 | |
| 4258 | |
| 4259 jQuery.fn.extend({ | |
| 4260 position: function() { | |
| 4261 var left = 0, top = 0, results; | |
| 4262 | |
| 4263 if ( this[0] ) { | |
| 4264 // Get *real* offsetParent | |
| 4265 var offsetParent = this.offsetParent(), | |
| 4266 | |
| 4267 // Get correct offsets | |
| 4268 offset = this.offset(), | |
| 4269 parentOffset = /^body|html$/i.test(offsetParent[0].tagNa
me) ? { top: 0, left: 0 } : offsetParent.offset(); | |
| 4270 | |
| 4271 // Subtract element margins | |
| 4272 // note: when an element has margin: auto the offsetLeft
and marginLeft | |
| 4273 // are the same in Safari causing offset.left to incorre
ctly be 0 | |
| 4274 offset.top -= num( this, 'marginTop' ); | |
| 4275 offset.left -= num( this, 'marginLeft' ); | |
| 4276 | |
| 4277 // Add offsetParent borders | |
| 4278 parentOffset.top += num( offsetParent, 'borderTopWidth'
); | |
| 4279 parentOffset.left += num( offsetParent, 'borderLeftWidth
' ); | |
| 4280 | |
| 4281 // Subtract the two offsets | |
| 4282 results = { | |
| 4283 top: offset.top - parentOffset.top, | |
| 4284 left: offset.left - parentOffset.left | |
| 4285 }; | |
| 4286 } | |
| 4287 | |
| 4288 return results; | |
| 4289 }, | |
| 4290 | |
| 4291 offsetParent: function() { | |
| 4292 var offsetParent = this[0].offsetParent || document.body; | |
| 4293 while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagNa
me) && jQuery.css(offsetParent, 'position') == 'static') ) | |
| 4294 offsetParent = offsetParent.offsetParent; | |
| 4295 return jQuery(offsetParent); | |
| 4296 } | |
| 4297 }); | |
| 4298 | |
| 4299 | |
| 4300 // Create scrollLeft and scrollTop methods | |
| 4301 jQuery.each( ['Left', 'Top'], function(i, name) { | |
| 4302 var method = 'scroll' + name; | |
| 4303 | |
| 4304 jQuery.fn[ method ] = function(val) { | |
| 4305 if (!this[0]) return null; | |
| 4306 | |
| 4307 return val !== undefined ? | |
| 4308 | |
| 4309 // Set the scroll offset | |
| 4310 this.each(function() { | |
| 4311 this == window || this == document ? | |
| 4312 window.scrollTo( | |
| 4313 !i ? val : jQuery(window).scroll
Left(), | |
| 4314 i ? val : jQuery(window).scroll
Top() | |
| 4315 ) : | |
| 4316 this[ method ] = val; | |
| 4317 }) : | |
| 4318 | |
| 4319 // Return the scroll offset | |
| 4320 this[0] == window || this[0] == document ? | |
| 4321 self[ i ? 'pageYOffset' : 'pageXOffset' ] || | |
| 4322 jQuery.boxModel && document.documentElem
ent[ method ] || | |
| 4323 document.body[ method ] : | |
| 4324 this[0][ method ]; | |
| 4325 }; | |
| 4326 }); | |
| 4327 // Create innerHeight, innerWidth, outerHeight and outerWidth methods | |
| 4328 jQuery.each([ "Height", "Width" ], function(i, name){ | |
| 4329 | |
| 4330 var tl = i ? "Left" : "Top", // top or left | |
| 4331 br = i ? "Right" : "Bottom", // bottom or right | |
| 4332 lower = name.toLowerCase(); | |
| 4333 | |
| 4334 // innerHeight and innerWidth | |
| 4335 jQuery.fn["inner" + name] = function(){ | |
| 4336 return this[0] ? | |
| 4337 jQuery.css( this[0], lower, false, "padding" ) : | |
| 4338 null; | |
| 4339 }; | |
| 4340 | |
| 4341 // outerHeight and outerWidth | |
| 4342 jQuery.fn["outer" + name] = function(margin) { | |
| 4343 return this[0] ? | |
| 4344 jQuery.css( this[0], lower, false, margin ? "margin" : "
border" ) : | |
| 4345 null; | |
| 4346 }; | |
| 4347 | |
| 4348 var type = name.toLowerCase(); | |
| 4349 | |
| 4350 jQuery.fn[ type ] = function( size ) { | |
| 4351 // Get window width or height | |
| 4352 return this[0] == window ? | |
| 4353 // Everyone else use document.documentElement or documen
t.body depending on Quirks vs Standards mode | |
| 4354 document.compatMode == "CSS1Compat" && document.document
Element[ "client" + name ] || | |
| 4355 document.body[ "client" + name ] : | |
| 4356 | |
| 4357 // Get document width or height | |
| 4358 this[0] == document ? | |
| 4359 // Either scroll[Width/Height] or offset[Width/H
eight], whichever is greater | |
| 4360 Math.max( | |
| 4361 document.documentElement["client" + name
], | |
| 4362 document.body["scroll" + name], document
.documentElement["scroll" + name], | |
| 4363 document.body["offset" + name], document
.documentElement["offset" + name] | |
| 4364 ) : | |
| 4365 | |
| 4366 // Get or set width or height on the element | |
| 4367 size === undefined ? | |
| 4368 // Get width or height on the element | |
| 4369 (this.length ? jQuery.css( this[0], type
) : null) : | |
| 4370 | |
| 4371 // Set the width or height on the elemen
t (default to pixels if value is unitless) | |
| 4372 this.css( type, typeof size === "string"
? size : size + "px" ); | |
| 4373 }; | |
| 4374 | |
| 4375 }); | |
| 4376 })(); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 424363004:
Update third_party/webdriver/pylib to r18456 and delete test_data (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master