Context Navigation

source: trunk/template-common/lib/jquery.js @ 4571

Last change on this file since 4571 was 3282, checked in by plg, 16 years ago
change: according to topic:15067, svn:keywords property was removed
Property svn:eol-style set to `LF`
File size: 97.8 KB

Line
1	(function(){
2	/*
3	* jQuery 1.2.6 - 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-08-28T01:26:26.034575Z $
10	* $Rev: 6329 $
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.6",
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 ( !elem )
948	return;
949
950	if ( elem.constructor == Number )
951	elem += '';
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	}
1250	});
1251
1252	jQuery.each({
1253	parent: function(elem){return elem.parentNode;},
1254	parents: function(elem){return jQuery.dir(elem,"parentNode");},
1255	next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
1256	prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
1257	nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
1258	prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
1259	siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
1260	children: function(elem){return jQuery.sibling(elem.firstChild);},
1261	contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument\|\|elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
1262	}, function(name, fn){
1263	jQuery.fn[ name ] = function( selector ) {
1264	var ret = jQuery.map( this, fn );
1265
1266	if ( selector && typeof selector == "string" )
1267	ret = jQuery.multiFilter( selector, ret );
1268
1269	return this.pushStack( jQuery.unique( ret ) );
1270	};
1271	});
1272
1273	jQuery.each({
1274	appendTo: "append",
1275	prependTo: "prepend",
1276	insertBefore: "before",
1277	insertAfter: "after",
1278	replaceAll: "replaceWith"
1279	}, function(name, original){
1280	jQuery.fn[ name ] = function() {
1281	var args = arguments;
1282
1283	return this.each(function(){
1284	for ( var i = 0, length = args.length; i < length; i++ )
1285	jQuery( args[ i ] )[ original ]( this );
1286	});
1287	};
1288	});
1289
1290	jQuery.each({
1291	removeAttr: function( name ) {
1292	jQuery.attr( this, name, "" );
1293	if (this.nodeType == 1)
1294	this.removeAttribute( name );
1295	},
1296
1297	addClass: function( classNames ) {
1298	jQuery.className.add( this, classNames );
1299	},
1300
1301	removeClass: function( classNames ) {
1302	jQuery.className.remove( this, classNames );
1303	},
1304
1305	toggleClass: function( classNames ) {
1306	jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
1307	},
1308
1309	remove: function( selector ) {
1310	if ( !selector \|\| jQuery.filter( selector, [ this ] ).r.length ) {
1311	// Prevent memory leaks
1312	jQuery( "*", this ).add(this).each(function(){
1313	jQuery.event.remove(this);
1314	jQuery.removeData(this);
1315	});
1316	if (this.parentNode)
1317	this.parentNode.removeChild( this );
1318	}
1319	},
1320
1321	empty: function() {
1322	// Remove element nodes and prevent memory leaks
1323	jQuery( ">*", this ).remove();
1324
1325	// Remove any remaining nodes
1326	while ( this.firstChild )
1327	this.removeChild( this.firstChild );
1328	}
1329	}, function(name, fn){
1330	jQuery.fn[ name ] = function(){
1331	return this.each( fn, arguments );
1332	};
1333	});
1334
1335	jQuery.each([ "Height", "Width" ], function(i, name){
1336	var type = name.toLowerCase();
1337
1338	jQuery.fn[ type ] = function( size ) {
1339	// Get window width or height
1340	return this[0] == window ?
1341	// Opera reports document.body.client[Width/Height] properly in both quirks and standards
1342	jQuery.browser.opera && document.body[ "client" + name ] \|\|
1343
1344	// Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
1345	jQuery.browser.safari && window[ "inner" + name ] \|\|
1346
1347	// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
1348	document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] \|\| document.body[ "client" + name ] :
1349
1350	// Get document width or height
1351	this[0] == document ?
1352	// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
1353	Math.max(
1354	Math.max(document.body["scroll" + name], document.documentElement["scroll" + name]),
1355	Math.max(document.body["offset" + name], document.documentElement["offset" + name])
1356	) :
1357
1358	// Get or set width or height on the element
1359	size == undefined ?
1360	// Get width or height on the element
1361	(this.length ? jQuery.css( this[0], type ) : null) :
1362
1363	// Set the width or height on the element (default to pixels if value is unitless)
1364	this.css( type, size.constructor == String ? size : size + "px" );
1365	};
1366	});
1367
1368	// Helper function used by the dimensions and offset modules
1369	function num(elem, prop) {
1370	return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) \|\| 0;
1371	}var chars = jQuery.browser.safari && parseInt(jQuery.browser.version) < 417 ?
1372	"(?:[\\w*_-]\|\\\\.)" :
1373	"(?:[\\w\u0128-\uFFFF*_-]\|\\\\.)",
1374	quickChild = new RegExp("^>\\s*(" + chars + "+)"),
1375	quickID = new RegExp("^(" + chars + "+)(#)(" + chars + "+)"),
1376	quickClass = new RegExp("^([#.]?)(" + chars + "*)");
1377
1378	jQuery.extend({
1379	expr: {
1380	"": function(a,i,m){return m[2]=="*"\|\|jQuery.nodeName(a,m[2]);},
1381	"#": function(a,i,m){return a.getAttribute("id")==m[2];},
1382	":": {
1383	// Position Checks
1384	lt: function(a,i,m){return i<m[3]-0;},
1385	gt: function(a,i,m){return i>m[3]-0;},
1386	nth: function(a,i,m){return m[3]-0==i;},
1387	eq: function(a,i,m){return m[3]-0==i;},
1388	first: function(a,i){return i==0;},
1389	last: function(a,i,m,r){return i==r.length-1;},
1390	even: function(a,i){return i%2==0;},
1391	odd: function(a,i){return i%2;},
1392
1393	// Child Checks
1394	"first-child": function(a){return a.parentNode.getElementsByTagName("*")[0]==a;},
1395	"last-child": function(a){return jQuery.nth(a.parentNode.lastChild,1,"previousSibling")==a;},
1396	"only-child": function(a){return !jQuery.nth(a.parentNode.lastChild,2,"previousSibling");},
1397
1398	// Parent Checks
1399	parent: function(a){return a.firstChild;},
1400	empty: function(a){return !a.firstChild;},
1401
1402	// Text Check
1403	contains: function(a,i,m){return (a.textContent\|\|a.innerText\|\|jQuery(a).text()\|\|"").indexOf(m[3])>=0;},
1404
1405	// Visibility
1406	visible: function(a){return "hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden";},
1407	hidden: function(a){return "hidden"==a.type\|\|jQuery.css(a,"display")=="none"\|\|jQuery.css(a,"visibility")=="hidden";},
1408
1409	// Form attributes
1410	enabled: function(a){return !a.disabled;},
1411	disabled: function(a){return a.disabled;},
1412	checked: function(a){return a.checked;},
1413	selected: function(a){return a.selected\|\|jQuery.attr(a,"selected");},
1414
1415	// Form elements
1416	text: function(a){return "text"==a.type;},
1417	radio: function(a){return "radio"==a.type;},
1418	checkbox: function(a){return "checkbox"==a.type;},
1419	file: function(a){return "file"==a.type;},
1420	password: function(a){return "password"==a.type;},
1421	submit: function(a){return "submit"==a.type;},
1422	image: function(a){return "image"==a.type;},
1423	reset: function(a){return "reset"==a.type;},
1424	button: function(a){return "button"==a.type\|\|jQuery.nodeName(a,"button");},
1425	input: function(a){return /input\|select\|textarea\|button/i.test(a.nodeName);},
1426
1427	// :has()
1428	has: function(a,i,m){return jQuery.find(m[3],a).length;},
1429
1430	// :header
1431	header: function(a){return /h\d/i.test(a.nodeName);},
1432
1433	// :animated
1434	animated: function(a){return jQuery.grep(jQuery.timers,function(fn){return a==fn.elem;}).length;}
1435	}
1436	},
1437
1438	// The regular expressions that power the parsing engine
1439	parse: [
1440	// Match: [@value='test'], [@foo]
1441	/^(\[) @?([\w-]+) ([!$^~=]) ('?"?)(.?)\4 *\]/,
1442
1443	// Match: :contains('foo')
1444	/^(:)([\w-]+)\("?'?(.?(\(.?\))?[^(]*?)"?'?\)/,
1445
1446	// Match: :even, :last-child, #id, .class
1447	new RegExp("^([:.#]*)(" + chars + "+)")
1448	],
1449
1450	multiFilter: function( expr, elems, not ) {
1451	var old, cur = [];
1452
1453	while ( expr && expr != old ) {
1454	old = expr;
1455	var f = jQuery.filter( expr, elems, not );
1456	expr = f.t.replace(/^\s,\s/, "" );
1457	cur = not ? elems = f.r : jQuery.merge( cur, f.r );
1458	}
1459
1460	return cur;
1461	},
1462
1463	find: function( t, context ) {
1464	// Quickly handle non-string expressions
1465	if ( typeof t != "string" )
1466	return [ t ];
1467
1468	// check to make sure context is a DOM element or a document
1469	if ( context && context.nodeType != 1 && context.nodeType != 9)
1470	return [ ];
1471
1472	// Set the correct context (if none is provided)
1473	context = context \|\| document;
1474
1475	// Initialize the search
1476	var ret = [context], done = [], last, nodeName;
1477
1478	// Continue while a selector expression exists, and while
1479	// we're no longer looping upon ourselves
1480	while ( t && last != t ) {
1481	var r = [];
1482	last = t;
1483
1484	t = jQuery.trim(t);
1485
1486	var foundToken = false,
1487
1488	// An attempt at speeding up child selectors that
1489	// point to a specific element tag
1490	re = quickChild,
1491
1492	m = re.exec(t);
1493
1494	if ( m ) {
1495	nodeName = m[1].toUpperCase();
1496
1497	// Perform our own iteration and filter
1498	for ( var i = 0; ret[i]; i++ )
1499	for ( var c = ret[i].firstChild; c; c = c.nextSibling )
1500	if ( c.nodeType == 1 && (nodeName == "*" \|\| c.nodeName.toUpperCase() == nodeName) )
1501	r.push( c );
1502
1503	ret = r;
1504	t = t.replace( re, "" );
1505	if ( t.indexOf(" ") == 0 ) continue;
1506	foundToken = true;
1507	} else {
1508	re = /^([>+~])\s(\w)/i;
1509
1510	if ( (m = re.exec(t)) != null ) {
1511	r = [];
1512
1513	var merge = {};
1514	nodeName = m[2].toUpperCase();
1515	m = m[1];
1516
1517	for ( var j = 0, rl = ret.length; j < rl; j++ ) {
1518	var n = m == "~" \|\| m == "+" ? ret[j].nextSibling : ret[j].firstChild;
1519	for ( ; n; n = n.nextSibling )
1520	if ( n.nodeType == 1 ) {
1521	var id = jQuery.data(n);
1522
1523	if ( m == "~" && merge[id] ) break;
1524
1525	if (!nodeName \|\| n.nodeName.toUpperCase() == nodeName ) {
1526	if ( m == "~" ) merge[id] = true;
1527	r.push( n );
1528	}
1529
1530	if ( m == "+" ) break;
1531	}
1532	}
1533
1534	ret = r;
1535
1536	// And remove the token
1537	t = jQuery.trim( t.replace( re, "" ) );
1538	foundToken = true;
1539	}
1540	}
1541
1542	// See if there's still an expression, and that we haven't already
1543	// matched a token
1544	if ( t && !foundToken ) {
1545	// Handle multiple expressions
1546	if ( !t.indexOf(",") ) {
1547	// Clean the result set
1548	if ( context == ret[0] ) ret.shift();
1549
1550	// Merge the result sets
1551	done = jQuery.merge( done, ret );
1552
1553	// Reset the context
1554	r = ret = [context];
1555
1556	// Touch up the selector string
1557	t = " " + t.substr(1,t.length);
1558
1559	} else {
1560	// Optimize for the case nodeName#idName
1561	var re2 = quickID;
1562	var m = re2.exec(t);
1563
1564	// Re-organize the results, so that they're consistent
1565	if ( m ) {
1566	m = [ 0, m[2], m[3], m[1] ];
1567
1568	} else {
1569	// Otherwise, do a traditional filter check for
1570	// ID, class, and element selectors
1571	re2 = quickClass;
1572	m = re2.exec(t);
1573	}
1574
1575	m[2] = m[2].replace(/\\/g, "");
1576
1577	var elem = ret[ret.length-1];
1578
1579	// Try to do a global search by ID, where we can
1580	if ( m[1] == "#" && elem && elem.getElementById && !jQuery.isXMLDoc(elem) ) {
1581	// Optimization for HTML document case
1582	var oid = elem.getElementById(m[2]);
1583
1584	// Do a quick check for the existence of the actual ID attribute
1585	// to avoid selecting by the name attribute in IE
1586	// also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
1587	if ( (jQuery.browser.msie\|\|jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
1588	oid = jQuery('[@id="'+m[2]+'"]', elem)[0];
1589
1590	// Do a quick check for node name (where applicable) so
1591	// that div#foo searches will be really fast
1592	ret = r = oid && (!m[3] \|\| jQuery.nodeName(oid, m[3])) ? [oid] : [];
1593	} else {
1594	// We need to find all descendant elements
1595	for ( var i = 0; ret[i]; i++ ) {
1596	// Grab the tag name being searched for
1597	var tag = m[1] == "#" && m[3] ? m[3] : m[1] != "" \|\| m[0] == "" ? "*" : m[2];
1598
1599	// Handle IE7 being really dumb about <object>s
1600	if ( tag == "*" && ret[i].nodeName.toLowerCase() == "object" )
1601	tag = "param";
1602
1603	r = jQuery.merge( r, ret[i].getElementsByTagName( tag ));
1604	}
1605
1606	// It's faster to filter by class and be done with it
1607	if ( m[1] == "." )
1608	r = jQuery.classFilter( r, m[2] );
1609
1610	// Same with ID filtering
1611	if ( m[1] == "#" ) {
1612	var tmp = [];
1613
1614	// Try to find the element with the ID
1615	for ( var i = 0; r[i]; i++ )
1616	if ( r[i].getAttribute("id") == m[2] ) {
1617	tmp = [ r[i] ];
1618	break;
1619	}
1620
1621	r = tmp;
1622	}
1623
1624	ret = r;
1625	}
1626
1627	t = t.replace( re2, "" );
1628	}
1629
1630	}
1631
1632	// If a selector string still exists
1633	if ( t ) {
1634	// Attempt to filter it
1635	var val = jQuery.filter(t,r);
1636	ret = r = val.r;
1637	t = jQuery.trim(val.t);
1638	}
1639	}
1640
1641	// An error occurred with the selector;
1642	// just return an empty set instead
1643	if ( t )
1644	ret = [];
1645
1646	// Remove the root context
1647	if ( ret && context == ret[0] )
1648	ret.shift();
1649
1650	// And combine the results
1651	done = jQuery.merge( done, ret );
1652
1653	return done;
1654	},
1655
1656	classFilter: function(r,m,not){
1657	m = " " + m + " ";
1658	var tmp = [];
1659	for ( var i = 0; r[i]; i++ ) {
1660	var pass = (" " + r[i].className + " ").indexOf( m ) >= 0;
1661	if ( !not && pass \|\| not && !pass )
1662	tmp.push( r[i] );
1663	}
1664	return tmp;
1665	},
1666
1667	filter: function(t,r,not) {
1668	var last;
1669
1670	// Look for common filter expressions
1671	while ( t && t != last ) {
1672	last = t;
1673
1674	var p = jQuery.parse, m;
1675
1676	for ( var i = 0; p[i]; i++ ) {
1677	m = p[i].exec( t );
1678
1679	if ( m ) {
1680	// Remove what we just matched
1681	t = t.substring( m[0].length );
1682
1683	m[2] = m[2].replace(/\\/g, "");
1684	break;
1685	}
1686	}
1687
1688	if ( !m )
1689	break;
1690
1691	// :not() is a special case that can be optimized by
1692	// keeping it out of the expression list
1693	if ( m[1] == ":" && m[2] == "not" )
1694	// optimize if only one selector found (most common case)
1695	r = isSimple.test( m[3] ) ?
1696	jQuery.filter(m[3], r, true).r :
1697	jQuery( r ).not( m[3] );
1698
1699	// We can get a big speed boost by filtering by class here
1700	else if ( m[1] == "." )
1701	r = jQuery.classFilter(r, m[2], not);
1702
1703	else if ( m[1] == "[" ) {
1704	var tmp = [], type = m[3];
1705
1706	for ( var i = 0, rl = r.length; i < rl; i++ ) {
1707	var a = r[i], z = a[ jQuery.props[m[2]] \|\| m[2] ];
1708
1709	if ( z == null \|\| /href\|src\|selected/.test(m[2]) )
1710	z = jQuery.attr(a,m[2]) \|\| '';
1711
1712	if ( (type == "" && !!z \|\|
1713	type == "=" && z == m[5] \|\|
1714	type == "!=" && z != m[5] \|\|
1715	type == "^=" && z && !z.indexOf(m[5]) \|\|
1716	type == "$=" && z.substr(z.length - m[5].length) == m[5] \|\|
1717	(type == "*=" \|\| type == "~=") && z.indexOf(m[5]) >= 0) ^ not )
1718	tmp.push( a );
1719	}
1720
1721	r = tmp;
1722
1723	// We can get a speed boost by handling nth-child here
1724	} else if ( m[1] == ":" && m[2] == "nth-child" ) {
1725	var merge = {}, tmp = [],
1726	// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
1727	test = /(-?)(\d)n((?:\+\|-)?\d)/.exec(
1728	m[3] == "even" && "2n" \|\| m[3] == "odd" && "2n+1" \|\|
1729	!/\D/.test(m[3]) && "0n+" + m[3] \|\| m[3]),
1730	// calculate the numbers (first)n+(last) including if they are negative
1731	first = (test[1] + (test[2] \|\| 1)) - 0, last = test[3] - 0;
1732
1733	// loop through all the elements left in the jQuery object
1734	for ( var i = 0, rl = r.length; i < rl; i++ ) {
1735	var node = r[i], parentNode = node.parentNode, id = jQuery.data(parentNode);
1736
1737	if ( !merge[id] ) {
1738	var c = 1;
1739
1740	for ( var n = parentNode.firstChild; n; n = n.nextSibling )
1741	if ( n.nodeType == 1 )
1742	n.nodeIndex = c++;
1743
1744	merge[id] = true;
1745	}
1746
1747	var add = false;
1748
1749	if ( first == 0 ) {
1750	if ( node.nodeIndex == last )
1751	add = true;
1752	} else if ( (node.nodeIndex - last) % first == 0 && (node.nodeIndex - last) / first >= 0 )
1753	add = true;
1754
1755	if ( add ^ not )
1756	tmp.push( node );
1757	}
1758
1759	r = tmp;
1760
1761	// Otherwise, find the expression to execute
1762	} else {
1763	var fn = jQuery.expr[ m[1] ];
1764	if ( typeof fn == "object" )
1765	fn = fn[ m[2] ];
1766
1767	if ( typeof fn == "string" )
1768	fn = eval("false\|\|function(a,i){return " + fn + ";}");
1769
1770	// Execute it against the current filter
1771	r = jQuery.grep( r, function(elem, i){
1772	return fn(elem, i, m, r);
1773	}, not );
1774	}
1775	}
1776
1777	// Return an array of filtered elements (r)
1778	// and the modified expression string (t)
1779	return { r: r, t: t };
1780	},
1781
1782	dir: function( elem, dir ){
1783	var matched = [],
1784	cur = elem[dir];
1785	while ( cur && cur != document ) {
1786	if ( cur.nodeType == 1 )
1787	matched.push( cur );
1788	cur = cur[dir];
1789	}
1790	return matched;
1791	},
1792
1793	nth: function(cur,result,dir,elem){
1794	result = result \|\| 1;
1795	var num = 0;
1796
1797	for ( ; cur; cur = cur[dir] )
1798	if ( cur.nodeType == 1 && ++num == result )
1799	break;
1800
1801	return cur;
1802	},
1803
1804	sibling: function( n, elem ) {
1805	var r = [];
1806
1807	for ( ; n; n = n.nextSibling ) {
1808	if ( n.nodeType == 1 && n != elem )
1809	r.push( n );
1810	}
1811
1812	return r;
1813	}
1814	});
1815	/*
1816	* A number of helper functions used for managing events.
1817	* Many of the ideas behind this code orignated from
1818	* Dean Edwards' addEvent library.
1819	*/
1820	jQuery.event = {
1821
1822	// Bind an event to an element
1823	// Original by Dean Edwards
1824	add: function(elem, types, handler, data) {
1825	if ( elem.nodeType == 3 \|\| elem.nodeType == 8 )
1826	return;
1827
1828	// For whatever reason, IE has trouble passing the window object
1829	// around, causing it to be cloned in the process
1830	if ( jQuery.browser.msie && elem.setInterval )
1831	elem = window;
1832
1833	// Make sure that the function being executed has a unique ID
1834	if ( !handler.guid )
1835	handler.guid = this.guid++;
1836
1837	// if data is passed, bind to handler
1838	if( data != undefined ) {
1839	// Create temporary function pointer to original handler
1840	var fn = handler;
1841
1842	// Create unique handler function, wrapped around original handler
1843	handler = this.proxy( fn, function() {
1844	// Pass arguments and context to original handler
1845	return fn.apply(this, arguments);
1846	});
1847
1848	// Store data in unique handler
1849	handler.data = data;
1850	}
1851
1852	// Init the element's event structure
1853	var events = jQuery.data(elem, "events") \|\| jQuery.data(elem, "events", {}),
1854	handle = jQuery.data(elem, "handle") \|\| jQuery.data(elem, "handle", function(){
1855	// Handle the second event of a trigger and when
1856	// an event is called after a page has unloaded
1857	if ( typeof jQuery != "undefined" && !jQuery.event.triggered )
1858	return jQuery.event.handle.apply(arguments.callee.elem, arguments);
1859	});
1860	// Add elem as a property of the handle function
1861	// This is to prevent a memory leak with non-native
1862	// event in IE.
1863	handle.elem = elem;
1864
1865	// Handle multiple events separated by a space
1866	// jQuery(...).bind("mouseover mouseout", fn);
1867	jQuery.each(types.split(/\s+/), function(index, type) {
1868	// Namespaced event handlers
1869	var parts = type.split(".");
1870	type = parts[0];
1871	handler.type = parts[1];
1872
1873	// Get the current list of functions bound to this event
1874	var handlers = events[type];
1875
1876	// Init the event handler queue
1877	if (!handlers) {
1878	handlers = events[type] = {};
1879
1880	// Check for a special event handler
1881	// Only use addEventListener/attachEvent if the special
1882	// events handler returns false
1883	if ( !jQuery.event.special[type] \|\| jQuery.event.special[type].setup.call(elem) === false ) {
1884	// Bind the global event handler to the element
1885	if (elem.addEventListener)
1886	elem.addEventListener(type, handle, false);
1887	else if (elem.attachEvent)
1888	elem.attachEvent("on" + type, handle);
1889	}
1890	}
1891
1892	// Add the function to the element's handler list
1893	handlers[handler.guid] = handler;
1894
1895	// Keep track of which events have been used, for global triggering
1896	jQuery.event.global[type] = true;
1897	});
1898
1899	// Nullify elem to prevent memory leaks in IE
1900	elem = null;
1901	},
1902
1903	guid: 1,
1904	global: {},
1905
1906	// Detach an event or set of events from an element
1907	remove: function(elem, types, handler) {
1908	// don't do events on text and comment nodes
1909	if ( elem.nodeType == 3 \|\| elem.nodeType == 8 )
1910	return;
1911
1912	var events = jQuery.data(elem, "events"), ret, index;
1913
1914	if ( events ) {
1915	// Unbind all events for the element
1916	if ( types == undefined \|\| (typeof types == "string" && types.charAt(0) == ".") )
1917	for ( var type in events )
1918	this.remove( elem, type + (types \|\| "") );
1919	else {
1920	// types is actually an event object here
1921	if ( types.type ) {
1922	handler = types.handler;
1923	types = types.type;
1924	}
1925
1926	// Handle multiple events seperated by a space
1927	// jQuery(...).unbind("mouseover mouseout", fn);
1928	jQuery.each(types.split(/\s+/), function(index, type){
1929	// Namespaced event handlers
1930	var parts = type.split(".");
1931	type = parts[0];
1932
1933	if ( events[type] ) {
1934	// remove the given handler for the given type
1935	if ( handler )
1936	delete events[type][handler.guid];
1937
1938	// remove all handlers for the given type
1939	else
1940	for ( handler in events[type] )
1941	// Handle the removal of namespaced events
1942	if ( !parts[1] \|\| events[type][handler].type == parts[1] )
1943	delete events[type][handler];
1944
1945	// remove generic event handler if no more handlers exist
1946	for ( ret in events[type] ) break;
1947	if ( !ret ) {
1948	if ( !jQuery.event.special[type] \|\| jQuery.event.special[type].teardown.call(elem) === false ) {
1949	if (elem.removeEventListener)
1950	elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
1951	else if (elem.detachEvent)
1952	elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
1953	}
1954	ret = null;
1955	delete events[type];
1956	}
1957	}
1958	});
1959	}
1960
1961	// Remove the expando if it's no longer used
1962	for ( ret in events ) break;
1963	if ( !ret ) {
1964	var handle = jQuery.data( elem, "handle" );
1965	if ( handle ) handle.elem = null;
1966	jQuery.removeData( elem, "events" );
1967	jQuery.removeData( elem, "handle" );
1968	}
1969	}
1970	},
1971
1972	trigger: function(type, data, elem, donative, extra) {
1973	// Clone the incoming data, if any
1974	data = jQuery.makeArray(data);
1975
1976	if ( type.indexOf("!") >= 0 ) {
1977	type = type.slice(0, -1);
1978	var exclusive = true;
1979	}
1980
1981	// Handle a global trigger
1982	if ( !elem ) {
1983	// Only trigger if we've ever bound an event for it
1984	if ( this.global[type] )
1985	jQuery("*").add([window, document]).trigger(type, data);
1986
1987	// Handle triggering a single element
1988	} else {
1989	// don't do events on text and comment nodes
1990	if ( elem.nodeType == 3 \|\| elem.nodeType == 8 )
1991	return undefined;
1992
1993	var val, ret, fn = jQuery.isFunction( elem[ type ] \|\| null ),
1994	// Check to see if we need to provide a fake event, or not
1995	event = !data[0] \|\| !data[0].preventDefault;
1996
1997	// Pass along a fake event
1998	if ( event ) {
1999	data.unshift({
2000	type: type,
2001	target: elem,
2002	preventDefault: function(){},
2003	stopPropagation: function(){},
2004	timeStamp: now()
2005	});
2006	data[0][expando] = true; // no need to fix fake event
2007	}
2008
2009	// Enforce the right trigger type
2010	data[0].type = type;
2011	if ( exclusive )
2012	data[0].exclusive = true;
2013
2014	// Trigger the event, it is assumed that "handle" is a function
2015	var handle = jQuery.data(elem, "handle");
2016	if ( handle )
2017	val = handle.apply( elem, data );
2018
2019	// Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
2020	if ( (!fn \|\| (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
2021	val = false;
2022
2023	// Extra functions don't get the custom event object
2024	if ( event )
2025	data.shift();
2026
2027	// Handle triggering of extra function
2028	if ( extra && jQuery.isFunction( extra ) ) {
2029	// call the extra function and tack the current return value on the end for possible inspection
2030	ret = extra.apply( elem, val == null ? data : data.concat( val ) );
2031	// if anything is returned, give it precedence and have it overwrite the previous value
2032	if (ret !== undefined)
2033	val = ret;
2034	}
2035
2036	// Trigger the native events (except for clicks on links)
2037	if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
2038	this.triggered = true;
2039	try {
2040	elem[ type ]();
2041	// prevent IE from throwing an error for some hidden elements
2042	} catch (e) {}
2043	}
2044
2045	this.triggered = false;
2046	}
2047
2048	return val;
2049	},
2050
2051	handle: function(event) {
2052	// returned undefined or false
2053	var val, ret, namespace, all, handlers;
2054
2055	event = arguments[0] = jQuery.event.fix( event \|\| window.event );
2056
2057	// Namespaced event handlers
2058	namespace = event.type.split(".");
2059	event.type = namespace[0];
2060	namespace = namespace[1];
2061	// Cache this now, all = true means, any handler
2062	all = !namespace && !event.exclusive;
2063
2064	handlers = ( jQuery.data(this, "events") \|\| {} )[event.type];
2065
2066	for ( var j in handlers ) {
2067	var handler = handlers[j];
2068
2069	// Filter the functions by class
2070	if ( all \|\| handler.type == namespace ) {
2071	// Pass in a reference to the handler function itself
2072	// So that we can later remove it
2073	event.handler = handler;
2074	event.data = handler.data;
2075
2076	ret = handler.apply( this, arguments );
2077
2078	if ( val !== false )
2079	val = ret;
2080
2081	if ( ret === false ) {
2082	event.preventDefault();
2083	event.stopPropagation();
2084	}
2085	}
2086	}
2087
2088	return val;
2089	},
2090
2091	fix: function(event) {
2092	if ( event[expando] == true )
2093	return event;
2094
2095	// store a copy of the original event object
2096	// and "clone" to set read-only properties
2097	var originalEvent = event;
2098	event = { originalEvent: originalEvent };
2099	var 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(" ");
2100	for ( var i=props.length; i; i-- )
2101	event[ props[i] ] = originalEvent[ props[i] ];
2102
2103	// Mark it as fixed
2104	event[expando] = true;
2105
2106	// add preventDefault and stopPropagation since
2107	// they will not work on the clone
2108	event.preventDefault = function() {
2109	// if preventDefault exists run it on the original event
2110	if (originalEvent.preventDefault)
2111	originalEvent.preventDefault();
2112	// otherwise set the returnValue property of the original event to false (IE)
2113	originalEvent.returnValue = false;
2114	};
2115	event.stopPropagation = function() {
2116	// if stopPropagation exists run it on the original event
2117	if (originalEvent.stopPropagation)
2118	originalEvent.stopPropagation();
2119	// otherwise set the cancelBubble property of the original event to true (IE)
2120	originalEvent.cancelBubble = true;
2121	};
2122
2123	// Fix timeStamp
2124	event.timeStamp = event.timeStamp \|\| now();
2125
2126	// Fix target property, if necessary
2127	if ( !event.target )
2128	event.target = event.srcElement \|\| document; // Fixes #1925 where srcElement might not be defined either
2129
2130	// check if target is a textnode (safari)
2131	if ( event.target.nodeType == 3 )
2132	event.target = event.target.parentNode;
2133
2134	// Add relatedTarget, if necessary
2135	if ( !event.relatedTarget && event.fromElement )
2136	event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
2137
2138	// Calculate pageX/Y if missing and clientX/Y available
2139	if ( event.pageX == null && event.clientX != null ) {
2140	var doc = document.documentElement, body = document.body;
2141	event.pageX = event.clientX + (doc && doc.scrollLeft \|\| body && body.scrollLeft \|\| 0) - (doc.clientLeft \|\| 0);
2142	event.pageY = event.clientY + (doc && doc.scrollTop \|\| body && body.scrollTop \|\| 0) - (doc.clientTop \|\| 0);
2143	}
2144
2145	// Add which for key events
2146	if ( !event.which && ((event.charCode \|\| event.charCode === 0) ? event.charCode : event.keyCode) )
2147	event.which = event.charCode \|\| event.keyCode;
2148
2149	// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2150	if ( !event.metaKey && event.ctrlKey )
2151	event.metaKey = event.ctrlKey;
2152
2153	// Add which for click: 1 == left; 2 == middle; 3 == right
2154	// Note: button is not normalized, so don't use it
2155	if ( !event.which && event.button )
2156	event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2157
2158	return event;
2159	},
2160
2161	proxy: function( fn, proxy ){
2162	// Set the guid of unique handler to the same of original handler, so it can be removed
2163	proxy.guid = fn.guid = fn.guid \|\| proxy.guid \|\| this.guid++;
2164	// So proxy can be declared as an argument
2165	return proxy;
2166	},
2167
2168	special: {
2169	ready: {
2170	setup: function() {
2171	// Make sure the ready event is setup
2172	bindReady();
2173	return;
2174	},
2175
2176	teardown: function() { return; }
2177	},
2178
2179	mouseenter: {
2180	setup: function() {
2181	if ( jQuery.browser.msie ) return false;
2182	jQuery(this).bind("mouseover", jQuery.event.special.mouseenter.handler);
2183	return true;
2184	},
2185
2186	teardown: function() {
2187	if ( jQuery.browser.msie ) return false;
2188	jQuery(this).unbind("mouseover", jQuery.event.special.mouseenter.handler);
2189	return true;
2190	},
2191
2192	handler: function(event) {
2193	// If we actually just moused on to a sub-element, ignore it
2194	if ( withinElement(event, this) ) return true;
2195	// Execute the right handlers by setting the event type to mouseenter
2196	event.type = "mouseenter";
2197	return jQuery.event.handle.apply(this, arguments);
2198	}
2199	},
2200
2201	mouseleave: {
2202	setup: function() {
2203	if ( jQuery.browser.msie ) return false;
2204	jQuery(this).bind("mouseout", jQuery.event.special.mouseleave.handler);
2205	return true;
2206	},
2207
2208	teardown: function() {
2209	if ( jQuery.browser.msie ) return false;
2210	jQuery(this).unbind("mouseout", jQuery.event.special.mouseleave.handler);
2211	return true;
2212	},
2213
2214	handler: function(event) {
2215	// If we actually just moused on to a sub-element, ignore it
2216	if ( withinElement(event, this) ) return true;
2217	// Execute the right handlers by setting the event type to mouseleave
2218	event.type = "mouseleave";
2219	return jQuery.event.handle.apply(this, arguments);
2220	}
2221	}
2222	}
2223	};
2224
2225	jQuery.fn.extend({
2226	bind: function( type, data, fn ) {
2227	return type == "unload" ? this.one(type, data, fn) : this.each(function(){
2228	jQuery.event.add( this, type, fn \|\| data, fn && data );
2229	});
2230	},
2231
2232	one: function( type, data, fn ) {
2233	var one = jQuery.event.proxy( fn \|\| data, function(event) {
2234	jQuery(this).unbind(event, one);
2235	return (fn \|\| data).apply( this, arguments );
2236	});
2237	return this.each(function(){
2238	jQuery.event.add( this, type, one, fn && data);
2239	});
2240	},
2241
2242	unbind: function( type, fn ) {
2243	return this.each(function(){
2244	jQuery.event.remove( this, type, fn );
2245	});
2246	},
2247
2248	trigger: function( type, data, fn ) {
2249	return this.each(function(){
2250	jQuery.event.trigger( type, data, this, true, fn );
2251	});
2252	},
2253
2254	triggerHandler: function( type, data, fn ) {
2255	return this[0] && jQuery.event.trigger( type, data, this[0], false, fn );
2256	},
2257
2258	toggle: function( fn ) {
2259	// Save reference to arguments for access in closure
2260	var args = arguments, i = 1;
2261
2262	// link all the functions, so any of them can unbind this click handler
2263	while( i < args.length )
2264	jQuery.event.proxy( fn, args[i++] );
2265
2266	return this.click( jQuery.event.proxy( fn, function(event) {
2267	// Figure out which function to execute
2268	this.lastToggle = ( this.lastToggle \|\| 0 ) % i;
2269
2270	// Make sure that clicks stop
2271	event.preventDefault();
2272
2273	// and execute the function
2274	return args[ this.lastToggle++ ].apply( this, arguments ) \|\| false;
2275	}));
2276	},
2277
2278	hover: function(fnOver, fnOut) {
2279	return this.bind('mouseenter', fnOver).bind('mouseleave', fnOut);
2280	},
2281
2282	ready: function(fn) {
2283	// Attach the listeners
2284	bindReady();
2285
2286	// If the DOM is already ready
2287	if ( jQuery.isReady )
2288	// Execute the function immediately
2289	fn.call( document, jQuery );
2290
2291	// Otherwise, remember the function for later
2292	else
2293	// Add the function to the wait list
2294	jQuery.readyList.push( function() { return fn.call(this, jQuery); } );
2295
2296	return this;
2297	}
2298	});
2299
2300	jQuery.extend({
2301	isReady: false,
2302	readyList: [],
2303	// Handle when the DOM is ready
2304	ready: function() {
2305	// Make sure that the DOM is not already loaded
2306	if ( !jQuery.isReady ) {
2307	// Remember that the DOM is ready
2308	jQuery.isReady = true;
2309
2310	// If there are functions bound, to execute
2311	if ( jQuery.readyList ) {
2312	// Execute all of them
2313	jQuery.each( jQuery.readyList, function(){
2314	this.call( document );
2315	});
2316
2317	// Reset the list of functions
2318	jQuery.readyList = null;
2319	}
2320
2321	// Trigger any bound ready events
2322	jQuery(document).triggerHandler("ready");
2323	}
2324	}
2325	});
2326
2327	var readyBound = false;
2328
2329	function bindReady(){
2330	if ( readyBound ) return;
2331	readyBound = true;
2332
2333	// Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
2334	if ( document.addEventListener && !jQuery.browser.opera)
2335	// Use the handy event callback
2336	document.addEventListener( "DOMContentLoaded", jQuery.ready, false );
2337
2338	// If IE is used and is not in a frame
2339	// Continually check to see if the document is ready
2340	if ( jQuery.browser.msie && window == top ) (function(){
2341	if (jQuery.isReady) return;
2342	try {
2343	// If IE is used, use the trick by Diego Perini
2344	// http://javascript.nwbox.com/IEContentLoaded/
2345	document.documentElement.doScroll("left");
2346	} catch( error ) {
2347	setTimeout( arguments.callee, 0 );
2348	return;
2349	}
2350	// and execute any waiting functions
2351	jQuery.ready();
2352	})();
2353
2354	if ( jQuery.browser.opera )
2355	document.addEventListener( "DOMContentLoaded", function () {
2356	if (jQuery.isReady) return;
2357	for (var i = 0; i < document.styleSheets.length; i++)
2358	if (document.styleSheets[i].disabled) {
2359	setTimeout( arguments.callee, 0 );
2360	return;
2361	}
2362	// and execute any waiting functions
2363	jQuery.ready();
2364	}, false);
2365
2366	if ( jQuery.browser.safari ) {
2367	var numStyles;
2368	(function(){
2369	if (jQuery.isReady) return;
2370	if ( document.readyState != "loaded" && document.readyState != "complete" ) {
2371	setTimeout( arguments.callee, 0 );
2372	return;
2373	}
2374	if ( numStyles === undefined )
2375	numStyles = jQuery("style, link[rel=stylesheet]").length;
2376	if ( document.styleSheets.length != numStyles ) {
2377	setTimeout( arguments.callee, 0 );
2378	return;
2379	}
2380	// and execute any waiting functions
2381	jQuery.ready();
2382	})();
2383	}
2384
2385	// A fallback to window.onload, that will always work
2386	jQuery.event.add( window, "load", jQuery.ready );
2387	}
2388
2389	jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
2390	"mousedown,mouseup,mousemove,mouseover,mouseout,change,select," +
2391	"submit,keydown,keypress,keyup,error").split(","), function(i, name){
2392
2393	// Handle event binding
2394	jQuery.fn[name] = function(fn){
2395	return fn ? this.bind(name, fn) : this.trigger(name);
2396	};
2397	});
2398
2399	// Checks if an event happened on an element within another element
2400	// Used in jQuery.event.special.mouseenter and mouseleave handlers
2401	var withinElement = function(event, elem) {
2402	// Check if mouse(over\|out) are still within the same parent element
2403	var parent = event.relatedTarget;
2404	// Traverse up the tree
2405	while ( parent && parent != elem ) try { parent = parent.parentNode; } catch(error) { parent = elem; }
2406	// Return true if we actually just moused on to a sub-element
2407	return parent == elem;
2408	};
2409
2410	// Prevent memory leaks in IE
2411	// And prevent errors on refresh with events like mouseover in other browsers
2412	// Window isn't included so as not to unbind existing unload events
2413	jQuery(window).bind("unload", function() {
2414	jQuery("*").add(document).unbind();
2415	});
2416	jQuery.fn.extend({
2417	// Keep a copy of the old load
2418	_load: jQuery.fn.load,
2419
2420	load: function( url, params, callback ) {
2421	if ( typeof url != 'string' )
2422	return this._load( url );
2423
2424	var off = url.indexOf(" ");
2425	if ( off >= 0 ) {
2426	var selector = url.slice(off, url.length);
2427	url = url.slice(0, off);
2428	}
2429
2430	callback = callback \|\| function(){};
2431
2432	// Default to a GET request
2433	var type = "GET";
2434
2435	// If the second parameter was provided
2436	if ( params )
2437	// If it's a function
2438	if ( jQuery.isFunction( params ) ) {
2439	// We assume that it's the callback
2440	callback = params;
2441	params = null;
2442
2443	// Otherwise, build a param string
2444	} else {
2445	params = jQuery.param( params );
2446	type = "POST";
2447	}
2448
2449	var self = this;
2450
2451	// Request the remote document
2452	jQuery.ajax({
2453	url: url,
2454	type: type,
2455	dataType: "html",
2456	data: params,
2457	complete: function(res, status){
2458	// If successful, inject the HTML into all the matched elements
2459	if ( status == "success" \|\| status == "notmodified" )
2460	// See if a selector was specified
2461	self.html( selector ?
2462	// Create a dummy div to hold the results
2463	jQuery("<div/>")
2464	// inject the contents of the document in, removing the scripts
2465	// to avoid any 'Permission Denied' errors in IE
2466	.append(res.responseText.replace(/<script(.\|\s)*?\/script>/g, ""))
2467
2468	// Locate the specified elements
2469	.find(selector) :
2470
2471	// If not, just inject the full result
2472	res.responseText );
2473
2474	self.each( callback, [res.responseText, status, res] );
2475	}
2476	});
2477	return this;
2478	},
2479
2480	serialize: function() {
2481	return jQuery.param(this.serializeArray());
2482	},
2483	serializeArray: function() {
2484	return this.map(function(){
2485	return jQuery.nodeName(this, "form") ?
2486	jQuery.makeArray(this.elements) : this;
2487	})
2488	.filter(function(){
2489	return this.name && !this.disabled &&
2490	(this.checked \|\| /select\|textarea/i.test(this.nodeName) \|\|
2491	/text\|hidden\|password/i.test(this.type));
2492	})
2493	.map(function(i, elem){
2494	var val = jQuery(this).val();
2495	return val == null ? null :
2496	val.constructor == Array ?
2497	jQuery.map( val, function(val, i){
2498	return {name: elem.name, value: val};
2499	}) :
2500	{name: elem.name, value: val};
2501	}).get();
2502	}
2503	});
2504
2505	// Attach a bunch of functions for handling common AJAX events
2506	jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
2507	jQuery.fn[o] = function(f){
2508	return this.bind(o, f);
2509	};
2510	});
2511
2512	var jsc = now();
2513
2514	jQuery.extend({
2515	get: function( url, data, callback, type ) {
2516	// shift arguments if data argument was ommited
2517	if ( jQuery.isFunction( data ) ) {
2518	callback = data;
2519	data = null;
2520	}
2521
2522	return jQuery.ajax({
2523	type: "GET",
2524	url: url,
2525	data: data,
2526	success: callback,
2527	dataType: type
2528	});
2529	},
2530
2531	getScript: function( url, callback ) {
2532	return jQuery.get(url, null, callback, "script");
2533	},
2534
2535	getJSON: function( url, data, callback ) {
2536	return jQuery.get(url, data, callback, "json");
2537	},
2538
2539	post: function( url, data, callback, type ) {
2540	if ( jQuery.isFunction( data ) ) {
2541	callback = data;
2542	data = {};
2543	}
2544
2545	return jQuery.ajax({
2546	type: "POST",
2547	url: url,
2548	data: data,
2549	success: callback,
2550	dataType: type
2551	});
2552	},
2553
2554	ajaxSetup: function( settings ) {
2555	jQuery.extend( jQuery.ajaxSettings, settings );
2556	},
2557
2558	ajaxSettings: {
2559	url: location.href,
2560	global: true,
2561	type: "GET",
2562	timeout: 0,
2563	contentType: "application/x-www-form-urlencoded",
2564	processData: true,
2565	async: true,
2566	data: null,
2567	username: null,
2568	password: null,
2569	accepts: {
2570	xml: "application/xml, text/xml",
2571	html: "text/html",
2572	script: "text/javascript, application/javascript",
2573	json: "application/json, text/javascript",
2574	text: "text/plain",
2575	_default: "/"
2576	}
2577	},
2578
2579	// Last-Modified header cache for next request
2580	lastModified: {},
2581
2582	ajax: function( s ) {
2583	// Extend the settings, but re-extend 's' so that it can be
2584	// checked again later (in the test suite, specifically)
2585	s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));
2586
2587	var jsonp, jsre = /=\?(&\|$)/g, status, data,
2588	type = s.type.toUpperCase();
2589
2590	// convert data if not already a string
2591	if ( s.data && s.processData && typeof s.data != "string" )
2592	s.data = jQuery.param(s.data);
2593
2594	// Handle JSONP Parameter Callbacks
2595	if ( s.dataType == "jsonp" ) {
2596	if ( type == "GET" ) {
2597	if ( !s.url.match(jsre) )
2598	s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp \|\| "callback") + "=?";
2599	} else if ( !s.data \|\| !s.data.match(jsre) )
2600	s.data = (s.data ? s.data + "&" : "") + (s.jsonp \|\| "callback") + "=?";
2601	s.dataType = "json";
2602	}
2603
2604	// Build temporary JSONP function
2605	if ( s.dataType == "json" && (s.data && s.data.match(jsre) \|\| s.url.match(jsre)) ) {
2606	jsonp = "jsonp" + jsc++;
2607
2608	// Replace the =? sequence both in the query string and the data
2609	if ( s.data )
2610	s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
2611	s.url = s.url.replace(jsre, "=" + jsonp + "$1");
2612
2613	// We need to make sure
2614	// that a JSONP style response is executed properly
2615	s.dataType = "script";
2616
2617	// Handle JSONP-style loading
2618	window[ jsonp ] = function(tmp){
2619	data = tmp;
2620	success();
2621	complete();
2622	// Garbage collect
2623	window[ jsonp ] = undefined;
2624	try{ delete window[ jsonp ]; } catch(e){}
2625	if ( head )
2626	head.removeChild( script );
2627	};
2628	}
2629
2630	if ( s.dataType == "script" && s.cache == null )
2631	s.cache = false;
2632
2633	if ( s.cache === false && type == "GET" ) {
2634	var ts = now();
2635	// try replacing _= if it is there
2636	var ret = s.url.replace(/(\?\|&)_=.*?(&\|$)/, "$1_=" + ts + "$2");
2637	// if nothing was replaced, add timestamp to the end
2638	s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
2639	}
2640
2641	// If data is available, append data to url for get requests
2642	if ( s.data && type == "GET" ) {
2643	s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
2644
2645	// IE likes to send both get and post data, prevent this
2646	s.data = null;
2647	}
2648
2649	// Watch for a new set of requests
2650	if ( s.global && ! jQuery.active++ )
2651	jQuery.event.trigger( "ajaxStart" );
2652
2653	// Matches an absolute URL, and saves the domain
2654	var remote = /^(?:\w+:)?\/\/([^\/?#]+)/;
2655
2656	// If we're requesting a remote document
2657	// and trying to load JSON or Script with a GET
2658	if ( s.dataType == "script" && type == "GET"
2659	&& remote.test(s.url) && remote.exec(s.url)[1] != location.host ){
2660	var head = document.getElementsByTagName("head")[0];
2661	var script = document.createElement("script");
2662	script.src = s.url;
2663	if (s.scriptCharset)
2664	script.charset = s.scriptCharset;
2665
2666	// Handle Script loading
2667	if ( !jsonp ) {
2668	var done = false;
2669
2670	// Attach handlers for all browsers
2671	script.onload = script.onreadystatechange = function(){
2672	if ( !done && (!this.readyState \|\|
2673	this.readyState == "loaded" \|\| this.readyState == "complete") ) {
2674	done = true;
2675	success();
2676	complete();
2677	head.removeChild( script );
2678	}
2679	};
2680	}
2681
2682	head.appendChild(script);
2683
2684	// We handle everything using the script element injection
2685	return undefined;
2686	}
2687
2688	var requestDone = false;
2689
2690	// Create the request object; Microsoft failed to properly
2691	// implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
2692	var xhr = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
2693
2694	// Open the socket
2695	// Passing null username, generates a login popup on Opera (#2865)
2696	if( s.username )
2697	xhr.open(type, s.url, s.async, s.username, s.password);
2698	else
2699	xhr.open(type, s.url, s.async);
2700
2701	// Need an extra try/catch for cross domain requests in Firefox 3
2702	try {
2703	// Set the correct header, if data is being sent
2704	if ( s.data )
2705	xhr.setRequestHeader("Content-Type", s.contentType);
2706
2707	// Set the If-Modified-Since header, if ifModified mode.
2708	if ( s.ifModified )
2709	xhr.setRequestHeader("If-Modified-Since",
2710	jQuery.lastModified[s.url] \|\| "Thu, 01 Jan 1970 00:00:00 GMT" );
2711
2712	// Set header so the called script knows that it's an XMLHttpRequest
2713	xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
2714
2715	// Set the Accepts header for the server, depending on the dataType
2716	xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
2717	s.accepts[ s.dataType ] + ", /" :
2718	s.accepts._default );
2719	} catch(e){}
2720
2721	// Allow custom headers/mimetypes
2722	if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
2723	// cleanup active request counter
2724	s.global && jQuery.active--;
2725	// close opended socket
2726	xhr.abort();
2727	return false;
2728	}
2729
2730	if ( s.global )
2731	jQuery.event.trigger("ajaxSend", [xhr, s]);
2732
2733	// Wait for a response to come back
2734	var onreadystatechange = function(isTimeout){
2735	// The transfer is complete and the data is available, or the request timed out
2736	if ( !requestDone && xhr && (xhr.readyState == 4 \|\| isTimeout == "timeout") ) {
2737	requestDone = true;
2738
2739	// clear poll interval
2740	if (ival) {
2741	clearInterval(ival);
2742	ival = null;
2743	}
2744
2745	status = isTimeout == "timeout" && "timeout" \|\|
2746	!jQuery.httpSuccess( xhr ) && "error" \|\|
2747	s.ifModified && jQuery.httpNotModified( xhr, s.url ) && "notmodified" \|\|
2748	"success";
2749
2750	if ( status == "success" ) {
2751	// Watch for, and catch, XML document parse errors
2752	try {
2753	// process the data (runs the xml through httpData regardless of callback)
2754	data = jQuery.httpData( xhr, s.dataType, s.dataFilter );
2755	} catch(e) {
2756	status = "parsererror";
2757	}
2758	}
2759
2760	// Make sure that the request was successful or notmodified
2761	if ( status == "success" ) {
2762	// Cache Last-Modified header, if ifModified mode.
2763	var modRes;
2764	try {
2765	modRes = xhr.getResponseHeader("Last-Modified");
2766	} catch(e) {} // swallow exception thrown by FF if header is not available
2767
2768	if ( s.ifModified && modRes )
2769	jQuery.lastModified[s.url] = modRes;
2770
2771	// JSONP handles its own success callback
2772	if ( !jsonp )
2773	success();
2774	} else
2775	jQuery.handleError(s, xhr, status);
2776
2777	// Fire the complete handlers
2778	complete();
2779
2780	// Stop memory leaks
2781	if ( s.async )
2782	xhr = null;
2783	}
2784	};
2785
2786	if ( s.async ) {
2787	// don't attach the handler to the request, just poll it instead
2788	var ival = setInterval(onreadystatechange, 13);
2789
2790	// Timeout checker
2791	if ( s.timeout > 0 )
2792	setTimeout(function(){
2793	// Check to see if the request is still happening
2794	if ( xhr ) {
2795	// Cancel the request
2796	xhr.abort();
2797
2798	if( !requestDone )
2799	onreadystatechange( "timeout" );
2800	}
2801	}, s.timeout);
2802	}
2803
2804	// Send the data
2805	try {
2806	xhr.send(s.data);
2807	} catch(e) {
2808	jQuery.handleError(s, xhr, null, e);
2809	}
2810
2811	// firefox 1.5 doesn't fire statechange for sync requests
2812	if ( !s.async )
2813	onreadystatechange();
2814
2815	function success(){
2816	// If a local callback was specified, fire it and pass it the data
2817	if ( s.success )
2818	s.success( data, status );
2819
2820	// Fire the global callback
2821	if ( s.global )
2822	jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
2823	}
2824
2825	function complete(){
2826	// Process result
2827	if ( s.complete )
2828	s.complete(xhr, status);
2829
2830	// The request was completed
2831	if ( s.global )
2832	jQuery.event.trigger( "ajaxComplete", [xhr, s] );
2833
2834	// Handle the global AJAX counter
2835	if ( s.global && ! --jQuery.active )
2836	jQuery.event.trigger( "ajaxStop" );
2837	}
2838
2839	// return XMLHttpRequest to allow aborting the request etc.
2840	return xhr;
2841	},
2842
2843	handleError: function( s, xhr, status, e ) {
2844	// If a local callback was specified, fire it
2845	if ( s.error ) s.error( xhr, status, e );
2846
2847	// Fire the global callback
2848	if ( s.global )
2849	jQuery.event.trigger( "ajaxError", [xhr, s, e] );
2850	},
2851
2852	// Counter for holding the number of active queries
2853	active: 0,
2854
2855	// Determines if an XMLHttpRequest was successful or not
2856	httpSuccess: function( xhr ) {
2857	try {
2858	// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
2859	return !xhr.status && location.protocol == "file:" \|\|
2860	( xhr.status >= 200 && xhr.status < 300 ) \|\| xhr.status == 304 \|\| xhr.status == 1223 \|\|
2861	jQuery.browser.safari && xhr.status == undefined;
2862	} catch(e){}
2863	return false;
2864	},
2865
2866	// Determines if an XMLHttpRequest returns NotModified
2867	httpNotModified: function( xhr, url ) {
2868	try {
2869	var xhrRes = xhr.getResponseHeader("Last-Modified");
2870
2871	// Firefox always returns 200. check Last-Modified date
2872	return xhr.status == 304 \|\| xhrRes == jQuery.lastModified[url] \|\|
2873	jQuery.browser.safari && xhr.status == undefined;
2874	} catch(e){}
2875	return false;
2876	},
2877
2878	httpData: function( xhr, type, filter ) {
2879	var ct = xhr.getResponseHeader("content-type"),
2880	xml = type == "xml" \|\| !type && ct && ct.indexOf("xml") >= 0,
2881	data = xml ? xhr.responseXML : xhr.responseText;
2882
2883	if ( xml && data.documentElement.tagName == "parsererror" )
2884	throw "parsererror";
2885
2886	// Allow a pre-filtering function to sanitize the response
2887	if( filter )
2888	data = filter( data, type );
2889
2890	// If the type is "script", eval it in global context
2891	if ( type == "script" )
2892	jQuery.globalEval( data );
2893
2894	// Get the JavaScript object, if JSON is used.
2895	if ( type == "json" )
2896	data = eval("(" + data + ")");
2897
2898	return data;
2899	},
2900
2901	// Serialize an array of form elements or a set of
2902	// key/values into a query string
2903	param: function( a ) {
2904	var s = [];
2905
2906	// If an array was passed in, assume that it is an array
2907	// of form elements
2908	if ( a.constructor == Array \|\| a.jquery )
2909	// Serialize the form elements
2910	jQuery.each( a, function(){
2911	s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) );
2912	});
2913
2914	// Otherwise, assume that it's an object of key/value pairs
2915	else
2916	// Serialize the key/values
2917	for ( var j in a )
2918	// If the value is an array then the key names need to be repeated
2919	if ( a[j] && a[j].constructor == Array )
2920	jQuery.each( a[j], function(){
2921	s.push( encodeURIComponent(j) + "=" + encodeURIComponent( this ) );
2922	});
2923	else
2924	s.push( encodeURIComponent(j) + "=" + encodeURIComponent( jQuery.isFunction(a[j]) ? a[j]() : a[j] ) );
2925
2926	// Return the resulting serialization
2927	return s.join("&").replace(/%20/g, "+");
2928	}
2929
2930	});
2931	jQuery.fn.extend({
2932	show: function(speed,callback){
2933	return speed ?
2934	this.animate({
2935	height: "show", width: "show", opacity: "show"
2936	}, speed, callback) :
2937
2938	this.filter(":hidden").each(function(){
2939	this.style.display = this.oldblock \|\| "";
2940	if ( jQuery.css(this,"display") == "none" ) {
2941	var elem = jQuery("<" + this.tagName + " />").appendTo("body");
2942	this.style.display = elem.css("display");
2943	// handle an edge condition where css is - div { display:none; } or similar
2944	if (this.style.display == "none")
2945	this.style.display = "block";
2946	elem.remove();
2947	}
2948	}).end();
2949	},
2950
2951	hide: function(speed,callback){
2952	return speed ?
2953	this.animate({
2954	height: "hide", width: "hide", opacity: "hide"
2955	}, speed, callback) :
2956
2957	this.filter(":visible").each(function(){
2958	this.oldblock = this.oldblock \|\| jQuery.css(this,"display");
2959	this.style.display = "none";
2960	}).end();
2961	},
2962
2963	// Save the old toggle function
2964	_toggle: jQuery.fn.toggle,
2965
2966	toggle: function( fn, fn2 ){
2967	return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
2968	this._toggle.apply( this, arguments ) :
2969	fn ?
2970	this.animate({
2971	height: "toggle", width: "toggle", opacity: "toggle"
2972	}, fn, fn2) :
2973	this.each(function(){
2974	jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
2975	});
2976	},
2977
2978	slideDown: function(speed,callback){
2979	return this.animate({height: "show"}, speed, callback);
2980	},
2981
2982	slideUp: function(speed,callback){
2983	return this.animate({height: "hide"}, speed, callback);
2984	},
2985
2986	slideToggle: function(speed, callback){
2987	return this.animate({height: "toggle"}, speed, callback);
2988	},
2989
2990	fadeIn: function(speed, callback){
2991	return this.animate({opacity: "show"}, speed, callback);
2992	},
2993
2994	fadeOut: function(speed, callback){
2995	return this.animate({opacity: "hide"}, speed, callback);
2996	},
2997
2998	fadeTo: function(speed,to,callback){
2999	return this.animate({opacity: to}, speed, callback);
3000	},
3001
3002	animate: function( prop, speed, easing, callback ) {
3003	var optall = jQuery.speed(speed, easing, callback);
3004
3005	return this[ optall.queue === false ? "each" : "queue" ](function(){
3006	if ( this.nodeType != 1)
3007	return false;
3008
3009	var opt = jQuery.extend({}, optall), p,
3010	hidden = jQuery(this).is(":hidden"), self = this;
3011
3012	for ( p in prop ) {
3013	if ( prop[p] == "hide" && hidden \|\| prop[p] == "show" && !hidden )
3014	return opt.complete.call(this);
3015
3016	if ( p == "height" \|\| p == "width" ) {
3017	// Store display property
3018	opt.display = jQuery.css(this, "display");
3019
3020	// Make sure that nothing sneaks out
3021	opt.overflow = this.style.overflow;
3022	}
3023	}
3024
3025	if ( opt.overflow != null )
3026	this.style.overflow = "hidden";
3027
3028	opt.curAnim = jQuery.extend({}, prop);
3029
3030	jQuery.each( prop, function(name, val){
3031	var e = new jQuery.fx( self, opt, name );
3032
3033	if ( /toggle\|show\|hide/.test(val) )
3034	e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
3035	else {
3036	var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
3037	start = e.cur(true) \|\| 0;
3038
3039	if ( parts ) {
3040	var end = parseFloat(parts[2]),
3041	unit = parts[3] \|\| "px";
3042
3043	// We need to compute starting value
3044	if ( unit != "px" ) {
3045	self.style[ name ] = (end \|\| 1) + unit;
3046	start = ((end \|\| 1) / e.cur(true)) * start;
3047	self.style[ name ] = start + unit;
3048	}
3049
3050	// If a +=/-= token was provided, we're doing a relative animation
3051	if ( parts[1] )
3052	end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
3053
3054	e.custom( start, end, unit );
3055	} else
3056	e.custom( start, val, "" );
3057	}
3058	});
3059
3060	// For JS strict compliance
3061	return true;
3062	});
3063	},
3064
3065	queue: function(type, fn){
3066	if ( jQuery.isFunction(type) \|\| ( type && type.constructor == Array )) {
3067	fn = type;
3068	type = "fx";
3069	}
3070
3071	if ( !type \|\| (typeof type == "string" && !fn) )
3072	return queue( this[0], type );
3073
3074	return this.each(function(){
3075	if ( fn.constructor == Array )
3076	queue(this, type, fn);
3077	else {
3078	queue(this, type).push( fn );
3079
3080	if ( queue(this, type).length == 1 )
3081	fn.call(this);
3082	}
3083	});
3084	},
3085
3086	stop: function(clearQueue, gotoEnd){
3087	var timers = jQuery.timers;
3088
3089	if (clearQueue)
3090	this.queue([]);
3091
3092	this.each(function(){
3093	// go in reverse order so anything added to the queue during the loop is ignored
3094	for ( var i = timers.length - 1; i >= 0; i-- )
3095	if ( timers[i].elem == this ) {
3096	if (gotoEnd)
3097	// force the next step to be the last
3098	timers[i](true);
3099	timers.splice(i, 1);
3100	}
3101	});
3102
3103	// start the next in the queue if the last step wasn't forced
3104	if (!gotoEnd)
3105	this.dequeue();
3106
3107	return this;
3108	}
3109
3110	});
3111
3112	var queue = function( elem, type, array ) {
3113	if ( elem ){
3114
3115	type = type \|\| "fx";
3116
3117	var q = jQuery.data( elem, type + "queue" );
3118
3119	if ( !q \|\| array )
3120	q = jQuery.data( elem, type + "queue", jQuery.makeArray(array) );
3121
3122	}
3123	return q;
3124	};
3125
3126	jQuery.fn.dequeue = function(type){
3127	type = type \|\| "fx";
3128
3129	return this.each(function(){
3130	var q = queue(this, type);
3131
3132	q.shift();
3133
3134	if ( q.length )
3135	q[0].call( this );
3136	});
3137	};
3138
3139	jQuery.extend({
3140
3141	speed: function(speed, easing, fn) {
3142	var opt = speed && speed.constructor == Object ? speed : {
3143	complete: fn \|\| !fn && easing \|\|
3144	jQuery.isFunction( speed ) && speed,
3145	duration: speed,
3146	easing: fn && easing \|\| easing && easing.constructor != Function && easing
3147	};
3148
3149	opt.duration = (opt.duration && opt.duration.constructor == Number ?
3150	opt.duration :
3151	jQuery.fx.speeds[opt.duration]) \|\| jQuery.fx.speeds.def;
3152
3153	// Queueing
3154	opt.old = opt.complete;
3155	opt.complete = function(){
3156	if ( opt.queue !== false )
3157	jQuery(this).dequeue();
3158	if ( jQuery.isFunction( opt.old ) )
3159	opt.old.call( this );
3160	};
3161
3162	return opt;
3163	},
3164
3165	easing: {
3166	linear: function( p, n, firstNum, diff ) {
3167	return firstNum + diff * p;
3168	},
3169	swing: function( p, n, firstNum, diff ) {
3170	return ((-Math.cos(pMath.PI)/2) + 0.5) diff + firstNum;
3171	}
3172	},
3173
3174	timers: [],
3175	timerId: null,
3176
3177	fx: function( elem, options, prop ){
3178	this.options = options;
3179	this.elem = elem;
3180	this.prop = prop;
3181
3182	if ( !options.orig )
3183	options.orig = {};
3184	}
3185
3186	});
3187
3188	jQuery.fx.prototype = {
3189
3190	// Simple function for setting a style value
3191	update: function(){
3192	if ( this.options.step )
3193	this.options.step.call( this.elem, this.now, this );
3194
3195	(jQuery.fx.step[this.prop] \|\| jQuery.fx.step._default)( this );
3196
3197	// Set display property to block for height/width animations
3198	if ( this.prop == "height" \|\| this.prop == "width" )
3199	this.elem.style.display = "block";
3200	},
3201
3202	// Get the current size
3203	cur: function(force){
3204	if ( this.elem[this.prop] != null && this.elem.style[this.prop] == null )
3205	return this.elem[ this.prop ];
3206
3207	var r = parseFloat(jQuery.css(this.elem, this.prop, force));
3208	return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) \|\| 0;
3209	},
3210
3211	// Start an animation from one number to another
3212	custom: function(from, to, unit){
3213	this.startTime = now();
3214	this.start = from;
3215	this.end = to;
3216	this.unit = unit \|\| this.unit \|\| "px";
3217	this.now = this.start;
3218	this.pos = this.state = 0;
3219	this.update();
3220
3221	var self = this;
3222	function t(gotoEnd){
3223	return self.step(gotoEnd);
3224	}
3225
3226	t.elem = this.elem;
3227
3228	jQuery.timers.push(t);
3229
3230	if ( jQuery.timerId == null ) {
3231	jQuery.timerId = setInterval(function(){
3232	var timers = jQuery.timers;
3233
3234	for ( var i = 0; i < timers.length; i++ )
3235	if ( !timers[i]() )
3236	timers.splice(i--, 1);
3237
3238	if ( !timers.length ) {
3239	clearInterval( jQuery.timerId );
3240	jQuery.timerId = null;
3241	}
3242	}, 13);
3243	}
3244	},
3245
3246	// Simple 'show' function
3247	show: function(){
3248	// Remember where we started, so that we can go back to it later
3249	this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
3250	this.options.show = true;
3251
3252	// Begin the animation
3253	this.custom(0, this.cur());
3254
3255	// Make sure that we start at a small width/height to avoid any
3256	// flash of content
3257	if ( this.prop == "width" \|\| this.prop == "height" )
3258	this.elem.style[this.prop] = "1px";
3259
3260	// Start by showing the element
3261	jQuery(this.elem).show();
3262	},
3263
3264	// Simple 'hide' function
3265	hide: function(){
3266	// Remember where we started, so that we can go back to it later
3267	this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
3268	this.options.hide = true;
3269
3270	// Begin the animation
3271	this.custom(this.cur(), 0);
3272	},
3273
3274	// Each step of an animation
3275	step: function(gotoEnd){
3276	var t = now();
3277
3278	if ( gotoEnd \|\| t > this.options.duration + this.startTime ) {
3279	this.now = this.end;
3280	this.pos = this.state = 1;
3281	this.update();
3282
3283	this.options.curAnim[ this.prop ] = true;
3284
3285	var done = true;
3286	for ( var i in this.options.curAnim )
3287	if ( this.options.curAnim[i] !== true )
3288	done = false;
3289
3290	if ( done ) {
3291	if ( this.options.display != null ) {
3292	// Reset the overflow
3293	this.elem.style.overflow = this.options.overflow;
3294
3295	// Reset the display
3296	this.elem.style.display = this.options.display;
3297	if ( jQuery.css(this.elem, "display") == "none" )
3298	this.elem.style.display = "block";
3299	}
3300
3301	// Hide the element if the "hide" operation was done
3302	if ( this.options.hide )
3303	this.elem.style.display = "none";
3304
3305	// Reset the properties, if the item has been hidden or shown
3306	if ( this.options.hide \|\| this.options.show )
3307	for ( var p in this.options.curAnim )
3308	jQuery.attr(this.elem.style, p, this.options.orig[p]);
3309	}
3310
3311	if ( done )
3312	// Execute the complete function
3313	this.options.complete.call( this.elem );
3314
3315	return false;
3316	} else {
3317	var n = t - this.startTime;
3318	this.state = n / this.options.duration;
3319
3320	// Perform the easing function, defaults to swing
3321	this.pos = jQuery.easing[this.options.easing \|\| (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
3322	this.now = this.start + ((this.end - this.start) * this.pos);
3323
3324	// Perform the next step of the animation
3325	this.update();
3326	}
3327
3328	return true;
3329	}
3330
3331	};
3332
3333	jQuery.extend( jQuery.fx, {
3334	speeds:{
3335	slow: 600,
3336	fast: 200,
3337	// Default speed
3338	def: 400
3339	},
3340	step: {
3341	scrollLeft: function(fx){
3342	fx.elem.scrollLeft = fx.now;
3343	},
3344
3345	scrollTop: function(fx){
3346	fx.elem.scrollTop = fx.now;
3347	},
3348
3349	opacity: function(fx){
3350	jQuery.attr(fx.elem.style, "opacity", fx.now);
3351	},
3352
3353	_default: function(fx){
3354	fx.elem.style[ fx.prop ] = fx.now + fx.unit;
3355	}
3356	}
3357	});
3358	// The Offset Method
3359	// Originally By Brandon Aaron, part of the Dimension Plugin
3360	// http://jquery.com/plugins/project/dimensions
3361	jQuery.fn.offset = function() {
3362	var left = 0, top = 0, elem = this[0], results;
3363
3364	if ( elem ) with ( jQuery.browser ) {
3365	var parent = elem.parentNode,
3366	offsetChild = elem,
3367	offsetParent = elem.offsetParent,
3368	doc = elem.ownerDocument,
3369	safari2 = safari && parseInt(version) < 522 && !/adobeair/i.test(userAgent),
3370	css = jQuery.curCSS,
3371	fixed = css(elem, "position") == "fixed";
3372
3373	// Use getBoundingClientRect if available
3374	if ( elem.getBoundingClientRect ) {
3375	var box = elem.getBoundingClientRect();
3376
3377	// Add the document scroll offsets
3378	add(box.left + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
3379	box.top + Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));
3380
3381	// IE adds the HTML element's border, by default it is medium which is 2px
3382	// IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
3383	// IE 7 standards mode, the border is always 2px
3384	// This border/offset is typically represented by the clientLeft and clientTop properties
3385	// However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
3386	// Therefore this method will be off by 2px in IE while in quirksmode
3387	add( -doc.documentElement.clientLeft, -doc.documentElement.clientTop );
3388
3389	// Otherwise loop through the offsetParents and parentNodes
3390	} else {
3391
3392	// Initial element offsets
3393	add( elem.offsetLeft, elem.offsetTop );
3394
3395	// Get parent offsets
3396	while ( offsetParent ) {
3397	// Add offsetParent offsets
3398	add( offsetParent.offsetLeft, offsetParent.offsetTop );
3399
3400	// Mozilla and Safari > 2 does not include the border on offset parents
3401	// However Mozilla adds the border for table or table cells
3402	if ( mozilla && !/^t(able\|d\|h)$/i.test(offsetParent.tagName) \|\| safari && !safari2 )
3403	border( offsetParent );
3404
3405	// Add the document scroll offsets if position is fixed on any offsetParent
3406	if ( !fixed && css(offsetParent, "position") == "fixed" )
3407	fixed = true;
3408
3409	// Set offsetChild to previous offsetParent unless it is the body element
3410	offsetChild = /^body$/i.test(offsetParent.tagName) ? offsetChild : offsetParent;
3411	// Get next offsetParent
3412	offsetParent = offsetParent.offsetParent;
3413	}
3414
3415	// Get parent scroll offsets
3416	while ( parent && parent.tagName && !/^body\|html$/i.test(parent.tagName) ) {
3417	// Remove parent scroll UNLESS that parent is inline or a table to work around Opera inline/table scrollLeft/Top bug
3418	if ( !/^inline\|table.*$/i.test(css(parent, "display")) )
3419	// Subtract parent scroll offsets
3420	add( -parent.scrollLeft, -parent.scrollTop );
3421
3422	// Mozilla does not add the border for a parent that has overflow != visible
3423	if ( mozilla && css(parent, "overflow") != "visible" )
3424	border( parent );
3425
3426	// Get next parent
3427	parent = parent.parentNode;
3428	}
3429
3430	// Safari <= 2 doubles body offsets with a fixed position element/offsetParent or absolutely positioned offsetChild
3431	// Mozilla doubles body offsets with a non-absolutely positioned offsetChild
3432	if ( (safari2 && (fixed \|\| css(offsetChild, "position") == "absolute")) \|\|
3433	(mozilla && css(offsetChild, "position") != "absolute") )
3434	add( -doc.body.offsetLeft, -doc.body.offsetTop );
3435
3436	// Add the document scroll offsets if position is fixed
3437	if ( fixed )
3438	add(Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
3439	Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));
3440	}
3441
3442	// Return an object with top and left properties
3443	results = { top: top, left: left };
3444	}
3445
3446	function border(elem) {
3447	add( jQuery.curCSS(elem, "borderLeftWidth", true), jQuery.curCSS(elem, "borderTopWidth", true) );
3448	}
3449
3450	function add(l, t) {
3451	left += parseInt(l, 10) \|\| 0;
3452	top += parseInt(t, 10) \|\| 0;
3453	}
3454
3455	return results;
3456	};
3457
3458
3459	jQuery.fn.extend({
3460	position: function() {
3461	var left = 0, top = 0, results;
3462
3463	if ( this[0] ) {
3464	// Get real offsetParent
3465	var offsetParent = this.offsetParent(),
3466
3467	// Get correct offsets
3468	offset = this.offset(),
3469	parentOffset = /^body\|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
3470
3471	// Subtract element margins
3472	// note: when an element has margin: auto the offsetLeft and marginLeft
3473	// are the same in Safari causing offset.left to incorrectly be 0
3474	offset.top -= num( this, 'marginTop' );
3475	offset.left -= num( this, 'marginLeft' );
3476
3477	// Add offsetParent borders
3478	parentOffset.top += num( offsetParent, 'borderTopWidth' );
3479	parentOffset.left += num( offsetParent, 'borderLeftWidth' );
3480
3481	// Subtract the two offsets
3482	results = {
3483	top: offset.top - parentOffset.top,
3484	left: offset.left - parentOffset.left
3485	};
3486	}
3487
3488	return results;
3489	},
3490
3491	offsetParent: function() {
3492	var offsetParent = this[0].offsetParent;
3493	while ( offsetParent && (!/^body\|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
3494	offsetParent = offsetParent.offsetParent;
3495	return jQuery(offsetParent);
3496	}
3497	});
3498
3499
3500	// Create scrollLeft and scrollTop methods
3501	jQuery.each( ['Left', 'Top'], function(i, name) {
3502	var method = 'scroll' + name;
3503
3504	jQuery.fn[ method ] = function(val) {
3505	if (!this[0]) return;
3506
3507	return val != undefined ?
3508
3509	// Set the scroll offset
3510	this.each(function() {
3511	this == window \|\| this == document ?
3512	window.scrollTo(
3513	!i ? val : jQuery(window).scrollLeft(),
3514	i ? val : jQuery(window).scrollTop()
3515	) :
3516	this[ method ] = val;
3517	}) :
3518
3519	// Return the scroll offset
3520	this[0] == window \|\| this[0] == document ?
3521	self[ i ? 'pageYOffset' : 'pageXOffset' ] \|\|
3522	jQuery.boxModel && document.documentElement[ method ] \|\|
3523	document.body[ method ] :
3524	this[0][ method ];
3525	};
3526	});
3527	// Create innerHeight, innerWidth, outerHeight and outerWidth methods
3528	jQuery.each([ "Height", "Width" ], function(i, name){
3529
3530	var tl = i ? "Left" : "Top", // top or left
3531	br = i ? "Right" : "Bottom"; // bottom or right
3532
3533	// innerHeight and innerWidth
3534	jQuery.fn["inner" + name] = function(){
3535	return this[ name.toLowerCase() ]() +
3536	num(this, "padding" + tl) +
3537	num(this, "padding" + br);
3538	};
3539
3540	// outerHeight and outerWidth
3541	jQuery.fn["outer" + name] = function(margin) {
3542	return this["inner" + name]() +
3543	num(this, "border" + tl + "Width") +
3544	num(this, "border" + br + "Width") +
3545	(margin ?
3546	num(this, "margin" + tl) + num(this, "margin" + br) : 0);
3547	};
3548
3549	});})();

Note: See TracBrowser for help on using the repository browser.

Download in other formats: