zoukankan      html  css  js  c++  java

  • HTML中动态图片切换JQuery实现

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

    Javascript代码 
    1.   
    Javascript代码 
    1. // JavaScript Document  
    2. var t = count = n = 0;  
    3. $(function(){  
    4.     $(".big_img a:not(:first)").hide();  
    5.     $(".link_nav a:not(:first)").hide();  
    6.     $num_nav = $(".num_nav span");  
    7.     $big_img = $(".big_img a");  
    8.     count = $big_img.length;  
    9.     t = setInterval("showAuto()", 3000);    
    10.       
    11.     $num_nav.click(function(){  
    12.         var num_nav = $(".num_nav span").index(this);  
    13.         $(this).addClass("selected").siblings().removeClass("selected");  
    14.         $big_img.filter(":visible").fadeOut(500).parent().children().eq(num_nav).fadeIn(1000);   
    15.         $(".link_nav a").filter(":visible").fadeOut(500).parent().children().eq(num_nav).fadeIn(1000);   
    16.     });  
    17.     $(".img_nav").hover(function(){clearInterval(t)}, function(){t = setInterval("showAuto()", 3000);});   
    18. })  
    19.   
    20. function showAuto()     
    21. {     
    22.     n = n >= 2 ? 0 : (n + 1);     
    23.     $num_nav.eq(n).trigger('click');     
    24. }  
    Javascript代码 
    1. /*! 
    2.  * jQuery JavaScript Library v1.3.1 
    3.  * http://jquery.com/ 
    4.  * 
    5.  * Copyright (c) 2009 John Resig 
    6.  * Dual licensed under the MIT and GPL licenses. 
    7.  * http://docs.jquery.com/License 
    8.  * 
    9.  * Date: 2009-01-21 20:42:16 -0500 (Wed, 21 Jan 2009) 
    10.  * Revision: 6158 
    11.  */  
    12. (function(){  
    13.   
    14. var   
    15.     // Will speed up references to window, and allows munging its name.  
    16.     window = this,  
    17.     // Will speed up references to undefined, and allows munging its name.  
    18.     undefined,  
    19.     // Map over jQuery in case of overwrite  
    20.     _jQuery = window.jQuery,  
    21.     // Map over the $ in case of overwrite  
    22.     _$ = window.$,  
    23.   
    24.     jQuery = window.jQuery = window.$ = function( selector, context ) {  
    25.         // The jQuery object is actually just the init constructor 'enhanced'  
    26.         return new jQuery.fn.init( selector, context );  
    27.     },  
    28.   
    29.     // A simple way to check for HTML strings or ID strings  
    30.     // (both of which we optimize for)  
    31.     quickExpr = /^[^<]*(<(.|s)+>)[^>]*$|^#([w-]+)$/,  
    32.     // Is it a simple selector  
    33.     isSimple = /^.[^:#[.,]*$/;  
    34.   
    35. jQuery.fn = jQuery.prototype = {  
    36.     init: function( selector, context ) {  
    37.         // Make sure that a selection was provided  
    38.         selector = selector || document;  
    39.   
    40.         // Handle $(DOMElement)  
    41.         if ( selector.nodeType ) {  
    42.             this[0] = selector;  
    43.             this.length = 1;  
    44.             this.context = selector;  
    45.             return this;  
    46.         }  
    47.         // Handle HTML strings  
    48.         if ( typeof selector === "string" ) {  
    49.             // Are we dealing with HTML string or an ID?  
    50.             var match = quickExpr.exec( selector );  
    51.   
    52.             // Verify a match, and that no context was specified for #id  
    53.             if ( match && (match[1] || !context) ) {  
    54.   
    55.                 // HANDLE: $(html) -> $(array)  
    56.                 if ( match[1] )  
    57.                     selector = jQuery.clean( [ match[1] ], context );  
    58.   
    59.                 // HANDLE: $("#id")  
    60.                 else {  
    61.                     var elem = document.getElementById( match[3] );  
    62.   
    63.                     // Handle the case where IE and Opera return items  
    64.                     // by name instead of ID  
    65.                     if ( elem && elem.id != match[3] )  
    66.                         return jQuery().find( selector );  
    67.   
    68.                     // Otherwise, we inject the element directly into the jQuery object  
    69.                     var ret = jQuery( elem || [] );  
    70.                     ret.context = document;  
    71.                     ret.selector = selector;  
    72.                     return ret;  
    73.                 }  
    74.   
    75.             // HANDLE: $(expr, [context])  
    76.             // (which is just equivalent to: $(content).find(expr)  
    77.             } else  
    78.                 return jQuery( context ).find( selector );  
    79.   
    80.         // HANDLE: $(function)  
    81.         // Shortcut for document ready  
    82.         } else if ( jQuery.isFunction( selector ) )  
    83.             return jQuery( document ).ready( selector );  
    84.   
    85.         // Make sure that old selector state is passed along  
    86.         if ( selector.selector && selector.context ) {  
    87.             this.selector = selector.selector;  
    88.             this.context = selector.context;  
    89.         }  
    90.   
    91.         return this.setArray(jQuery.makeArray(selector));  
    92.     },  
    93.   
    94.     // Start with an empty selector  
    95.     selector: "",  
    96.   
    97.     // The current version of jQuery being used  
    98.     jquery: "1.3.1",  
    99.   
    100.     // The number of elements contained in the matched element set  
    101.     size: function() {  
    102.         return this.length;  
    103.     },  
    104.   
    105.     // Get the Nth element in the matched element set OR  
    106.     // Get the whole matched element set as a clean array  
    107.     get: function( num ) {  
    108.         return num === undefined ?  
    109.   
    110.             // Return a 'clean' array  
    111.             jQuery.makeArray( this ) :  
    112.   
    113.             // Return just the object  
    114.             this[ num ];  
    115.     },  
    116.   
    117.     // Take an array of elements and push it onto the stack  
    118.     // (returning the new matched element set)  
    119.     pushStack: function( elems, name, selector ) {  
    120.         // Build a new jQuery matched element set  
    121.         var ret = jQuery( elems );  
    122.   
    123.         // Add the old object onto the stack (as a reference)  
    124.         ret.prevObject = this;  
    125.   
    126.         ret.context = this.context;  
    127.   
    128.         if ( name === "find" )  
    129.             ret.selector = this.selector + (this.selector ? " " : "") + selector;  
    130.         else if ( name )  
    131.             ret.selector = this.selector + "." + name + "(" + selector + ")";  
    132.   
    133.         // Return the newly-formed element set  
    134.         return ret;  
    135.     },  
    136.   
    137.     // Force the current matched set of elements to become  
    138.     // the specified array of elements (destroying the stack in the process)  
    139.     // You should use pushStack() in order to do this, but maintain the stack  
    140.     setArray: function( elems ) {  
    141.         // Resetting the length to 0, then using the native Array push  
    142.         // is a super-fast way to populate an object with array-like properties  
    143.         this.length = 0;  
    144.         Array.prototype.push.apply( this, elems );  
    145.   
    146.         return this;  
    147.     },  
    148.   
    149.     // Execute a callback for every element in the matched set.  
    150.     // (You can seed the arguments with an array of args, but this is  
    151.     // only used internally.)  
    152.     each: function( callback, args ) {  
    153.         return jQuery.each( this, callback, args );  
    154.     },  
    155.   
    156.     // Determine the position of an element within  
    157.     // the matched set of elements  
    158.     index: function( elem ) {  
    159.         // Locate the position of the desired element  
    160.         return jQuery.inArray(  
    161.             // If it receives a jQuery object, the first element is used  
    162.             elem && elem.jquery ? elem[0] : elem  
    163.         , this );  
    164.     },  
    165.   
    166.     attr: function( name, value, type ) {  
    167.         var options = name;  
    168.   
    169.         // Look for the case where we're accessing a style value  
    170.         if ( typeof name === "string" )  
    171.             if ( value === undefined )  
    172.                 return this[0] && jQuery[ type || "attr" ]( this[0], name );  
    173.   
    174.             else {  
    175.                 options = {};  
    176.                 options[ name ] = value;  
    177.             }  
    178.   
    179.         // Check to see if we're setting style values  
    180.         return this.each(function(i){  
    181.             // Set all the styles  
    182.             for ( name in options )  
    183.                 jQuery.attr(  
    184.                     type ?  
    185.                         this.style :  
    186.                         this,  
    187.                     name, jQuery.prop( this, options[ name ], type, i, name )  
    188.                 );  
    189.         });  
    190.     },  
    191.   
    192.     css: function( key, value ) {  
    193.         // ignore negative width and height values  
    194.         if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )  
    195.             value = undefined;  
    196.         return this.attr( key, value, "curCSS" );  
    197.     },  
    198.   
    199.     text: function( text ) {  
    200.         if ( typeof text !== "object" && text != null )  
    201.             return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );  
    202.   
    203.         var ret = "";  
    204.   
    205.         jQuery.each( text || this, function(){  
    206.             jQuery.each( this.childNodes, function(){  
    207.                 if ( this.nodeType != 8 )  
    208.                     ret += this.nodeType != 1 ?  
    209.                         this.nodeValue :  
    210.                         jQuery.fn.text( [ this ] );  
    211.             });  
    212.         });  
    213.   
    214.         return ret;  
    215.     },  
    216.   
    217.     wrapAll: function( html ) {  
    218.         if ( this[0] ) {  
    219.             // The elements to wrap the target around  
    220.             var wrap = jQuery( html, this[0].ownerDocument ).clone();  
    221.   
    222.             if ( this[0].parentNode )  
    223.                 wrap.insertBefore( this[0] );  
    224.   
    225.             wrap.map(function(){  
    226.                 var elem = this;  
    227.   
    228.                 while ( elem.firstChild )  
    229.                     elem = elem.firstChild;  
    230.   
    231.                 return elem;  
    232.             }).append(this);  
    233.         }  
    234.   
    235.         return this;  
    236.     },  
    237.   
    238.     wrapInner: function( html ) {  
    239.         return this.each(function(){  
    240.             jQuery( this ).contents().wrapAll( html );  
    241.         });  
    242.     },  
    243.   
    244.     wrap: function( html ) {  
    245.         return this.each(function(){  
    246.             jQuery( this ).wrapAll( html );  
    247.         });  
    248.     },  
    249.   
    250.     append: function() {  
    251.         return this.domManip(arguments, true, function(elem){  
    252.             if (this.nodeType == 1)  
    253.                 this.appendChild( elem );  
    254.         });  
    255.     },  
    256.   
    257.     prepend: function() {  
    258.         return this.domManip(arguments, true, function(elem){  
    259.             if (this.nodeType == 1)  
    260.                 this.insertBefore( elem, this.firstChild );  
    261.         });  
    262.     },  
    263.   
    264.     before: function() {  
    265.         return this.domManip(arguments, false, function(elem){  
    266.             this.parentNode.insertBefore( elem, this );  
    267.         });  
    268.     },  
    269.   
    270.     after: function() {  
    271.         return this.domManip(arguments, false, function(elem){  
    272.             this.parentNode.insertBefore( elem, this.nextSibling );  
    273.         });  
    274.     },  
    275.   
    276.     end: function() {  
    277.         return this.prevObject || jQuery( [] );  
    278.     },  
    279.   
    280.     // For internal use only.  
    281.     // Behaves like an Array's .push method, not like a jQuery method.  
    282.     push: [].push,  
    283.   
    284.     find: function( selector ) {  
    285.         if ( this.length === 1 && !/,/.test(selector) ) {  
    286.             var ret = this.pushStack( [], "find", selector );  
    287.             ret.length = 0;  
    288.             jQuery.find( selector, this[0], ret );  
    289.             return ret;  
    290.         } else {  
    291.             var elems = jQuery.map(this, function(elem){  
    292.                 return jQuery.find( selector, elem );  
    293.             });  
    294.   
    295.             return this.pushStack( /[^+>] [^+>]/.test( selector ) ?  
    296.                 jQuery.unique( elems ) :  
    297.                 elems, "find", selector );  
    298.         }  
    299.     },  
    300.   
    301.     clone: function( events ) {  
    302.         // Do the clone  
    303.         var ret = this.map(function(){  
    304.             if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {  
    305.                 // IE copies events bound via attachEvent when  
    306.                 // using cloneNode. Calling detachEvent on the  
    307.                 // clone will also remove the events from the orignal  
    308.                 // In order to get around this, we use innerHTML.  
    309.                 // Unfortunately, this means some modifications to  
    310.                 // attributes in IE that are actually only stored  
    311.                 // as properties will not be copied (such as the  
    312.                 // the name attribute on an input).  
    313.                 var clone = this.cloneNode(true),  
    314.                     container = document.createElement("div");  
    315.                 container.appendChild(clone);  
    316.                 return jQuery.clean([container.innerHTML])[0];  
    317.             } else  
    318.                 return this.cloneNode(true);  
    319.         });  
    320.   
    321.         // Need to set the expando to null on the cloned set if it exists  
    322.         // removeData doesn't work here, IE removes it from the original as well  
    323.         // this is primarily for IE but the data expando shouldn't be copied over in any browser  
    324.         var clone = ret.find("*").andSelf().each(function(){  
    325.             if ( this[ expando ] !== undefined )  
    326.                 this[ expando ] = null;  
    327.         });  
    328.   
    329.         // Copy the events from the original to the clone  
    330.         if ( events === true )  
    331.             this.find("*").andSelf().each(function(i){  
    332.                 if (this.nodeType == 3)  
    333.                     return;  
    334.                 var events = jQuery.data( this, "events" );  
    335.   
    336.                 for ( var type in events )  
    337.                     for ( var handler in events[ type ] )  
    338.                         jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );  
    339.             });  
    340.   
    341.         // Return the cloned set  
    342.         return ret;  
    343.     },  
    344.   
    345.     filter: function( selector ) {  
    346.         return this.pushStack(  
    347.             jQuery.isFunction( selector ) &&  
    348.             jQuery.grep(this, function(elem, i){  
    349.                 return selector.call( elem, i );  
    350.             }) ||  
    351.   
    352.             jQuery.multiFilter( selector, jQuery.grep(this, function(elem){  
    353.                 return elem.nodeType === 1;  
    354.             }) ), "filter", selector );  
    355.     },  
    356.   
    357.     closest: function( selector ) {  
    358.         var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null;  
    359.   
    360.         return this.map(function(){  
    361.             var cur = this;  
    362.             while ( cur && cur.ownerDocument ) {  
    363.                 if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) )  
    364.                     return cur;  
    365.                 cur = cur.parentNode;  
    366.             }  
    367.         });  
    368.     },  
    369.   
    370.     not: function( selector ) {  
    371.         if ( typeof selector === "string" )  
    372.             // test special case where just one selector is passed in  
    373.             if ( isSimple.test( selector ) )  
    374.                 return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );  
    375.             else  
    376.                 selector = jQuery.multiFilter( selector, this );  
    377.   
    378.         var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;  
    379.         return this.filter(function() {  
    380.             return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;  
    381.         });  
    382.     },  
    383.   
    384.     add: function( selector ) {  
    385.         return this.pushStack( jQuery.unique( jQuery.merge(  
    386.             this.get(),  
    387.             typeof selector === "string" ?  
    388.                 jQuery( selector ) :  
    389.                 jQuery.makeArray( selector )  
    390.         )));  
    391.     },  
    392.   
    393.     is: function( selector ) {  
    394.         return !!selector && jQuery.multiFilter( selector, this ).length > 0;  
    395.     },  
    396.   
    397.     hasClass: function( selector ) {  
    398.         return !!selector && this.is( "." + selector );  
    399.     },  
    400.   
    401.     val: function( value ) {  
    402.         if ( value === undefined ) {              
    403.             var elem = this[0];  
    404.   
    405.             if ( elem ) {  
    406.                 if( jQuery.nodeName( elem, 'option' ) )  
    407.                     return (elem.attributes.value || {}).specified ? elem.value : elem.text;  
    408.                   
    409.                 // We need to handle select boxes special  
    410.                 if ( jQuery.nodeName( elem, "select" ) ) {  
    411.                     var index = elem.selectedIndex,  
    412.                         values = [],  
    413.                         options = elem.options,  
    414.                         one = elem.type == "select-one";  
    415.   
    416.                     // Nothing was selected  
    417.                     if ( index < 0 )  
    418.                         return null;  
    419.   
    420.                     // Loop through all the selected options  
    421.                     for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {  
    422.                         var option = options[ i ];  
    423.   
    424.                         if ( option.selected ) {  
    425.                             // Get the specifc value for the option  
    426.                             value = jQuery(option).val();  
    427.   
    428.                             // We don't need an array for one selects  
    429.                             if ( one )  
    430.                                 return value;  
    431.   
    432.                             // Multi-Selects return an array  
    433.                             values.push( value );  
    434.                         }  
    435.                     }  
    436.   
    437.                     return values;                
    438.                 }  
    439.   
    440.                 // Everything else, we just grab the value  
    441.                 return (elem.value || "").replace(/ /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: /#((?:[wu00c0-uFFFF_-]|\.)+)/,  
    1630.         CLASS: /.((?:[wu00c0-uFFFF_-]|\.)+)/,  
    1631.         NAME: /[name=['"]*((?:[wu00c0-uFFFF_-]|\.)+)['"]*]/,  
    1632.         ATTR: /[s*((?:[wu00c0-uFFFF_-]|\.)+)s*(?:(S?=)s*(['"]*)(.*?)3|)s*]/,  
    1633.         TAG: /^((?:[wu00c0-uFFFF*_-]|\.)+)/,  
    1634.         CHILD: /:(only|nth|last|first)-child(?:((even|odd|[dn+-]*)))?/,  
    1635.         POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:((d*)))?(?=[^-]|$)/,  
    1636.         PSEUDO: /:((?:[wu00c0-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 /hd/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;1px;height:1px;"><div></div></div><table style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;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,  '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;  300px; float: left; height: 356px}  
    10. .big_img a {position: absolute; top: 0px; left: 0px}  
    11. .img_nav img { 300px; height: 356px}  
    12. .link_nav {position: absolute; filter: alpha(opacity=50);  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;  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>  
  • 相关阅读:
    Linux grep命令使用方法
    Linux crontab使用方法
    Linux find命令使用方法
    软件测试全流程
    Linux查看CPU、内存、IO占用高的进程
    使用py2exe转换python文件为可执行程序
    Shell脚本调试方法
    Shell编程常用函数
    Win10常用快捷键使用指南
    mac上一键配置和安装adb驱动或者环境
  • 原文地址：https://www.cnblogs.com/ranran/p/3764889.html
Copyright © 2011-2022 走看看