HTML中动态图片切换JQuery实现

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

 

HTML中动态图片切换JQuery实现

 

 

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>  

你可能感兴趣的:(jquery)

  • C# 开发教程-入门基础 天马3798 教程系列整理c#开发语言
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
  • html 删除事件,html 事件的添加和删除 列蒂齐亚 html删除事件
    jQuery在jQuery1.7版本中bind()unbind(),live()die(),on()off(),delegate()下面我们给li元素添加事件bind()旧版写法:事件不能适用脚本创建的新元素live()旧版写法:适用脚本创建的新元素写法，但性能极不好on()新版写法，事件不能适用脚本创建的新元素(接收多个函数绑定)这三种方法都是基于要给添加事件的元素本身。$("ulli").bi
  • 动态生成的html元素绑定click事件 .NET跨平台 Jquery及其组件htmljquery
    第一篇博客，开启技术博客的生涯，欢迎大家批评指教（坚信妹子也可以做好程序猿）今天想说帮公司做项目的时候遇到的一个小问题，动态添加html元素以后再去事件监听出问题。在实际开发中会遇到要给动态生成的html元素绑定触发事件的情况。就是上面的一张表格要动态实现添加行，然后序列号还要随着增加，当删除的时候序列号依旧是按顺序排列。刚开始使用jQuery的on方法来解决，但是发现一个问题会出现事件绑定很多次
  • 前端页面实现table可拖动改变列宽 牧 码 人 jsjQueryjs表格拖动csscolResizable
    此处实现页面的table表格可以自由拖动列宽，拖动时表格内文字不换行，超出部分以...代替，实现步骤如下：1.首先引入jQuery和colResizable的js文件，colResizable支持表格拖动改变列宽，但基于jQuery，（1）colResizable可以去：http://www.bacubacu.com/colresizable/#rangeSlider下载（2）引入文件：2.编写j
  • 关于jquery的on(“click”,function(){}),事件绑定无效 微特尔普拉斯 javascriptjquery
    之前在做jquery时,遇到一个问题,就是我在append一个给啊标签绑定click点击事件时不起作用,jquery的版本时3.4.1,也找不到起的错误.就是没触发:$(self).find(".comment-action.cancel").off("click");//console.log("点击了取消回复的按钮!");$(self).find(".comment-action.cancel
  • （hilo）摇钱树项目梳理 大胡子111
    摇钱树项目用到了：1.jquery（js库）2.hilo.js(游戏框架)3.tida.js（淘宝相关api--要在淘宝中实现摇一摇功能）4.原生陀螺仪（因为要在微信中实现摇一摇功能）5.静态文件资源预加载项目组成部分：1.摇钱树2.摇一摇按钮3.树下礼包4.游戏标题5.树上的红包和金币6.音乐7.获奖记录7.活动规则（活动说明/玩法介绍）8.红包雨下落9.地上红包10.获奖/失败层11.玩法介绍
  • jQuery Easyui 源码分析之combo组件 90后北京程序员 前端-easyuieasyui之combobox
    /***jQueryEasyUI1.3.1*该源码完全由压缩码翻译而来，并非网络上放出的源码，请勿索要。*/(function($){functionsetSize(target,width){varopts=$.data(target,"combo").options;varcombo=$.data(target,"combo").combo;varpanel=$.data(target,"co
  • jquery打包到webpack项目 不cong明的亚子 前端webpackjqueryjavascript
    入口文件—index.jswindow.$=require('jquery')webpack.config.jsconstwebpack=require('webpack')module.exports={...plugins:[...newwebpack.ProvidePlugin({$:'jquery',jQuery:'jquery'})...]...}
  • 通过前端实现导出生成pdf文件并下载 银河小铁皮 vue原生JS前端javascriptvue.js
    通过前端实现导出生成pdf文件并下载使用jspdf.js+html2canvas插件，实现前端生成pdf并下载的功能步骤如下1、先通过npm安装插件npminstalljspdf.jsnpminstallhtml2canvas2、单独在utils文件夹下，新建文件，存放处理代码/*eslint-disable*///不使用JQuery版的importhtml2canvasfrom'html2can
  • java计算机毕业设计Vue潍坊学院宿舍管理系统设计与实现MyBatis+系统+LW文档+源码+调试部署 一梵sheji288 javamybatisvue.js
    java计算机毕业设计Vue潍坊学院宿舍管理系统设计与实现MyBatis+系统+LW文档+源码+调试部署java计算机毕业设计Vue潍坊学院宿舍管理系统设计与实现MyBatis+系统+LW文档+源码+调试部署本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、
  • TypeScript---类型批注 Anglie
    TS通过类型批注提供静态类型，方便在编译时启动类型检查，这不是必须的，甚至可以被忽略，去使用js常规的动态类型。基本类型的批注是number,bool,string,弱类型或动态类型的结构可以是任意类型。将类型批注导出到一个单独的文件，方便使用类型已经被编译成为js的ts脚本的类型信息可用。批注可以为一个现有的js库声明。就像已经为node.js和jquery.js所做的那样。当没有给出类型时，T
  • 基于Java毕业设计新锐台球厅管理系统源码+系统+mysql+lw文档+部署软件 练练科技 java课程设计mysql
    基于Java毕业设计新锐台球厅管理系统源码+系统+mysql+lw文档+部署软件基于Java毕业设计新锐台球厅管理系统源码+系统+mysql+lw文档+部署软件本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQL5.7/8.0源码
  • java计算机毕业设计高校学生资助管理信息系统源码+mysql数据库+系统+lw文档+部署 鸿源网络 数据库mysqljava
    java计算机毕业设计高校学生资助管理信息系统源码+mysql数据库+系统+lw文档+部署java计算机毕业设计高校学生资助管理信息系统源码+mysql数据库+系统+lw文档+部署本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQ
  • 基于JAVA高校毕业就业管理系统计算机毕业设计源码+数据库+lw文档+系统+部署 源新网络 java开发语言
    基于JAVA高校毕业就业管理系统计算机毕业设计源码+数据库+lw文档+系统+部署基于JAVA高校毕业就业管理系统计算机毕业设计源码+数据库+lw文档+系统+部署本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQL5.7/8.0源码
  • jQuery选择器 VaporGas 前端jquery前端javascript学习
    jQuery选择器jQuery选择器类似于CSS选择器，用来选取网页中的元素$("h3").css("background","#09F");代码分析：获取并设置网页中所有元素的背景“h3”为选择器语法，必须放在$()中$(“h3”)返回jQuery对象.css()是为jQuery对象设置样式的方法jQuery选择器分类jQuery选择器功能强大，种类也很多，分类如下：类CSS选择器基本选择器层次
  • Java架构师学习路线 网络全息测量 心得体会
    (1)第一步：研究spring,hibernate。通过研究jeecms开源框架。也同时学习css,html,javascript,jquery.以前都学习过，不过没有系统学习过，现在必须系统学习。同时看cms相关的论文。然后，改造jeecms能够改为自己的一个开源框架，以后开发cms系统都用我自己开发的框架，作为第一阶段的成果。(2)第二步：学习开源工作流引擎Activiti5，jbpm4.4以
  • AJAX实时表单验证系统 三年九班蓝同学
    本文还有配套的精品资源，点击获取简介：在网页开发中，"ajax验证表单"是一项关键任务，确保数据符合格式和规则，提升数据质量和用户体验。本应用通过使用JavaScript和XMLHttpRequest对象实现后台验证，无需页面刷新。它包括前端验证、事件处理、Ajax调用、服务器端处理、响应处理、用户体验和安全性等关键步骤，以jQuery库简化开发流程，创建高效、安全的表单验证系统。1.表单验证的重
  • 利用jQuery框架的ajax请求获取json格式的数据 听海边涛声 jqueryajaxjson
    Document$('#btn').click(()=>{$.get('http://localhost:8080/jsajaxproject/jquery_json','username=tom&age=20',(data)=>{//alert(data)alert(data.name+'\t'+data.age+'\t'+data.gender)},'json')})点击按钮：
  • jquery加载页面的方法(页面加载完成就执行) JaosnY JQueryjquery自动加载
    转自http://www.jb51.net/article/27444.htmjquery加载页面的方法(页面加载完成就执行),建议大家看下windows.onload与$(document).ready之间的区别。1、$(function(){$("#a").click(function(){//addingyourcodehere});});2、$(document).ready(functi
  • jquery事件 上心心上
    jquery事件事件函数列表：blur()元素失去焦点focus()元素获得焦点change()表单元素的值发生变化click()鼠标单击dblclick()鼠标双击mouseover()鼠标进入（进入子元素也触发）mouseout()鼠标离开（离开子元素也触发）mouseenter()鼠标进入（进入子元素不触发）mouseleave()鼠标离开（离开子元素不触发）hover()同时为mousee
  • node模块 weiweiweb888 前端javascriptbootstrap
    模块系统模块化介绍传统开发的问题随着项目的扩大，然后代码就越来越庞大，如果没有很好的规划，后期维护非常复杂（甚至就维护不了）。比如：前端html中有很多特效会依赖js文件。比如：index.html:bootstrap以上就是一个依赖关系，bootstrap依赖于jquery。先引入jquery后引入bootstrap。而且随着项目的扩大，我们的html页面也就随之增加，并且每一个html页面都会
  • jQuery中的ajax通信技术的讲解 盛夏绽放 jqueryajaxokhttp
    jQuery提供了多种方法来处理AJAX请求，这些方法简化了异步请求的创建和处理。以下是一些常用的jQueryAJAX方法及其演示：1.$.ajax()（1）解释这个方法是最基础也是最强大的AJAX方法，它可以接受一个配置对象来构建并发送HTTP请求。（2）示例：这是一个GET请求模版$.ajax({url:'https://api.example.com/data',//请求的URL地址type
  • 记录-小程序720°VR（跳转H5页面实现） 久违的小技巧 小程序小程序vrjavascript
    全景浏览提前准备1拍照支架/照片合成软件（KolorAutopanoGiga4.0）或者全景相机2pannellum（pannellum是一个轻量级、免费和开源的Web全景查看器。它使用HTML5、CSS3、JavaScript和WebGL构建，没有插件。）3H5页面引入pannellum.js/css文件，swiper/jquery文件（因为需要在全景图底部显示可切换图片，与dom操作/ajax
  • HTML表格 一壶浊酒.. 前端开发html前端
    table,tr,td{border:lpxsolidsilver;}表格标题表头单元格HTMLCSSJavaScriptJQuery标准单元格合并行：rowspan在HTML中，我们可以使用rowspan属性来合并行。所谓的合并行，指的是将“纵向的N个单元格”合并。rowspan属性table,tr,td{border:1pxsolidsilver;}姓名:小明喜欢水果:苹果香蕉合并列：cols
  • 前端篇—ajax wolf67 Djangodjangojsajax
    文章目录前言一、基于JS的ajax实现1.1基础1.2完整代码示例1.3应用二、JSON和JSONP2.1什么是JSON2.2JSON语法2.3应用2.4json与django交互2.5json与xml比较三、基于jQuery的ajax实现3.1基础方法3.2快捷方法用法示例四、跨域请求4.1同源机制4.2jsonp的js实现（未完成）4.3jsonp的jQuery实现4.4jsonp的ajax实
  • 菜谱推荐系统(前台android原生,后台java,SSH,mysql) weixingliang_123 菜谱食谱android数据库java编程语言mysql
    Android菜谱推荐系统(前台android原生,后台java,SSH,mysql)(程序代码,MySQL数据库)【运行环境】MyEclipse(后台)Eclipse(前台)JDK1.7tomcat7【技术栈】JAVA,JSP,mvc,SSH,MYSQL,HTML,CSS,JAVASCRIPT,JQUERY,android原生【项目包含内容】【下载全套源码】【项目功能介绍】
  • 【jQuery】前端八股文面试题 菜鸟una 前端八股文面试题前端jqueryjavascript
    jQuery这个问的没有那么多，暂时我被问到的就这几个。大家可以直接订阅专栏。文章目录jQuery1.jQuery常见的方法有哪几个？2.在jQuery中，常见使用委托的事件有哪些？1）点击事件（click）2）鼠标悬停事件（mouseenter和mouseleave）3）表单提交事件（submit）4）输入框变化事件（change）3.在jQuery中，常见的鼠标事件方法有哪些？1）click（
  • jQuery第八章 原生ajax 小涛涛啊！ jqueryjquery
    第八章原生ajax1：ajax的概念AJAX=AsynchronousJavaScriptandXML（异步的JavaScript和XML）。AJAX不是新的编程语言，而是一种使用现有标准的新方法。*AJAX异步请求数据。什么是AJAX？AJAX=异步JavaScript和XML。AJAX是一种用于创建快速动态网页的技术。通过在后台与服务器进行少量数据交换，AJAX可以使网页实现异步更新。这意味着
  • java计算机毕业设计生产管理系统源代码+数据库+系统+lw文档 影伴设计 java开发语言前端
    java计算机毕业设计生产管理系统源代码+数据库+系统+lw文档java计算机毕业设计生产管理系统源代码+数据库+系统+lw文档本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win10、JDK1.8数据库：MySQL5.7/8.0源码地址：https://pan.b
  • 第三章：发送AJAX请求的几种方式 Muko_0x7d2 AJAXajax
    1.jquery发送Ajax请求1.1引进jQuery资源进入bootcdn.cn网站搜索jQuery复制script标签放到目标html文件head标签中添加跨源的属性的设置crossorigin="anonymous"1.2jQuery发送请求的四个参数：url参数（可以没有）函数响应体类型（一般为json）1.3GET请求请求类型为get参数在名称里面//1.发送GET请求$('button
  • HttpClient 4.3与4.3版本以下版本比较 spjich javahttpclient
    网上利用java发送http请求的代码很多，一搜一大把，有的利用的是java.net.*下的HttpURLConnection，有的用httpclient，而且发送的代码也分门别类。今天我们主要来说的是利用httpclient发送请求。 httpclient又可分为 httpclient3.x httpclient4.x到httpclient4.3以下 httpclient4.3
  • Essential Studio Enterprise Edition 2015 v1新功能体验 Axiba .net
    概述：Essential Studio已全线升级至2015 v1版本了！新版本为JavaScript和ASP.NET MVC添加了新的文件资源管理器控件，还有其他一些控件功能升级，精彩不容错过，让我们一起来看看吧！ syncfusion公司是世界领先的Windows开发组件提供商，该公司正式对外发布Essential Studio Enterprise Edition 2015 v1版本。新版本
  • [宇宙与天文]微波背景辐射值与地球温度 comsci 背景
            宇宙这个庞大,无边无际的空间是否存在某种确定的,变化的温度呢?      如果宇宙微波背景辐射值是表示宇宙空间温度的参数之一,那么测量这些数值,并观测周围的恒星能量输出值,我们是否获得地球的长期气候变化的情况呢?   &nbs
  • lvs-server 男人50 server
    #!/bin/bash # # LVS script for VS/DR # #./etc/rc.d/init.d/functions # VIP=10.10.6.252 RIP1=10.10.6.101 RIP2=10.10.6.13 PORT=80 case $1 in start)   /sbin/ifconfig eth2:0 $VIP broadca
  • java的WebCollector爬虫框架 oloz 爬虫
    WebCollector主页： https://github.com/CrawlScript/WebCollector 下载：webcollector-版本号-bin.zip将解压后文件夹中的所有jar包添加到工程既可。 接下来看demo package org.spider.myspider; import cn.edu.hfut.dmic.webcollector.cra
  • jQuery append 与 after 的区别 小猪猪08
    1、after函数 定义和用法： after() 方法在被选元素后插入指定的内容。 语法： $(selector).after(content) 实例： <html> <head> <script type="text/javascript" src="/jquery/jquery.js"></scr
  • mysql知识充电 香水浓 mysql
    索引 索引是在存储引擎中实现的，因此每种存储引擎的索引都不一定完全相同，并且每种存储引擎也不一定支持所有索引类型。 根据存储引擎定义每个表的最大索引数和最大索引长度。所有存储引擎支持每个表至少16个索引，总索引长度至少为256字节。 大多数存储引擎有更高的限制。MYSQL中索引的存储类型有两种：BTREE和HASH，具体和表的存储引擎相关； MYISAM和InnoDB存储引擎
  • 我的架构经验系列文章索引 agevs 架构
    下面是一些个人架构上的总结，本来想只在公司内部进行共享的，因此内容写的口语化一点，也没什么图示，所有内容没有查任何资料是脑子里面的东西吐出来的因此可能会不准确不全，希望抛砖引玉，大家互相讨论。 要注意，我这些文章是一个总体的架构经验不针对具体的语言和平台，因此也不一定是适用所有的语言和平台的。 （内容是前几天写的，现附上索引）   前端架构 http://www.
  • Android so lib库远程http下载和动态注册 aijuans andorid
    一、背景      在开发Android应用程序的实现，有时候需要引入第三方so lib库，但第三方so库比较大，例如开源第三方播放组件ffmpeg库, 如果直接打包的apk包里面, 整个应用程序会大很多.经过查阅资料和实验，发现通过远程下载so文件，然后再动态注册so文件时可行的。主要需要解决下载so文件存放位置以及文件读写权限问题。   二、主要
  • linux中svn配置出错 conf/svnserve.conf:12: Option expected 解决方法 baalwolf option
    在客户端访问subversion版本库时出现这个错误： svnserve.conf:12: Option expected 为什么会出现这个错误呢，就是因为subversion读取配置文件svnserve.conf时，无法识别有前置空格的配置文件，如### This file controls the configuration of the svnserve daemon, if you##
  • MongoDB的连接池和连接管理 BigCat2013 mongodb
    在关系型数据库中，我们总是需要关闭使用的数据库连接，不然大量的创建连接会导致资源的浪费甚至于数据库宕机。这篇文章主要想解释一下mongoDB的连接池以及连接管理机制，如果正对此有疑惑的朋友可以看一下。 通常我们习惯于new 一个connection并且通常在finally语句中调用connection的close()方法将其关闭。正巧，mongoDB中当我们new一个Mongo的时候，会发现它也
  • AngularJS使用Socket.IO bijian1013 JavaScriptAngularJSSocket.IO
            目前，web应用普遍被要求是实时web应用，即服务端的数据更新之后，应用能立即更新。以前使用的技术（例如polling）存在一些局限性，而且有时我们需要在客户端打开一个socket，然后进行通信。         Socket.IO(http://socket.io/)是一个非常优秀的库，它可以帮你实
  • [Maven学习笔记四]Maven依赖特性 bit1129 maven
    三个模块 为了说明问题，以用户登陆小web应用为例。通常一个web应用分为三个模块，模型和数据持久化层user-core, 业务逻辑层user-service以及web展现层user-web， user-service依赖于user-core user-web依赖于user-core和user-service   依赖作用范围  Maven的dependency定义
  • 【Akka一】Akka入门 bit1129 akka
    什么是Akka Message-Driven Runtime is the Foundation to Reactive Applications In Akka, your business logic is driven through message-based communication patterns that are independent of physical locatio
  • zabbix_api之perl语言写法 ronin47 zabbix_api之perl
    zabbix_api网上比较多的写法是python或curl。上次我用java－－http://bossr.iteye.com/blog/2195679，这次用perl。for example: #!/usr/bin/perl use 5.010 ; use strict ; use warnings ; use JSON :: RPC :: Client ; use
  • 比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！ brotherlamp linux运维工程师linux运维工程师教程linux运维工程师视频linux运维工程师资料linux运维工程师自学
    比优衣库跟牛掰的视频流出了，兄弟连Linux运维工程师课堂实录，更加刺激，更加实在！   ----------------------------------------------------- 兄弟连Linux运维工程师课堂实录-计算机基础-1-课程体系介绍1 链接：http://pan.baidu.com/s/1i3GQtGL 密码：bl65   兄弟连Lin
  • bitmap求哈密顿距离-给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y( bylijinnan java
    import java.util.Random; /** * 题目： * 给定N（1<=N<=100000）个五维的点A(x1,x2,x3,x4,x5)，求两个点X(x1,x2,x3,x4,x5)和Y(y1,y2,y3,y4,y5)， * 使得他们的哈密顿距离（d=|x1-y1| + |x2-y2| + |x3-y3| + |x4-y4| + |x5-y5|）最大
  • map的三种遍历方法 chicony map
    package com.test; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; public class TestMap { public static v
  • Linux安装mysql的一些坑 chenchao051 linux
    1、mysql不建议在root用户下运行   2、出现服务启动不了，111错误，注意要用chown来赋予权限， 我在root用户下装的mysql，我就把usr/share/mysql/mysql.server复制到/etc/init.d/mysqld, (同时把my-huge.cnf复制/etc/my.cnf)  chown -R cc /etc/init.d/mysql
  • Sublime Text 3 配置 daizj 配置Sublime Text
    Sublime Text 3 配置解释(默认){// 设置主题文件“color_scheme”: “Packages/Color Scheme – Default/Monokai.tmTheme”,// 设置字体和大小“font_face”: “Consolas”,“font_size”: 12,// 字体选项：no_bold不显示粗体字，no_italic不显示斜体字，no_antialias和
  • MySQL server has gone away 问题的解决方法 dcj3sjt126com SQL Server
    MySQL server has gone away 问题解决方法，需要的朋友可以参考下。 应用程序（比如PHP）长时间的执行批量的MYSQL语句。执行一个SQL，但SQL语句过大或者语句中含有BLOB或者longblob字段。比如，图片数据的处理。都容易引起MySQL server has gone away。 今天遇到类似的情景，MySQL只是冷冷的说：MySQL server h
  • javascript/dom:固定居中效果 dcj3sjt126com JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&
  • 使用 Spring 2.5 注释驱动的 IoC 功能 e200702084 springbean配置管理IOCOffice
    使用 Spring 2.5 注释驱动的 IoC 功能 developerWorks 文档选项 将打印机的版面设置成横向打印模式 打印本页 将此页作为电子邮件发送 将此页作为电子邮件发送 级别： 初级 陈 雄华 ([email protected]), 技术总监, 宝宝淘网络科技有限公司 2008 年 2 月 28 日  &nb
  • MongoDB常用操作命令 geeksun mongodb
    1.   基本操作 db.AddUser(username,password)               添加用户 db.auth(usrename,password)      设置数据库连接验证 db.cloneDataBase(fromhost)    
  • php写守护进程（Daemon） hongtoushizi PHP
    转载自： http://blog.csdn.net/tengzhaorong/article/details/9764655   守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。php也可以实现守护进程的功能。   1、基本概念   &nbs
  • spring整合mybatis,关于注入Dao对象出错问题 jonsvien DAOspringbeanmybatisprototype
    今天在公司测试功能时发现一问题： 先进行代码说明： 1，controller配置了Scope="prototype"（表明每一次请求都是原子型）    @resource/@autowired service对象都可以（两种注解都可以）。 2，service 配置了Scope="prototype"（表明每一次请求都是原子型）
  • 对象关系行为模式之标识映射 home198979 PHP架构企业应用对象关系标识映射
    HELLO!架构   一、概念 identity Map:通过在映射中保存每个已经加载的对象，确保每个对象只加载一次，当要访问对象的时候，通过映射来查找它们。其实在数据源架构模式之数据映射器代码中有提及到标识映射，Mapper类的getFromMap方法就是实现标识映射的实现。     二、为什么要使用标识映射？ 在数据源架构模式之数据映射器中 //c
  • Linux下hosts文件详解 pda158 linux
    　1、主机名： 　　无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。 　　公网：IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。 　　局域网：每台机器都有一个主机名，用于主机与主机之间的便于区分，就可以为每台机器设置主机
  • nginx配置文件粗解 spjich javanginx
    #运行用户#user  nobody;#启动进程,通常设置成和cpu的数量相等worker_processes  2;#全局错误日志及PID文件#error_log  logs/error.log;#error_log  logs/error.log  notice;#error_log  logs/error.log  inf
  • 数学函数 w54653520 java
    public  class  S {        // 传入两个整数，进行比较，返回两个数中的最大值的方法。      public  int  get( int  num1, int  nu
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他