HTML中动态图片切换JQuery实现

相信很多同学都注意到了，各大新闻或者娱乐网站都含有动态图片切换，那个漂亮的感觉让刚刚学习html的人，都非常好奇和心动。那下面就让我们看一下到底如何实现动态图片切换呢？看一下百度贴吧的效果图吧~

 

 

 

Javascript代码 
  1.   
Javascript代码 
  1. // JavaScript Document  
  2. var t = count = n = 0;  
  3. $(function(){  
  4.     $(".big_img a:not(:first)").hide();  
  5.     $(".link_nav a:not(:first)").hide();  
  6.     $num_nav = $(".num_nav span");  
  7.     $big_img = $(".big_img a");  
  8.     count = $big_img.length;  
  9.     t = setInterval("showAuto()", 3000);    
  10.       
  11.     $num_nav.click(function(){  
  12.         var num_nav = $(".num_nav span").index(this);  
  13.         $(this).addClass("selected").siblings().removeClass("selected");  
  14.         $big_img.filter(":visible").fadeOut(500).parent().children().eq(num_nav).fadeIn(1000);   
  15.         $(".link_nav a").filter(":visible").fadeOut(500).parent().children().eq(num_nav).fadeIn(1000);   
  16.     });  
  17.     $(".img_nav").hover(function(){clearInterval(t)}, function(){t = setInterval("showAuto()", 3000);});   
  18. })  
  19.   
  20. function showAuto()     
  21. {     
  22.     n = n >= 2 ? 0 : (n + 1);     
  23.     $num_nav.eq(n).trigger('click');     
  24. }  

 

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

 

好的，历经千辛万苦我们将jquery部分和js部分都制作好了，让我们在页面上实现他们吧

 

 

Html代码 
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
  2. <html xmlns="http://www.w3.org/1999/xhtml">  
  3. <head>  
  4. <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />  
  5. <style type="text/css">  
  6. a {text-decoration:none; color:#282828;}  
  7. a img {border:none;}  
  8. body {font-size:12px; font-family:宋体,arial, helvetica, sans-serif; color:#282828;}  
  9. .img_nav {position: relative; width: 300px; float: left; height: 356px}  
  10. .big_img a {position: absolute; top: 0px; left: 0px}  
  11. .img_nav img {width: 300px; height: 356px}  
  12. .link_nav {position: absolute; filter: alpha(opacity=50); width: 300px; bottom: 0px; background: #000; height: 32px; opacity: 0.5}  
  13. .link_nav a {position: absolute; line-height: 32px; color: #fff; left: 5px}  
  14. .num_nav {position: absolute; bottom: 7px; right: 2px}  
  15. .num_nav span {border-bottom: #b2b2b2 1px solid; text-align: center; border-left: #b2b2b2 1px solid; line-height: 18px; width: 18px; background: #84827e; float: left; height: 18px; color: #fff; font-size: 14px; border-top: #b2b2b2 1px solid; cursor: pointer; font-weight: bold; margin-right: 4px; border-right: #b2b2b2 1px solid}  
  16. .num_nav span.selected {border-bottom: #c25e5e 1px solid; border-left: #c25e5e 1px solid; background: #86312e; border-top: #c25e5e 1px solid; border-right: #c25e5e 1px solid}    
  17. </style>  
  18. <script type="text/javascript" src="jquery-1.3.1.js"></script>  
  19. <script type="text/javascript" src="foucs.js"></script>  
  20. <title>滚动图片-示例</title>  
  21. </head>  
  22.   
  23. <body>  
  24.   <div class="img_nav">  
  25.     <div class="big_img">  
  26.       <a href="#" target="_blank"><img src="images/1.jpg" /></a>  
  27.       <a href="#" target="_blank"><img src="images/2.jpg" /></a>  
  28.       <a href="#" target="_blank"><img src="images/3.jpg" /></a>  
  29.     </div>  
  30.     <div class="link_nav">  
  31.       <a href="#" target="_blank">图片1：标题</a> <a href="#" target="_blank">图片2：标题</a> <a href="#" target="_blank">图片3：标题</a>  
  32.     </div>  
  33.     <div class="num_nav">  
  34.       <span class="selected">1</span> <span>2</span> <span>3</span>  
  35.     </div>  
  36.   </div>  
  37. </body>  
  38. </html>  
posted @ 2014-06-10 17:32  Ranran  阅读(908)  评论(0)  编辑  收藏  举报