4228a57ed36f3503b0cb03f6623b16114c2926cc
[euphorik.git] / js / libs / jquery.js
1 (function(){
2 /*
3 * jQuery 1.2.7pre - New Wave Javascript
4 *
5 * Copyright (c) 2008 John Resig (jquery.com)
6 * Dual licensed under the MIT (MIT-LICENSE.txt)
7 * and GPL (GPL-LICENSE.txt) licenses.
8 *
9 * $Date: 2008-06-30 12:17:44 -0400 (Mon, 30 Jun 2008) $
10 * $Rev: 5754 $
11 */
12
13 // Map over jQuery in case of overwrite
14 var _jQuery = window.jQuery,
15 // Map over the $ in case of overwrite
16 _$ = window.$;
17
18 var jQuery = window.jQuery = window.$ = function( selector, context ) {
19 // The jQuery object is actually just the init constructor 'enhanced'
20 return new jQuery.fn.init( selector, context );
21 };
22
23 // A simple way to check for HTML strings or ID strings
24 // (both of which we optimize for)
25 var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,
26
27 // Is it a simple selector
28 isSimple = /^.[^:#\[\.]*$/,
29
30 // Will speed up references to undefined, and allows munging its name.
31 undefined;
32
33 jQuery.fn = jQuery.prototype = {
34 init: function( selector, context ) {
35 // Make sure that a selection was provided
36 selector = selector || document;
37
38 // Handle $(DOMElement)
39 if ( selector.nodeType ) {
40 this[0] = selector;
41 this.length = 1;
42 return this;
43 }
44 // Handle HTML strings
45 if ( typeof selector == "string" ) {
46 // Are we dealing with HTML string or an ID?
47 var match = quickExpr.exec( selector );
48
49 // Verify a match, and that no context was specified for #id
50 if ( match && (match[1] || !context) ) {
51
52 // HANDLE: $(html) -> $(array)
53 if ( match[1] )
54 selector = jQuery.clean( [ match[1] ], context );
55
56 // HANDLE: $("#id")
57 else {
58 var elem = document.getElementById( match[3] );
59
60 // Make sure an element was located
61 if ( elem ){
62 // Handle the case where IE and Opera return items
63 // by name instead of ID
64 if ( elem.id != match[3] )
65 return jQuery().find( selector );
66
67 // Otherwise, we inject the element directly into the jQuery object
68 return jQuery( elem );
69 }
70 selector = [];
71 }
72
73 // HANDLE: $(expr, [context])
74 // (which is just equivalent to: $(content).find(expr)
75 } else
76 return jQuery( context ).find( selector );
77
78 // HANDLE: $(function)
79 // Shortcut for document ready
80 } else if ( jQuery.isFunction( selector ) )
81 return jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );
82
83 return this.setArray(jQuery.makeArray(selector));
84 },
85
86 // The current version of jQuery being used
87 jquery: "1.2.7pre",
88
89 // The number of elements contained in the matched element set
90 size: function() {
91 return this.length;
92 },
93
94 // The number of elements contained in the matched element set
95 length: 0,
96
97 // Get the Nth element in the matched element set OR
98 // Get the whole matched element set as a clean array
99 get: function( num ) {
100 return num == undefined ?
101
102 // Return a 'clean' array
103 jQuery.makeArray( this ) :
104
105 // Return just the object
106 this[ num ];
107 },
108
109 // Take an array of elements and push it onto the stack
110 // (returning the new matched element set)
111 pushStack: function( elems ) {
112 // Build a new jQuery matched element set
113 var ret = jQuery( elems );
114
115 // Add the old object onto the stack (as a reference)
116 ret.prevObject = this;
117
118 // Return the newly-formed element set
119 return ret;
120 },
121
122 // Force the current matched set of elements to become
123 // the specified array of elements (destroying the stack in the process)
124 // You should use pushStack() in order to do this, but maintain the stack
125 setArray: function( elems ) {
126 // Resetting the length to 0, then using the native Array push
127 // is a super-fast way to populate an object with array-like properties
128 this.length = 0;
129 Array.prototype.push.apply( this, elems );
130
131 return this;
132 },
133
134 // Execute a callback for every element in the matched set.
135 // (You can seed the arguments with an array of args, but this is
136 // only used internally.)
137 each: function( callback, args ) {
138 return jQuery.each( this, callback, args );
139 },
140
141 // Determine the position of an element within
142 // the matched set of elements
143 index: function( elem ) {
144 var ret = -1;
145
146 // Locate the position of the desired element
147 return jQuery.inArray(
148 // If it receives a jQuery object, the first element is used
149 elem && elem.jquery ? elem[0] : elem
150 , this );
151 },
152
153 attr: function( name, value, type ) {
154 var options = name;
155
156 // Look for the case where we're accessing a style value
157 if ( name.constructor == String )
158 if ( value === undefined )
159 return this[0] && jQuery[ type || "attr" ]( this[0], name );
160
161 else {
162 options = {};
163 options[ name ] = value;
164 }
165
166 // Check to see if we're setting style values
167 return this.each(function(i){
168 // Set all the styles
169 for ( name in options )
170 jQuery.attr(
171 type ?
172 this.style :
173 this,
174 name, jQuery.prop( this, options[ name ], type, i, name )
175 );
176 });
177 },
178
179 css: function( key, value ) {
180 // ignore negative width and height values
181 if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
182 value = undefined;
183 return this.attr( key, value, "curCSS" );
184 },
185
186 text: function( text ) {
187 if ( typeof text != "object" && text != null )
188 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
189
190 var ret = "";
191
192 jQuery.each( text || this, function(){
193 jQuery.each( this.childNodes, function(){
194 if ( this.nodeType != 8 )
195 ret += this.nodeType != 1 ?
196 this.nodeValue :
197 jQuery.fn.text( [ this ] );
198 });
199 });
200
201 return ret;
202 },
203
204 wrapAll: function( html ) {
205 if ( this[0] )
206 // The elements to wrap the target around
207 jQuery( html, this[0].ownerDocument )
208 .clone()
209 .insertBefore( this[0] )
210 .map(function(){
211 var elem = this;
212
213 while ( elem.firstChild )
214 elem = elem.firstChild;
215
216 return elem;
217 })
218 .append(this);
219
220 return this;
221 },
222
223 wrapInner: function( html ) {
224 return this.each(function(){
225 jQuery( this ).contents().wrapAll( html );
226 });
227 },
228
229 wrap: function( html ) {
230 return this.each(function(){
231 jQuery( this ).wrapAll( html );
232 });
233 },
234
235 append: function() {
236 return this.domManip(arguments, true, false, function(elem){
237 if (this.nodeType == 1)
238 this.appendChild( elem );
239 });
240 },
241
242 prepend: function() {
243 return this.domManip(arguments, true, true, function(elem){
244 if (this.nodeType == 1)
245 this.insertBefore( elem, this.firstChild );
246 });
247 },
248
249 before: function() {
250 return this.domManip(arguments, false, false, function(elem){
251 this.parentNode.insertBefore( elem, this );
252 });
253 },
254
255 after: function() {
256 return this.domManip(arguments, false, true, function(elem){
257 this.parentNode.insertBefore( elem, this.nextSibling );
258 });
259 },
260
261 end: function() {
262 return this.prevObject || jQuery( [] );
263 },
264
265 find: function( selector ) {
266 var elems = jQuery.map(this, function(elem){
267 return jQuery.find( selector, elem );
268 });
269
270 return this.pushStack( /[^+>] [^+>]/.test( selector ) || selector.indexOf("..") > -1 ?
271 jQuery.unique( elems ) :
272 elems );
273 },
274
275 clone: function( events ) {
276 // Do the clone
277 var ret = this.map(function(){
278 if ( jQuery.browser.msie && !jQuery.isXMLDoc(this) ) {
279 // IE copies events bound via attachEvent when
280 // using cloneNode. Calling detachEvent on the
281 // clone will also remove the events from the orignal
282 // In order to get around this, we use innerHTML.
283 // Unfortunately, this means some modifications to
284 // attributes in IE that are actually only stored
285 // as properties will not be copied (such as the
286 // the name attribute on an input).
287 var clone = this.cloneNode(true),
288 container = document.createElement("div");
289 container.appendChild(clone);
290 return jQuery.clean([container.innerHTML])[0];
291 } else
292 return this.cloneNode(true);
293 });
294
295 // Need to set the expando to null on the cloned set if it exists
296 // removeData doesn't work here, IE removes it from the original as well
297 // this is primarily for IE but the data expando shouldn't be copied over in any browser
298 var clone = ret.find("*").andSelf().each(function(){
299 if ( this[ expando ] != undefined )
300 this[ expando ] = null;
301 });
302
303 // Copy the events from the original to the clone
304 if ( events === true )
305 this.find("*").andSelf().each(function(i){
306 if (this.nodeType == 3)
307 return;
308 var events = jQuery.data( this, "events" );
309
310 for ( var type in events )
311 for ( var handler in events[ type ] )
312 jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
313 });
314
315 // Return the cloned set
316 return ret;
317 },
318
319 filter: function( selector ) {
320 return this.pushStack(
321 jQuery.isFunction( selector ) &&
322 jQuery.grep(this, function(elem, i){
323 return selector.call( elem, i );
324 }) ||
325
326 jQuery.multiFilter( selector, this ) );
327 },
328
329 not: function( selector ) {
330 if ( selector.constructor == String )
331 // test special case where just one selector is passed in
332 if ( isSimple.test( selector ) )
333 return this.pushStack( jQuery.multiFilter( selector, this, true ) );
334 else
335 selector = jQuery.multiFilter( selector, this );
336
337 var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
338 return this.filter(function() {
339 return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
340 });
341 },
342
343 add: function( selector ) {
344 return this.pushStack( jQuery.unique( jQuery.merge(
345 this.get(),
346 typeof selector == 'string' ?
347 jQuery( selector ) :
348 jQuery.makeArray( selector )
349 )));
350 },
351
352 is: function( selector ) {
353 return !!selector && jQuery.multiFilter( selector, this ).length > 0;
354 },
355
356 hasClass: function( selector ) {
357 return this.is( "." + selector );
358 },
359
360 val: function( value ) {
361 if ( value == undefined ) {
362
363 if ( this.length ) {
364 var elem = this[0];
365
366 // We need to handle select boxes special
367 if ( jQuery.nodeName( elem, "select" ) ) {
368 var index = elem.selectedIndex,
369 values = [],
370 options = elem.options,
371 one = elem.type == "select-one";
372
373 // Nothing was selected
374 if ( index < 0 )
375 return null;
376
377 // Loop through all the selected options
378 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
379 var option = options[ i ];
380
381 if ( option.selected ) {
382 // Get the specifc value for the option
383 value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;
384
385 // We don't need an array for one selects
386 if ( one )
387 return value;
388
389 // Multi-Selects return an array
390 values.push( value );
391 }
392 }
393
394 return values;
395
396 // Everything else, we just grab the value
397 } else
398 return (this[0].value || "").replace(/\r/g, "");
399
400 }
401
402 return undefined;
403 }
404
405 if( value.constructor == Number )
406 value += '';
407
408 return this.each(function(){
409 if ( this.nodeType != 1 )
410 return;
411
412 if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
413 this.checked = (jQuery.inArray(this.value, value) >= 0 ||
414 jQuery.inArray(this.name, value) >= 0);
415
416 else if ( jQuery.nodeName( this, "select" ) ) {
417 var values = jQuery.makeArray(value);
418
419 jQuery( "option", this ).each(function(){
420 this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
421 jQuery.inArray( this.text, values ) >= 0);
422 });
423
424 if ( !values.length )
425 this.selectedIndex = -1;
426
427 } else
428 this.value = value;
429 });
430 },
431
432 html: function( value ) {
433 return value == undefined ?
434 (this[0] ?
435 this[0].innerHTML :
436 null) :
437 this.empty().append( value );
438 },
439
440 replaceWith: function( value ) {
441 return this.after( value ).remove();
442 },
443
444 eq: function( i ) {
445 return this.slice( i, +i + 1 );
446 },
447
448 slice: function() {
449 return this.pushStack( Array.prototype.slice.apply( this, arguments ) );
450 },
451
452 map: function( callback ) {
453 return this.pushStack( jQuery.map(this, function(elem, i){
454 return callback.call( elem, i, elem );
455 }));
456 },
457
458 andSelf: function() {
459 return this.add( this.prevObject );
460 },
461
462 data: function( key, value ){
463 var parts = key.split(".");
464 parts[1] = parts[1] ? "." + parts[1] : "";
465
466 if ( value === undefined ) {
467 var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
468
469 if ( data === undefined && this.length )
470 data = jQuery.data( this[0], key );
471
472 return data === undefined && parts[1] ?
473 this.data( parts[0] ) :
474 data;
475 } else
476 return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
477 jQuery.data( this, key, value );
478 });
479 },
480
481 removeData: function( key ){
482 return this.each(function(){
483 jQuery.removeData( this, key );
484 });
485 },
486
487 domManip: function( args, table, reverse, callback ) {
488 var clone = this.length > 1, elems;
489
490 return this.each(function(){
491 if ( !elems ) {
492 elems = jQuery.clean( args, this.ownerDocument );
493
494 if ( reverse )
495 elems.reverse();
496 }
497
498 var obj = this;
499
500 if ( table && jQuery.nodeName( this, "table" ) && jQuery.nodeName( elems[0], "tr" ) )
501 obj = this.getElementsByTagName("tbody")[0] || this.appendChild( this.ownerDocument.createElement("tbody") );
502
503 var scripts = jQuery( [] );
504
505 jQuery.each(elems, function(){
506 var elem = clone ?
507 jQuery( this ).clone( true )[0] :
508 this;
509
510 // execute all scripts after the elements have been injected
511 if ( jQuery.nodeName( elem, "script" ) )
512 scripts = scripts.add( elem );
513 else {
514 // Remove any inner scripts for later evaluation
515 if ( elem.nodeType == 1 )
516 scripts = scripts.add( jQuery( "script", elem ).remove() );
517
518 // Inject the elements into the document
519 callback.call( obj, elem );
520 }
521 });
522
523 scripts.each( evalScript );
524 });
525 }
526 };
527
528 // Give the init function the jQuery prototype for later instantiation
529 jQuery.fn.init.prototype = jQuery.fn;
530
531 function evalScript( i, elem ) {
532 if ( elem.src )
533 jQuery.ajax({
534 url: elem.src,
535 async: false,
536 dataType: "script"
537 });
538
539 else
540 jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
541
542 if ( elem.parentNode )
543 elem.parentNode.removeChild( elem );
544 }
545
546 function now(){
547 return +new Date;
548 }
549
550 jQuery.extend = jQuery.fn.extend = function() {
551 // copy reference to target object
552 var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
553
554 // Handle a deep copy situation
555 if ( target.constructor == Boolean ) {
556 deep = target;
557 target = arguments[1] || {};
558 // skip the boolean and the target
559 i = 2;
560 }
561
562 // Handle case when target is a string or something (possible in deep copy)
563 if ( typeof target != "object" && typeof target != "function" )
564 target = {};
565
566 // extend jQuery itself if only one argument is passed
567 if ( length == i ) {
568 target = this;
569 --i;
570 }
571
572 for ( ; i < length; i++ )
573 // Only deal with non-null/undefined values
574 if ( (options = arguments[ i ]) != null )
575 // Extend the base object
576 for ( var name in options ) {
577 var src = target[ name ], copy = options[ name ];
578
579 // Prevent never-ending loop
580 if ( target === copy )
581 continue;
582
583 // Recurse if we're merging object values
584 if ( deep && copy && typeof copy == "object" && !copy.nodeType )
585 target[ name ] = jQuery.extend( deep,
586 // Never move original objects, clone them
587 src || ( copy.length != null ? [ ] : { } )
588 , copy );
589
590 // Don't bring in undefined values
591 else if ( copy !== undefined )
592 target[ name ] = copy;
593
594 }
595
596 // Return the modified object
597 return target;
598 };
599
600 var expando = "jQuery" + now(), uuid = 0, windowData = {},
601 // exclude the following css properties to add px
602 exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
603 // cache defaultView
604 defaultView = document.defaultView || {};
605
606 jQuery.extend({
607 noConflict: function( deep ) {
608 window.$ = _$;
609
610 if ( deep )
611 window.jQuery = _jQuery;
612
613 return jQuery;
614 },
615
616 // See test/unit/core.js for details concerning this function.
617 isFunction: function( fn ) {
618 return !!fn && typeof fn != "string" && !fn.nodeName &&
619 fn.constructor != Array && /^[\s[]?function/.test( fn + "" );
620 },
621
622 // check if an element is in a (or is an) XML document
623 isXMLDoc: function( elem ) {
624 return elem.documentElement && !elem.body ||
625 elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
626 },
627
628 // Evalulates a script in a global context
629 globalEval: function( data ) {
630 data = jQuery.trim( data );
631
632 if ( data ) {
633 // Inspired by code by Andrea Giammarchi
634 // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
635 var head = document.getElementsByTagName("head")[0] || document.documentElement,
636 script = document.createElement("script");
637
638 script.type = "text/javascript";
639 if ( jQuery.browser.msie )
640 script.text = data;
641 else
642 script.appendChild( document.createTextNode( data ) );
643
644 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
645 // This arises when a base node is used (#2709).
646 head.insertBefore( script, head.firstChild );
647 head.removeChild( script );
648 }
649 },
650
651 nodeName: function( elem, name ) {
652 return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
653 },
654
655 cache: {},
656
657 data: function( elem, name, data ) {
658 elem = elem == window ?
659 windowData :
660 elem;
661
662 var id = elem[ expando ];
663
664 // Compute a unique ID for the element
665 if ( !id )
666 id = elem[ expando ] = ++uuid;
667
668 // Only generate the data cache if we're
669 // trying to access or manipulate it
670 if ( name && !jQuery.cache[ id ] )
671 jQuery.cache[ id ] = {};
672
673 // Prevent overriding the named cache with undefined values
674 if ( data !== undefined )
675 jQuery.cache[ id ][ name ] = data;
676
677 // Return the named cache data, or the ID for the element
678 return name ?
679 jQuery.cache[ id ][ name ] :
680 id;
681 },
682
683 removeData: function( elem, name ) {
684 elem = elem == window ?
685 windowData :
686 elem;
687
688 var id = elem[ expando ];
689
690 // If we want to remove a specific section of the element's data
691 if ( name ) {
692 if ( jQuery.cache[ id ] ) {
693 // Remove the section of cache data
694 delete jQuery.cache[ id ][ name ];
695
696 // If we've removed all the data, remove the element's cache
697 name = "";
698
699 for ( name in jQuery.cache[ id ] )
700 break;
701
702 if ( !name )
703 jQuery.removeData( elem );
704 }
705
706 // Otherwise, we want to remove all of the element's data
707 } else {
708 // Clean up the element expando
709 try {
710 delete elem[ expando ];
711 } catch(e){
712 // IE has trouble directly removing the expando
713 // but it's ok with using removeAttribute
714 if ( elem.removeAttribute )
715 elem.removeAttribute( expando );
716 }
717
718 // Completely remove the data cache
719 delete jQuery.cache[ id ];
720 }
721 },
722
723 // args is for internal usage only
724 each: function( object, callback, args ) {
725 var name, i = 0, length = object.length;
726
727 if ( args ) {
728 if ( length == undefined ) {
729 for ( name in object )
730 if ( callback.apply( object[ name ], args ) === false )
731 break;
732 } else
733 for ( ; i < length; )
734 if ( callback.apply( object[ i++ ], args ) === false )
735 break;
736
737 // A special, fast, case for the most common use of each
738 } else {
739 if ( length == undefined ) {
740 for ( name in object )
741 if ( callback.call( object[ name ], name, object[ name ] ) === false )
742 break;
743 } else
744 for ( var value = object[0];
745 i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
746 }
747
748 return object;
749 },
750
751 prop: function( elem, value, type, i, name ) {
752 // Handle executable functions
753 if ( jQuery.isFunction( value ) )
754 value = value.call( elem, i );
755
756 // Handle passing in a number to a CSS property
757 return value && value.constructor == Number && type == "curCSS" && !exclude.test( name ) ?
758 value + "px" :
759 value;
760 },
761
762 className: {
763 // internal only, use addClass("class")
764 add: function( elem, classNames ) {
765 jQuery.each((classNames || "").split(/\s+/), function(i, className){
766 if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
767 elem.className += (elem.className ? " " : "") + className;
768 });
769 },
770
771 // internal only, use removeClass("class")
772 remove: function( elem, classNames ) {
773 if (elem.nodeType == 1)
774 elem.className = classNames != undefined ?
775 jQuery.grep(elem.className.split(/\s+/), function(className){
776 return !jQuery.className.has( classNames, className );
777 }).join(" ") :
778 "";
779 },
780
781 // internal only, use hasClass("class")
782 has: function( elem, className ) {
783 return jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
784 }
785 },
786
787 // A method for quickly swapping in/out CSS properties to get correct calculations
788 swap: function( elem, options, callback ) {
789 var old = {};
790 // Remember the old values, and insert the new ones
791 for ( var name in options ) {
792 old[ name ] = elem.style[ name ];
793 elem.style[ name ] = options[ name ];
794 }
795
796 callback.call( elem );
797
798 // Revert the old values
799 for ( var name in options )
800 elem.style[ name ] = old[ name ];
801 },
802
803 css: function( elem, name, force ) {
804 if ( name == "width" || name == "height" ) {
805 var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
806
807 function getWH() {
808 val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
809 var padding = 0, border = 0;
810 jQuery.each( which, function() {
811 padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
812 border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
813 });
814 val -= Math.round(padding + border);
815 }
816
817 if ( jQuery(elem).is(":visible") )
818 getWH();
819 else
820 jQuery.swap( elem, props, getWH );
821
822 return Math.max(0, val);
823 }
824
825 return jQuery.curCSS( elem, name, force );
826 },
827
828 curCSS: function( elem, name, force ) {
829 var ret, style = elem.style;
830
831 // A helper method for determining if an element's values are broken
832 function color( elem ) {
833 if ( !jQuery.browser.safari )
834 return false;
835
836 // defaultView is cached
837 var ret = defaultView.getComputedStyle( elem, null );
838 return !ret || ret.getPropertyValue("color") == "";
839 }
840
841 // We need to handle opacity special in IE
842 if ( name == "opacity" && jQuery.browser.msie ) {
843 ret = jQuery.attr( style, "opacity" );
844
845 return ret == "" ?
846 "1" :
847 ret;
848 }
849 // Opera sometimes will give the wrong display answer, this fixes it, see #2037
850 if ( jQuery.browser.opera && name == "display" ) {
851 var save = style.outline;
852 style.outline = "0 solid black";
853 style.outline = save;
854 }
855
856 // Make sure we're using the right name for getting the float value
857 if ( name.match( /float/i ) )
858 name = styleFloat;
859
860 if ( !force && style && style[ name ] )
861 ret = style[ name ];
862
863 else if ( defaultView.getComputedStyle ) {
864
865 // Only "float" is needed here
866 if ( name.match( /float/i ) )
867 name = "float";
868
869 name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
870
871 var computedStyle = defaultView.getComputedStyle( elem, null );
872
873 if ( computedStyle && !color( elem ) )
874 ret = computedStyle.getPropertyValue( name );
875
876 // If the element isn't reporting its values properly in Safari
877 // then some display: none elements are involved
878 else {
879 var swap = [], stack = [], a = elem, i = 0;
880
881 // Locate all of the parent display: none elements
882 for ( ; a && color(a); a = a.parentNode )
883 stack.unshift(a);
884
885 // Go through and make them visible, but in reverse
886 // (It would be better if we knew the exact display type that they had)
887 for ( ; i < stack.length; i++ )
888 if ( color( stack[ i ] ) ) {
889 swap[ i ] = stack[ i ].style.display;
890 stack[ i ].style.display = "block";
891 }
892
893 // Since we flip the display style, we have to handle that
894 // one special, otherwise get the value
895 ret = name == "display" && swap[ stack.length - 1 ] != null ?
896 "none" :
897 ( computedStyle && computedStyle.getPropertyValue( name ) ) || "";
898
899 // Finally, revert the display styles back
900 for ( i = 0; i < swap.length; i++ )
901 if ( swap[ i ] != null )
902 stack[ i ].style.display = swap[ i ];
903 }
904
905 // We should always get a number back from opacity
906 if ( name == "opacity" && ret == "" )
907 ret = "1";
908
909 } else if ( elem.currentStyle ) {
910 var camelCase = name.replace(/\-(\w)/g, function(all, letter){
911 return letter.toUpperCase();
912 });
913
914 ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
915
916 // From the awesome hack by Dean Edwards
917 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
918
919 // If we're not dealing with a regular pixel number
920 // but a number that has a weird ending, we need to convert it to pixels
921 if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
922 // Remember the original values
923 var left = style.left, rsLeft = elem.runtimeStyle.left;
924
925 // Put in the new values to get a computed value out
926 elem.runtimeStyle.left = elem.currentStyle.left;
927 style.left = ret || 0;
928 ret = style.pixelLeft + "px";
929
930 // Revert the changed values
931 style.left = left;
932 elem.runtimeStyle.left = rsLeft;
933 }
934 }
935
936 return ret;
937 },
938
939 clean: function( elems, context ) {
940 var ret = [];
941 context = context || document;
942 // !context.createElement fails in IE with an error but returns typeof 'object'
943 if (typeof context.createElement == 'undefined')
944 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
945
946 jQuery.each(elems, function(i, elem){
947 if ( typeof elem == 'number' )
948 elem += '';
949
950 if ( !elem )
951 return;
952
953 // Convert html string into DOM nodes
954 if ( typeof elem == "string" ) {
955 // Fix "XHTML"-style tags in all browsers
956 elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
957 return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
958 all :
959 front + "></" + tag + ">";
960 });
961
962 // Trim whitespace, otherwise indexOf won't work as expected
963 var tags = jQuery.trim( elem ).toLowerCase(), div = context.createElement("div");
964
965 var wrap =
966 // option or optgroup
967 !tags.indexOf("<opt") &&
968 [ 1, "<select multiple='multiple'>", "</select>" ] ||
969
970 !tags.indexOf("<leg") &&
971 [ 1, "<fieldset>", "</fieldset>" ] ||
972
973 tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
974 [ 1, "<table>", "</table>" ] ||
975
976 !tags.indexOf("<tr") &&
977 [ 2, "<table><tbody>", "</tbody></table>" ] ||
978
979 // <thead> matched above
980 (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
981 [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
982
983 !tags.indexOf("<col") &&
984 [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
985
986 // IE can't serialize <link> and <script> tags normally
987 jQuery.browser.msie &&
988 [ 1, "div<div>", "</div>" ] ||
989
990 [ 0, "", "" ];
991
992 // Go to html and back, then peel off extra wrappers
993 div.innerHTML = wrap[1] + elem + wrap[2];
994
995 // Move to the right depth
996 while ( wrap[0]-- )
997 div = div.lastChild;
998
999 // Remove IE's autoinserted <tbody> from table fragments
1000 if ( jQuery.browser.msie ) {
1001
1002 // String was a <table>, *may* have spurious <tbody>
1003 var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
1004 div.firstChild && div.firstChild.childNodes :
1005
1006 // String was a bare <thead> or <tfoot>
1007 wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
1008 div.childNodes :
1009 [];
1010
1011 for ( var j = tbody.length - 1; j >= 0 ; --j )
1012 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
1013 tbody[ j ].parentNode.removeChild( tbody[ j ] );
1014
1015 // IE completely kills leading whitespace when innerHTML is used
1016 if ( /^\s/.test( elem ) )
1017 div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
1018
1019 }
1020
1021 elem = jQuery.makeArray( div.childNodes );
1022 }
1023
1024 if ( elem.length === 0 && (!jQuery.nodeName( elem, "form" ) && !jQuery.nodeName( elem, "select" )) )
1025 return;
1026
1027 if ( elem[0] == undefined || jQuery.nodeName( elem, "form" ) || elem.options )
1028 ret.push( elem );
1029
1030 else
1031 ret = jQuery.merge( ret, elem );
1032
1033 });
1034
1035 return ret;
1036 },
1037
1038 attr: function( elem, name, value ) {
1039 // don't set attributes on text and comment nodes
1040 if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
1041 return undefined;
1042
1043 var notxml = !jQuery.isXMLDoc( elem ),
1044 // Whether we are setting (or getting)
1045 set = value !== undefined,
1046 msie = jQuery.browser.msie;
1047
1048 // Try to normalize/fix the name
1049 name = notxml && jQuery.props[ name ] || name;
1050
1051 // Only do all the following if this is a node (faster for style)
1052 // IE elem.getAttribute passes even for style
1053 if ( elem.tagName ) {
1054
1055 // These attributes require special treatment
1056 var special = /href|src|style/.test( name );
1057
1058 // Safari mis-reports the default selected property of a hidden option
1059 // Accessing the parent's selectedIndex property fixes it
1060 if ( name == "selected" && jQuery.browser.safari )
1061 elem.parentNode.selectedIndex;
1062
1063 // If applicable, access the attribute via the DOM 0 way
1064 if ( name in elem && notxml && !special ) {
1065 if ( set ){
1066 // We can't allow the type property to be changed (since it causes problems in IE)
1067 if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
1068 throw "type property can't be changed";
1069
1070 elem[ name ] = value;
1071 }
1072
1073 // browsers index elements by id/name on forms, give priority to attributes.
1074 if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
1075 return elem.getAttributeNode( name ).nodeValue;
1076
1077 return elem[ name ];
1078 }
1079
1080 if ( msie && notxml && name == "style" )
1081 return jQuery.attr( elem.style, "cssText", value );
1082
1083 if ( set )
1084 // convert the value to a string (all browsers do this but IE) see #1070
1085 elem.setAttribute( name, "" + value );
1086
1087 var attr = msie && notxml && special
1088 // Some attributes require a special call on IE
1089 ? elem.getAttribute( name, 2 )
1090 : elem.getAttribute( name );
1091
1092 // Non-existent attributes return null, we normalize to undefined
1093 return attr === null ? undefined : attr;
1094 }
1095
1096 // elem is actually elem.style ... set the style
1097
1098 // IE uses filters for opacity
1099 if ( msie && name == "opacity" ) {
1100 if ( set ) {
1101 // IE has trouble with opacity if it does not have layout
1102 // Force it by setting the zoom level
1103 elem.zoom = 1;
1104
1105 // Set the alpha filter to set the opacity
1106 elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
1107 (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
1108 }
1109
1110 return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
1111 (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
1112 "";
1113 }
1114
1115 name = name.replace(/-([a-z])/ig, function(all, letter){
1116 return letter.toUpperCase();
1117 });
1118
1119 if ( set )
1120 elem[ name ] = value;
1121
1122 return elem[ name ];
1123 },
1124
1125 trim: function( text ) {
1126 return (text || "").replace( /^\s+|\s+$/g, "" );
1127 },
1128
1129 makeArray: function( array ) {
1130 var ret = [];
1131
1132 if( array != null ){
1133 var i = array.length;
1134 //the window, strings and functions also have 'length'
1135 if( i == null || array.split || array.setInterval || array.call )
1136 ret[0] = array;
1137 else
1138 while( i )
1139 ret[--i] = array[i];
1140 }
1141
1142 return ret;
1143 },
1144
1145 inArray: function( elem, array ) {
1146 for ( var i = 0, length = array.length; i < length; i++ )
1147 // Use === because on IE, window == document
1148 if ( array[ i ] === elem )
1149 return i;
1150
1151 return -1;
1152 },
1153
1154 merge: function( first, second ) {
1155 // We have to loop this way because IE & Opera overwrite the length
1156 // expando of getElementsByTagName
1157 var i = 0, elem, pos = first.length;
1158 // Also, we need to make sure that the correct elements are being returned
1159 // (IE returns comment nodes in a '*' query)
1160 if ( jQuery.browser.msie ) {
1161 while ( elem = second[ i++ ] )
1162 if ( elem.nodeType != 8 )
1163 first[ pos++ ] = elem;
1164
1165 } else
1166 while ( elem = second[ i++ ] )
1167 first[ pos++ ] = elem;
1168
1169 return first;
1170 },
1171
1172 unique: function( array ) {
1173 var ret = [], done = {};
1174
1175 try {
1176
1177 for ( var i = 0, length = array.length; i < length; i++ ) {
1178 var id = jQuery.data( array[ i ] );
1179
1180 if ( !done[ id ] ) {
1181 done[ id ] = true;
1182 ret.push( array[ i ] );
1183 }
1184 }
1185
1186 } catch( e ) {
1187 ret = array;
1188 }
1189
1190 return ret;
1191 },
1192
1193 grep: function( elems, callback, inv ) {
1194 var ret = [];
1195
1196 // Go through the array, only saving the items
1197 // that pass the validator function
1198 for ( var i = 0, length = elems.length; i < length; i++ )
1199 if ( !inv != !callback( elems[ i ], i ) )
1200 ret.push( elems[ i ] );
1201
1202 return ret;
1203 },
1204
1205 map: function( elems, callback ) {
1206 var ret = [];
1207
1208 // Go through the array, translating each of the items to their
1209 // new value (or values).
1210 for ( var i = 0, length = elems.length; i < length; i++ ) {
1211 var value = callback( elems[ i ], i );
1212
1213 if ( value != null )
1214 ret[ ret.length ] = value;
1215 }
1216
1217 return ret.concat.apply( [], ret );
1218 }
1219 });
1220
1221 var userAgent = navigator.userAgent.toLowerCase();
1222
1223 // Figure out what browser is being used
1224 jQuery.browser = {
1225 version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
1226 safari: /webkit/.test( userAgent ),
1227 opera: /opera/.test( userAgent ),
1228 msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
1229 mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
1230 };
1231
1232 var styleFloat = jQuery.browser.msie ?
1233 "styleFloat" :
1234 "cssFloat";
1235
1236 jQuery.extend({
1237 // Check to see if the W3C box model is being used
1238 boxModel: !jQuery.browser.msie || document.compatMode == "CSS1Compat",
1239
1240 props: {
1241 "for": "htmlFor",
1242 "class": "className",
1243 "float": styleFloat,
1244 cssFloat: styleFloat,
1245 styleFloat: styleFloat,
1246 readonly: "readOnly",
1247 maxlength: "maxLength",
1248 cellspacing: "cellSpacing",
1249 rowspan: "rowSpan"
1250 }
1251 });
1252
1253 jQuery.each({
1254 parent: function(elem){return elem.parentNode;},
1255 parents: function(elem){return jQuery.dir(elem,"parentNode");},
1256 next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
1257 prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
1258 nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
1259 prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
1260 siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
1261 children: function(elem){return jQuery.sibling(elem.firstChild);},
1262 contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1263 }, function(name, fn){
1264 jQuery.fn[ name ] = function( selector ) {
1265 var ret = jQuery.map( this, fn );
1266
1267 if ( selector && typeof selector == "string" )
1268 ret = jQuery.multiFilter( selector, ret );
1269
1270 return this.pushStack( jQuery.unique( ret ) );
1271 };
1272 });
1273
1274 jQuery.each({
1275 appendTo: "append",
1276 prependTo: "prepend",
1277 insertBefore: "before",
1278 insertAfter: "after",
1279 replaceAll: "replaceWith"
1280 }, function(name, original){
1281 jQuery.fn[ name ] = function() {
1282 var args = arguments;
1283
1284 return this.each(function(){
1285 for ( var i = 0, length = args.length; i < length; i++ )
1286 jQuery( args[ i ] )[ original ]( this );
1287 });
1288 };
1289 });
1290
1291 jQuery.each({
1292 removeAttr: function( name ) {
1293 jQuery.attr( this, name, "" );
1294 if (this.nodeType == 1)
1295 this.removeAttribute( name );
1296 },
1297
1298 addClass: function( classNames ) {
1299 jQuery.className.add( this, classNames );
1300 },
1301
1302 removeClass: function( classNames ) {
1303 jQuery.className.remove( this, classNames );
1304 },
1305
1306 toggleClass: function( classNames ) {
1307 jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
1308 },
1309
1310 remove: function( selector ) {
1311 if ( !selector || jQuery.filter( selector, [ this ] ).r.length ) {
1312 // Prevent memory leaks
1313 jQuery( "*", this ).add(this).each(function(){
1314 jQuery.event.remove(this);
1315 jQuery.removeData(this);
1316 });
1317 if (this.parentNode)
1318 this.parentNode.removeChild( this );
1319 }
1320 },
1321
1322 empty: function() {
1323 // Remove element nodes and prevent memory leaks
1324 jQuery( ">*", this ).remove();
1325
1326 // Remove any remaining nodes
1327 while ( this.firstChild )
1328 this.removeChild( this.firstChild );
1329 }
1330 }, function(name, fn){
1331 jQuery.fn[ name ] = function(){
1332 return this.each( fn, arguments );
1333 };
1334 });
1335
1336 jQuery.each([ "Height", "Width" ], function(i, name){
1337 var type = name.toLowerCase();
1338
1339 jQuery.fn[ type ] = function( size ) {
1340 // Get window width or height
1341 return this[0] == window ?
1342 // Opera reports document.body.client[Width/Height] properly in both quirks and standards
1343 jQuery.browser.opera && document.body[ "client" + name ] ||
1344
1345 // Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
1346 jQuery.browser.safari && window[ "inner" + name ] ||
1347
1348 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
1349 document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :
1350
1351 // Get document width or height
1352 this[0] == document ?
1353 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
1354 Math.max(
1355 Math.max(document.body["scroll" + name], document.documentElement["scroll" + name]),
1356 Math.max(document.body["offset" + name], document.documentElement["offset" + name])
1357 ) :
1358
1359 // Get or set width or height on the element
1360 size == undefined ?
1361 // Get width or height on the element
1362 (this.length ? jQuery.css( this[0], type ) : null) :
1363
1364 // Set the width or height on the element (default to pixels if value is unitless)
1365 this.css( type, size.constructor == String ? size : size + "px" );
1366 };
1367 });
1368
1369 // Helper function used by the dimensions and offset modules
1370 function num(elem, prop) {
1371 return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
1372 }
1373 var chars = jQuery.browser.safari && parseInt(jQuery.browser.version) < 417 ?
1374 "(?:[\\w*_-]|\\\\.)" :
1375 "(?:[\\w\u0128-\uFFFF*_-]|\\\\.)",
1376 quickChild = new RegExp("^>\\s*(" + chars + "+)"),
1377 quickID = new RegExp("^(" + chars + "+)(#)(" + chars + "+)"),
1378 quickClass = new RegExp("^([#.]?)(" + chars + "*)");
1379
1380 jQuery.extend({
1381 expr: {
1382 "": function(a,i,m){return m[2]=="*"||jQuery.nodeName(a,m[2]);},
1383 "#": function(a,i,m){return a.getAttribute("id")==m[2];},
1384 ":": {
1385 // Position Checks
1386 lt: function(a,i,m){return i<m[3]-0;},
1387 gt: function(a,i,m){return i>m[3]-0;},
1388 nth: function(a,i,m){return m[3]-0==i;},
1389 eq: function(a,i,m){return m[3]-0==i;},
1390 first: function(a,i){return i==0;},
1391 last: function(a,i,m,r){return i==r.length-1;},
1392 even: function(a,i){return i%2==0;},
1393 odd: function(a,i){return i%2;},
1394
1395 // Child Checks
1396 "first-child": function(a){return a.parentNode.getElementsByTagName("*")[0]==a;},
1397 "last-child": function(a){return jQuery.nth(a.parentNode.lastChild,1,"previousSibling")==a;},
1398 "only-child": function(a){return !jQuery.nth(a.parentNode.lastChild,2,"previousSibling");},
1399
1400 // Parent Checks
1401 parent: function(a){return a.firstChild;},
1402 empty: function(a){return !a.firstChild;},
1403
1404 // Text Check
1405 contains: function(a,i,m){return (a.textContent||a.innerText||jQuery(a).text()||"").indexOf(m[3])>=0;},
1406
1407 // Visibility
1408 visible: function(a){return "hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden";},
1409 hidden: function(a){return "hidden"==a.type||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden";},
1410
1411 // Form attributes
1412 enabled: function(a){return !a.disabled;},
1413 disabled: function(a){return a.disabled;},
1414 checked: function(a){return a.checked;},
1415 selected: function(a){return a.selected||jQuery.attr(a,"selected");},
1416
1417 // Form elements
1418 text: function(a){return "text"==a.type;},
1419 radio: function(a){return "radio"==a.type;},
1420 checkbox: function(a){return "checkbox"==a.type;},
1421 file: function(a){return "file"==a.type;},
1422 password: function(a){return "password"==a.type;},
1423 submit: function(a){return "submit"==a.type;},
1424 image: function(a){return "image"==a.type;},
1425 reset: function(a){return "reset"==a.type;},
1426 button: function(a){return "button"==a.type||jQuery.nodeName(a,"button");},
1427 input: function(a){return /input|select|textarea|button/i.test(a.nodeName);},
1428
1429 // :has()
1430 has: function(a,i,m){return jQuery.find(m[3],a).length;},
1431
1432 // :header
1433 header: function(a){return /h\d/i.test(a.nodeName);},
1434
1435 // :animated
1436 animated: function(a){return jQuery.grep(jQuery.timers,function(fn){return a==fn.elem;}).length;}
1437 }
1438 },
1439
1440 // The regular expressions that power the parsing engine
1441 parse: [
1442 // Match: [@value='test'], [@foo]
1443 /^(\[) *@?([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,
1444
1445 // Match: :contains('foo')
1446 /^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/,
1447
1448 // Match: :even, :last-child, #id, .class
1449 new RegExp("^([:.#]*)(" + chars + "+)")
1450 ],
1451
1452 multiFilter: function( expr, elems, not ) {
1453 var old, cur = [];
1454
1455 while ( expr && expr != old ) {
1456 old = expr;
1457 var f = jQuery.filter( expr, elems, not );
1458 expr = f.t.replace(/^\s*,\s*/, "" );
1459 cur = not ? elems = f.r : jQuery.merge( cur, f.r );
1460 }
1461
1462 return cur;
1463 },
1464
1465 find: function( t, context ) {
1466 // Quickly handle non-string expressions
1467 if ( typeof t != "string" )
1468 return [ t ];
1469
1470 // check to make sure context is a DOM element or a document
1471 if ( context && context.nodeType != 1 && context.nodeType != 9)
1472 return [ ];
1473
1474 // Set the correct context (if none is provided)
1475 context = context || document;
1476
1477 // Initialize the search
1478 var ret = [context], done = [], last, nodeName;
1479
1480 // Continue while a selector expression exists, and while
1481 // we're no longer looping upon ourselves
1482 while ( t && last != t ) {
1483 var r = [];
1484 last = t;
1485
1486 t = jQuery.trim(t);
1487
1488 var foundToken = false,
1489
1490 // An attempt at speeding up child selectors that
1491 // point to a specific element tag
1492 re = quickChild,
1493
1494 m = re.exec(t);
1495
1496 if ( m ) {
1497 nodeName = m[1].toUpperCase();
1498
1499 // Perform our own iteration and filter
1500 for ( var i = 0; ret[i]; i++ )
1501 for ( var c = ret[i].firstChild; c; c = c.nextSibling )
1502 if ( c.nodeType == 1 && (nodeName == "*" || c.nodeName.toUpperCase() == nodeName) )
1503 r.push( c );
1504
1505 ret = r;
1506 t = t.replace( re, "" );
1507 if ( t.indexOf(" ") == 0 ) continue;
1508 foundToken = true;
1509 } else {
1510 re = /^([>+~])\s*(\w*)/i;
1511
1512 if ( (m = re.exec(t)) != null ) {
1513 r = [];
1514
1515 var merge = {};
1516 nodeName = m[2].toUpperCase();
1517 m = m[1];
1518
1519 for ( var j = 0, rl = ret.length; j < rl; j++ ) {
1520 var n = m == "~" || m == "+" ? ret[j].nextSibling : ret[j].firstChild;
1521 for ( ; n; n = n.nextSibling )
1522 if ( n.nodeType == 1 ) {
1523 var id = jQuery.data(n);
1524
1525 if ( m == "~" && merge[id] ) break;
1526
1527 if (!nodeName || n.nodeName.toUpperCase() == nodeName ) {
1528 if ( m == "~" ) merge[id] = true;
1529 r.push( n );
1530 }
1531
1532 if ( m == "+" ) break;
1533 }
1534 }
1535
1536 ret = r;
1537
1538 // And remove the token
1539 t = jQuery.trim( t.replace( re, "" ) );
1540 foundToken = true;
1541 }
1542 }
1543
1544 // See if there's still an expression, and that we haven't already
1545 // matched a token
1546 if ( t && !foundToken ) {
1547 // Handle multiple expressions
1548 if ( !t.indexOf(",") ) {
1549 // Clean the result set
1550 if ( context == ret[0] ) ret.shift();
1551
1552 // Merge the result sets
1553 done = jQuery.merge( done, ret );
1554
1555 // Reset the context
1556 r = ret = [context];
1557
1558 // Touch up the selector string
1559 t = " " + t.substr(1,t.length);
1560
1561 } else {
1562 // Optimize for the case nodeName#idName
1563 var re2 = quickID;
1564 var m = re2.exec(t);
1565
1566 // Re-organize the results, so that they're consistent
1567 if ( m ) {
1568 m = [ 0, m[2], m[3], m[1] ];
1569
1570 } else {
1571 // Otherwise, do a traditional filter check for
1572 // ID, class, and element selectors
1573 re2 = quickClass;
1574 m = re2.exec(t);
1575 }
1576
1577 m[2] = m[2].replace(/\\/g, "");
1578
1579 var elem = ret[ret.length-1];
1580
1581 // Try to do a global search by ID, where we can
1582 if ( m[1] == "#" && elem && elem.getElementById && !jQuery.isXMLDoc(elem) ) {
1583 // Optimization for HTML document case
1584 var oid = elem.getElementById(m[2]);
1585
1586 // Do a quick check for the existence of the actual ID attribute
1587 // to avoid selecting by the name attribute in IE
1588 // also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
1589 if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
1590 oid = jQuery('[@id="'+m[2]+'"]', elem)[0];
1591
1592 // Do a quick check for node name (where applicable) so
1593 // that div#foo searches will be really fast
1594 ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : [];
1595 } else {
1596 // We need to find all descendant elements
1597 for ( var i = 0; ret[i]; i++ ) {
1598 // Grab the tag name being searched for
1599 var tag = m[1] == "#" && m[3] ? m[3] : m[1] != "" || m[0] == "" ? "*" : m[2];
1600
1601 // Handle IE7 being really dumb about <object>s
1602 if ( tag == "*" && ret[i].nodeName.toLowerCase() == "object" )
1603 tag = "param";
1604
1605 r = jQuery.merge( r, ret[i].getElementsByTagName( tag ));
1606 }
1607
1608 // It's faster to filter by class and be done with it
1609 if ( m[1] == "." )
1610 r = jQuery.classFilter( r, m[2] );
1611
1612 // Same with ID filtering
1613 if ( m[1] == "#" ) {
1614 var tmp = [];
1615
1616 // Try to find the element with the ID
1617 for ( var i = 0; r[i]; i++ )
1618 if ( r[i].getAttribute("id") == m[2] ) {
1619 tmp = [ r[i] ];
1620 break;
1621 }
1622
1623 r = tmp;
1624 }
1625
1626 ret = r;
1627 }
1628
1629 t = t.replace( re2, "" );
1630 }
1631
1632 }
1633
1634 // If a selector string still exists
1635 if ( t ) {
1636 // Attempt to filter it
1637 var val = jQuery.filter(t,r);
1638 ret = r = val.r;
1639 t = jQuery.trim(val.t);
1640 }
1641 }
1642
1643 // An error occurred with the selector;
1644 // just return an empty set instead
1645 if ( t )
1646 ret = [];
1647
1648 // Remove the root context
1649 if ( ret && context == ret[0] )
1650 ret.shift();
1651
1652 // And combine the results
1653 done = jQuery.merge( done, ret );
1654
1655 return done;
1656 },
1657
1658 classFilter: function(r,m,not){
1659 m = " " + m + " ";
1660 var tmp = [];
1661 for ( var i = 0; r[i]; i++ ) {
1662 var pass = (" " + r[i].className + " ").indexOf( m ) >= 0;
1663 if ( !not && pass || not && !pass )
1664 tmp.push( r[i] );
1665 }
1666 return tmp;
1667 },
1668
1669 filter: function(t,r,not) {
1670 var last;
1671
1672 // Look for common filter expressions
1673 while ( t && t != last ) {
1674 last = t;
1675
1676 var p = jQuery.parse, m;
1677
1678 for ( var i = 0; p[i]; i++ ) {
1679 m = p[i].exec( t );
1680
1681 if ( m ) {
1682 // Remove what we just matched
1683 t = t.substring( m[0].length );
1684
1685 m[2] = m[2].replace(/\\/g, "");
1686 break;
1687 }
1688 }
1689
1690 if ( !m )
1691 break;
1692
1693 // :not() is a special case that can be optimized by
1694 // keeping it out of the expression list
1695 if ( m[1] == ":" && m[2] == "not" )
1696 // optimize if only one selector found (most common case)
1697 r = isSimple.test( m[3] ) ?
1698 jQuery.filter(m[3], r, true).r :
1699 jQuery( r ).not( m[3] );
1700
1701 // We can get a big speed boost by filtering by class here
1702 else if ( m[1] == "." )
1703 r = jQuery.classFilter(r, m[2], not);
1704
1705 else if ( m[1] == "[" ) {
1706 var tmp = [], type = m[3];
1707
1708 for ( var i = 0, rl = r.length; i < rl; i++ ) {
1709 var a = r[i], z = a[ jQuery.props[m[2]] || m[2] ];
1710
1711 if ( z == null || /href|src|selected/.test(m[2]) )
1712 z = jQuery.attr(a,m[2]) || '';
1713
1714 if ( (type == "" && !!z ||
1715 type == "=" && z == m[5] ||
1716 type == "!=" && z != m[5] ||
1717 type == "^=" && z && !z.indexOf(m[5]) ||
1718 type == "$=" && z.substr(z.length - m[5].length) == m[5] ||
1719 (type == "*=" || type == "~=") && z.indexOf(m[5]) >= 0) ^ not )
1720 tmp.push( a );
1721 }
1722
1723 r = tmp;
1724
1725 // We can get a speed boost by handling nth-child here
1726 } else if ( m[1] == ":" && m[2] == "nth-child" ) {
1727 var merge = {}, tmp = [],
1728 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
1729 test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
1730 m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
1731 !/\D/.test(m[3]) && "0n+" + m[3] || m[3]),
1732 // calculate the numbers (first)n+(last) including if they are negative
1733 first = (test[1] + (test[2] || 1)) - 0, last = test[3] - 0;
1734
1735 // loop through all the elements left in the jQuery object
1736 for ( var i = 0, rl = r.length; i < rl; i++ ) {
1737 var node = r[i], parentNode = node.parentNode, id = jQuery.data(parentNode);
1738
1739 if ( !merge[id] ) {
1740 var c = 1;
1741
1742 for ( var n = parentNode.firstChild; n; n = n.nextSibling )
1743 if ( n.nodeType == 1 )
1744 n.nodeIndex = c++;
1745
1746 merge[id] = true;
1747 }
1748
1749 var add = false;
1750
1751 if ( first == 0 ) {
1752 if ( node.nodeIndex == last )
1753 add = true;
1754 } else if ( (node.nodeIndex - last) % first == 0 && (node.nodeIndex - last) / first >= 0 )
1755 add = true;
1756
1757 if ( add ^ not )
1758 tmp.push( node );
1759 }
1760
1761 r = tmp;
1762
1763 // Otherwise, find the expression to execute
1764 } else {
1765 var fn = jQuery.expr[ m[1] ];
1766 if ( typeof fn == "object" )
1767 fn = fn[ m[2] ];
1768
1769 if ( typeof fn == "string" )
1770 fn = eval("false||function(a,i){return " + fn + ";}");
1771
1772 // Execute it against the current filter
1773 r = jQuery.grep( r, function(elem, i){
1774 return fn(elem, i, m, r);
1775 }, not );
1776 }
1777 }
1778
1779 // Return an array of filtered elements (r)
1780 // and the modified expression string (t)
1781 return { r: r, t: t };
1782 },
1783
1784 dir: function( elem, dir ){
1785 var matched = [],
1786 cur = elem[dir];
1787 while ( cur && cur != document ) {
1788 if ( cur.nodeType == 1 )
1789 matched.push( cur );
1790 cur = cur[dir];
1791 }
1792 return matched;
1793 },
1794
1795 nth: function(cur,result,dir,elem){
1796 result = result || 1;
1797 var num = 0;
1798
1799 for ( ; cur; cur = cur[dir] )
1800 if ( cur.nodeType == 1 && ++num == result )
1801 break;
1802
1803 return cur;
1804 },
1805
1806 sibling: function( n, elem ) {
1807 var r = [];
1808
1809 for ( ; n; n = n.nextSibling ) {
1810 if ( n.nodeType == 1 && n != elem )
1811 r.push( n );
1812 }
1813
1814 return r;
1815 }
1816 });
1817 /*
1818 * A number of helper functions used for managing events.
1819 * Many of the ideas behind this code originated from
1820 * Dean Edwards' addEvent library.
1821 */
1822 jQuery.event = {
1823
1824 // Bind an event to an element
1825 // Original by Dean Edwards
1826 add: function(elem, types, handler, data) {
1827 if ( elem.nodeType == 3 || elem.nodeType == 8 )
1828 return;
1829
1830 // For whatever reason, IE has trouble passing the window object
1831 // around, causing it to be cloned in the process
1832 if ( jQuery.browser.msie && elem.setInterval )
1833 elem = window;
1834
1835 // Make sure that the function being executed has a unique ID
1836 if ( !handler.guid )
1837 handler.guid = this.guid++;
1838
1839 // if data is passed, bind to handler
1840 if( data != undefined ) {
1841 // Create temporary function pointer to original handler
1842 var fn = handler;
1843
1844 // Create unique handler function, wrapped around original handler
1845 handler = this.proxy( fn, function() {
1846 // Pass arguments and context to original handler
1847 return fn.apply(this, arguments);
1848 });
1849
1850 // Store data in unique handler
1851 handler.data = data;
1852 }
1853
1854 // Init the element's event structure
1855 var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
1856 handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
1857 // Handle the second event of a trigger and when
1858 // an event is called after a page has unloaded
1859 if ( typeof jQuery != "undefined" && !jQuery.event.triggered )
1860 return jQuery.event.handle.apply(arguments.callee.elem, arguments);
1861 });
1862 // Add elem as a property of the handle function
1863 // This is to prevent a memory leak with non-native
1864 // event in IE.
1865 handle.elem = elem;
1866
1867 // Handle multiple events separated by a space
1868 // jQuery(...).bind("mouseover mouseout", fn);
1869 jQuery.each(types.split(/\s+/), function(index, type) {
1870 // Namespaced event handlers
1871 var parts = type.split(".");
1872 type = parts[0];
1873 handler.type = parts[1];
1874
1875 // Get the current list of functions bound to this event
1876 var handlers = events[type];
1877
1878 // Init the event handler queue
1879 if (!handlers) {
1880 handlers = events[type] = {};
1881
1882 // Check for a special event handler
1883 // Only use addEventListener/attachEvent if the special
1884 // events handler returns false
1885 if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem) === false ) {
1886 // Bind the global event handler to the element
1887 if (elem.addEventListener)
1888 elem.addEventListener(type, handle, false);
1889 else if (elem.attachEvent)
1890 elem.attachEvent("on" + type, handle);
1891 }
1892 }
1893
1894 // Add the function to the element's handler list
1895 handlers[handler.guid] = handler;
1896
1897 // Keep track of which events have been used, for global triggering
1898 jQuery.event.global[type] = true;
1899 });
1900
1901 // Nullify elem to prevent memory leaks in IE
1902 elem = null;
1903 },
1904
1905 guid: 1,
1906 global: {},
1907
1908 // Detach an event or set of events from an element
1909 remove: function(elem, types, handler) {
1910 // don't do events on text and comment nodes
1911 if ( elem.nodeType == 3 || elem.nodeType == 8 )
1912 return;
1913
1914 var events = jQuery.data(elem, "events"), ret, index;
1915
1916 if ( events ) {
1917 // Unbind all events for the element
1918 if ( types == undefined || (typeof types == "string" && types.charAt(0) == ".") )
1919 for ( var type in events )
1920 this.remove( elem, type + (types || "") );
1921 else {
1922 // types is actually an event object here
1923 if ( types.type ) {
1924 handler = types.handler;
1925 types = types.type;
1926 }
1927
1928 // Handle multiple events seperated by a space
1929 // jQuery(...).unbind("mouseover mouseout", fn);
1930 jQuery.each(types.split(/\s+/), function(index, type){
1931 // Namespaced event handlers
1932 var parts = type.split(".");
1933 type = parts[0];
1934
1935 if ( events[type] ) {
1936 // remove the given handler for the given type
1937 if ( handler )
1938 delete events[type][handler.guid];
1939
1940 // remove all handlers for the given type
1941 else
1942 for ( handler in events[type] )
1943 // Handle the removal of namespaced events
1944 if ( !parts[1] || events[type][handler].type == parts[1] )
1945 delete events[type][handler];
1946
1947 // remove generic event handler if no more handlers exist
1948 for ( ret in events[type] ) break;
1949 if ( !ret ) {
1950 if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) {
1951 if (elem.removeEventListener)
1952 elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
1953 else if (elem.detachEvent)
1954 elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
1955 }
1956 ret = null;
1957 delete events[type];
1958 }
1959 }
1960 });
1961 }
1962
1963 // Remove the expando if it's no longer used
1964 for ( ret in events ) break;
1965 if ( !ret ) {
1966 var handle = jQuery.data( elem, "handle" );
1967 if ( handle ) handle.elem = null;
1968 jQuery.removeData( elem, "events" );
1969 jQuery.removeData( elem, "handle" );
1970 }
1971 }
1972 },
1973
1974 trigger: function(type, data, elem, donative, extra) {
1975 // Clone the incoming data, if any
1976 data = jQuery.makeArray(data);
1977
1978 if ( type.indexOf("!") >= 0 ) {
1979 type = type.slice(0, -1);
1980 var exclusive = true;
1981 }
1982
1983 // Handle a global trigger
1984 if ( !elem ) {
1985 // Only trigger if we've ever bound an event for it
1986 if ( this.global[type] )
1987 jQuery.each( jQuery.cache, function(){
1988 if ( this.events && this.events[type] )
1989 jQuery.event.trigger( type, data, this.handle.elem );
1990 });
1991
1992 // Handle triggering a single element
1993 } else {
1994 // don't do events on text and comment nodes
1995 if ( elem.nodeType == 3 || elem.nodeType == 8 )
1996 return undefined;
1997
1998 var val, ret, fn = jQuery.isFunction( elem[ type ] || null ),
1999 // Check to see if we need to provide a fake event, or not
2000 event = !data[0] || !data[0].preventDefault;
2001
2002 // Pass along a fake event
2003 if ( event ) {
2004 data.unshift({
2005 type: type,
2006 target: elem,
2007 preventDefault: function(){},
2008 stopPropagation: function(){},
2009 timeStamp: now()
2010 });
2011 data[0][expando] = true; // no need to fix fake event
2012 }
2013
2014 // Enforce the right trigger type
2015 data[0].type = type;
2016 if ( exclusive )
2017 data[0].exclusive = true;
2018
2019 // Trigger the event, it is assumed that "handle" is a function
2020 var handle = jQuery.data(elem, "handle");
2021 if ( handle )
2022 val = handle.apply( elem, data );
2023
2024 // Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
2025 if ( (!fn || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
2026 val = false;
2027
2028 // Extra functions don't get the custom event object
2029 if ( event )
2030 data.shift();
2031
2032 // Handle triggering of extra function
2033 if ( extra && jQuery.isFunction( extra ) ) {
2034 // call the extra function and tack the current return value on the end for possible inspection
2035 ret = extra.apply( elem, val == null ? data : data.concat( val ) );
2036 // if anything is returned, give it precedence and have it overwrite the previous value
2037 if (ret !== undefined)
2038 val = ret;
2039 }
2040
2041 // Trigger the native events (except for clicks on links)
2042 if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2043 this.triggered = true;
2044 try {
2045 elem[ type ]();
2046 // prevent IE from throwing an error for some hidden elements
2047 } catch (e) {}
2048 }
2049
2050 this.triggered = false;
2051 }
2052
2053 return val;
2054 },
2055
2056 handle: function(event) {
2057 // returned undefined or false
2058 var val, ret, namespace, all, handlers;
2059
2060 event = arguments[0] = jQuery.event.fix( event || window.event );
2061
2062 // Namespaced event handlers
2063 namespace = event.type.split(".");
2064 event.type = namespace[0];
2065 namespace = namespace[1];
2066 // Cache this now, all = true means, any handler
2067 all = !namespace && !event.exclusive;
2068
2069 handlers = ( jQuery.data(this, "events") || {} )[event.type];
2070
2071 for ( var j in handlers ) {
2072 var handler = handlers[j];
2073
2074 // Filter the functions by class
2075 if ( all || handler.type == namespace ) {
2076 // Pass in a reference to the handler function itself
2077 // So that we can later remove it
2078 event.handler = handler;
2079 event.data = handler.data;
2080
2081 ret = handler.apply( this, arguments );
2082
2083 if ( val !== false )
2084 val = ret;
2085
2086 if ( ret === false ) {
2087 event.preventDefault();
2088 event.stopPropagation();
2089 }
2090 }
2091 }
2092
2093 return val;
2094 },
2095
2096 props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target timeStamp toElement type view wheelDelta which".split(" "),
2097
2098 fix: function(event) {
2099 if ( event[expando] == true )
2100 return event;
2101
2102 // store a copy of the original event object
2103 // and "clone" to set read-only properties
2104 var originalEvent = event;
2105 event = { originalEvent: originalEvent };
2106
2107 for ( var i = this.props.length, prop; i; ){
2108 prop = this.props[ --i ];
2109 event[ prop ] = originalEvent[ prop ];
2110 }
2111
2112 // Mark it as fixed
2113 event[expando] = true;
2114
2115 // add preventDefault and stopPropagation since
2116 // they will not work on the clone
2117 event.preventDefault = function() {
2118 // if preventDefault exists run it on the original event
2119 if (originalEvent.preventDefault)
2120 originalEvent.preventDefault();
2121 // otherwise set the returnValue property of the original event to false (IE)
2122 originalEvent.returnValue = false;
2123 };
2124 event.stopPropagation = function() {
2125 // if stopPropagation exists run it on the original event
2126 if (originalEvent.stopPropagation)
2127 originalEvent.stopPropagation();
2128 // otherwise set the cancelBubble property of the original event to true (IE)
2129 originalEvent.cancelBubble = true;
2130 };
2131
2132 // Fix timeStamp
2133 event.timeStamp = event.timeStamp || now();
2134
2135 // Fix target property, if necessary
2136 if ( !event.target )
2137 event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
2138
2139 // check if target is a textnode (safari)
2140 if ( event.target.nodeType == 3 )
2141 event.target = event.target.parentNode;
2142
2143 // Add relatedTarget, if necessary
2144 if ( !event.relatedTarget && event.fromElement )
2145 event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
2146
2147 // Calculate pageX/Y if missing and clientX/Y available
2148 if ( event.pageX == null && event.clientX != null ) {
2149 var doc = document.documentElement, body = document.body;
2150 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
2151 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
2152 }
2153
2154 // Add which for key events
2155 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
2156 event.which = event.charCode || event.keyCode;
2157
2158 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2159 if ( !event.metaKey && event.ctrlKey )
2160 event.metaKey = event.ctrlKey;
2161
2162 // Add which for click: 1 == left; 2 == middle; 3 == right
2163 // Note: button is not normalized, so don't use it
2164 if ( !event.which && event.button )
2165 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2166
2167 return event;
2168 },
2169
2170 proxy: function( fn, proxy ){
2171 // Set the guid of unique handler to the same of original handler, so it can be removed
2172 proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
2173 // So proxy can be declared as an argument
2174 return proxy;
2175 },
2176
2177 special: {
2178 ready: {
2179 setup: function() {
2180 // Make sure the ready event is setup
2181 bindReady();
2182 return;
2183 },
2184
2185 teardown: function() { return; }
2186 },
2187
2188 mouseenter: {
2189 setup: function() {
2190 if ( jQuery.browser.msie ) return false;
2191 jQuery(this).bind("mouseover", jQuery.event.special.mouseenter.handler);
2192 return true;
2193 },
2194
2195 teardown: function() {
2196 if ( jQuery.browser.msie ) return false;
2197 jQuery(this).unbind("mouseover", jQuery.event.special.mouseenter.handler);
2198 return true;
2199 },
2200
2201 handler: function(event) {
2202 // If we actually just moused on to a sub-element, ignore it
2203 if ( withinElement(event, this) ) return true;
2204 // Execute the right handlers by setting the event type to mouseenter
2205 event.type = "mouseenter";
2206 return jQuery.event.handle.apply(this, arguments);
2207 }
2208 },
2209
2210 mouseleave: {
2211 setup: function() {
2212 if ( jQuery.browser.msie ) return false;
2213 jQuery(this).bind("mouseout", jQuery.event.special.mouseleave.handler);
2214 return true;
2215 },
2216
2217 teardown: function() {
2218 if ( jQuery.browser.msie ) return false;
2219 jQuery(this).unbind("mouseout", jQuery.event.special.mouseleave.handler);
2220 return true;
2221 },
2222
2223 handler: function(event) {
2224 // If we actually just moused on to a sub-element, ignore it
2225 if ( withinElement(event, this) ) return true;
2226 // Execute the right handlers by setting the event type to mouseleave
2227 event.type = "mouseleave";
2228 return jQuery.event.handle.apply(this, arguments);
2229 }
2230 }
2231 }
2232 };
2233
2234 jQuery.fn.extend({
2235 bind: function( type, data, fn ) {
2236 return type == "unload" ? this.one(type, data, fn) : this.each(function(){
2237 jQuery.event.add( this, type, fn || data, fn && data );
2238 });
2239 },
2240
2241 one: function( type, data, fn ) {
2242 var one = jQuery.event.proxy( fn || data, function(event) {
2243 jQuery(this).unbind(event, one);
2244 return (fn || data).apply( this, arguments );
2245 });
2246 return this.each(function(){
2247 jQuery.event.add( this, type, one, fn && data);
2248 });
2249 },
2250
2251 unbind: function( type, fn ) {
2252 return this.each(function(){
2253 jQuery.event.remove( this, type, fn );
2254 });
2255 },
2256
2257 trigger: function( type, data, fn ) {
2258 return this.each(function(){
2259 jQuery.event.trigger( type, data, this, true, fn );
2260 });
2261 },
2262
2263 triggerHandler: function( type, data, fn ) {
2264 return this[0] && jQuery.event.trigger( type, data, this[0], false, fn );
2265 },
2266
2267 toggle: function( fn ) {
2268 // Save reference to arguments for access in closure
2269 var args = arguments, i = 1;
2270
2271 // link all the functions, so any of them can unbind this click handler
2272 while( i < args.length )
2273 jQuery.event.proxy( fn, args[i++] );
2274
2275 return this.click( jQuery.event.proxy( fn, function(event) {
2276 // Figure out which function to execute
2277 this.lastToggle = ( this.lastToggle || 0 ) % i;
2278
2279 // Make sure that clicks stop
2280 event.preventDefault();
2281
2282 // and execute the function
2283 return args[ this.lastToggle++ ].apply( this, arguments ) || false;
2284 }));
2285 },
2286
2287 hover: function(fnOver, fnOut) {
2288 return this.bind('mouseenter', fnOver).bind('mouseleave', fnOut);
2289 },
2290
2291 ready: function(fn) {
2292 // Attach the listeners
2293 bindReady();
2294
2295 // If the DOM is already ready
2296 if ( jQuery.isReady )
2297 // Execute the function immediately
2298 fn.call( document, jQuery );
2299
2300 // Otherwise, remember the function for later
2301 else
2302 // Add the function to the wait list
2303 jQuery.readyList.push( function() { return fn.call(this, jQuery); } );
2304
2305 return this;
2306 }
2307 });
2308
2309 jQuery.extend({
2310 isReady: false,
2311 readyList: [],
2312 // Handle when the DOM is ready
2313 ready: function() {
2314 // Make sure that the DOM is not already loaded
2315 if ( !jQuery.isReady ) {
2316 // Remember that the DOM is ready
2317 jQuery.isReady = true;
2318
2319 // If there are functions bound, to execute
2320 if ( jQuery.readyList ) {
2321 // Execute all of them
2322 jQuery.each( jQuery.readyList, function(){
2323 this.call( document );
2324 });
2325
2326 // Reset the list of functions
2327 jQuery.readyList = null;
2328 }
2329
2330 // Trigger any bound ready events
2331 jQuery(document).triggerHandler("ready");
2332 }
2333 }
2334 });
2335
2336 var readyBound = false;
2337
2338 function bindReady(){
2339 if ( readyBound ) return;
2340 readyBound = true;
2341
2342 // Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
2343 if ( document.addEventListener && !jQuery.browser.opera)
2344 // Use the handy event callback
2345 document.addEventListener( "DOMContentLoaded", jQuery.ready, false );
2346
2347 // If IE is used and is not in a frame
2348 // Continually check to see if the document is ready
2349 if ( jQuery.browser.msie && window == top ) (function(){
2350 if (jQuery.isReady) return;
2351 try {
2352 // If IE is used, use the trick by Diego Perini
2353 // http://javascript.nwbox.com/IEContentLoaded/
2354 document.documentElement.doScroll("left");
2355 } catch( error ) {
2356 setTimeout( arguments.callee, 0 );
2357 return;
2358 }
2359 // and execute any waiting functions
2360 jQuery.ready();
2361 })();
2362
2363 if ( jQuery.browser.opera )
2364 document.addEventListener( "DOMContentLoaded", function () {
2365 if (jQuery.isReady) return;
2366 for (var i = 0; i < document.styleSheets.length; i++)
2367 if (document.styleSheets[i].disabled) {
2368 setTimeout( arguments.callee, 0 );
2369 return;
2370 }
2371 // and execute any waiting functions
2372 jQuery.ready();
2373 }, false);
2374
2375 if ( jQuery.browser.safari ) {
2376 var numStyles;
2377 (function(){
2378 if (jQuery.isReady) return;
2379 if ( document.readyState != "loaded" && document.readyState != "complete" ) {
2380 setTimeout( arguments.callee, 0 );
2381 return;
2382 }
2383 if ( numStyles === undefined )
2384 numStyles = jQuery("style, link[rel=stylesheet]").length;
2385 if ( document.styleSheets.length != numStyles ) {
2386 setTimeout( arguments.callee, 0 );
2387 return;
2388 }
2389 // and execute any waiting functions
2390 jQuery.ready();
2391 })();
2392 }
2393
2394 // A fallback to window.onload, that will always work
2395 jQuery.event.add( window, "load", jQuery.ready );
2396 }
2397
2398 jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
2399 "mousedown,mouseup,mousemove,mouseover,mouseout,change,select," +
2400 "submit,keydown,keypress,keyup,error").split(","), function(i, name){
2401
2402 // Handle event binding
2403 jQuery.fn[name] = function(fn){
2404 return fn ? this.bind(name, fn) : this.trigger(name);
2405 };
2406 });
2407
2408 // Checks if an event happened on an element within another element
2409 // Used in jQuery.event.special.mouseenter and mouseleave handlers
2410 var withinElement = function(event, elem) {
2411 // Check if mouse(over|out) are still within the same parent element
2412 var parent = event.relatedTarget;
2413 // Traverse up the tree
2414 while ( parent && parent != elem ) try { parent = parent.parentNode; } catch(error) { parent = elem; }
2415 // Return true if we actually just moused on to a sub-element
2416 return parent == elem;
2417 };
2418
2419 // Prevent memory leaks in IE
2420 // And prevent errors on refresh with events like mouseover in other browsers
2421 // Window isn't included so as not to unbind existing unload events
2422 jQuery( window ).bind( 'unload', function(){
2423 for ( var id in jQuery.cache )
2424 // Skip the window
2425 if ( id != 1 && jQuery.cache[ id ].handle )
2426 jQuery.event.remove( jQuery.cache[ id ].handle.elem );
2427 });
2428 jQuery.fn.extend({
2429 // Keep a copy of the old load
2430 _load: jQuery.fn.load,
2431
2432 load: function( url, params, callback ) {
2433 if ( typeof url != 'string' )
2434 return this._load( url );
2435
2436 var off = url.indexOf(" ");
2437 if ( off >= 0 ) {
2438 var selector = url.slice(off, url.length);
2439 url = url.slice(0, off);
2440 }
2441
2442 callback = callback || function(){};
2443
2444 // Default to a GET request
2445 var type = "GET";
2446
2447 // If the second parameter was provided
2448 if ( params )
2449 // If it's a function
2450 if ( jQuery.isFunction( params ) ) {
2451 // We assume that it's the callback
2452 callback = params;
2453 params = null;
2454
2455 // Otherwise, build a param string
2456 } else if( typeof params == 'object' ) {
2457 params = jQuery.param( params );
2458 type = "POST";
2459 }
2460
2461 var self = this;
2462
2463 // Request the remote document
2464 jQuery.ajax({
2465 url: url,
2466 type: type,
2467 dataType: "html",
2468 data: params,
2469 complete: function(res, status){
2470 // If successful, inject the HTML into all the matched elements
2471 if ( status == "success" || status == "notmodified" )
2472 // See if a selector was specified
2473 self.html( selector ?
2474 // Create a dummy div to hold the results
2475 jQuery("<div/>")
2476 // inject the contents of the document in, removing the scripts
2477 // to avoid any 'Permission Denied' errors in IE
2478 .append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))
2479
2480 // Locate the specified elements
2481 .find(selector) :
2482
2483 // If not, just inject the full result
2484 res.responseText );
2485
2486 self.each( callback, [res.responseText, status, res] );
2487 }
2488 });
2489 return this;
2490 },
2491
2492 serialize: function() {
2493 return jQuery.param(this.serializeArray());
2494 },
2495 serializeArray: function() {
2496 return this.map(function(){
2497 return jQuery.nodeName(this, "form") ?
2498 jQuery.makeArray(this.elements) : this;
2499 })
2500 .filter(function(){
2501 return this.name && !this.disabled &&
2502 (this.checked || /select|textarea/i.test(this.nodeName) ||
2503 /text|hidden|password/i.test(this.type));
2504 })
2505 .map(function(i, elem){
2506 var val = jQuery(this).val();
2507 return val == null ? null :
2508 val.constructor == Array ?
2509 jQuery.map( val, function(val, i){
2510 return {name: elem.name, value: val};
2511 }) :
2512 {name: elem.name, value: val};
2513 }).get();
2514 }
2515 });
2516
2517 // Attach a bunch of functions for handling common AJAX events
2518 jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
2519 jQuery.fn[o] = function(f){
2520 return this.bind(o, f);
2521 };
2522 });
2523
2524 var jsc = now();
2525
2526 jQuery.extend({
2527 get: function( url, data, callback, type ) {
2528 // shift arguments if data argument was ommited
2529 if ( jQuery.isFunction( data ) ) {
2530 callback = data;
2531 data = null;
2532 }
2533
2534 return jQuery.ajax({
2535 type: "GET",
2536 url: url,
2537 data: data,
2538 success: callback,
2539 dataType: type
2540 });
2541 },
2542
2543 getScript: function( url, callback ) {
2544 return jQuery.get(url, null, callback, "script");
2545 },
2546
2547 getJSON: function( url, data, callback ) {
2548 return jQuery.get(url, data, callback, "json");
2549 },
2550
2551 post: function( url, data, callback, type ) {
2552 if ( jQuery.isFunction( data ) ) {
2553 callback = data;
2554 data = {};
2555 }
2556
2557 return jQuery.ajax({
2558 type: "POST",
2559 url: url,
2560 data: data,
2561 success: callback,
2562 dataType: type
2563 });
2564 },
2565
2566 ajaxSetup: function( settings ) {
2567 jQuery.extend( jQuery.ajaxSettings, settings );
2568 },
2569
2570 ajaxSettings: {
2571 url: location.href,
2572 global: true,
2573 type: "GET",
2574 timeout: 0,
2575 contentType: "application/x-www-form-urlencoded",
2576 processData: true,
2577 async: true,
2578 data: null,
2579 username: null,
2580 password: null,
2581 accepts: {
2582 xml: "application/xml, text/xml",
2583 html: "text/html",
2584 script: "text/javascript, application/javascript",
2585 json: "application/json, text/javascript",
2586 text: "text/plain",
2587 _default: "*/*"
2588 }
2589 },
2590
2591 // Last-Modified header cache for next request
2592 lastModified: {},
2593
2594 ajax: function( s ) {
2595 // Extend the settings, but re-extend 's' so that it can be
2596 // checked again later (in the test suite, specifically)
2597 s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));
2598
2599 var jsonp, jsre = /=\?(&|$)/g, status, data,
2600 type = s.type.toUpperCase();
2601
2602 // convert data if not already a string
2603 if ( s.data && s.processData && typeof s.data != "string" )
2604 s.data = jQuery.param(s.data);
2605
2606 // Handle JSONP Parameter Callbacks
2607 if ( s.dataType == "jsonp" ) {
2608 if ( type == "GET" ) {
2609 if ( !s.url.match(jsre) )
2610 s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
2611 } else if ( !s.data || !s.data.match(jsre) )
2612 s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
2613 s.dataType = "json";
2614 }
2615
2616 // Build temporary JSONP function
2617 if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
2618 jsonp = "jsonp" + jsc++;
2619
2620 // Replace the =? sequence both in the query string and the data
2621 if ( s.data )
2622 s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
2623 s.url = s.url.replace(jsre, "=" + jsonp + "$1");
2624
2625 // We need to make sure
2626 // that a JSONP style response is executed properly
2627 s.dataType = "script";
2628
2629 // Handle JSONP-style loading
2630 window[ jsonp ] = function(tmp){
2631 data = tmp;
2632 success();
2633 complete();
2634 // Garbage collect
2635 window[ jsonp ] = undefined;
2636 try{ delete window[ jsonp ]; } catch(e){}
2637 if ( head )
2638 head.removeChild( script );
2639 };
2640 }
2641
2642 if ( s.dataType == "script" && s.cache == null )
2643 s.cache = false;
2644
2645 if ( s.cache === false && type == "GET" ) {
2646 var ts = now();
2647 // try replacing _= if it is there
2648 var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
2649 // if nothing was replaced, add timestamp to the end
2650 s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
2651 }
2652
2653 // If data is available, append data to url for get requests
2654 if ( s.data && type == "GET" ) {
2655 s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
2656
2657 // IE likes to send both get and post data, prevent this
2658 s.data = null;
2659 }
2660
2661 // Watch for a new set of requests
2662 if ( s.global && ! jQuery.active++ )
2663 jQuery.event.trigger( "ajaxStart" );
2664
2665 // Matches an absolute URL, and saves the domain
2666 var parts = /^(\w+:)?\/\/([^\/?#]+)/.exec( s.url );
2667
2668 // If we're requesting a remote document
2669 // and trying to load JSON or Script with a GET
2670 if ( s.dataType == "script" && type == "GET" && parts
2671 && ( parts[1] && parts[1] != location.protocol || parts[2] != location.host )){
2672
2673 var head = document.getElementsByTagName("head")[0];
2674 var script = document.createElement("script");
2675 script.src = s.url;
2676 if (s.scriptCharset)
2677 script.charset = s.scriptCharset;
2678
2679 // Handle Script loading
2680 if ( !jsonp ) {
2681 var done = false;
2682
2683 // Attach handlers for all browsers
2684 script.onload = script.onreadystatechange = function(){
2685 if ( !done && (!this.readyState ||
2686 this.readyState == "loaded" || this.readyState == "complete") ) {
2687 done = true;
2688 success();
2689 complete();
2690 head.removeChild( script );
2691 }
2692 };
2693 }
2694
2695 head.appendChild(script);
2696
2697 // We handle everything using the script element injection
2698 return undefined;
2699 }
2700
2701 var requestDone = false;
2702
2703 // Create the request object; Microsoft failed to properly
2704 // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
2705 var xhr = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
2706
2707 // Open the socket
2708 // Passing null username, generates a login popup on Opera (#2865)
2709 if( s.username )
2710 xhr.open(type, s.url, s.async, s.username, s.password);
2711 else
2712 xhr.open(type, s.url, s.async);
2713
2714 // Need an extra try/catch for cross domain requests in Firefox 3
2715 try {
2716 // Set the correct header, if data is being sent
2717 if ( s.data )
2718 xhr.setRequestHeader("Content-Type", s.contentType);
2719
2720 // Set the If-Modified-Since header, if ifModified mode.
2721 if ( s.ifModified )
2722 xhr.setRequestHeader("If-Modified-Since",
2723 jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
2724
2725 // Set header so the called script knows that it's an XMLHttpRequest
2726 xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
2727
2728 // Set the Accepts header for the server, depending on the dataType
2729 xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
2730 s.accepts[ s.dataType ] + ", */*" :
2731 s.accepts._default );
2732 } catch(e){}
2733
2734 // Allow custom headers/mimetypes
2735 if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
2736 // cleanup active request counter
2737 s.global && jQuery.active--;
2738 // close opended socket
2739 xhr.abort();
2740 return false;
2741 }
2742
2743 if ( s.global )
2744 jQuery.event.trigger("ajaxSend", [xhr, s]);
2745
2746 // Wait for a response to come back
2747 var onreadystatechange = function(isTimeout){
2748 // The transfer is complete and the data is available, or the request timed out
2749 if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
2750 requestDone = true;
2751
2752 // clear poll interval
2753 if (ival) {
2754 clearInterval(ival);
2755 ival = null;
2756 }
2757
2758 status = isTimeout == "timeout" ? "timeout" :
2759 !jQuery.httpSuccess( xhr ) ? "error" :
2760 s.ifModified && jQuery.httpNotModified( xhr, s.url ) ? "notmodified" :
2761 "success";
2762
2763 if ( status == "success" ) {
2764 // Watch for, and catch, XML document parse errors
2765 try {
2766 // process the data (runs the xml through httpData regardless of callback)
2767 data = jQuery.httpData( xhr, s.dataType, s );
2768 } catch(e) {
2769 status = "parsererror";
2770 }
2771 }
2772
2773 // Make sure that the request was successful or notmodified
2774 if ( status == "success" ) {
2775 // Cache Last-Modified header, if ifModified mode.
2776 var modRes;
2777 try {
2778 modRes = xhr.getResponseHeader("Last-Modified");
2779 } catch(e) {} // swallow exception thrown by FF if header is not available
2780
2781 if ( s.ifModified && modRes )
2782 jQuery.lastModified[s.url] = modRes;
2783
2784 // JSONP handles its own success callback
2785 if ( !jsonp )
2786 success();
2787 } else
2788 jQuery.handleError(s, xhr, status);
2789
2790 // Fire the complete handlers
2791 complete();
2792
2793 // Stop memory leaks
2794 if ( s.async )
2795 xhr = null;
2796 }
2797 };
2798
2799 if ( s.async ) {
2800 // don't attach the handler to the request, just poll it instead
2801 var ival = setInterval(onreadystatechange, 13);
2802
2803 // Timeout checker
2804 if ( s.timeout > 0 )
2805 setTimeout(function(){
2806 // Check to see if the request is still happening
2807 if ( xhr ) {
2808 // Cancel the request
2809 xhr.abort();
2810
2811 if( !requestDone )
2812 onreadystatechange( "timeout" );
2813 }
2814 }, s.timeout);
2815 }
2816
2817 // Send the data
2818 try {
2819 xhr.send(s.data);
2820 } catch(e) {
2821 jQuery.handleError(s, xhr, null, e);
2822 }
2823
2824 // firefox 1.5 doesn't fire statechange for sync requests
2825 if ( !s.async )
2826 onreadystatechange();
2827
2828 function success(){
2829 // If a local callback was specified, fire it and pass it the data
2830 if ( s.success )
2831 s.success( data, status );
2832
2833 // Fire the global callback
2834 if ( s.global )
2835 jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
2836 }
2837
2838 function complete(){
2839 // Process result
2840 if ( s.complete )
2841 s.complete(xhr, status);
2842
2843 // The request was completed
2844 if ( s.global )
2845 jQuery.event.trigger( "ajaxComplete", [xhr, s] );
2846
2847 // Handle the global AJAX counter
2848 if ( s.global && ! --jQuery.active )
2849 jQuery.event.trigger( "ajaxStop" );
2850 }
2851
2852 // return XMLHttpRequest to allow aborting the request etc.
2853 return xhr;
2854 },
2855
2856 handleError: function( s, xhr, status, e ) {
2857 // If a local callback was specified, fire it
2858 if ( s.error ) s.error( xhr, status, e );
2859
2860 // Fire the global callback
2861 if ( s.global )
2862 jQuery.event.trigger( "ajaxError", [xhr, s, e] );
2863 },
2864
2865 // Counter for holding the number of active queries
2866 active: 0,
2867
2868 // Determines if an XMLHttpRequest was successful or not
2869 httpSuccess: function( xhr ) {
2870 try {
2871 // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
2872 return !xhr.status && location.protocol == "file:" ||
2873 ( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223 ||
2874 jQuery.browser.safari && xhr.status == undefined;
2875 } catch(e){}
2876 return false;
2877 },
2878
2879 // Determines if an XMLHttpRequest returns NotModified
2880 httpNotModified: function( xhr, url ) {
2881 try {
2882 var xhrRes = xhr.getResponseHeader("Last-Modified");
2883
2884 // Firefox always returns 200. check Last-Modified date
2885 return xhr.status == 304 || xhrRes == jQuery.lastModified[url] ||
2886 jQuery.browser.safari && xhr.status == undefined;
2887 } catch(e){}
2888 return false;
2889 },
2890
2891 httpData: function( xhr, type, s ) {
2892 var ct = xhr.getResponseHeader("content-type"),
2893 xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
2894 data = xml ? xhr.responseXML : xhr.responseText;
2895
2896 if ( xml && data.documentElement.tagName == "parsererror" )
2897 throw "parsererror";
2898
2899 // Allow a pre-filtering function to sanitize the response
2900 // s != null is checked to keep backwards compatibility
2901 if( s && s.dataFilter )
2902 data = s.dataFilter( data, type );
2903
2904 // If the type is "script", eval it in global context
2905 if ( type == "script" )
2906 jQuery.globalEval( data );
2907
2908 // Get the JavaScript object, if JSON is used.
2909 if ( type == "json" )
2910 data = eval("(" + data + ")");
2911
2912 return data;
2913 },
2914
2915 // Serialize an array of form elements or a set of
2916 // key/values into a query string
2917 param: function( a ) {
2918 var s = [ ];
2919
2920 function add( key, value ){
2921 s[ s.length ] = encodeURIComponent(key) + '=' + encodeURIComponent(value);
2922 };
2923
2924 // If an array was passed in, assume that it is an array
2925 // of form elements
2926 if ( a.constructor == Array || a.jquery )
2927 // Serialize the form elements
2928 jQuery.each( a, function(){
2929 add( this.name, this.value );
2930 });
2931
2932 // Otherwise, assume that it's an object of key/value pairs
2933 else
2934 // Serialize the key/values
2935 for ( var j in a )
2936 // If the value is an array then the key names need to be repeated
2937 if ( a[j] && a[j].constructor == Array )
2938 jQuery.each( a[j], function(){
2939 add( j, this );
2940 });
2941 else
2942 add( j, jQuery.isFunction(a[j]) ? a[j]() : a[j] );
2943
2944 // Return the resulting serialization
2945 return s.join("&").replace(/%20/g, "+");
2946 }
2947
2948 });
2949 jQuery.fn.extend({
2950 show: function(speed,callback){
2951 return speed ?
2952 this.animate({
2953 height: "show", width: "show", opacity: "show"
2954 }, speed, callback) :
2955
2956 this.filter(":hidden").each(function(){
2957 this.style.display = this.oldblock || "";
2958 if ( jQuery.css(this,"display") == "none" ) {
2959 var elem = jQuery("<" + this.tagName + " />").appendTo("body");
2960 this.style.display = elem.css("display");
2961 // handle an edge condition where css is - div { display:none; } or similar
2962 if (this.style.display == "none")
2963 this.style.display = "block";
2964 elem.remove();
2965 }
2966 }).end();
2967 },
2968
2969 hide: function(speed,callback){
2970 return speed ?
2971 this.animate({
2972 height: "hide", width: "hide", opacity: "hide"
2973 }, speed, callback) :
2974
2975 this.filter(":visible").each(function(){
2976 this.oldblock = this.oldblock || jQuery.css(this,"display");
2977 this.style.display = "none";
2978 }).end();
2979 },
2980
2981 // Save the old toggle function
2982 _toggle: jQuery.fn.toggle,
2983
2984 toggle: function( fn, fn2 ){
2985 return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
2986 this._toggle.apply( this, arguments ) :
2987 fn ?
2988 this.animate({
2989 height: "toggle", width: "toggle", opacity: "toggle"
2990 }, fn, fn2) :
2991 this.each(function(){
2992 jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
2993 });
2994 },
2995
2996 fadeTo: function(speed,to,callback){
2997 return this.animate({opacity: to}, speed, callback);
2998 },
2999
3000 animate: function( prop, speed, easing, callback ) {
3001 var optall = jQuery.speed(speed, easing, callback);
3002
3003 return this[ optall.queue === false ? "each" : "queue" ](function(){
3004
3005 var opt = jQuery.extend({}, optall), p,
3006 hidden = this.nodeType == 1 && jQuery(this).is(":hidden"),
3007 self = this;
3008
3009 for ( p in prop ) {
3010 if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
3011 return opt.complete.call(this);
3012
3013 if ( ( p == "height" || p == "width" ) && this.style ) {
3014 // Store display property
3015 opt.display = jQuery.css(this, "display");
3016
3017 // Make sure that nothing sneaks out
3018 opt.overflow = this.style.overflow;
3019 }
3020 }
3021
3022 if ( opt.overflow != null )
3023 this.style.overflow = "hidden";
3024
3025 opt.curAnim = jQuery.extend({}, prop);
3026
3027 jQuery.each( prop, function(name, val){
3028 var e = new jQuery.fx( self, opt, name );
3029
3030 if ( /toggle|show|hide/.test(val) )
3031 e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
3032 else {
3033 var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
3034 start = e.cur(true) || 0;
3035
3036 if ( parts ) {
3037 var end = parseFloat(parts[2]),
3038 unit = parts[3] || "px";
3039
3040 // We need to compute starting value
3041 if ( unit != "px" ) {
3042 self.style[ name ] = (end || 1) + unit;
3043 start = ((end || 1) / e.cur(true)) * start;
3044 self.style[ name ] = start + unit;
3045 }
3046
3047 // If a +=/-= token was provided, we're doing a relative animation
3048 if ( parts[1] )
3049 end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
3050
3051 e.custom( start, end, unit );
3052 } else
3053 e.custom( start, val, "" );
3054 }
3055 });
3056
3057 // For JS strict compliance
3058 return true;
3059 });
3060 },
3061
3062 queue: function(type, fn){
3063 if ( jQuery.isFunction(type) || ( type && type.constructor == Array )) {
3064 fn = type;
3065 type = "fx";
3066 }
3067
3068 if ( !type || (typeof type == "string" && !fn) )
3069 return queue( this[0], type );
3070
3071 return this.each(function(){
3072 if ( fn.constructor == Array )
3073 queue(this, type, fn);
3074 else {
3075 queue(this, type).push( fn );
3076
3077 if ( queue(this, type).length == 1 )
3078 fn.call(this);
3079 }
3080 });
3081 },
3082
3083 stop: function(clearQueue, gotoEnd){
3084 var timers = jQuery.timers;
3085
3086 if (clearQueue)
3087 this.queue([]);
3088
3089 this.each(function(){
3090 // go in reverse order so anything added to the queue during the loop is ignored
3091 for ( var i = timers.length - 1; i >= 0; i-- )
3092 if ( timers[i].elem == this ) {
3093 if (gotoEnd)
3094 // force the next step to be the last
3095 timers[i](true);
3096 timers.splice(i, 1);
3097 }
3098 });
3099
3100 // start the next in the queue if the last step wasn't forced
3101 if (!gotoEnd)
3102 this.dequeue();
3103
3104 return this;
3105 }
3106
3107 });
3108
3109 // Generate shortcuts for custom animations
3110 jQuery.each({
3111 slideDown: { height:"show" },
3112 slideUp: { height: "hide" },
3113 slideToggle: { height: "toggle" },
3114 fadeIn: { opacity: "show" },
3115 fadeOut: { opacity: "hide" }
3116 }, function( name, props ){
3117 jQuery.fn[ name ] = function( speed, callback ){
3118 return this.animate( props, speed, callback );
3119 };
3120 });
3121
3122 var queue = function( elem, type, array ) {
3123 if ( elem ){
3124
3125 type = type || "fx";
3126
3127 var q = jQuery.data( elem, type + "queue" );
3128
3129 if ( !q || array )
3130 q = jQuery.data( elem, type + "queue", jQuery.makeArray(array) );
3131
3132 }
3133 return q;
3134 };
3135
3136 jQuery.fn.dequeue = function(type){
3137 type = type || "fx";
3138
3139 return this.each(function(){
3140 var q = queue(this, type);
3141
3142 q.shift();
3143
3144 if ( q.length )
3145 q[0].call( this );
3146 });
3147 };
3148
3149 jQuery.extend({
3150
3151 speed: function(speed, easing, fn) {
3152 var opt = speed && speed.constructor == Object ? speed : {
3153 complete: fn || !fn && easing ||
3154 jQuery.isFunction( speed ) && speed,
3155 duration: speed,
3156 easing: fn && easing || easing && easing.constructor != Function && easing
3157 };
3158
3159 opt.duration = (opt.duration && opt.duration.constructor == Number ?
3160 opt.duration :
3161 jQuery.fx.speeds[opt.duration]) || jQuery.fx.speeds._default;
3162
3163 // Queueing
3164 opt.old = opt.complete;
3165 opt.complete = function(){
3166 if ( opt.queue !== false )
3167 jQuery(this).dequeue();
3168 if ( jQuery.isFunction( opt.old ) )
3169 opt.old.call( this );
3170 };
3171
3172 return opt;
3173 },
3174
3175 easing: {
3176 linear: function( p, n, firstNum, diff ) {
3177 return firstNum + diff * p;
3178 },
3179 swing: function( p, n, firstNum, diff ) {
3180 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
3181 }
3182 },
3183
3184 timers: [],
3185 timerId: null,
3186
3187 fx: function( elem, options, prop ){
3188 this.options = options;
3189 this.elem = elem;
3190 this.prop = prop;
3191
3192 if ( !options.orig )
3193 options.orig = {};
3194 }
3195
3196 });
3197
3198 jQuery.fx.prototype = {
3199
3200 // Simple function for setting a style value
3201 update: function(){
3202 if ( this.options.step )
3203 this.options.step.call( this.elem, this.now, this );
3204
3205 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
3206
3207 // Set display property to block for height/width animations
3208 if ( ( this.prop == "height" || this.prop == "width" ) && this.elem.style )
3209 this.elem.style.display = "block";
3210 },
3211
3212 // Get the current size
3213 cur: function(force){
3214 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) )
3215 return this.elem[ this.prop ];
3216
3217 var r = parseFloat(jQuery.css(this.elem, this.prop, force));
3218 return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
3219 },
3220
3221 // Start an animation from one number to another
3222 custom: function(from, to, unit){
3223 this.startTime = now();
3224 this.start = from;
3225 this.end = to;
3226 this.unit = unit || this.unit || "px";
3227 this.now = this.start;
3228 this.pos = this.state = 0;
3229 this.update();
3230
3231 var self = this;
3232 function t(gotoEnd){
3233 return self.step(gotoEnd);
3234 }
3235
3236 t.elem = this.elem;
3237
3238 jQuery.timers.push(t);
3239
3240 if ( jQuery.timerId == null ) {
3241 jQuery.timerId = setInterval(function(){
3242 var timers = jQuery.timers;
3243
3244 for ( var i = 0; i < timers.length; i++ )
3245 if ( !timers[i]() )
3246 timers.splice(i--, 1);
3247
3248 if ( !timers.length ) {
3249 clearInterval( jQuery.timerId );
3250 jQuery.timerId = null;
3251 }
3252 }, 13);
3253 }
3254 },
3255
3256 // Simple 'show' function
3257 show: function(){
3258 // Remember where we started, so that we can go back to it later
3259 this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
3260 this.options.show = true;
3261
3262 // Begin the animation
3263 this.custom(0, this.cur());
3264
3265 // Make sure that we start at a small width/height to avoid any
3266 // flash of content
3267 if ( this.prop == "width" || this.prop == "height" )
3268 this.elem.style[this.prop] = "1px";
3269
3270 // Start by showing the element
3271 jQuery(this.elem).show();
3272 },
3273
3274 // Simple 'hide' function
3275 hide: function(){
3276 // Remember where we started, so that we can go back to it later
3277 this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
3278 this.options.hide = true;
3279
3280 // Begin the animation
3281 this.custom(this.cur(), 0);
3282 },
3283
3284 // Each step of an animation
3285 step: function(gotoEnd){
3286 var t = now();
3287
3288 if ( gotoEnd || t > this.options.duration + this.startTime ) {
3289 this.now = this.end;
3290 this.pos = this.state = 1;
3291 this.update();
3292
3293 this.options.curAnim[ this.prop ] = true;
3294
3295 var done = true;
3296 for ( var i in this.options.curAnim )
3297 if ( this.options.curAnim[i] !== true )
3298 done = false;
3299
3300 if ( done ) {
3301 if ( this.options.display != null ) {
3302 // Reset the overflow
3303 this.elem.style.overflow = this.options.overflow;
3304
3305 // Reset the display
3306 this.elem.style.display = this.options.display;
3307 if ( jQuery.css(this.elem, "display") == "none" )
3308 this.elem.style.display = "block";
3309 }
3310
3311 // Hide the element if the "hide" operation was done
3312 if ( this.options.hide )
3313 this.elem.style.display = "none";
3314
3315 // Reset the properties, if the item has been hidden or shown
3316 if ( this.options.hide || this.options.show )
3317 for ( var p in this.options.curAnim )
3318 jQuery.attr(this.elem.style, p, this.options.orig[p]);
3319 }
3320
3321 if ( done )
3322 // Execute the complete function
3323 this.options.complete.call( this.elem );
3324
3325 return false;
3326 } else {
3327 var n = t - this.startTime;
3328 this.state = n / this.options.duration;
3329
3330 // Perform the easing function, defaults to swing
3331 this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
3332 this.now = this.start + ((this.end - this.start) * this.pos);
3333
3334 // Perform the next step of the animation
3335 this.update();
3336 }
3337
3338 return true;
3339 }
3340
3341 };
3342
3343 jQuery.extend( jQuery.fx, {
3344 speeds:{
3345 slow: 600,
3346 fast: 200,
3347 // Default speed
3348 _default: 400
3349 },
3350 step: {
3351
3352 opacity: function(fx){
3353 jQuery.attr(fx.elem.style, "opacity", fx.now);
3354 },
3355
3356 _default: function(fx){
3357 if( fx.prop in fx.elem )
3358 fx.elem[ fx.prop ] = fx.now;
3359 else if( fx.elem.style )
3360 fx.elem.style[ fx.prop ] = fx.now + fx.unit;
3361 }
3362 }
3363 });
3364 // The Offset Method
3365 // Originally By Brandon Aaron, part of the Dimension Plugin
3366 // http://jquery.com/plugins/project/dimensions
3367 jQuery.fn.offset = function() {
3368 var left = 0, top = 0, elem = this[0], results;
3369
3370 if ( elem ) with ( jQuery.browser ) {
3371 var parent = elem.parentNode,
3372 offsetChild = elem,
3373 offsetParent = elem.offsetParent,
3374 doc = elem.ownerDocument,
3375 safari2 = safari && parseInt(version) < 522 && !/adobeair/i.test(userAgent),
3376 css = jQuery.curCSS,
3377 fixed = css(elem, "position") == "fixed";
3378
3379 // Use getBoundingClientRect if available
3380 if ( !(mozilla && elem == document.body) && elem.getBoundingClientRect ) {
3381 var box = elem.getBoundingClientRect();
3382
3383 // Add the document scroll offsets
3384 add(box.left + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
3385 box.top + Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));
3386
3387 // IE adds the HTML element's border, by default it is medium which is 2px
3388 // IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
3389 // IE 7 standards mode, the border is always 2px
3390 // This border/offset is typically represented by the clientLeft and clientTop properties
3391 // However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
3392 // Therefore this method will be off by 2px in IE while in quirksmode
3393 add( -doc.documentElement.clientLeft, -doc.documentElement.clientTop );
3394