jquery 实现网页右下角固定层广告代码

发布时间:2011年10月21日      浏览次数:536 次
本功能主要有三个文件,分别为:index.html、jquery.floatDiv.js、jquery.js

文件压缩包下载:http://jishu.hao513.com/downloads/div_right_float.rar

-----------------------------------------------------------------------------------------
index.html 代码如下:
-----------------------------------------------------------------------------------------

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>任意位置浮动固定层</title>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="jquery.floatDiv.js"></script>
</head>
<body>
<div style="height:1500px;">任意位置浮动固定层</div>
</body>
</html>

-----------------------------------------------------------------------------------------
jquery.floatDiv.js 代码如下:
-----------------------------------------------------------------------------------------

/////////////////////////////////////////////////////////////////////////
// 主要调用代码,以下代码可直接剪帖到HTML页面调用
/////////////////////////////////////////////////////////////////////////
//以下输出的是固定层的内容,是为了使本JS可同时在多个页面进行包含使用
//如果不需要多页面包含显示相同内容,可将以下DIV放到html页面里去
document.write("<div id="test" style=" width: 300px; height: 200px; line-height:200px; text-align:center; padding:2px; color:white; background-color: #666; border:1px #000 solid;">这是固定在右下角的层</div>");

$(function(){
      $("#test").floatdiv(); //在此省略了参数,默认浮动在右下角
});

/////////////////////////////////////////////////////////////////////////
// 以下是函数,不需要修改
/////////////////////////////////////////////////////////////////////////
/*任意位置浮动固定层*/
/*说明:可以让指定的层浮动到网页上的任何位置,当滚动条滚动时它会保持在当前位置不变,不会产生闪动*/
/*调用:$("#id").floatdiv(); //无参数调用,默认浮动在右下角

2 内置固定位置浮动,调用方法
$("#id").floatdiv("rightbottom");//右下角
$("#id").floatdiv("leftbottom");//左下角
$("#id").floatdiv("rightbottom");//右下角
$("#id").floatdiv("lefttop");//左上角
$("#id").floatdiv("righttop");//右上角
$("#id").floatdiv("middle");//居中

另外新添加了四个新的固定位置方法
middletop(居中置顶)、middlebottom(居中置低)、leftmiddle、rightmiddle

3 自定义位置浮动
$("#id").floatdiv({left:"10px",top:"10px"});
以上参数,设置浮动层在left 10个像素,top 10个像素的位置
*/

jQuery.fn.floatdiv=function(location){
            //判断浏览器版本
      var isIE6=false;
      var Sys = {};
var ua = navigator.userAgent.toLowerCase();
var s;
(s = ua.match(/msie ([\d.]+)/)) ? Sys.ie = s[1] : 0;
      if(Sys.ie && Sys.ie=="6.0"){
            isIE6=true;
      }
      var windowWidth,windowHeight;//窗口的高和宽
      //取得窗口的高和宽
      if (self.innerHeight) {
            windowWidth=self.innerWidth;
            windowHeight=self.innerHeight;
      }else if (document.documentElement&&document.documentElement.clientHeight) {
            windowWidth=document.documentElement.clientWidth;
            windowHeight=document.documentElement.clientHeight;
      } else if (document.body) {
            windowWidth=document.body.clientWidth;
            windowHeight=document.body.clientHeight;
      }
      return this.each(function(){
            var loc;//层的绝对定位位置
            var wrap=$("<div></div>");
            var top=-1;
            if(location==undefined || location.constructor == String){
                  switch(location){
                        case("rightbottom")://右下角
                              loc={right:"0px",bottom:"0px"};
                              break;
                        case("leftbottom")://左下角
                              loc={left:"0px",bottom:"0px"};
                              break;      
                        case("lefttop")://左上角
                              loc={left:"0px",top:"0px"};
                              top=0;
                              break;
                        case("righttop")://右上角
                              loc={right:"0px",top:"0px"};
                              top=0;
                              break;
                        case("middletop")://居中置顶
                              loc={left:windowWidth/2-$(this).width()/2+"px",top:"0px"};
                              top=0;
                              break;
                        case("middlebottom")://居中置低
                              loc={left:windowWidth/2-$(this).width()/2+"px",bottom:"0px"};
                              break;
                        case("leftmiddle")://左边居中
                              loc={left:"0px",top:windowHeight/2-$(this).height()/2+"px"};
                              top=windowHeight/2-$(this).height()/2;
                              break;
                        case("rightmiddle")://右边居中
                              loc={right:"0px",top:windowHeight/2-$(this).height()/2+"px"};
                              top=windowHeight/2-$(this).height()/2;
                              break;
                        case("middle")://居中
                              var l=0;//居左
                              var t=0;//居上
                              l=windowWidth/2-$(this).width()/2;
                              t=windowHeight/2-$(this).height()/2;
                              top=t;
                              loc={left:l+"px",top:t+"px"};
                              break;
                        default://默认为右下角
                              location="rightbottom";
                              loc={right:"0px",bottom:"0px"};
                              break;
                  }
            }else{
                  loc=location;
                  alert(loc.bottom);
                  var str=loc.top;
                  //判断top是否为空
                  if (typeof(str)!= 'undefined'){
                        str=str.replace("px","");
                        top=str;
                  }
            }
            /* 兼容IE6 */
            if(isIE6){
                  if (top>=0)
                  {
                        wrap=$("<div style="top:expression(documentElement.scrollTop+"+top+");"></div>");
                  }else{
                        wrap=$("<div style="top:expression(documentElement.scrollTop+documentElement.clientHeight-this.offsetHeight);"></div>");
                  }
            }
            $("body").append(wrap);            
            wrap.css(loc).css({position:"fixed",z_index:"999"});
            if (isIE6)
            {
                  wrap.css("position","absolute");
                  //没有加这个的话,ie6使用表达式时就会发生跳动现象
                  //如果HTML页面使用了背景图片,以下代码可能会导致原背景图片无效,请将bg_img_url改为背景图片的路径
                  $("body").css("background-attachment","fixed").css("background-image","url(bg_img_url)");
            }
            //将要固定的层添加到固定层里
            $(this).appendTo(wrap);
      });
};

//如果您的html页面使用到了别的jquery.js,而在此可以不包含本jquery.js文件(如果测试运行正常的话),如果由于jquery.js的不完全相同,而导致某些莫名其妙的JS错误,而又无法修正,在不影响页面功能正常使用的情况下,可使用以下代码进行屏蔽JS的错误输出
window.onerror = function() {       return true; } //屏蔽JS的错误显示

-----------------------------------------------------------------------------------------
jquery.js 代码如下:
-----------------------------------------------------------------------------------------

(function(){
/*
* jQuery 1.2.3 - New Wave Javascript
*
* Copyright (c) 2008 John Resig (jquery.com)
* Dual licensed under the MIT (MIT-LICENSE.txt)
* and GPL (GPL-LICENSE.txt) licenses.
*
* $Date: 2008-02-06 00:21:25 -0500 (Wed, 06 Feb 2008) $
* $Rev: 4663 $
*/

// Map over jQuery in case of overwrite
if ( window.jQuery )
      var _jQuery = window.jQuery;

var jQuery = window.jQuery = function( selector, context ) {
      // The jQuery object is actually just the init constructor 'enhanced'
      return new jQuery.prototype.init( selector, context );
};

// Map over the $ in case of overwrite
if ( window.$ )
      var _$ = window.$;
      
// Map the jQuery namespace to the '$' one
window.$ = jQuery;

// A simple way to check for HTML strings or ID strings
// (both of which we optimize for)
var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/;

// Is it a simple selector
var isSimple = /^.[^:#\[\.]*$/;

jQuery.fn = jQuery.prototype = {
      init: function( selector, context ) {
            // Make sure that a selection was provided
            selector = selector || document;

            // Handle $(DOMElement)
            if ( selector.nodeType ) {
                  this[0] = selector;
                  this.length = 1;
                  return this;

            // Handle HTML strings
            } else if ( typeof selector == "string" ) {
                  // Are we dealing with HTML string or an ID?
                  var match = quickExpr.exec( selector );

                  // Verify a match, and that no context was specified for #id
                  if ( match && (match[1] || !context) ) {

                        // HANDLE: $(html) -> $(array)
                        if ( match[1] )
                              selector = jQuery.clean( [ match[1] ], context );

                        // HANDLE: $("#id")
                        else {
                              var elem = document.getElementById( match[3] );

                              // Make sure an element was located
                              if ( elem )
                                    // Handle the case where IE and Opera return items
                                    // by name instead of ID
                                    if ( elem.id != match[3] )
                                          return jQuery().find( selector );

                                    // Otherwise, we inject the element directly into the jQuery object
                                    else {
                                          this[0] = elem;
                                          this.length = 1;
                                          return this;
                                    }

                              else
                                    selector = [];
                        }

                  // HANDLE: $(expr, [context])
                  // (which is just equivalent to: $(content).find(expr)
                  } else
                        return new jQuery( context ).find( selector );

            // HANDLE: $(function)
            // Shortcut for document ready
            } else if ( jQuery.isFunction( selector ) )
                  return new jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );

            return this.setArray(
                  // HANDLE: $(array)
                  selector.constructor == Array && selector ||

                  // HANDLE: $(arraylike)
                  // Watch for when an array-like object, contains DOM nodes, is passed in as the selector
                  (selector.jquery || selector.length && selector != window && !selector.nodeType && selector[0] != undefined && selector[0].nodeType) && jQuery.makeArray( selector ) ||

                  // HANDLE: $(*)
                  [ selector ] );
      },
      
      // The current version of jQuery being used
      jquery: "1.2.3",

      // The number of elements contained in the matched element set
      size: function() {
            return this.length;
      },
      
      // The number of elements contained in the matched element set
      length: 0,

      // Get the Nth element in the matched element set OR
      // Get the whole matched element set as a clean array
      get: function( num ) {
            return num == undefined ?

                  // Return a 'clean' array
                  jQuery.makeArray( this ) :

                  // Return just the object
                  this[ num ];
      },
      
      // Take an array of elements and push it onto the stack
      // (returning the new matched element set)
      pushStack: function( elems ) {
            // Build a new jQuery matched element set
            var ret = jQuery( elems );

            // Add the old object onto the stack (as a reference)
            ret.prevObject = this;

            // Return the newly-formed element set
            return ret;
      },
      
      // Force the current matched set of elements to become
      // the specified array of elements (destroying the stack in the process)
      // You should use pushStack() in order to do this, but maintain the stack
      setArray: function( elems ) {
            // Resetting the length to 0, then using the native Array push
            // is a super-fast way to populate an object with array-like properties
            this.length = 0;
            Array.prototype.push.apply( this, elems );
            
            return this;
      },

      // Execute a callback for every element in the matched set.
      // (You can seed the arguments with an array of args, but this is
      // only used internally.)
      each: function( callback, args ) {
            return jQuery.each( this, callback, args );
      },

      // Determine the position of an element within
      // the matched set of elements
      index: function( elem ) {
            var ret = -1;

            // Locate the position of the desired element
            this.each(function(i){
                  if ( this == elem )
                        ret = i;
            });

            return ret;
      },

      attr: function( name, value, type ) {
            var options = name;
            
            // Look for the case where we're accessing a style value
            if ( name.constructor == String )
                  if ( value == undefined )
                        return this.length && jQuery[ type || "attr" ]( this[0], name ) || undefined;

                  else {
                        options = {};
                        options[ name ] = value;
                  }
            
            // Check to see if we're setting style values
            return this.each(function(i){
                  // Set all the styles
                  for ( name in options )
                        jQuery.attr(
                              type ?
                                    this.style :
                                    this,
                              name, jQuery.prop( this, options[ name ], type, i, name )
                        );
            });
      },

      css: function( key, value ) {
            // ignore negative width and height values
            if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
                  value = undefined;
            return this.attr( key, value, "curCSS" );
      },

      text: function( text ) {
            if ( typeof text != "object" && text != null )
                  return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );

            var ret = "";

            jQuery.each( text || this, function(){
                  jQuery.each( this.childNodes, function(){
                        if ( this.nodeType != 8 )
                              ret += this.nodeType != 1 ?
                                    this.nodeValue :
                                    jQuery.fn.text( [ this ] );
                  });
            });

            return ret;
      },

      wrapAll: function( html ) {
            if ( this[0] )
                  // The elements to wrap the target around
                  jQuery( html, this[0].ownerDocument )
                        .clone()
                        .insertBefore( this[0] )
                        .map(function(){
                              var elem = this;

                              while ( elem.firstChild )
                                    elem = elem.firstChild;

                              return elem;
                        })
                        .append(this);

            return this;
      },

      wrapInner: function( html ) {
            return this.each(function(){
                  jQuery( this ).contents().wrapAll( html );
            });
      },

      wrap: function( html ) {
            return this.each(function(){
                  jQuery( this ).wrapAll( html );
            });
      },

      append: function() {
            return this.domManip(arguments, true, false, function(elem){
                  if (this.nodeType == 1)
                        this.appendChild( elem );
            });
      },

      prepend: function() {
            return this.domManip(arguments, true, true, function(elem){
                  if (this.nodeType == 1)
                        this.insertBefore( elem, this.firstChild );
            });
      },
      
      before: function() {
            return this.domManip(arguments, false, false, function(elem){
                  this.parentNode.insertBefore( elem, this );
            });
      },

      after: function() {
            return this.domManip(arguments, false, true, function(elem){
                  this.parentNode.insertBefore( elem, this.nextSibling );
            });
      },

      end: function() {
            return this.prevObject || jQuery( [] );
      },

      find: function( selector ) {
            var elems = jQuery.map(this, function(elem){
                  return jQuery.find( selector, elem );
            });

            return this.pushStack( /[^+>] [^+>]/.test( selector ) || selector.indexOf("..") > -1 ?
                  jQuery.unique( elems ) :
                  elems );
      },

      clone: function( events ) {
            // Do the clone
            var ret = this.map(function(){
                  if ( jQuery.browser.msie && !jQuery.isXMLDoc(this) ) {
                        // IE copies events bound via attachEvent when
                        // using cloneNode. Calling detachEvent on the
                        // clone will also remove the events from the orignal
                        // In order to get around this, we use innerHTML.
                        // Unfortunately, this means some modifications to
                        // attributes in IE that are actually only stored
                        // as properties will not be copied (such as the
                        // the name attribute on an input).
                        var clone = this.cloneNode(true),
                              container = document.createElement("div");
                        container.appendChild(clone);
                        return jQuery.clean([container.innerHTML])[0];
                  } else
                        return this.cloneNode(true);
            });

            // Need to set the expando to null on the cloned set if it exists
            // removeData doesn't work here, IE removes it from the original as well
            // this is primarily for IE but the data expando shouldn't be copied over in any browser
            var clone = ret.find("*").andSelf().each(function(){
                  if ( this[ expando ] != undefined )
                        this[ expando ] = null;
            });
            
            // Copy the events from the original to the clone
            if ( events === true )
                  this.find("*").andSelf().each(function(i){
                        if (this.nodeType == 3)
                              return;
                        var events = jQuery.data( this, "events" );

                        for ( var type in events )
                              for ( var handler in events[ type ] )
                                    jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
                  });

            // Return the cloned set
            return ret;
      },

      filter: function( selector ) {
            return this.pushStack(
                  jQuery.isFunction( selector ) &&
                  jQuery.grep(this, function(elem, i){
                        return selector.call( elem, i );
                  }) ||

                  jQuery.multiFilter( selector, this ) );
      },

      not: function( selector ) {
            if ( selector.constructor == String )
                  // test special case where just one selector is passed in
                  if ( isSimple.test( selector ) )
                        return this.pushStack( jQuery.multiFilter( selector, this, true ) );
                  else
                        selector = jQuery.multiFilter( selector, this );

            var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
            return this.filter(function() {
                  return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
            });
      },

      add: function( selector ) {
            return !selector ? this : this.pushStack( jQuery.merge(
                  this.get(),
                  selector.constructor == String ?
                        jQuery( selector ).get() :
                        selector.length != undefined && (!selector.nodeName || jQuery.nodeName(selector, "form")) ?
                              selector : [selector] ) );
      },

      is: function( selector ) {
            return selector ?
                  jQuery.multiFilter( selector, this ).length > 0 :
                  false;
      },

      hasClass: function( selector ) {
            return this.is( "." + selector );
      },
      
      val: function( value ) {
            if ( value == undefined ) {

                  if ( this.length ) {
                        var elem = this[0];

                        // We need to handle select boxes special
                        if ( jQuery.nodeName( elem, "select" ) ) {
                              var index = elem.selectedIndex,
                                    values = [],
                                    options = elem.options,
                                    one = elem.type == "select-one";
                              
                              // Nothing was selected
                              if ( index < 0 )
                                    return null;

                              // Loop through all the selected options
                              for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
                                    var option = options[ i ];

                                    if ( option.selected ) {
                                          // Get the specifc value for the option
                                          value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;
                                          
                                          // We don't need an array for one selects
                                          if ( one )
                                                return value;
                                          
                                          // Multi-Selects return an array
                                          values.push( value );
                                    }
                              }
                              
                              return values;
                              
                        // Everything else, we just grab the value
                        } else
                              return (this[0].value || "").replace(/\r/g, "");

                  }

                  return undefined;
            }

            return this.each(function(){
                  if ( this.nodeType != 1 )
                        return;

                  if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
                        this.checked = (jQuery.inArray(this.value, value) >= 0 ||
                              jQuery.inArray(this.name, value) >= 0);

                  else if ( jQuery.nodeName( this, "select" ) ) {
                        var values = value.constructor == Array ?
                              value :
                              [ value ];

                        jQuery( "option", this ).each(function(){
                              this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
                                    jQuery.inArray( this.text, values ) >= 0);
                        });

                        if ( !values.length )
                              this.selectedIndex = -1;

                  } else
                        this.value = value;
            });
      },
      
      html: function( value ) {
            return value == undefined ?
                  (this.length ?
                        this[0].innerHTML :
                        null) :
                  this.empty().append( value );
      },

      replaceWith: function( value ) {
            return this.after( value ).remove();
      },

      eq: function( i ) {
            return this.slice( i, i + 1 );
      },

      slice: function() {
            return this.pushStack( Array.prototype.slice.apply( this, arguments ) );
      },

      map: function( callback ) {
            return this.pushStack( jQuery.map(this, function(elem, i){
                  return callback.call( elem, i, elem );
            }));
      },

      andSelf: function() {
            return this.add( this.prevObject );
      },

      data: function( key, value ){
            var parts = key.split(".");
            parts[1] = parts[1] ? "." + parts[1] : "";

            if ( value == null ) {
                  var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
                  
                  if ( data == undefined && this.length )
                        data = jQuery.data( this[0], key );

                  return data == null && parts[1] ?
                        this.data( parts[0] ) :
                        data;
            } else
                  return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
                        jQuery.data( this, key, value );
                  });
      },

      removeData: function( key ){
            return this.each(function(){
                  jQuery.removeData( this, key );
            });
      },
      
      domManip: function( args, table, reverse, callback ) {
            var clone = this.length > 1, elems;

            return this.each(function(){
                  if ( !elems ) {
                        elems = jQuery.clean( args, this.ownerDocument );

                        if ( reverse )
                              elems.reverse();
                  }

                  var obj = this;

                  if ( table && jQuery.nodeName( this, "table" ) && jQuery.nodeName( elems[0], "tr" ) )
                        obj = this.getElementsByTagName("tbody")[0] || this.appendChild( this.ownerDocument.createElement("tbody") );

                  var scripts = jQuery( [] );

                  jQuery.each(elems, function(){
                        var elem = clone ?
                              jQuery( this ).clone( true )[0] :
                              this;

                        // execute all scripts after the elements have been injected
                        if ( jQuery.nodeName( elem, "script" ) ) {
                              scripts = scripts.add( elem );
                        } else {
                              // Remove any inner scripts for later evaluation
                              if ( elem.nodeType == 1 )
                                    scripts = scripts.add( jQuery( "script", elem ).remove() );

                              // Inject the elements into the document
                              callback.call( obj, elem );
                        }
                  });

                  scripts.each( evalScript );
            });
      }
};

// Give the init function the jQuery prototype for later instantiation
jQuery.prototype.init.prototype = jQuery.prototype;

function evalScript( i, elem ) {
      if ( elem.src )
            jQuery.ajax({
                  url: elem.src,
                  async: false,
                  dataType: "script"
            });

      else
            jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );

      if ( elem.parentNode )
            elem.parentNode.removeChild( elem );
}

jQuery.extend = jQuery.fn.extend = function() {
      // copy reference to target object
      var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;

      // Handle a deep copy situation
      if ( target.constructor == Boolean ) {
            deep = target;
            target = arguments[1] || {};
            // skip the boolean and the target
            i = 2;
      }

      // Handle case when target is a string or something (possible in deep copy)
      if ( typeof target != "object" && typeof target != "function" )
            target = {};

      // extend jQuery itself if only one argument is passed
      if ( length == 1 ) {
            target = this;
            i = 0;
      }

      for ( ; i < length; i++ )
            // Only deal with non-null/undefined values
            if ( (options = arguments[ i ]) != null )
                  // Extend the base object
                  for ( var name in options ) {
                        // Prevent never-ending loop
                        if ( target === options[ name ] )
                              continue;

                        // Recurse if we're merging object values
                        if ( deep && options[ name ] && typeof options[ name ] == "object" && target[ name ] && !options[ name ].nodeType )
                              target[ name ] = jQuery.extend( target[ name ], options[ name ] );

                        // Don't bring in undefined values
                        else if ( options[ name ] != undefined )
                              target[ name ] = options[ name ];

                  }

      // Return the modified object
      return target;
};

var expando = "jQuery" + (new Date()).getTime(), uuid = 0, windowData = {};

// exclude the following css properties to add px
var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i;

jQuery.extend({
      noConflict: function( deep ) {
            window.$ = _$;

            if ( deep )
                  window.jQuery = _jQuery;

            return jQuery;
      },

      // See test/unit/core.js for details concerning this function.
      isFunction: function( fn ) {
            return !!fn && typeof fn != "string" && !fn.nodeName &&
                  fn.constructor != Array && /function/i.test( fn + "" );
      },
      
      // check if an element is in a (or is an) XML document
      isXMLDoc: function( elem ) {
            return elem.documentElement && !elem.body ||
                  elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
      },

      // Evalulates a script in a global context
      globalEval: function( data ) {
            data = jQuery.trim( data );

            if ( data ) {
                  // Inspired by code by Andrea Giammarchi
                  // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
                  var head = document.getElementsByTagName("head")[0] || document.documentElement,
                        script = document.createElement("script");

                  script.type = "text/javascript";
                  if ( jQuery.browser.msie )
                        script.text = data;
                  else
                        script.appendChild( document.createTextNode( data ) );

                  head.appendChild( script );
                  head.removeChild( script );
            }
      },

      nodeName: function( elem, name ) {
            return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
      },
      
      cache: {},
      
      data: function( elem, name, data ) {
            elem = elem == window ?
                  windowData :
                  elem;

            var id = elem[ expando ];

            // Compute a unique ID for the element
            if ( !id )
                  id = elem[ expando ] = ++uuid;

            // Only generate the data cache if we're
            // trying to access or manipulate it
            if ( name && !jQuery.cache[ id ] )
                  jQuery.cache[ id ] = {};
            
            // Prevent overriding the named cache with undefined values
            if ( data != undefined )
                  jQuery.cache[ id ][ name ] = data;
            
            // Return the named cache data, or the ID for the element      
            return name ?
                  jQuery.cache[ id ][ name ] :
                  id;
      },
      
      removeData: function( elem, name ) {
            elem = elem == window ?
                  windowData :
                  elem;

            var id = elem[ expando ];

            // If we want to remove a specific section of the element's data
            if ( name ) {
                  if ( jQuery.cache[ id ] ) {
                        // Remove the section of cache data
                        delete jQuery.cache[ id ][ name ];

                        // If we've removed all the data, remove the element's cache
                        name = "";

                        for ( name in jQuery.cache[ id ] )
                              break;

                        if ( !name )
                              jQuery.removeData( elem );
                  }

            // Otherwise, we want to remove all of the element's data
            } else {
                  // Clean up the element expando
                  try {
                        delete elem[ expando ];
                  } catch(e){
                        // IE has trouble directly removing the expando
                        // but it's ok with using removeAttribute
                        if ( elem.removeAttribute )
                              elem.removeAttribute( expando );
                  }

                  // Completely remove the data cache
                  delete jQuery.cache[ id ];
            }
      },

      // args is for internal usage only
      each: function( object, callback, args ) {
            if ( args ) {
                  if ( object.length == undefined ) {
                        for ( var name in object )
                              if ( callback.apply( object[ name ], args ) === false )
                                    break;
                  } else
                        for ( var i = 0, length = object.length; i < length; i++ )
                              if ( callback.apply( object[ i ], args ) === false )
                                    break;

            // A special, fast, case for the most common use of each
            } else {
                  if ( object.length == undefined ) {
                        for ( var name in object )
                              if ( callback.call( object[ name ], name, object[ name ] ) === false )
                                    break;
                  } else
                        for ( var i = 0, length = object.length, value = object[0];
                              i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
            }

            return object;
      },
      
      prop: function( elem, value, type, i, name ) {
                  // Handle executable functions
                  if ( jQuery.isFunction( value ) )
                        value = value.call( elem, i );
                        
                  // Handle passing in a number to a CSS property
                  return value && value.constructor == Number && type == "curCSS" && !exclude.test( name ) ?
                        value + "px" :
                        value;
      },

      className: {
            // internal only, use addClass("class")
            add: function( elem, classNames ) {
                  jQuery.each((classNames || "").split(/\s+/), function(i, className){
                        if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
                              elem.className += (elem.className ? " " : "") + className;
                  });
            },

            // internal only, use removeClass("class")
            remove: function( elem, classNames ) {
                  if (elem.nodeType == 1)
                        elem.className = classNames != undefined ?
                              jQuery.grep(elem.className.split(/\s+/), function(className){
                                    return !jQuery.className.has( classNames, className );      
                              }).join(" ") :
                              "";
            },

            // internal only, use is(".class")
            has: function( elem, className ) {
                  return jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
            }
      },

      // A method for quickly swapping in/out CSS properties to get correct calculations
      swap: function( elem, options, callback ) {
            var old = {};
            // Remember the old values, and insert the new ones
            for ( var name in options ) {
                  old[ name ] = elem.style[ name ];
                  elem.style[ name ] = options[ name ];
            }

            callback.call( elem );

            // Revert the old values
            for ( var name in options )
                  elem.style[ name ] = old[ name ];
      },

      css: function( elem, name, force ) {
            if ( name == "width" || name == "height" ) {
                  var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
            
                  function getWH() {
                        val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
                        var padding = 0, border = 0;
                        jQuery.each( which, function() {
                              padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
                              border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
                        });
                        val -= Math.round(padding + border);
                  }
            
                  if ( jQuery(elem).is(":visible") )
                        getWH();
                  else
                        jQuery.swap( elem, props, getWH );
                  
                  return Math.max(0, val);
            }
            
            return jQuery.curCSS( elem, name, force );
      },

      curCSS: function( elem, name, force ) {
            var ret;

            // A helper method for determining if an element's values are broken
            function color( elem ) {
                  if ( !jQuery.browser.safari )
                        return false;

                  var ret = document.defaultView.getComputedStyle( elem, null );
                  return !ret || ret.getPropertyValue("color") == "";
            }

            // We need to handle opacity special in IE
            if ( name == "opacity" && jQuery.browser.msie ) {
                  ret = jQuery.attr( elem.style, "opacity" );

                  return ret == "" ?
                        "1" :
                        ret;
            }
            // Opera sometimes will give the wrong display answer, this fixes it, see #2037
            if ( jQuery.browser.opera && name == "display" ) {
                  var save = elem.style.outline;
                  elem.style.outline = "0 solid black";
                  elem.style.outline = save;
            }
            
            // Make sure we're using the right name for getting the float value
            if ( name.match( /float/i ) )
                  name = styleFloat;

            if ( !force && elem.style && elem.style[ name ] )
                  ret = elem.style[ name ];

            else if ( document.defaultView && document.defaultView.getComputedStyle ) {

                  // Only "float" is needed here
                  if ( name.match( /float/i ) )
                        name = "float";

                  name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();

                  var getComputedStyle = document.defaultView.getComputedStyle( elem, null );

                  if ( getComputedStyle && !color( elem ) )
                        ret = getComputedStyle.getPropertyValue( name );

                  // If the element isn't reporting its values properly in Safari
                  // then some display: none elements are involved
                  else {
                        var swap = [], stack = [];

                        // Locate all of the parent display: none elements
                        for ( var a = elem; a && color(a); a = a.parentNode )
                              stack.unshift(a);

                        // Go through and make them visible, but in reverse
                        // (It would be better if we knew the exact display type that they had)
                        for ( var i = 0; i < stack.length; i++ )
                              if ( color( stack[ i ] ) ) {
                                    swap[ i ] = stack[ i ].style.display;
                                    stack[ i ].style.display = "block";
                              }

                        // Since we flip the display style, we have to handle that
                        // one special, otherwise get the value
                        ret = name == "display" && swap[ stack.length - 1 ] != null ?
                              "none" :
                              ( getComputedStyle && getComputedStyle.getPropertyValue( name ) ) || "";

                        // Finally, revert the display styles back
                        for ( var i = 0; i < swap.length; i++ )
                              if ( swap[ i ] != null )
                                    stack[ i ].style.display = swap[ i ];
                  }

                  // We should always get a number back from opacity
                  if ( name == "opacity" && ret == "" )
                        ret = "1";

            } else if ( elem.currentStyle ) {
                  var camelCase = name.replace(/\-(\w)/g, function(all, letter){
                        return letter.toUpperCase();
                  });

                  ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];

                  // From the awesome hack by Dean Edwards
                  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291

                  // If we're not dealing with a regular pixel number
                  // but a number that has a weird ending, we need to convert it to pixels
                  if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
                        // Remember the original values
                        var style = elem.style.left, runtimeStyle = elem.runtimeStyle.left;

                        // Put in the new values to get a computed value out
                        elem.runtimeStyle.left = elem.currentStyle.left;
                        elem.style.left = ret || 0;
                        ret = elem.style.pixelLeft + "px";

                        // Revert the changed values
                        elem.style.left = style;
                        elem.runtimeStyle.left = runtimeStyle;
                  }
            }

            return ret;
      },
      
      clean: function( elems, context ) {
            var ret = [];
            context = context || document;
            // !context.createElement fails in IE with an error but returns typeof 'object'
            if (typeof context.createElement == 'undefined')
                  context = context.ownerDocument || context[0] && context[0].ownerDocument || document;

            jQuery.each(elems, function(i, elem){
                  if ( !elem )
                        return;

                  if ( elem.constructor == Number )
                        elem = elem.toString();
                  
                  // Convert html string into DOM nodes
                  if ( typeof elem == "string" ) {
                        // Fix "XHTML"-style tags in all browsers
                        elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
                              return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
                                    all :
                                    front + "></" + tag + ">";
                        });

                        // Trim whitespace, otherwise indexOf won't work as expected
                        var tags = jQuery.trim( elem ).toLowerCase(), div = context.createElement("div");

                        var wrap =
                              // option or optgroup
                              !tags.indexOf("<opt") &&
                              [ 1, "<select multiple='multiple'>", "</select>" ] ||
                              
                              !tags.indexOf("<leg") &&
                              [ 1, "<fieldset>", "</fieldset>" ] ||
                              
                              tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
                              [ 1, "<table>", "</table>" ] ||
                              
                              !tags.indexOf("<tr") &&
                              [ 2, "<table><tbody>", "</tbody></table>" ] ||
                              
                               // <thead> matched above
                              (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
                              [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
                              
                              !tags.indexOf("<col") &&
                              [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||

                              // IE can't serialize <link> and <script> tags normally
                              jQuery.browser.msie &&
                              [ 1, "div<div>", "</div>" ] ||
                              
                              [ 0, "", "" ];

                        // Go to html and back, then peel off extra wrappers
                        div.innerHTML = wrap[1] + elem + wrap[2];
                        
                        // Move to the right depth
                        while ( wrap[0]-- )
                              div = div.lastChild;
                        
                        // Remove IE's autoinserted <tbody> from table fragments
                        if ( jQuery.browser.msie ) {
                              
                              // String was a <table>, *may* have spurious <tbody>
                              var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
                                    div.firstChild && div.firstChild.childNodes :
                                    
                                    // String was a bare <thead> or <tfoot>
                                    wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
                                          div.childNodes :
                                          [];
                        
                              for ( var j = tbody.length - 1; j >= 0 ; --j )
                                    if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
                                          tbody[ j ].parentNode.removeChild( tbody[ j ] );
                              
                              // IE completely kills leading whitespace when innerHTML is used      
                              if ( /^\s/.test( elem ) )      
                                    div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
                        
                        }
                        
                        elem = jQuery.makeArray( div.childNodes );
                  }

                  if ( elem.length === 0 && (!jQuery.nodeName( elem, "form" ) && !jQuery.nodeName( elem, "select" )) )
                        return;

                  if ( elem[0] == undefined || jQuery.nodeName( elem, "form" ) || elem.options )
                        ret.push( elem );

                  else
                        ret = jQuery.merge( ret, elem );

            });

            return ret;
      },
      
      attr: function( elem, name, value ) {
            // don't set attributes on text and comment nodes
            if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
                  return undefined;

            var fix = jQuery.isXMLDoc( elem ) ?
                  {} :
                  jQuery.props;

            // Safari mis-reports the default selected property of a hidden option
            // Accessing the parent's selectedIndex property fixes it
            if ( name == "selected" && jQuery.browser.safari )
                  elem.parentNode.selectedIndex;
            
            // Certain attributes only work when accessed via the old DOM 0 way
            if ( fix[ name ] ) {
                  if ( value != undefined )
                        elem[ fix[ name ] ] = value;

                  return elem[ fix[ name ] ];

            } else if ( jQuery.browser.msie && name == "style" )
                  return jQuery.attr( elem.style, "cssText", value );

            else if ( value == undefined && jQuery.browser.msie && jQuery.nodeName( elem, "form" ) && (name == "action" || name == "method") )
                  return elem.getAttributeNode( name ).nodeValue;

            // IE elem.getAttribute passes even for style
            else if ( elem.tagName ) {

                  if ( value != undefined ) {
                        // We can't allow the type property to be changed (since it causes problems in IE)
                        if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
                              throw "type property can't be changed";

                        // convert the value to a string (all browsers do this but IE) see #1070
                        elem.setAttribute( name, "" + value );
                  }

                  if ( jQuery.browser.msie && /href|src/.test( name ) && !jQuery.isXMLDoc( elem ) )
                        return elem.getAttribute( name, 2 );

                  return elem.getAttribute( name );

            // elem is actually elem.style ... set the style
            } else {
                  // IE actually uses filters for opacity
                  if ( name == "opacity" && jQuery.browser.msie ) {
                        if ( value != undefined ) {
                              // IE has trouble with opacity if it does not have layout
                              // Force it by setting the zoom level
                              elem.zoom = 1;
      
                              // Set the alpha filter to set the opacity
                              elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
                                    (parseFloat( value ).toString() == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
                        }
      
                        return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
                              (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100).toString() :
                              "";
                  }

                  name = name.replace(/-([a-z])/ig, function(all, letter){
                        return letter.toUpperCase();
                  });

                  if ( value != undefined )
                        elem[ name ] = value;

                  return elem[ name ];
            }
      },
      
      trim: function( text ) {
            return (text || "").replace( /^\s+|\s+$/g, "" );
      },

      makeArray: function( array ) {
            var ret = [];

            // Need to use typeof to fight Safari childNodes crashes
            if ( typeof array != "array" )
                  for ( var i = 0, length = array.length; i < length; i++ )
                        ret.push( array[ i ] );
            else
                  ret = array.slice( 0 );

            return ret;
      },

      inArray: function( elem, array ) {
            for ( var i = 0, length = array.length; i < length; i++ )
                  if ( array[ i ] == elem )
                        return i;

            return -1;
      },

      merge: function( first, second ) {
            // We have to loop this way because IE & Opera overwrite the length
            // expando of getElementsByTagName

            // Also, we need to make sure that the correct elements are being returned
            // (IE returns comment nodes in a '*' query)
            if ( jQuery.browser.msie ) {
                  for ( var i = 0; second[ i ]; i++ )
                        if ( second[ i ].nodeType != 8 )
                              first.push( second[ i ] );

            } else
                  for ( var i = 0; second[ i ]; i++ )
                        first.push( second[ i ] );

            return first;
      },

      unique: function( array ) {
            var ret = [], done = {};

            try {

                  for ( var i = 0, length = array.length; i < length; i++ ) {
                        var id = jQuery.data( array[ i ] );

                        if ( !done[ id ] ) {
                              done[ id ] = true;
                              ret.push( array[ i ] );
                        }
                  }

            } catch( e ) {
                  ret = array;
            }

            return ret;
      },

      grep: function( elems, callback, inv ) {
            var ret = [];

            // Go through the array, only saving the items
            // that pass the validator function
            for ( var i = 0, length = elems.length; i < length; i++ )
                  if ( !inv && callback( elems[ i ], i ) || inv && !callback( elems[ i ], i ) )
                        ret.push( elems[ i ] );

            return ret;
      },

      map: function( elems, callback ) {
            var ret = [];

            // Go through the array, translating each of the items to their
            // new value (or values).
            for ( var i = 0, length = elems.length; i < length; i++ ) {
                  var value = callback( elems[ i ], i );

                  if ( value !== null && value != undefined ) {
                        if ( value.constructor != Array )
                              value = [ value ];

                        ret = ret.concat( value );
                  }
            }

            return ret;
      }
});

var userAgent = navigator.userAgent.toLowerCase();

// Figure out what browser is being used
jQuery.browser = {
      version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
      safari: /webkit/.test( userAgent ),
      opera: /opera/.test( userAgent ),
      msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
      mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
};

var styleFloat = jQuery.browser.msie ?
      "styleFloat" :
      "cssFloat";
      
jQuery.extend({
      // Check to see if the W3C box model is being used
      boxModel: !jQuery.browser.msie || document.compatMode == "CSS1Compat",
      
      props: {
            "for": "htmlFor",
            "class": "className",
            "float": styleFloat,
            cssFloat: styleFloat,
            styleFloat: styleFloat,
            innerHTML: "innerHTML",
            className: "className",
            value: "value",
            disabled: "disabled",
            checked: "checked",
            readonly: "readOnly",
            selected: "selected",
            maxlength: "maxLength",
            selectedIndex: "selectedIndex",
            defaultValue: "defaultValue",
            tagName: "tagName",
            nodeName: "nodeName"
      }
});

jQuery.each({
      parent: function(elem){return elem.parentNode;},
      parents: function(elem){return jQuery.dir(elem,"parentNode");},
      next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
      prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
      nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
      prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
      siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
      children: function(elem){return jQuery.sibling(elem.firstChild);},
      contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
}, function(name, fn){
      jQuery.fn[ name ] = function( selector ) {
            var ret = jQuery.map( this, fn );

            if ( selector && typeof selector == "string" )
                  ret = jQuery.multiFilter( selector, ret );

            return this.pushStack( jQuery.unique( ret ) );
      };
});

jQuery.each({
      appendTo: "append",
      prependTo: "prepend",
      insertBefore: "before",
      insertAfter: "after",
      replaceAll: "replaceWith"
}, function(name, original){
      jQuery.fn[ name ] = function() {
            var args = arguments;

            return this.each(function(){
                  for ( var i = 0, length = args.length; i < length; i++ )
                        jQuery( args[ i ] )[ original ]( this );
            });
      };
});

jQuery.each({
      removeAttr: function( name ) {
            jQuery.attr( this, name, "" );
            if (this.nodeType == 1)
                  this.removeAttribute( name );
      },

      addClass: function( classNames ) {
            jQuery.className.add( this, classNames );
      },

      removeClass: function( classNames ) {
            jQuery.className.remove( this, classNames );
      },

      toggleClass: function( classNames ) {
            jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
      },

      remove: function( selector ) {
            if ( !selector || jQuery.filter( selector, [ this ] ).r.length ) {
                  // Prevent memory leaks
                  jQuery( "*", this ).add(this).each(function(){
                        jQuery.event.remove(this);
                        jQuery.removeData(this);
                  });
                  if (this.parentNode)
                        this.parentNode.removeChild( this );
            }
      },

      empty: function() {
            // Remove element nodes and prevent memory leaks
            jQuery( ">*", this ).remove();
            
            // Remove any remaining nodes
            while ( this.firstChild )
                  this.removeChild( this.firstChild );
      }
}, function(name, fn){
      jQuery.fn[ name ] = function(){
            return this.each( fn, arguments );
      };
});

jQuery.each([ "Height", "Width" ], function(i, name){
      var type = name.toLowerCase();
      
      jQuery.fn[ type ] = function( size ) {
            // Get window width or height
            return this[0] == window ?
                  // Opera reports document.body.client[Width/Height] properly in both quirks and standards
                  jQuery.browser.opera && document.body[ "client" + name ] ||
                  
                  // Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
                  jQuery.browser.safari && window[ "inner" + name ] ||
                  
                  // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
                  document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :
            
                  // Get document width or height
                  this[0] == document ?
                        // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
                        Math.max(
                              Math.max(document.body["scroll" + name], document.documentElement["scroll" + name]),
                              Math.max(document.body["offset" + name], document.documentElement["offset" + name])
                        ) :

                        // Get or set width or height on the element
                        size == undefined ?
                              // Get width or height on the element
                              (this.length ? jQuery.css( this[0], type ) : null) :

                              // Set the width or height on the element (default to pixels if value is unitless)
                              this.css( type, size.constructor == String ? size : size + "px" );
      };
});

var chars = jQuery.browser.safari && parseInt(jQuery.browser.version) < 417 ?
            "(?:[\w*_-]|\.)" :
            "(?:[\w\u0128-\uFFFF*_-]|\.)",
      quickChild = new RegExp("^>\s*(" + chars + "+)"),
      quickID = new RegExp("^(" + chars + "+)(#)(" + chars + "+)"),
      quickClass = new RegExp("^([#.]?)(" + chars + "*)");

jQuery.extend({
      expr: {
            "": function(a,i,m){return m[2]=="*"||jQuery.nodeName(a,m[2]);},
            "#": function(a,i,m){return a.getAttribute("id")==m[2];},
            ":": {
                  // Position Checks
                  lt: function(a,i,m){return i<m[3]-0;},
                  gt: function(a,i,m){return i>m[3]-0;},
                  nth: function(a,i,m){return m[3]-0==i;},
                  eq: function(a,i,m){return m[3]-0==i;},
                  first: function(a,i){return i==0;},
                  last: function(a,i,m,r){return i==r.length-1;},
                  even: function(a,i){return i%2==0;},
                  odd: function(a,i){return i%2;},

                  // Child Checks
                  "first-child": function(a){return a.parentNode.getElementsByTagName("*")[0]==a;},
                  "last-child": function(a){return jQuery.nth(a.parentNode.lastChild,1,"previousSibling")==a;},
                  "only-child": function(a){return !jQuery.nth(a.parentNode.lastChild,2,"previousSibling");},

                  // Parent Checks
                  parent: function(a){return a.firstChild;},
                  empty: function(a){return !a.firstChild;},

                  // Text Check
                  contains: function(a,i,m){return (a.textContent||a.innerText||jQuery(a).text()||"").indexOf(m[3])>=0;},

                  // Visibility
                  visible: function(a){return "hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden";},
                  hidden: function(a){return "hidden"==a.type||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden";},

                  // Form attributes
                  enabled: function(a){return !a.disabled;},
                  disabled: function(a){return a.disabled;},
                  checked: function(a){return a.checked;},
                  selected: function(a){return a.selected||jQuery.attr(a,"selected");},

                  // Form elements
                  text: function(a){return "text"==a.type;},
                  radio: function(a){return "radio"==a.type;},
                  checkbox: function(a){return "checkbox"==a.type;},
                  file: function(a){return "file"==a.type;},
                  password: function(a){return "password"==a.type;},
                  submit: function(a){return "submit"==a.type;},
                  image: function(a){return "image"==a.type;},
                  reset: function(a){return "reset"==a.type;},
                  button: function(a){return "button"==a.type||jQuery.nodeName(a,"button");},
                  input: function(a){return /input|select|textarea|button/i.test(a.nodeName);},

                  // :has()
                  has: function(a,i,m){return jQuery.find(m[3],a).length;},

                  // :header
                  header: function(a){return /h\d/i.test(a.nodeName);},

                  // :animated
                  animated: function(a){return jQuery.grep(jQuery.timers,function(fn){return a==fn.elem;}).length;}
            }
      },
      
      // The regular expressions that power the parsing engine
      parse: [
            // Match: [@value='test'], [@foo]
            /^(\[) *@?([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,

            // Match: :contains('foo')
            /^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/,

            // Match: :even, :last-chlid, #id, .class
            new RegExp("^([:.#]*)(" + chars + "+)")
      ],

      multiFilter: function( expr, elems, not ) {
            var old, cur = [];

            while ( expr && expr != old ) {
                  old = expr;
                  var f = jQuery.filter( expr, elems, not );
                  expr = f.t.replace(/^\s*,\s*/, "" );
                  cur = not ? elems = f.r : jQuery.merge( cur, f.r );
            }

            return cur;
      },

      find: function( t, context ) {
            // Quickly handle non-string expressions
            if ( typeof t != "string" )
                  return [ t ];

            // check to make sure context is a DOM element or a document
            if ( context && context.nodeType != 1 && context.nodeType != 9)
                  return [ ];

            // Set the correct context (if none is provided)
            context = context || document;

            // Initialize the search
            var ret = [context], done = [], last, nodeName;

            // Continue while a selector expression exists, and while
            // we're no longer looping upon ourselves
            while ( t && last != t ) {
                  var r = [];
                  last = t;

                  t = jQuery.trim(t);

                  var foundToken = false;

                  // An attempt at speeding up child selectors that
                  // point to a specific element tag
                  var re = quickChild;
                  var m = re.exec(t);

                  if ( m ) {
                        nodeName = m[1].toUpperCase();

                        // Perform our own iteration and filter
                        for ( var i = 0; ret[i]; i++ )
                              for ( var c = ret[i].firstChild; c; c = c.nextSibling )
                                    if ( c.nodeType == 1 && (nodeName == "*" || c.nodeName.toUpperCase() == nodeName) )
                                          r.push( c );

                        ret = r;
                        t = t.replace( re, "" );
                        if ( t.indexOf(" ") == 0 ) continue;
                        foundToken = true;
                  } else {
                        re = /^([>+~])\s*(\w*)/i;

                        if ( (m = re.exec(t)) != null ) {
                              r = [];

                              var merge = {};
                              nodeName = m[2].toUpperCase();
                              m = m[1];

                              for ( var j = 0, rl = ret.length; j < rl; j++ ) {
                                    var n = m == "~" || m == "+" ? ret[j].nextSibling : ret[j].firstChild;
                                    for ( ; n; n = n.nextSibling )
                                          if ( n.nodeType == 1 ) {
                                                var id = jQuery.data(n);

                                                if ( m == "~" && merge[id] ) break;
                                                
                                                if (!nodeName || n.nodeName.toUpperCase() == nodeName ) {
                                                      if ( m == "~" ) merge[id] = true;
                                                      r.push( n );
                                                }
                                                
                                                if ( m == "+" ) break;
                                          }
                              }

                              ret = r;

                              // And remove the token
                              t = jQuery.trim( t.replace( re, "" ) );
                              foundToken = true;
                        }
                  }

                  // See if there's still an expression, and that we haven't already
                  // matched a token
                  if ( t && !foundToken ) {
                        // Handle multiple expressions
                        if ( !t.indexOf(",") ) {
                              // Clean the result set
                              if ( context == ret[0] ) ret.shift();

                              // Merge the result sets
                              done = jQuery.merge( done, ret );

                              // Reset the context
                              r = ret = [context];

                              // Touch up the selector string
                              t = " " + t.substr(1,t.length);

                        } else {
                              // Optimize for the case nodeName#idName
                              var re2 = quickID;
                              var m = re2.exec(t);
                              
                              // Re-organize the results, so that they're consistent
                              if ( m ) {
                                    m = [ 0, m[2], m[3], m[1] ];

                              } else {
                                    // Otherwise, do a traditional filter check for
                                    // ID, class, and element selectors
                                    re2 = quickClass;
                                    m = re2.exec(t);
                              }

                              m[2] = m[2].replace(/\/g, "");

                              var elem = ret[ret.length-1];

                              // Try to do a global search by ID, where we can
                              if ( m[1] == "#" && elem && elem.getElementById && !jQuery.isXMLDoc(elem) ) {
                                    // Optimization for HTML document case
                                    var oid = elem.getElementById(m[2]);
                                    
                                    // Do a quick check for the existence of the actual ID attribute
                                    // to avoid selecting by the name attribute in IE
                                    // also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
                                    if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
                                          oid = jQuery('[@id="'+m[2]+'"]', elem)[0];

                                    // Do a quick check for node name (where applicable) so
                                    // that div#foo searches will be really fast
                                    ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : [];
                              } else {
                                    // We need to find all descendant elements
                                    for ( var i = 0; ret[i]; i++ ) {
                                          // Grab the tag name being searched for
                                          var tag = m[1] == "#" && m[3] ? m[3] : m[1] != "" || m[0] == "" ? "*" : m[2];

                                          // Handle IE7 being really dumb about <object>s
                                          if ( tag == "*" && ret[i].nodeName.toLowerCase() == "object" )
                                                tag = "param";

                                          r = jQuery.merge( r, ret[i].getElementsByTagName( tag ));
                                    }

                                    // It's faster to filter by class and be done with it
                                    if ( m[1] == "." )
                                          r = jQuery.classFilter( r, m[2] );

                                    // Same with ID filtering
                                    if ( m[1] == "#" ) {
                                          var tmp = [];

                                          // Try to find the element with the ID
                                          for ( var i = 0; r[i]; i++ )
                                                if ( r[i].getAttribute("id") == m[2] ) {
                                                      tmp = [ r[i] ];
                                                      break;
                                                }

                                          r = tmp;
                                    }

                                    ret = r;
                              }

                              t = t.replace( re2, "" );
                        }

                  }

                  // If a selector string still exists
                  if ( t ) {
                        // Attempt to filter it
                        var val = jQuery.filter(t,r);
                        ret = r = val.r;
                        t = jQuery.trim(val.t);
                  }
            }

            // An error occurred with the selector;
            // just return an empty set instead
            if ( t )
                  ret = [];

            // Remove the root context
            if ( ret && context == ret[0] )
                  ret.shift();

            // And combine the results
            done = jQuery.merge( done, ret );

            return done;
      },

      classFilter: function(r,m,not){
            m = " " + m + " ";
            var tmp = [];
            for ( var i = 0; r[i]; i++ ) {
                  var pass = (" " + r[i].className + " ").indexOf( m ) >= 0;
                  if ( !not && pass || not && !pass )
                        tmp.push( r[i] );
            }
            return tmp;
      },

      filter: function(t,r,not) {
            var last;

            // Look for common filter expressions
            while ( t && t != last ) {
                  last = t;

                  var p = jQuery.parse, m;

                  for ( var i = 0; p[i]; i++ ) {
                        m = p[i].exec( t );

                        if ( m ) {
                              // Remove what we just matched
                              t = t.substring( m[0].length );

                              m[2] = m[2].replace(/\/g, "");
                              break;
                        }
                  }

                  if ( !m )
                        break;

                  // :not() is a special case that can be optimized by
                  // keeping it out of the expression list
                  if ( m[1] == ":" && m[2] == "not" )
                        // optimize if only one selector found (most common case)
                        r = isSimple.test( m[3] ) ?
                              jQuery.filter(m[3], r, true).r :
                              jQuery( r ).not( m[3] );

                  // We can get a big speed boost by filtering by class here
                  else if ( m[1] == "." )
                        r = jQuery.classFilter(r, m[2], not);

                  else if ( m[1] == "[" ) {
                        var tmp = [], type = m[3];
                        
                        for ( var i = 0, rl = r.length; i < rl; i++ ) {
                              var a = r[i], z = a[ jQuery.props[m[2]] || m[2] ];
                              
                              if ( z == null || /href|src|selected/.test(m[2]) )
                                    z = jQuery.attr(a,m[2]) || '';

                              if ( (type == "" && !!z ||
                                     type == "=" && z == m[5] ||
                                     type == "!=" && z != m[5] ||
                                     type == "^=" && z && !z.indexOf(m[5]) ||
                                     type == "$=" && z.substr(z.length - m[5].length) == m[5] ||
                                     (type == "*=" || type == "~=") && z.indexOf(m[5]) >= 0) ^ not )
                                          tmp.push( a );
                        }
                        
                        r = tmp;

                  // We can get a speed boost by handling nth-child here
                  } else if ( m[1] == ":" && m[2] == "nth-child" ) {
                        var merge = {}, tmp = [],
                              // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
                              test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
                                    m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
                                    !/\D/.test(m[3]) && "0n+" + m[3] || m[3]),
                              // calculate the numbers (first)n+(last) including if they are negative
                              first = (test[1] + (test[2] || 1)) - 0, last = test[3] - 0;

                        // loop through all the elements left in the jQuery object
                        for ( var i = 0, rl = r.length; i < rl; i++ ) {
                              var node = r[i], parentNode = node.parentNode, id = jQuery.data(parentNode);

                              if ( !merge[id] ) {
                                    var c = 1;

                                    for ( var n = parentNode.firstChild; n; n = n.nextSibling )
                                          if ( n.nodeType == 1 )
                                                n.nodeIndex = c++;

                                    merge[id] = true;
                              }

                              var add = false;

                              if ( first == 0 ) {
                                    if ( node.nodeIndex == last )
                                          add = true;
                              } else if ( (node.nodeIndex - last) % first == 0 && (node.nodeIndex - last) / first >= 0 )
                                    add = true;

                              if ( add ^ not )
                                    tmp.push( node );
                        }

                        r = tmp;

                  // Otherwise, find the expression to execute
                  } else {
                        var fn = jQuery.expr[ m[1] ];
                        if ( typeof fn == "object" )
                              fn = fn[ m[2] ];

                        if ( typeof fn == "string" )
                              fn = eval("false||function(a,i){return " + fn + ";}");

                        // Execute it against the current filter
                        r = jQuery.grep( r, function(elem, i){
                              return fn(elem, i, m, r);
                        }, not );
                  }
            }

            // Return an array of filtered elements (r)
            // and the modified expression string (t)
            return { r: r, t: t };
      },

      dir: function( elem, dir ){
            var matched = [];
            var cur = elem[dir];
            while ( cur && cur != document ) {
                  if ( cur.nodeType == 1 )
                        matched.push( cur );
                  cur = cur[dir];
            }
            return matched;
      },
      
      nth: function(cur,result,dir,elem){
            result = result || 1;
            var num = 0;

            for ( ; cur; cur = cur[dir] )
                  if ( cur.nodeType == 1 && ++num == result )
                        break;

            return cur;
      },
      
      sibling: function( n, elem ) {
            var r = [];

            for ( ; n; n = n.nextSibling ) {
                  if ( n.nodeType == 1 && (!elem || n != elem) )
                        r.push( n );
            }

            return r;
      }
});

/*
* A number of helper functions used for managing events.
* Many of the ideas behind this code orignated from
* Dean Edwards' addEvent library.
*/
jQuery.event = {

      // Bind an event to an element
      // Original by Dean Edwards
      add: function(elem, types, handler, data) {
            if ( elem.nodeType == 3 || elem.nodeType == 8 )
                  return;

            // For whatever reason, IE has trouble passing the window object
            // around, causing it to be cloned in the process
            if ( jQuery.browser.msie && elem.setInterval != undefined )
                  elem = window;

            // Make sure that the function being executed has a unique ID
            if ( !handler.guid )
                  handler.guid = this.guid++;
                  
            // if data is passed, bind to handler
            if( data != undefined ) {
                  // Create temporary function pointer to original handler
                  var fn = handler;

                  // Create unique handler function, wrapped around original handler
                  handler = function() {
                        // Pass arguments and context to original handler
                        return fn.apply(this, arguments);
                  };

                  // Store data in unique handler
                  handler.data = data;

                  // Set the guid of unique handler to the same of original handler, so it can be removed
                  handler.guid = fn.guid;
            }

            // Init the element's event structure
            var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
                  handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
                        // returned undefined or false
                        var val;

                        // Handle the second event of a trigger and when
                        // an event is called after a page has unloaded
                        if ( typeof jQuery == "undefined" || jQuery.event.triggered )
                              return val;
            
                        val = jQuery.event.handle.apply(arguments.callee.elem, arguments);
            
                        return val;
                  });
            // Add elem as a property of the handle function
            // This is to prevent a memory leak with non-native
            // event in IE.
            handle.elem = elem;
                  
                  // Handle multiple events seperated by a space
                  // jQuery(...).bind("mouseover mouseout", fn);
                  jQuery.each(types.split(/\s+/), function(index, type) {
                        // Namespaced event handlers
                        var parts = type.split(".");
                        type = parts[0];
                        handler.type = parts[1];

                        // Get the current list of functions bound to this event
                        var handlers = events[type];

                        // Init the event handler queue
                        if (!handlers) {
                              handlers = events[type] = {};
            
                              // Check for a special event handler
                              // On
免责声明:本站相关技术文章信息部分来自网络,目的主要是传播更多信息,如果您认为本站的某些信息侵犯了您的版权,请与我们联系,我们会即时妥善的处理,谢谢合作!