行业应用

开发平台：

JavaScript

jquery-1.3.2.min-vsdoc.js：源码内容

/*
* This file has been commented to support Visual Studio Intellisense.
* You should not use this file at runtime inside the browser--it is only
* intended to be used only for design-time IntelliSense. Please use the
* standard jQuery library for all production use.
*
* Comment version: 1.3.2b
*/
/* 1.3.2 汉化说明
本汉化文件部分翻译取自 1.2.6-vsdoc-cn 文件。
经本人整合、校对与增加新版帮助文档，供免费学习与个人使用，若有商业需求请联系作者。
更深的蓝， QQ621394 E-mail:topskill@gmail.com
2010-01-07:
修正：修改了一处导致语法提示无法工作的BUG。
增加：同时发布 GBK 和 UTF-8 版本，供不同环境使用。
2009-12-21:
增加：insertAfter,insertBefore,prependTo,live,die 的翻译。
增加：innerHeight, innerWidth, outerHeight and outerWidth 的翻译。
增加：offset 的翻译。
增加：scrollLeft and scrollTop
增加：attr的详细描述。
2009-12-20:
修正：检查所有注释的param节，使其与函数声明一致。
修正：clone 的文档错误（源文档有错误）。
修正：noConflict 文档补充。
修正：toggle 的翻译。
修正：完善fadeTo的翻译。
2009-12-18:
修正：window.JQuery 文档错误。
修正：noConflict 翻译错误。
修正：$.grep 文档去除了 lambda 格式的说明(当前版本已不支持)
修正：$.map 文档去除了 lambda 格式的说明(当前版本已不支持)
修正：appendTo,prependTo,insertBefore,insertAfter 和 replaceAll 增加了对 1.3.2 的特别说明
修正：ready 函数增加了特别说明。
增加：closest 选择器的翻译。
增加：isArray 翻译。
增加：mouseenter,mouseleave 的翻译。
增加：slideDown,slideUp,slideToggle 的翻译。
增加：fadeIn,fadeOut 的翻译。
TODO：setArray
TODO：queue,dqueue
*/
/* 原 1.2.6 汉化说明
*billsquall汉化
*感谢之前为API1.1 1.2汉化的各位高手，参考了不少^^
*感谢shawphy，鼓励我的好人！
*不知道有没有侵权的说法，反正这汉化仅供大家参考，版权方面不负任何责任。
*估计不会有人拿去做什么吧？不要用做商业用途，否则后果自负。
*/
/*
* jQuery JavaScript Library v1.3.2
* http://jquery.com/
*
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009)
* Revision: 6246
*/
(function(){
var
// Will speed up references to window, and allows munging its name.
window = this,
// Will speed up references to undefined, and allows munging its name.
undefined,
// Map over jQuery in case of overwrite
_jQuery = window.jQuery,
// Map over the $ in case of overwrite
_$ = window.$,
jQuery = window.jQuery = window.$ = function(selector, context) {
/// <summary>
/// 1: $(expression, context) - 这个函数接收一个包含 CSS 选择器的字符串，然后用这个字符串去匹配一组元素。
/// 2: $(html) - 根据提供的原始 HTML 标记字符串，动态创建由 jQuery 对象包装的 DOM 元素。
/// 3: $(elements) - 将一个或多个DOM元素转化为jQuery对象。
/// 4: $(callback) - $(document).ready()的简写。
/// </summary>
/// <param name="selector" type="String">
/// 1: expression - 用来查找的表达式。
/// 2: html -用于动态创建DOM元素的HTML标记字符串
/// 3: elements - 用于封装成jQuery对象的DOM元素
/// 4: callback - 当DOM加载完成后，执行其中的函数。
/// </param>
/// <param name="context" type="jQuery">
/// 1: context - (可选) 作为待查找的 DOM 元素集、文档或 jQuery 对象。
/// </param>
/// <field name="selector" Type="Object">
/// 传递给JQuery的一个选择器表达式。
/// </field>
/// <field name="context" Type="String">
/// (可选) 作为待查找的 DOM 元素集，默认为document。
/// </field>
/// <returns type="jQuery" />
// The jQuery object is actually just the init constructor 'enhanced'
return new jQuery.fn.init( selector, context );
},
// A simple way to check for HTML strings or ID strings
// (both of which we optimize for)
quickExpr = /^[^<]*(<(.|s)+>)[^>]*$|^#([w-]+)$/,
// Is it a simple selector
isSimple = /^.[^:#[.,]*$/;
jQuery.fn = jQuery.prototype = {
init: function( selector, context ) {
/// <summary>
/// 1: $(expression, context) - 这个函数接收一个包含 CSS 选择器的字符串，然后用这个字符串去匹配一组元素。
/// 2: $(html) - 根据提供的原始 HTML 标记字符串，动态创建由 jQuery 对象包装的 DOM 元素。
/// 3: $(elements) - 将一个或多个DOM元素转化为jQuery对象。
/// 4: $(callback) - $(document).ready()的简写。
/// </summary>
/// <param name="selector" type="String">
/// 1: expression - 用来查找的表达式。
/// 2: html -用于动态创建DOM元素的HTML标记字符串
/// 3: elements - 用于封装成jQuery对象的DOM元素
/// 4: callback - 当DOM加载完成后，执行其中的函数。
/// </param>
/// <param name="context" type="jQuery">
/// 1: context - (可选) 作为待查找的 DOM 元素集、文档或 jQuery 对象。
/// </param>
/// <returns type="jQuery" />
// Make sure that a selection was provided
selector = selector || document;
// Handle $(DOMElement)
if ( selector.nodeType ) {
this[0] = selector;
this.length = 1;
this.context = selector;
return this;
}
// Handle HTML strings
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]);
// Handle the case where IE and Opera return items
// by name instead of ID
if (elem && elem.id != match[3])
return jQuery().find(selector);
// Otherwise, we inject the element directly into the jQuery object
var ret = jQuery(elem || []);
ret.context = document;
ret.selector = selector;
return ret;
}
// HANDLE: $(expr, [context])
// (which is just equivalent to: $(content).find(expr)
} else
return jQuery(context).find(selector);
// HANDLE: $(function)
// Shortcut for document ready
} else if ( jQuery.isFunction( selector ) )
return jQuery( document ).ready( selector );
// Make sure that old selector state is passed along
if ( selector.selector && selector.context ) {
this.selector = selector.selector;
this.context = selector.context;
}
return this.setArray(jQuery.isArray( selector ) ?
selector :
jQuery.makeArray(selector));
},
// Start with an empty selector
selector: "",
// The current version of jQuery being used
jquery: "1.3.2",
// The number of elements contained in the matched element set
size: function() {
/// <summary>
/// 当前已匹配的元素数量。
/// Part of Core
/// </summary>
/// <returns type="Number" />
return this.length;
},
// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
get: function( num ) {
/// <summary>
/// 获取匹配集中的一个元素。
/// Part of Core
/// </summary>
/// <returns type="Element" />
/// <param name="num" type="Number">
/// 要获取的元素的数字索引。
/// </param>
return num == undefined ?
// Return a 'clean' array
Array.prototype.slice.call( 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, name, selector ) {
/// <summary>
/// Set the jQuery object to an array of elements, while maintaining
/// the stack.
/// Part of Core
/// </summary>
/// <returns type="jQuery" />
/// <param name="elems" type="Elements">
/// An array of elements
/// </param>
// Build a new jQuery matched element set
var ret = jQuery( elems );
// Add the old object onto the stack (as a reference)
ret.prevObject = this;
ret.context = this.context;
if ( name === "find" )
ret.selector = this.selector + (this.selector ? " " : "") + selector;
else if ( name )
ret.selector = this.selector + "." + name + "(" + selector + ")";
// 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 ) {
/// <summary>
/// Set the jQuery object to an array of elements. This operation is
/// completely destructive - be sure to use .pushStack() if you wish to maintain
/// the jQuery stack.
/// Part of Core
/// </summary>
/// <returns type="jQuery" />
/// <param name="elems" type="Elements">
/// An array of elements
/// </param>
// 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 ) {
/// <summary>
/// 以每一个匹配的元素作为上下文来执行一个函数。
/// 意味着，每次执行传递进来的函数时，
/// 函数中的this关键字都指向一个不同的DOM元素
/// （每次都是一个不同的匹配元素）。
/// 而且，在每次执行函数时，
/// 都会给函数传递一个表示作为执行环境的元素在匹配的元素集合中所处位置的数字值作为参数
/// （从零开始的整形）。
/// </summary>
/// <returns type="jQuery" />
/// <param name="callback" type="Function">
/// 对于每个匹配的元素所要执行的函数
/// </param>
return jQuery.each( this, callback, args );
},
// Determine the position of an element within
// the matched set of elements
index: function( elem ) {
/// <summary>
/// 搜索与参数表示的对象匹配的元素，
/// 并返回相应元素的索引值值。
/// 如果找到了匹配的元素，从0开始返回；如果没有找到匹配的元素，返回-1。
/// Part of Core
/// </summary>
/// <returns type="Number" />
/// <param name="elem" type="Element">
/// 要搜索的对象
/// </param>
// Locate the position of the desired element
return jQuery.inArray(
// If it receives a jQuery object, the first element is used
elem && elem.jquery ? elem[0] : elem
, this );
},
attr: function( name, value, type ) {
/// <summary>
/// 1. attr(name) 获取第一个匹配元素的指定名字的属性值。
/// 2. attr(properties) 通过一个字典参数为集合设置多个属性值。
/// 3. attr( key, value ) 为集合设置一个属性。
/// 4. attr( key, fn ) 不提供值，而是提供一个回调函数，把函数的结果设置为属性值。
/// Part of DOM/Attributes
/// </summary>
/// <returns type="jQuery" />
/// <param name="name" type="String">
/// 属性名称
/// </param>
/// <param name="value" type="Function">
/// 返回值的函数范围:当前元素, 参数: 当前元素的索引值
/// </param>
var options = name;
// Look for the case where we're accessing a style value
if ( typeof name === "string" )
if ( value === undefined )
return this[0] && jQuery[ type || "attr" ]( this[0], name );
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 ) {
/// <summary>
/// 在所有匹配的元素中，设置一个样式属性的值。
/// 数字将自动转化为像素值
/// Part of CSS
/// </summary>
/// <returns type="jQuery" />
/// <param name="key" type="String">
/// 属性名
/// </param>
/// <param name="value" type="String">
/// 属性值
/// </param>
// 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 ) {
/// <summary>
/// 设置所有匹配元素的文本内容
/// 与 html() 类似, 但将编码 HTML (将 "<" 和 ">" 替换成相应的HTML实体)。
/// Part of DOM/Attributes
/// </summary>
/// <returns type="String" />
/// <param name="text" type="String">
/// 用于设置元素内容的文本
/// </param>
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 ) {
/// <summary>
/// 将所有匹配的元素用单个元素包裹起来
/// 这于 '.wrap()' 是不同的，
/// '.wrap()'为每一个匹配的元素都包裹一次。
/// 这种包装对于在文档中插入额外的结构化标记最有用，
/// 而且它不会破坏原始文档的语义品质。
/// 这个函数的原理是检查提供的第一个元素并在它的代码结构中找到最上层的祖先元素－－这个祖先元素就是包装元素。
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="html" type="Element">
/// HTML标记代码字符串，用于动态生成元素并包装目标元素
/// </param>
if ( this[0] ) {
// The elements to wrap the target around
var wrap = jQuery( html, this[0].ownerDocument ).clone();
if ( this[0].parentNode )
wrap.insertBefore( this[0] );
wrap.map(function(){
var elem = this;
while ( elem.firstChild )
elem = elem.firstChild;
return elem;
}).append(this);
}
return this;
},
wrapInner: function( html ) {
/// <summary>
/// 将每一个匹配的元素的子内容(包括文本节点)用一个HTML结构包裹起来。
/// </summary>
/// <param name="html" type="String">
/// HTML标记代码字符串，用于动态生成元素并包装目标元素
/// </param>
/// <returns type="jQuery" />
return this.each(function(){
jQuery( this ).contents().wrapAll( html );
});
},
wrap: function( html ) {
/// <summary>
/// 把所有匹配的元素用其他元素的结构化标记包裹起来。
/// 这种包装对于在文档中插入额外的结构化标记最有用，
/// 而且它不会破坏原始文档的语义品质。
/// 这个函数的原理是检查提供的第一个元素
/// （它是由所提供的HTML标记代码动态生成的），
/// 并在它的代码结构中找到最上层的祖先元素－－这个祖先元素就是包裹元素。
/// 当HTML标记代码中的元素包含文本时无法使用这个函数。
/// 因此，如果要添加文本应该在包裹完成之后再行添加。
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="html" type="Element">
/// HTML标记代码字符串，用于动态生成元素并包裹目标元素
/// </param>
return this.each(function(){
jQuery( this ).wrapAll( html );
});
},
append: function(content) {
/// <summary>
/// 向每个匹配的元素内部追加内容。
/// 这个操作与对指定的元素执行appendChild方法，
/// 将它们添加到文档中的情况类似。
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="content" type="Content">
/// 要追加到目标中的内容
/// </param>
return this.domManip(arguments, true, function(elem){
if (this.nodeType == 1)
this.appendChild( elem );
});
},
prepend: function(content) {
/// <summary>
/// 向每个匹配的元素内部前置内容。
/// 这是向所有匹配元素内部的开始处插入内容的最佳方式。
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="content" type="Content">
/// 要插入到目标元素内部前端的内容
/// </param>
return this.domManip(arguments, true, function(elem){
if (this.nodeType == 1)
this.insertBefore( elem, this.firstChild );
});
},
before: function(content) {
/// <summary>
/// 在每个匹配的元素之前插入内容。
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="content" type="Content">
/// 在所有段落之前插入一些HTML标记代码。
/// </param>
return this.domManip(arguments, false, function(elem){
this.parentNode.insertBefore( elem, this );
});
},
after: function(content) {
/// <summary>
/// 在每个匹配的元素之后插入内容。
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="content" type="Content">
/// 插入到每个目标后的内容
/// </param>
return this.domManip(arguments, false, function(elem){
this.parentNode.insertBefore( elem, this.nextSibling );
});
},
end: function() {
/// <summary>
/// 回到最近的一个"破坏性"操作之前。
/// 即，将匹配的元素列表变为前一次的状态。
/// 如果之前没有破坏性操作，则返回一个空集。
/// 所谓的"破坏性"就是指任何改变所匹配的jQuery元素的操作。
/// 这包括在 Traversing 中任何返回一个jQuery对象的函数--'add', 'andSelf', 'children', 'filter'
/// , 'find', 'map', 'next', 'nextAll', 'not', 'parent', 'parents', 'prev', 'prevAll'
/// , 'siblings' and 'slice'--再加上 Manipulation 中的 'clone'。
/// Part of DOM/Traversing
/// </summary>
/// <returns type="jQuery" />
return this.prevObject || jQuery( [] );
},
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: [].push,
sort: [].sort,
splice: [].splice,
find: function( selector ) {
/// <summary>
/// 搜索所有与指定表达式匹配的元素。
/// 这个函数是找出正在处理的元素的后代元素的好方法。
/// 所有搜索都依靠jQuery表达式来完成。
/// 这个表达式可以使用CSS1-3的选择器，或简单的XPATH语法来写。
/// Part of DOM/Traversing
/// </summary>
/// <returns type="jQuery" />
/// <param name="selector" type="String">
/// 用于查找的表达式
/// </param>
/// <returns type="jQuery" />
if ( this.length === 1 ) {
var ret = this.pushStack( [], "find", selector );
ret.length = 0;
jQuery.find( selector, this[0], ret );
return ret;
} else {
return this.pushStack( jQuery.unique(jQuery.map(this, function(elem){
return jQuery.find( selector, elem );
})), "find", selector );
}
},
clone: function( events ) {
/// <summary>
/// 克隆匹配的DOM元素并且选中这些克隆的副本。
/// 在想把DOM文档中元素的副本添加到其他位置时这个函数非常有用。
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="events" type="Boolean" optional="true">
/// (可选) 是否拷贝元素附加的事件，默认为不拷贝。
/// </param>
// Do the clone
var ret = this.map(function(){
if ( !jQuery.support.noCloneEvent && !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 html = this.outerHTML;
if ( !html ) {
var div = this.ownerDocument.createElement("div");
div.appendChild( this.cloneNode(true) );
html = div.innerHTML;
}
return jQuery.clean([html.replace(/ jQueryd+="(?:d+|null)"/g, "").replace(/^s*/, "")])[0];
} else
return this.cloneNode(true);
});
// Copy the events from the original to the clone
if ( events === true ) {
var orig = this.find("*").andSelf(), i = 0;
ret.find("*").andSelf().each(function(){
if ( this.nodeName !== orig[i].nodeName )
return;
var events = jQuery.data( orig[i], "events" );
for ( var type in events ) {
for ( var handler in events[ type ] ) {
jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
}
}
i++;
});
}
// Return the cloned set
return ret;
},
filter: function( selector ) {
/// <summary>
/// 筛选出与指定函数返回值匹配的元素集合
/// 这个函数内部将对每个对象计算一次 (正如 '$.each').
/// 如果调用的函数返回false则这个元素被删除，否则就会保留。
/// })
/// Part of DOM/Traversing
/// </summary>
/// <returns type="jQuery" />
/// <param name="selector" type="Function">
/// 传递进filter的函数
/// </param>
/// <returns type="jQuery" />
return this.pushStack(
jQuery.isFunction( selector ) &&
jQuery.grep(this, function(elem, i){
return selector.call( elem, i );
}) ||
jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
return elem.nodeType === 1;
}) ), "filter", selector );
},
closest: function( selector ) {
/// <summary>
/// 返回匹配选择器，并且与起始节点最靠近的父级节点，起始节点也会被判断。
/// </summary>
/// <returns type="jQuery" />
/// <param name="selector" type="Function">
/// 用于筛选的表达式。
/// </param>
/// <returns type="jQuery" />
var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null,
closer = 0;
return this.map(function(){
var cur = this;
while ( cur && cur.ownerDocument ) {
if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) {
jQuery.data(cur, "closest", closer);
return cur;
}
cur = cur.parentNode;
closer++;
}
});
},
not: function( selector ) {
/// <summary>
/// 将元素集合中所有与指定元素匹配的元素删除。
/// 这个方法被用来删除一个jQuery对象中一个或多个元素。
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="jQuery">
/// jQuery对象中一组要被删除的元素。
/// </param>
/// <returns type="jQuery" />
if ( typeof selector === "string" )
// test special case where just one selector is passed in
if ( isSimple.test( selector ) )
return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
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 ) {
/// <summary>
/// 把与表达式匹配的元素添加到jQuery对象中。
/// 这个函数可以用于连接分别与两个表达式匹配的元素结果集。
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="Element">
/// 一个或多个要添加的元素。
/// </param>
/// <returns type="jQuery" />
return this.pushStack( jQuery.unique( jQuery.merge(
this.get(),
typeof selector === "string" ?
jQuery( selector ) :
jQuery.makeArray( selector )
)));
},
is: function( selector ) {
/// <summary>
/// 用一个表达式来检查当前选择的元素集合，
/// 如果其中至少有一个元素符合这个给定的表达式就返回true。
/// 如果没有元素符合，或者表达式无效，都返回'false'.
/// 'filter' 内部实际也是在调用这个函数，
/// 所以，filter()函数原有的规则在这里也适用。
/// Part of DOM/Traversing
/// </summary>
/// <returns type="Boolean" />
/// <param name="selector" type="String">
/// 用于筛选的表达式
/// </param>
return !!selector && jQuery.multiFilter( selector, this ).length > 0;
},
hasClass: function( selector ) {
/// <summary>
/// 检查当前的元素是否含有某个特定的类，如果有，则返回true。这其实就是 is("." + class)。
/// </summary>
/// <param name="selector" type="String">用于匹配的类名</param>
/// <returns type="Boolean">如果有，则返回true，否则返回false.</returns>
return !!selector && this.is( "." + selector );
},
val: function( value ) {
/// <summary>
/// 设置每一个匹配元素的值。在 jQuery 1.2, 这也可以为select元件赋值
/// Part of DOM/Attributes
/// </summary>
/// <returns type="jQuery" />
/// <param name="value" type="String">
/// 要设置的值。
/// </param>
if ( value === undefined ) {
var elem = this[0];
if ( elem ) {
if( jQuery.nodeName( elem, 'option' ) )
return (elem.attributes.value || {}).specified ? elem.value : elem.text;
// 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(option).val();
// 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
return (elem.value || "").replace(/r/g, "");
}
return undefined;
}
if ( typeof value === "number" )
value += '';
return this.each(function(){
if ( this.nodeType != 1 )
return;
if ( jQuery.isArray(value) && /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 = jQuery.makeArray(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 ) {
/// <summary>
/// 设置每一个匹配元素的html内容。
/// 这个函数不能用于XML文档。但可以用于XHTML文档。
/// Part of DOM/Attributes
/// </summary>
/// <returns type="jQuery" />
/// <param name="value" type="String">
/// 用于设定HTML内容的值
/// </param>
return value === undefined ?
(this[0] ?
this[0].innerHTML.replace(/ jQueryd+="(?:d+|null)"/g, "") :
null) :
this.empty().append( value );
},
replaceWith: function( value ) {
/// <summary>
/// 将所有匹配的元素替换成指定的HTML或DOM元素。
/// </summary>
/// <param name="value" type="String">
/// 用于将匹配元素替换掉的内容
/// </param>
/// <returns type="jQuery">刚替换的元素</returns>
return this.after( value ).remove();
},
eq: function( i ) {
/// <summary>
/// 匹配一个给定索引值的元素。
/// 从 0 开始计数
/// Part of Core
/// </summary>
/// <returns type="jQuery" />
/// <param name="i" type="Number">
/// 你想要的那个元素的索引值
/// </param>
return this.slice( i, +i + 1 );
},
slice: function(start, end) {
/// <summary>
/// 选取一个匹配的子集。与原来的slice方法类似。
/// </summary>
/// <param name="start" type="Number" integer="true">开始选取子集的位置。（从0开始，负数是从集合的尾部开始选起）</param>
/// <param name="end" optional="true" type="Number" integer="true"> (可选) 结束选取自己的位置，
/// 如果不指定，则就是本身的结尾。</param>
/// <returns type="jQuery">被选择的元素</returns>
return this.pushStack( Array.prototype.slice.apply( this, arguments ),
"slice", Array.prototype.slice.call(arguments).join(",") );
},
map: function( callback ) {
/// <summary>
/// 将一组元素转换成其他数组（不论是否是元素数组）
/// 你可以用这个函数来建立一个列表，不论是值、属性还是CSS样式，或者其他特别形式。
/// 这都可以用'$.map()'来方便的建立。
/// This member is internal.
/// </summary>
/// <private />
/// <returns type="jQuery" />
return this.pushStack( jQuery.map(this, function(elem, i){
return callback.call( elem, i, elem );
}));
},
andSelf: function() {
/// <summary>
/// 加入上一次所选的结果到前结果集中。
/// 对于筛选或查找后的元素，要加入先前所选元素时将会很有用。
/// </summary>
/// <returns type="jQuery" />
return this.add( this.prevObject );
},
domManip: function( args, table, callback ) {
/// <param name="args" type="Array">
/// Args
/// </param>
/// <param name="table" type="Boolean">
/// 如果没有就在TABLE元素中插入tbody。
/// </param>
/// <param name="dir" type="Number">
/// 如果dir小于0，则以相反的程序处理参数
/// </param>
/// <param name="callback" type="Function">
/// 执行DOM处理的函数
/// </param>
/// <returns type="jQuery" />
/// <summary>
/// Part of Core
/// </summary>
if ( this[0] ) {
var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),
scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ),
first = fragment.firstChild;
if ( first )
for ( var i = 0, l = this.length; i < l; i++ )
callback.call( root(this[i], first), this.length > 1 || i > 0 ?
fragment.cloneNode(true) : fragment );
if ( scripts )
jQuery.each( scripts, evalScript );
}
return this;
function root( elem, cur ) {
return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
(elem.getElementsByTagName("tbody")[0] ||
elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
elem;
}
}
};
// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;
function evalScript( i, elem ) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
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 );
}
function now(){
/// <summary>
/// Gets the current date.
/// </summary>
/// <returns type="Date">The current date.</returns>
return +new Date;
}
jQuery.extend = jQuery.fn.extend = function(_target, _prop1, _propN) {
/// <summary>
/// 用一个或多个其他对象来扩展一个对象，返回被扩展的对象。
/// 用于简化继承。
/// jQuery.extend(settings, options);
/// var settings = jQuery.extend({}, defaults, options);
/// Part of JavaScript
/// </summary>
/// <param name="_target" type="Object">
/// 待修改对象。
/// </param>
/// <param name="_prop1" type="Object">
/// 待合并到第一个对象的对象。
/// </param>
/// <param name="_propN" type="Object" optional="true" parameterArray="true">
/// (可选) 待合并到第一个对象的对象。
/// </param>
/// <returns type="Object" />
// copy reference to target object
var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
// Handle a deep copy situation
if ( typeof target === "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" && !jQuery.isFunction(target) )
target = {};
// extend jQuery itself if only one argument is passed
if ( length == i ) {
target = this;
--i;
}
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 ) {
var src = target[ name ], copy = options[ name ];
// Prevent never-ending loop
if ( target === copy )
continue;
// Recurse if we're merging object values
if ( deep && copy && typeof copy === "object" && !copy.nodeType )
target[ name ] = jQuery.extend( deep,
// Never move original objects, clone them
src || ( copy.length != null ? [ ] : { } )
, copy );
// Don't bring in undefined values
else if ( copy !== undefined )
target[ name ] = copy;
}
// Return the modified object
return target;
};
// exclude the following css properties to add px
var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
// cache defaultView
defaultView = document.defaultView || {},
toString = Object.prototype.toString;
jQuery.extend({
noConflict: function( deep ) {
/// <summary>
/// 将 $ 符号还原到加载jQuery之前其他库的定义以避免冲突。
/// 这个功能允许jQuery库与其他使用 $ 符号的库并存，如prototype。
/// 在使用这个函数后，就只能通过'jQuery'来访问jQuery对象。
/// 比如原先是 $("div p")，之后必须为 jQuery("div p")。
/// Part of Core
/// </summary>
/// <param name="deep" type="Boolean">
/// (试验)不仅还原 window.$，还将还原 window.jQuery 到先前的版本。默认只还原$
/// </param>
/// <returns type="undefined" />
window.$ = _$;
if ( deep )
window.jQuery = _jQuery;
return jQuery;
},
// See test/unit/core.js for details concerning isFunction.
// Since version 1.3, DOM methods and functions like alert
// aren't supported. They return false on IE (#2968).
isFunction: function( obj ) {
/// <summary>
/// 检查一个对象是否为函数。
/// </summary>
/// <param name="obj" type="Object">要检查的对象</param>
/// <returns type="Boolean">如果参数是一个函数返回true，否则返回false。</returns>
return toString.call(obj) === "[object Function]";
},
isArray: function(obj) {
/// <summary>
/// 检查一个对象是否为数组(Array)对象。
/// </summary>
/// <param name="obj" type="Object">要检查的对象</param>
/// <returns type="Boolean">如果参数是一个数组对象返回true，否则返回false。</returns>
return toString.call(obj) === "[object Array]";
},
// check if an element is in a (or is an) XML document
isXMLDoc: function( elem ) {
/// <summary>
/// 检查一个节点是否为XML文档。
/// </summary>
/// <param name="elem" type="Object">要测试的对象</param>
/// <returns type="Boolean">如果参数是XML文档就返回true，否则返回false。</returns>
return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
!!elem.ownerDocument && jQuery.isXMLDoc(elem.ownerDocument);
},
// Evalulates a script in a global context
globalEval: function( data ) {
/// <summary>
/// Internally evaluates a script in a global context.
/// </summary>
/// <private />
if ( data && /S/.test(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.support.scriptEval )
script.appendChild( document.createTextNode( data ) );
else
script.text = data;
// Use insertBefore instead of appendChild to circumvent an IE6 bug.
// This arises when a base node is used (#2709).
head.insertBefore( script, head.firstChild );
head.removeChild( script );
}
},
nodeName: function( elem, name ) {
/// <summary>
/// 检查指定的元素里是否有指定的DOM节点的名称。
/// </summary>
/// <param name="elem" type="Element">要检查的元素</param>
/// <param name="name" type="String">要核对的节点名称</param>
/// <returns type="Boolean">如果指定的节点名称匹配对应的节点的DOM节点名称返回true，否则返回 false</returns>
return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
},
// args is for internal usage only
each: function( object, callback, args ) {
/// <summary>
/// 以每一个匹配的元素作为上下文来执行一个函数。
/// 意味着，每次执行传递进来的函数时，
/// 函数中的this关键字都指向一个不同的DOM元素（每次都是一个不同的匹配元素）。
/// 而且，在每次执行函数时，都会给函数传递一个表示作为执行环境的元素在匹配的元素集合中所处位置的数字值作为参数（从零开始的整形）。
/// 返回 false 将停止循环 (就像在普通的循环中使用 break)。
/// 返回 true 跳至下一个循环(就像在普通的循环中使用 continue)。
/// Part of JavaScript
/// </summary>
/// <param name="object" type="Object">
/// 要迭代的对象或数组
/// </param>
/// <param name="callback" type="Function">
/// 对于每个匹配的元素所要执行的函数
/// </param>
/// <returns type="Object" />
var name, i = 0, length = object.length;
if ( args ) {
if ( length === undefined ) {
for ( name in object )
if ( callback.apply( object[ name ], args ) === false )
break;
} else
for ( ; i < length; )
if ( callback.apply( object[ i++ ], args ) === false )
break;
// A special, fast, case for the most common use of each
} else {
if ( length === undefined ) {
for ( name in object )
if ( callback.call( object[ name ], name, object[ name ] ) === false )
break;
} else
for ( var value = object[0];
i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
}
return object;
},
prop: function( elem, value, type, i, name ) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
// This member is not documented within the jQuery API: http://docs.jquery.com/action/edit/Internals/jQuery.prop
// Handle executable functions
if ( jQuery.isFunction( value ) )
value = value.call( elem, i );
// Handle passing in a number to a CSS property
return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?
value + "px" :
value;
},
className: {
// internal only, use addClass("class")
add: function( elem, classNames ) {
/// <summary>
/// Internal use only; use addClass('class')
/// </summary>
/// <private />
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 ) {
/// <summary>
/// Internal use only; use removeClass('class')
/// </summary>
/// <private />
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 hasClass("class")
has: function( elem, className ) {
/// <summary>
/// Internal use only; use hasClass('class')
/// </summary>
/// <private />
return elem && 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 ) {
/// <summary>
/// Swap in/out style options.
/// </summary>
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, extra ) {
/// <summary>
/// This method is internal only.
/// </summary>
/// <private />
// This method is undocumented in jQuery API: http://docs.jquery.com/action/edit/Internals/jQuery.css
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;
if ( extra === "border" )
return;
jQuery.each( which, function() {
if ( !extra )
val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
if ( extra === "margin" )
val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0;
else
val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
});
}
if ( elem.offsetWidth !== 0 )
getWH();
else
jQuery.swap( elem, props, getWH );
return Math.max(0, Math.round(val));
}
return jQuery.curCSS( elem, name, force );
},
curCSS: function( elem, name, force ) {
/// <summary>
/// This method is internal only.
/// </summary>
/// <private />
// This method is undocumented in jQuery API: http://docs.jquery.com/action/edit/Internals/jQuery.curCSS
var ret, style = elem.style;
// We need to handle opacity special in IE
if ( name == "opacity" && !jQuery.support.opacity ) {
ret = jQuery.attr( style, "opacity" );
return ret == "" ?
"1" :
ret;
}
// Make sure we're using the right name for getting the float value
if ( name.match( /float/i ) )
name = styleFloat;
if ( !force && style && style[ name ] )
ret = style[ name ];
else if ( defaultView.getComputedStyle ) {
// Only "float" is needed here
if ( name.match( /float/i ) )
name = "float";
name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
var computedStyle = defaultView.getComputedStyle( elem, null );
if ( computedStyle )
ret = computedStyle.getPropertyValue( name );
// 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 left = style.left, rsLeft = elem.runtimeStyle.left;
// Put in the new values to get a computed value out
elem.runtimeStyle.left = elem.currentStyle.left;
style.left = ret || 0;
ret = style.pixelLeft + "px";
// Revert the changed values
style.left = left;
elem.runtimeStyle.left = rsLeft;
}
}
return ret;
},
clean: function( elems, context, fragment ) {
/// <summary>
/// This method is internal only.
/// </summary>
/// <private />
// This method is undocumented in the jQuery API: http://docs.jquery.com/action/edit/Internals/jQuery.clean
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;
// If a single string is passed in and it's a single tag
// just do a createElement and skip the rest
if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {
var match = /^<(w+)s*/?>$/.exec(elems[0]);
if ( match )
return [ context.createElement( match[1] ) ];
}
var ret = [], scripts = [], div = context.createElement("div");
jQuery.each(elems, function(i, elem){
if ( typeof elem === "number" )
elem += '';
if ( !elem )
return;
// 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 = elem.replace(/^s+/, "").substring(0, 10).toLowerCase();
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.support.htmlSerialize &&
[ 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.support.tbody ) {
// String was a <table>, *may* have spurious <tbody>
var hasBody = /<tbody/i.test(elem),
tbody = !tags.indexOf("<table") && !hasBody ?
div.firstChild && div.firstChild.childNodes :
// String was a bare <thead> or <tfoot>
wrap[1] == "<table>" && !hasBody ?
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 ( !jQuery.support.leadingWhitespace && /^s/.test( elem ) )
div.insertBefore( context.createTextNode( elem.match(/^s*/)[0] ), div.firstChild );
elem = jQuery.makeArray( div.childNodes );
}
if ( elem.nodeType )
ret.push( elem );
else
ret = jQuery.merge( ret, elem );
});
if ( fragment ) {
for ( var i = 0; ret[i]; i++ ) {
if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
} else {
if ( ret[i].nodeType === 1 )
ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
fragment.appendChild( ret[i] );
}
}
return scripts;
}
return ret;
},
attr: function( elem, name, value ) {
/// <summary>
/// 取得第一个匹配元素的属性值。通过这个方法可以方便地从第一个匹配元素中获取一个属性的值。
/// 如果元素没有相应属性，则返回 undefined 。
/// 内部方法。
/// </summary>
/// <private />
// don't set attributes on text and comment nodes
if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
return undefined;
var notxml = !jQuery.isXMLDoc( elem ),
// Whether we are setting (or getting)
set = value !== undefined;
// Try to normalize/fix the name
name = notxml && jQuery.props[ name ] || name;
// Only do all the following if this is a node (faster for style)
// IE elem.getAttribute passes even for style
if ( elem.tagName ) {
// These attributes require special treatment
var special = /href|src|style/.test( name );
// Safari mis-reports the default selected property of a hidden option
// Accessing the parent's selectedIndex property fixes it
if ( name == "selected" && elem.parentNode )
elem.parentNode.selectedIndex;
// If applicable, access the attribute via the DOM 0 way
if ( name in elem && notxml && !special ) {
if ( set ){
// 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";
elem[ name ] = value;
}
// browsers index elements by id/name on forms, give priority to attributes.
if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
return elem.getAttributeNode( name ).nodeValue;
// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
if ( name == "tabIndex" ) {
var attributeNode = elem.getAttributeNode( "tabIndex" );
return attributeNode && attributeNode.specified
? attributeNode.value
: elem.nodeName.match(/(button|input|object|select|textarea)/i)
? 0
: elem.nodeName.match(/^(a|area)$/i) && elem.href
? 0
: undefined;
}
return elem[ name ];
}
if ( !jQuery.support.style && notxml && name == "style" )
return jQuery.attr( elem.style, "cssText", value );
if ( set )
// convert the value to a string (all browsers do this but IE) see #1070
elem.setAttribute( name, "" + value );
var attr = !jQuery.support.hrefNormalized && notxml && special
// Some attributes require a special call on IE
? elem.getAttribute( name, 2 )
: elem.getAttribute( name );
// Non-existent attributes return null, we normalize to undefined
return attr === null ? undefined : attr;
}
// elem is actually elem.style ... set the style
// IE uses filters for opacity
if ( !jQuery.support.opacity && name == "opacity" ) {
if ( set ) {
// 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([^)]*)/, "" ) +
(parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
}
return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
(parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
"";
}
name = name.replace(/-([a-z])/ig, function(all, letter){
return letter.toUpperCase();
});
if ( set )
elem[ name ] = value;
return elem[ name ];
},
trim: function( text ) {
/// <summary>
/// 去掉字符串起始和结尾的空格。
/// Part of JavaScript
/// </summary>
/// <returns type="String" />
/// <param name="text" type="String">
/// 要去空格的字符串
/// </param>
return (text || "").replace( /^s+|s+$/g, "" );
},
makeArray: function( array ) {
/// <summary>
/// 将类数组对象转换为数组对象。
/// 类数组对象有 length 属性，其成员索引为 0 至 length - 1。实际中此函数在 jQuery 中将自动使用而无需特意转换。
/// </summary>
/// <param name="array" type="Object">要转换为数组对象的类数组对象。</param>
/// <returns type="Array" />
/// <private />
var ret = [];
if( array != null ){
var i = array.length;
// The window, strings (and functions) also have 'length'
if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval )
ret[0] = array;
else
while( i )
ret[--i] = array[i];
}
return ret;
},
inArray: function( elem, array ) {
/// <summary>
/// 确定第一个参数在数组中的位置(如果没有找到则返回 -1 )。
/// </summary>
/// <param name="elem">用于在数组中查找是否存在的值</param>
/// <param name="array" type="Array">待处理数组。</param>
/// <returns type="Number" integer="true">如果找到，则从0开始累计，没有找到则返回 -1</returns>
for ( var i = 0, length = array.length; i < length; i++ )
// Use === because on IE, window == document
if ( array[ i ] === elem )
return i;
return -1;
},
merge: function( first, second ) {
/// <summary>
/// 合并两个数组。第二个数组中与第一个数组重复的元素将会被忽略。
/// Part of JavaScript
/// </summary>
/// <returns type="Array" />
/// <param name="first" type="Array">
/// 第一个要合并的数组。
/// </param>
/// <param name="second" type="Array">
/// 第二个要合并的数组。
/// </param>
// We have to loop this way because IE & Opera overwrite the length
// expando of getElementsByTagName
var i = 0, elem, pos = first.length;
// Also, we need to make sure that the correct elements are being returned
// (IE returns comment nodes in a '*' query)
if ( !jQuery.support.getAll ) {
while ( (elem = second[ i++ ]) != null )
if ( elem.nodeType != 8 )
first[ pos++ ] = elem;
} else
while ( (elem = second[ i++ ]) != null )
first[ pos++ ] = elem;
return first;
},
unique: function( array ) {
/// <summary>
/// 删除元素数组中所有的重复元素。
/// </summary>
/// <param name="array" type="Array<Element>">要转换的数组</param>
/// <returns type="Array<Element>">转换后的数组</returns>
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 ) {
/// <summary>
/// 使用过滤函数过滤数组元素。
/// 此函数至少传递两个参数：待过滤数组和过滤函数。
/// 过滤函数必须返回 true 以保留元素或 false 以删除元素。
/// });
/// Part of JavaScript
/// </summary>
/// <returns type="Array" />
/// <param name="elems" type="Array">
/// 待过滤数组。
/// </param>
/// <param name="callback" type="Function">
/// 此函数将处理数组每个元素。第一个参数为当前元素，第二个参数为元素索引值。
/// 此函数应返回一个布尔值。
/// fn 必须为函数对象，旧的 lambda 格式已经不再支持。
/// </param>
/// <param name="inv" type="Boolean">
/// (可选) 如果 "invert" 为 false 或为设置，则函数返回数组中由过滤函数返回 true 的元素，
/// 当"invert" 为 true，则返回过滤函数中返回 false 的元素集。
/// </param>
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 ) )
ret.push( elems[ i ] );
return ret;
},
map: function( elems, callback ) {
/// <summary>
/// 将一个数组中的元素转换到另一个数组中。
/// 作为参数的转换函数会为每个数组元素调用，
/// 而且会给这个转换函数传递一个表示被转换的元素作为参数。
/// 转换函数可以返回转换后的值、null（删除数组中的项目）
/// 或一个包含值的数组，并扩展至原始数组中。
/// Part of JavaScript
/// </summary>
/// <returns type="Array" />
/// <param name="elems" type="Array">
/// 待转换数组。
/// </param>
/// <param name="callback" type="Function">
/// 为每个数组元素调用，而且会给这个转换函数传递一个表示被转换的元素作为参数。函数可返回任何值。
/// fn 必须为函数对象，旧的 lambda 格式已经不再支持。
/// </param>
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 )
ret[ ret.length ] = value;
}
return ret.concat.apply( [], ret );
}
});
// Use of jQuery.browser is deprecated.
// It's included for backwards compatibility and plugins,
// although they should work to migrate away.
var userAgent = navigator.userAgent.toLowerCase();
// Figure out what browser is being used
jQuery.browser = {
version: (userAgent.match( /.+(?:rv|it|ra|ie)[/: ]([d.]+)/ ) || [0,'0'])[1],
safari: /webkit/.test( userAgent ),
opera: /opera/.test( userAgent ),
msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
};
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
// 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 ) {
// /// <summary>
// /// 取得一个包含着所有匹配元素的唯一父元素的元素集合。
// /// 你可以使用可选的表达式来筛选。
// /// Part of DOM/Traversing
// /// </summary>
// /// <param name="selector" type="String" optional="true">
// /// (可选)用来筛选的表达式
// /// </param>
// /// <returns type="jQuery" />
//
// var ret = jQuery.map( this, fn );
//
// if ( selector && typeof selector == "string" )
// ret = jQuery.multiFilter( selector, ret );
//
// return this.pushStack( jQuery.unique( ret ), name, selector );
// };
// });
jQuery.each({
parent: function(elem){return elem.parentNode;}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// 取得一个包含着所有匹配元素的唯一父元素的元素集合。
/// 你可以使用可选的表达式来筛选。
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="String" optional="true">
/// (可选)用来筛选的表达式
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
parents: function(elem){return jQuery.dir(elem,"parentNode");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// 取得一组包含唯一祖先元素的匹配元素
/// （除了根元素）
/// 你可以使用可选的表达式来筛选。
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="String" optional="true">
/// (可选) 用来筛选元素的表达式
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
next: function(elem){return jQuery.nth(elem,2,"nextSibling");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// 取得一组包含唯一后一个兄弟元素的匹配元素
/// 它只能返回下一个子元素，而不是所有的子元素。
/// 你可以使用可选的表达式来筛选。
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="String" optional="true">
/// (可选) 用来筛选兄弟元素的表达式
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
prev: function(elem){return jQuery.nth(elem,2,"previousSibling");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// 取得一组包含唯一前一个兄弟元素的匹配元素
/// 它只能返回前一个子元素，而不是所有的子元素
/// 你可以使用可选的表达式来筛选。
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="String" optional="true">
/// (可选) 用来筛选兄弟元素的表达式
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
nextAll: function(elem){return jQuery.dir(elem,"nextSibling");}
}, function(name, fn){
jQuery.fn[name] = function(selector) {
/// <summary>
/// 找出当前元素后的所有兄弟元素
/// 你可以使用可选的表达式来筛选。
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="String" optional="true">
/// (可选) 用来筛选元素的表达式
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
prevAll: function(elem){return jQuery.dir(elem,"previousSibling");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// 找出当前元素前面的所有兄弟元素
/// 你可以使用可选的表达式来筛选。
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="String" optional="true">
/// (可选) 用来筛选兄弟元素的表达式
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// 迭代并取得一组包含唯一所有兄弟元素的匹配元素
/// 你可以使用可选的表达式来筛选。
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="String" optional="true">
/// (可选) 用来筛选兄弟元素的表达式
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
children: function(elem){return jQuery.sibling(elem.firstChild);}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// 迭代并取得一组包含唯一所有子元素的匹配元素
/// 你可以使用可选的表达式来筛选。
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="String" optional="true">
/// (可选) 用来筛选子元素的表达式
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
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 ) {
/// <summary>Finds all the child nodes inside the matched elements including text nodes, or the content document if the element is an iframe.</summary>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
// 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.fn.appendTo = function( selector ) {
/// <summary>
/// 把所有匹配的元素插入到另一个、指定的元素元素集合的结束标记前。
/// jQuery 1.3.2 会返回所有已插入的元素。
/// $(源集合).appendTo(目标集合); 会把源集合的每个元素依次插入目标集合每个元素的结束标记之前。
/// Part of DOM/Manipulation
/// </summary>
/// <param name="selector" type="Selector">
/// 要插入的目标集合
/// </param>
/// <returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "append" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "appendTo", selector );
};
jQuery.fn.prependTo = function( selector ) {
/// <summary>
/// 把所有匹配的元素插入到另一个、指定的元素元素集合的开始标记后。
/// jQuery 1.3.2 会返回所有已插入的元素。
/// $(源集合).prependTo(目标集合); 会把源集合的每个元素依次插入目标集合每个元素的开始标记之后。
/// Part of DOM/Manipulation
/// </summary>
/// <param name="selector" type="Selector">
/// 要插入的目标集合
/// </param>
/// <returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "prepend" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "prependTo", selector );
};
jQuery.fn.insertBefore = function( selector ) {
/// <summary>
/// 把所有匹配的元素插入到另一个、指定的元素元素集合的前面。
/// jQuery 1.3.2 会返回所有已插入的元素。
/// $(源集合).insertBefore(目标集合); 会把源集合的每个元素依次插入目标集合每个元素之前。
/// Part of DOM/Manipulation
/// </summary>
/// <param name="selector" type="String">
/// 要插入的目标集合
/// </param>
/// <returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "before" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "insertBefore", selector );
};
jQuery.fn.insertAfter = function( selector ) {
/// <summary>
/// 把所有匹配的元素插入到另一个、指定的元素元素集合的后面。
/// jQuery 1.3.2 会返回所有已插入的元素。
/// $(源集合).insertBefore(目标集合); 会把源集合的每个元素依次插入目标集合每个元素之后。
/// </summary>
/// <param name="selector" type="String">
/// 要插入的目标集合
/// </param>
/// <returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "after" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "insertAfter", selector );
};
jQuery.fn.replaceAll = function( selector ) {
/// <summary>
/// 用匹配的元素替换掉所有（selector选择器）匹配到的元素。
/// jQuery 1.3.2 会返回所有已插入的元素。
/// </summary>
/// <param name="selector" type="Selector">用于查找所要被替换的元素的选择器/param>
/// <returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "replaceWith" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "replaceAll", selector );
};
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
// 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, state ) {
// if( typeof state !== "boolean" )
// state = !jQuery.className.has( this, classNames );
// jQuery.className[ state ? "add" : "remove" ]( this, classNames );
// },
//
// remove: function( selector ) {
// if ( !selector || jQuery.filter( selector, [ this ] ).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.fn.removeAttr = function(){
/// <summary>
/// 从每一个匹配的元素中删除一个属性
/// Part of DOM/Attributes
/// </summary>
/// <param name="key" type="String">
/// 要删除的属性名
/// </param>
/// <returns type="jQuery" />
return this.each( function( name ) {
jQuery.attr( this, name, "" );
if (this.nodeType == 1)
this.removeAttribute( name );
}, arguments );
};
jQuery.fn.addClass = function(clsNames){
/// <summary>
/// 为每个匹配的元素添加指定的类名。
/// Part of DOM/Attributes
/// </summary>
/// <param name="clsNames" type="String">
/// 一个或多个要添加到元素中的CSS类名，请用空格分开。也支持多个参数，每个参数一个类名。
/// </param>
/// <returns type="jQuery" />
return this.each( function( classNames ) {
jQuery.className.add( this, classNames );
}, arguments );
};
jQuery.fn.removeClass = function(cssClasses){
/// <summary>
/// 从所有匹配的元素中删除全部或者指定的类。
/// Part of DOM/Attributes
/// </summary>
/// <param name="cssClasses" type="String" optional="true">
/// (可选) 一个或多个要删除的CSS类名，请用空格分开。也支持多个参数，每个参数一个类名。
/// </param>
/// <returns type="jQuery" />
return this.each( function( classNames ) {
jQuery.className.remove( this, classNames );
}, arguments );
};
jQuery.fn.toggleClass = function(cssClass){
/// <summary>
/// 如果存在（不存在）就删除（添加）一个类。
/// Part of DOM/Attributes
/// </summary>
/// <param name="cssClass" type="String">
/// CSS类名
/// </param>
/// <returns type="jQuery" />
return this.each( function( classNames, state ) {
if( typeof state !== "boolean" )
state = !jQuery.className.has( this, classNames );
jQuery.className[ state ? "add" : "remove" ]( this, classNames );
}, arguments );
};
jQuery.fn.remove = function(){
/// <summary>
/// 从DOM中删除所有匹配的元素。
/// 这个方法不会把匹配的元素从jQuery对象中删除，
/// 因而可以在将来再使用这些匹配的元素。
/// Part of DOM/Manipulation
/// </summary>
/// <param name="expr" type="String" optional="true">
/// (可选) 用于筛选元素的jQuery表达式
/// </param>
/// <returns type="jQuery" />
return this.each( function( selector ) {
if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
// Prevent memory leaks
jQuery( "*", this ).add([this]).each(function(){
jQuery.event.remove(this);
jQuery.removeData(this);
});
if (this.parentNode)
this.parentNode.removeChild( this );
}
}, arguments );
};
jQuery.fn.empty = function(){
/// <summary>
/// 删除匹配的元素集合中所有的子节点。
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
return this.each( function() {
// Remove element nodes and prevent memory leaks
jQuery(this).children().remove();
// Remove any remaining nodes
while ( this.firstChild )
this.removeChild( this.firstChild );
}, arguments );
};
// Helper function used by the dimensions and offset modules
function num(elem, prop) {
return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
}
var expando = "jQuery" + now(), uuid = 0, windowData = {};
jQuery.extend({
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 ];
}
},
queue: function( elem, type, data ) {
if ( elem ){
type = (type || "fx") + "queue";
var q = jQuery.data( elem, type );
if ( !q || jQuery.isArray(data) )
q = jQuery.data( elem, type, jQuery.makeArray(data) );
else if( data )
q.push( data );
}
return q;
},
dequeue: function( elem, type ){
var queue = jQuery.queue( elem, type ),
fn = queue.shift();
if( !type || type === "fx" )
fn = queue[0];
if( fn !== undefined )
fn.call(elem);
}
});
jQuery.fn.extend({
data: function( key, value ){
var parts = key.split(".");
parts[1] = parts[1] ? "." + parts[1] : "";
if ( value === undefined ) {
var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
if ( data === undefined && this.length )
data = jQuery.data( this[0], key );
return data === undefined && 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 );
});
},
queue: function(type, data){
/// <summary>
/// 1: queue() - 返回指向第一个匹配元素的队列(将是一个函数数组)
/// 2: queue(callback) - 在匹配的元素的动画队列中添加一个函数
/// 3: queue(queue) - 将匹配元素的动画队列用新的一个队列来代替(函数数组).
/// </summary>
/// <param name="type" type="Function">要添加进队列的函数</param>
/// <returns type="jQuery" />
if ( typeof type !== "string" ) {
data = type;
type = "fx";
}
if ( data === undefined )
return jQuery.queue( this[0], type );
return this.each(function(){
var queue = jQuery.queue( this, type, data );
if( type == "fx" && queue.length == 1 )
queue[0].call(this);
});
},
dequeue: function(type){
/// <summary>
/// Removes a queued function from the front of the queue and executes it.
/// </summary>
/// <param name="type" type="String" optional="true">The type of queue to access.</param>
/// <returns type="jQuery" />
return this.each(function(){
jQuery.dequeue( this, type );
});
}
});/*!
* Sizzle CSS Selector Engine - v0.9.3
* Released under the MIT, BSD, and GPL Licenses.
* More information: http://sizzlejs.com/
*/
(function(){
var chunker = /((?:((?:([^()]+)|[^()]+)+)|[(?:[[^[]]*]|['"][^'"]*['"]|[^[]'"]+)+]|\.|[^ >+~,([\]+)+|[>+~])(s*,s*)?/g,
done = 0,
toString = Object.prototype.toString;
var Sizzle = function(selector, context, results, seed) {
results = results || [];
context = context || document;
if ( context.nodeType !== 1 && context.nodeType !== 9 )
return [];
if ( !selector || typeof selector !== "string" ) {
return results;
}
var parts = [], m, set, checkSet, check, mode, extra, prune = true;
// Reset the position of the chunker regexp (start from head)
chunker.lastIndex = 0;
while ( (m = chunker.exec(selector)) !== null ) {
parts.push( m[1] );
if ( m[2] ) {
extra = RegExp.rightContext;
break;
}
}
if ( parts.length > 1 && origPOS.exec( selector ) ) {
if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
set = posProcess( parts[0] + parts[1], context );
} else {
set = Expr.relative[ parts[0] ] ?
[ context ] :
Sizzle( parts.shift(), context );
while ( parts.length ) {
selector = parts.shift();
if ( Expr.relative[ selector ] )
selector += parts.shift();
set = posProcess( selector, set );
}
}
} else {
var ret = seed ?
{ expr: parts.pop(), set: makeArray(seed) } :
Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) );
set = Sizzle.filter( ret.expr, ret.set );
if ( parts.length > 0 ) {
checkSet = makeArray(set);
} else {
prune = false;
}
while ( parts.length ) {
var cur = parts.pop(), pop = cur;
if ( !Expr.relative[ cur ] ) {
cur = "";
} else {
pop = parts.pop();
}
if ( pop == null ) {
pop = context;
}
Expr.relative[ cur ]( checkSet, pop, isXML(context) );
}
}
if ( !checkSet ) {
checkSet = set;
}
if ( !checkSet ) {
throw "Syntax error, unrecognized expression: " + (cur || selector);
}
if ( toString.call(checkSet) === "[object Array]" ) {
if ( !prune ) {
results.push.apply( results, checkSet );
} else if ( context.nodeType === 1 ) {
for ( var i = 0; checkSet[i] != null; i++ ) {
if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
results.push( set[i] );
}
}
} else {
for ( var i = 0; checkSet[i] != null; i++ ) {
if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
results.push( set[i] );
}
}
}
} else {
makeArray( checkSet, results );
}
if ( extra ) {
Sizzle( extra, context, results, seed );
if ( sortOrder ) {
hasDuplicate = false;
results.sort(sortOrder);
if ( hasDuplicate ) {
for ( var i = 1; i < results.length; i++ ) {
if ( results[i] === results[i-1] ) {
results.splice(i--, 1);
}
}
}
}
}
return results;
};
Sizzle.matches = function(expr, set){
return Sizzle(expr, null, null, set);
};
Sizzle.find = function(expr, context, isXML){
var set, match;
if ( !expr ) {
return [];
}
for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
var type = Expr.order[i], match;
if ( (match = Expr.match[ type ].exec( expr )) ) {
var left = RegExp.leftContext;
if ( left.substr( left.length - 1 ) !== "\" ) {
match[1] = (match[1] || "").replace(/\/g, "");
set = Expr.find[ type ]( match, context, isXML );
if ( set != null ) {
expr = expr.replace( Expr.match[ type ], "" );
break;
}
}
}
}
if ( !set ) {
set = context.getElementsByTagName("*");
}
return {set: set, expr: expr};
};
Sizzle.filter = function(expr, set, inplace, not){
var old = expr, result = [], curLoop = set, match, anyFound,
isXMLFilter = set && set[0] && isXML(set[0]);
while ( expr && set.length ) {
for ( var type in Expr.filter ) {
if ( (match = Expr.match[ type ].exec( expr )) != null ) {
var filter = Expr.filter[ type ], found, item;
anyFound = false;
if ( curLoop == result ) {
result = [];
}
if ( Expr.preFilter[ type ] ) {
match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
if ( !match ) {
anyFound = found = true;
} else if ( match === true ) {
continue;
}
}
if ( match ) {
for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
if ( item ) {
found = filter( item, match, i, curLoop );
var pass = not ^ !!found;
if ( inplace && found != null ) {
if ( pass ) {
anyFound = true;
} else {
curLoop[i] = false;
}
} else if ( pass ) {
result.push( item );
anyFound = true;
}
}
}
}
if ( found !== undefined ) {
if ( !inplace ) {
curLoop = result;
}
expr = expr.replace( Expr.match[ type ], "" );
if ( !anyFound ) {
return [];
}
break;
}
}
}
// Improper expression
if ( expr == old ) {
if ( anyFound == null ) {
throw "Syntax error, unrecognized expression: " + expr;
} else {
break;
}
}
old = expr;
}
return curLoop;
};
var Expr = Sizzle.selectors = {
order: [ "ID", "NAME", "TAG" ],
match: {
ID: /#((?:[wu00c0-uFFFF_-]|\.)+)/,
CLASS: /.((?:[wu00c0-uFFFF_-]|\.)+)/,
NAME: /[name=['"]*((?:[wu00c0-uFFFF_-]|\.)+)['"]*]/,
ATTR: /[s*((?:[wu00c0-uFFFF_-]|\.)+)s*(?:(S?=)s*(['"]*)(.*?)3|)s*]/,
TAG: /^((?:[wu00c0-uFFFF*_-]|\.)+)/,
CHILD: /:(only|nth|last|first)-child(?:((even|odd|[dn+-]*)))?/,
POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:((d*)))?(?=[^-]|$)/,
PSEUDO: /:((?:[wu00c0-uFFFF_-]|\.)+)(?:((['"]*)((?:([^)]+)|[^2()]*)+)2))?/
},
attrMap: {
"class": "className",
"for": "htmlFor"
},
attrHandle: {
href: function(elem){
return elem.getAttribute("href");
}
},
relative: {
"+": function(checkSet, part, isXML){
var isPartStr = typeof part === "string",
isTag = isPartStr && !/W/.test(part),
isPartStrNotTag = isPartStr && !isTag;
if ( isTag && !isXML ) {
part = part.toUpperCase();
}
for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
if ( (elem = checkSet[i]) ) {
while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?
elem || false :
elem === part;
}
}
if ( isPartStrNotTag ) {
Sizzle.filter( part, checkSet, true );
}
},
">": function(checkSet, part, isXML){
var isPartStr = typeof part === "string";
if ( isPartStr && !/W/.test(part) ) {
part = isXML ? part : part.toUpperCase();
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
var parent = elem.parentNode;
checkSet[i] = parent.nodeName === part ? parent : false;
}
}
} else {
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
checkSet[i] = isPartStr ?
elem.parentNode :
elem.parentNode === part;
}
}
if ( isPartStr ) {
Sizzle.filter( part, checkSet, true );
}
}
},
"": function(checkSet, part, isXML){
var doneName = done++, checkFn = dirCheck;
if ( !part.match(/W/) ) {
var nodeCheck = part = isXML ? part : part.toUpperCase();
checkFn = dirNodeCheck;
}
checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
},
"~": function(checkSet, part, isXML){
var doneName = done++, checkFn = dirCheck;
if ( typeof part === "string" && !part.match(/W/) ) {
var nodeCheck = part = isXML ? part : part.toUpperCase();
checkFn = dirNodeCheck;
}
checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
}
},
find: {
ID: function(match, context, isXML){
if ( typeof context.getElementById !== "undefined" && !isXML ) {
var m = context.getElementById(match[1]);
return m ? [m] : [];
}
},
NAME: function(match, context, isXML){
if ( typeof context.getElementsByName !== "undefined" ) {
var ret = [], results = context.getElementsByName(match[1]);
for ( var i = 0, l = results.length; i < l; i++ ) {
if ( results[i].getAttribute("name") === match[1] ) {
ret.push( results[i] );
}
}
return ret.length === 0 ? null : ret;
}
},
TAG: function(match, context){
return context.getElementsByTagName(match[1]);
}
},
preFilter: {
CLASS: function(match, curLoop, inplace, result, not, isXML){
match = " " + match[1].replace(/\/g, "") + " ";
if ( isXML ) {
return match;
}
for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
if ( elem ) {
if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
if ( !inplace )
result.push( elem );
} else if ( inplace ) {
curLoop[i] = false;
}
}
}
return false;
},
ID: function(match){
return match[1].replace(/\/g, "");
},
TAG: function(match, curLoop){
for ( var i = 0; curLoop[i] === false; i++ ){}
return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
},
CHILD: function(match){
if ( match[1] == "nth" ) {
// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
var test = /(-?)(d*)n((?:+|-)?d*)/.exec(
match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
!/D/.test( match[2] ) && "0n+" + match[2] || match[2]);
// calculate the numbers (first)n+(last) including if they are negative
match[2] = (test[1] + (test[2] || 1)) - 0;
match[3] = test[3] - 0;
}
// TODO: Move to normal caching system
match[0] = done++;
return match;
},
ATTR: function(match, curLoop, inplace, result, not, isXML){
var name = match[1].replace(/\/g, "");
if ( !isXML && Expr.attrMap[name] ) {
match[1] = Expr.attrMap[name];
}
if ( match[2] === "~=" ) {
match[4] = " " + match[4] + " ";
}
return match;
},
PSEUDO: function(match, curLoop, inplace, result, not){
if ( match[1] === "not" ) {
// If we're dealing with a complex expression, or a simple one
if ( match[3].match(chunker).length > 1 || /^w/.test(match[3]) ) {
match[3] = Sizzle(match[3], null, null, curLoop);
} else {
var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
if ( !inplace ) {
result.push.apply( result, ret );
}
return false;
}
} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
return true;
}
return match;
},
POS: function(match){
match.unshift( true );
return match;
}
},
filters: {
enabled: function(elem){
return elem.disabled === false && elem.type !== "hidden";
},
disabled: function(elem){
return elem.disabled === true;
},
checked: function(elem){
return elem.checked === true;
},
selected: function(elem){
// Accessing this property makes selected-by-default
// options in Safari work properly
elem.parentNode.selectedIndex;
return elem.selected === true;
},
parent: function(elem){
return !!elem.firstChild;
},
empty: function(elem){
return !elem.firstChild;
},
has: function(elem, i, match){
return !!Sizzle( match[3], elem ).length;
},
header: function(elem){
return /hd/i.test( elem.nodeName );
},
text: function(elem){
return "text" === elem.type;
},
radio: function(elem){
return "radio" === elem.type;
},
checkbox: function(elem){
return "checkbox" === elem.type;
},
file: function(elem){
return "file" === elem.type;
},
password: function(elem){
return "password" === elem.type;
},
submit: function(elem){
return "submit" === elem.type;
},
image: function(elem){
return "image" === elem.type;
},
reset: function(elem){
return "reset" === elem.type;
},
button: function(elem){
return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
},
input: function(elem){
return /input|select|textarea|button/i.test(elem.nodeName);
}
},
setFilters: {
first: function(elem, i){
return i === 0;
},
last: function(elem, i, match, array){
return i === array.length - 1;
},
even: function(elem, i){
return i % 2 === 0;
},
odd: function(elem, i){
return i % 2 === 1;
},
lt: function(elem, i, match){
return i < match[3] - 0;
},
gt: function(elem, i, match){
return i > match[3] - 0;
},
nth: function(elem, i, match){
return match[3] - 0 == i;
},
eq: function(elem, i, match){
return match[3] - 0 == i;
}
},
filter: {
PSEUDO: function(elem, match, i, array){
var name = match[1], filter = Expr.filters[ name ];
if ( filter ) {
return filter( elem, i, match, array );
} else if ( name === "contains" ) {
return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
} else if ( name === "not" ) {
var not = match[3];
for ( var i = 0, l = not.length; i < l; i++ ) {
if ( not[i] === elem ) {
return false;
}
}
return true;
}
},
CHILD: function(elem, match){
var type = match[1], node = elem;
switch (type) {
case 'only':
case 'first':
while (node = node.previousSibling) {
if ( node.nodeType === 1 ) return false;
}
if ( type == 'first') return true;
node = elem;
case 'last':
while (node = node.nextSibling) {
if ( node.nodeType === 1 ) return false;
}
return true;
case 'nth':
var first = match[2], last = match[3];
if ( first == 1 && last == 0 ) {
return true;
}
var doneName = match[0],
parent = elem.parentNode;
if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
var count = 0;
for ( node = parent.firstChild; node; node = node.nextSibling ) {
if ( node.nodeType === 1 ) {
node.nodeIndex = ++count;
}
}
parent.sizcache = doneName;
}
var diff = elem.nodeIndex - last;
if ( first == 0 ) {
return diff == 0;
} else {
return ( diff % first == 0 && diff / first >= 0 );
}
}
},
ID: function(elem, match){
return elem.nodeType === 1 && elem.getAttribute("id") === match;
},
TAG: function(elem, match){
return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
},
CLASS: function(elem, match){
return (" " + (elem.className || elem.getAttribute("class")) + " ")
.indexOf( match ) > -1;
},
ATTR: function(elem, match){
var name = match[1],
result = Expr.attrHandle[ name ] ?
Expr.attrHandle[ name ]( elem ) :
elem[ name ] != null ?
elem[ name ] :
elem.getAttribute( name ),
value = result + "",
type = match[2],
check = match[4];
return result == null ?
type === "!=" :