|
/*! |
|
* jQuery JavaScript Library v1.8.0 |
|
* http://jquery.com/ |
|
* |
|
* Includes Sizzle.js |
|
* http://sizzlejs.com/ |
|
* |
|
* Copyright 2012 jQuery Foundation and other contributors |
|
* Released under the MIT license |
|
* http://jquery.org/license |
|
* |
|
* Date: Thu Aug 09 2012 16:24:48 GMT-0400 (Eastern Daylight Time) |
|
*/ |
|
(function( window, undefined ) { |
|
var |
|
// A central reference to the root jQuery(document) |
|
rootjQuery, |
|
|
|
// The deferred used on DOM ready |
|
readyList, |
|
|
|
// Use the correct document accordingly with window argument (sandbox) |
|
document = window.document, |
|
location = window.location, |
|
navigator = window.navigator, |
|
|
|
// Map over jQuery in case of overwrite |
|
_jQuery = window.jQuery, |
|
|
|
// Map over the $ in case of overwrite |
|
_$ = window.$, |
|
|
|
// Save a reference to some core methods |
|
core_push = Array.prototype.push, |
|
core_slice = Array.prototype.slice, |
|
core_indexOf = Array.prototype.indexOf, |
|
core_toString = Object.prototype.toString, |
|
core_hasOwn = Object.prototype.hasOwnProperty, |
|
core_trim = String.prototype.trim, |
|
|
|
// Define a local copy of jQuery |
|
jQuery = function( selector, context ) { |
|
// The jQuery object is actually just the init constructor 'enhanced' |
|
return new jQuery.fn.init( selector, context, rootjQuery ); |
|
}, |
|
|
|
// Used for matching numbers |
|
core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source, |
|
|
|
// Used for detecting and trimming whitespace |
|
core_rnotwhite = /\S/, |
|
core_rspace = /\s+/, |
|
|
|
// IE doesn't match non-breaking spaces with \s |
|
rtrim = core_rnotwhite.test("\xA0") ? (/^[\s\xA0]+|[\s\xA0]+$/g) : /^\s+|\s+$/g, |
|
|
|
// A simple way to check for HTML strings |
|
// Prioritize #id over <tag> to avoid XSS via location.hash (#9521) |
|
rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/, |
|
|
|
// Match a standalone tag |
|
rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/, |
|
|
|
// JSON RegExp |
|
rvalidchars = /^[\],:{}\s]*$/, |
|
rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g, |
|
rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g, |
|
rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g, |
|
|
|
// Matches dashed string for camelizing |
|
rmsPrefix = /^-ms-/, |
|
rdashAlpha = /-([\da-z])/gi, |
|
|
|
// Used by jQuery.camelCase as callback to replace() |
|
fcamelCase = function( all, letter ) { |
|
return ( letter + "" ).toUpperCase(); |
|
}, |
|
|
|
// The ready event handler and self cleanup method |
|
DOMContentLoaded = function() { |
|
if ( document.addEventListener ) { |
|
document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false ); |
|
jQuery.ready(); |
|
} else if ( document.readyState === "complete" ) { |
|
// we're here because readyState === "complete" in oldIE |
|
// which is good enough for us to call the dom ready! |
|
document.detachEvent( "onreadystatechange", DOMContentLoaded ); |
|
jQuery.ready(); |
|
} |
|
}, |
|
|
|
// [[Class]] -> type pairs |
|
class2type = {}; |
|
|
|
jQuery.fn = jQuery.prototype = { |
|
constructor: jQuery, |
|
init: function( selector, context, rootjQuery ) { |
|
var match, elem, ret, doc; |
|
|
|
// Handle $(""), $(null), $(undefined), $(false) |
|
if ( !selector ) { |
|
return this; |
|
} |
|
|
|
// Handle $(DOMElement) |
|
if ( selector.nodeType ) { |
|
this.context = this[0] = selector; |
|
this.length = 1; |
|
return this; |
|
} |
|
|
|
// Handle HTML strings |
|
if ( typeof selector === "string" ) { |
|
if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) { |
|
// Assume that strings that start and end with <> are HTML and skip the regex check |
|
match = [ null, selector, null ]; |
|
|
|
} else { |
|
match = rquickExpr.exec( selector ); |
|
} |
|
|
|
// Match html or make sure no context is specified for #id |
|
if ( match && (match[1] || !context) ) { |
|
|
|
// HANDLE: $(html) -> $(array) |
|
if ( match[1] ) { |
|
context = context instanceof jQuery ? context[0] : context; |
|
doc = ( context && context.nodeType ? context.ownerDocument || context : document ); |
|
|
|
// scripts is true for back-compat |
|
selector = jQuery.parseHTML( match[1], doc, true ); |
|
if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) { |
|
this.attr.call( selector, context, true ); |
|
} |
|
|
|
return jQuery.merge( this, selector ); |
|
|
|
// HANDLE: $(#id) |
|
} else { |
|
elem = document.getElementById( match[2] ); |
|
|
|
// Check parentNode to catch when Blackberry 4.6 returns |
|
// nodes that are no longer in the document #6963 |
|
if ( elem && elem.parentNode ) { |
|
// Handle the case where IE and Opera return items |
|
// by name instead of ID |
|
if ( elem.id !== match[2] ) { |
|
return rootjQuery.find( selector ); |
|
} |
|
|
|
// Otherwise, we inject the element directly into the jQuery object |
|
this.length = 1; |
|
this[0] = elem; |
|
} |
|
|
|
this.context = document; |
|
this.selector = selector; |
|
return this; |
|
} |
|
|
|
// HANDLE: $(expr, $(...)) |
|
} else if ( !context || context.jquery ) { |
|
return ( context || rootjQuery ).find( selector ); |
|
|
|
// HANDLE: $(expr, context) |
|
// (which is just equivalent to: $(context).find(expr) |
|
} else { |
|
return this.constructor( context ).find( selector ); |
|
} |
|
|
|
// HANDLE: $(function) |
|
// Shortcut for document ready |
|
} else if ( jQuery.isFunction( selector ) ) { |
|
return rootjQuery.ready( selector ); |
|
} |
|
|
|
if ( selector.selector !== undefined ) { |
|
this.selector = selector.selector; |
|
this.context = selector.context; |
|
} |
|
|
|
return jQuery.makeArray( selector, this ); |
|
}, |
|
|
|
// Start with an empty selector |
|
selector: "", |
|
|
|
// The current version of jQuery being used |
|
jquery: "1.8.0", |
|
|
|
// The default length of a jQuery object is 0 |
|
length: 0, |
|
|
|
// The number of elements contained in the matched element set |
|
size: function() { |
|
return this.length; |
|
}, |
|
|
|
toArray: function() { |
|
return core_slice.call( this ); |
|
}, |
|
|
|
// 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 == null ? |
|
|
|
// Return a 'clean' array |
|
this.toArray() : |
|
|
|
// Return just the object |
|
( num < 0 ? this[ this.length + num ] : this[ num ] ); |
|
}, |
|
|
|
// Take an array of elements and push it onto the stack |
|
// (returning the new matched element set) |
|
pushStack: function( elems, name, selector ) { |
|
|
|
// Build a new jQuery matched element set |
|
var ret = jQuery.merge( this.constructor(), 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; |
|
}, |
|
|
|
// 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 ); |
|
}, |
|
|
|
ready: function( fn ) { |
|
// Add the callback |
|
jQuery.ready.promise().done( fn ); |
|
|
|
return this; |
|
}, |
|
|
|
eq: function( i ) { |
|
i = +i; |
|
return i === -1 ? |
|
this.slice( i ) : |
|
this.slice( i, i + 1 ); |
|
}, |
|
|
|
first: function() { |
|
return this.eq( 0 ); |
|
}, |
|
|
|
last: function() { |
|
return this.eq( -1 ); |
|
}, |
|
|
|
slice: function() { |
|
return this.pushStack( core_slice.apply( this, arguments ), |
|
"slice", core_slice.call(arguments).join(",") ); |
|
}, |
|
|
|
map: function( callback ) { |
|
return this.pushStack( jQuery.map(this, function( elem, i ) { |
|
return callback.call( elem, i, elem ); |
|
})); |
|
}, |
|
|
|
end: function() { |
|
return this.prevObject || this.constructor(null); |
|
}, |
|
|
|
// For internal use only. |
|
// Behaves like an Array's method, not like a jQuery method. |
|
push: core_push, |
|
sort: [].sort, |
|
splice: [].splice |
|
}; |
|
|
|
// Give the init function the jQuery prototype for later instantiation |
|
jQuery.fn.init.prototype = jQuery.fn; |
|
|
|
jQuery.extend = jQuery.fn.extend = function() { |
|
var options, name, src, copy, copyIsArray, clone, |
|
target = arguments[0] || {}, |
|
i = 1, |
|
length = arguments.length, |
|
deep = false; |
|
|
|
// 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 ( name in options ) { |
|
src = target[ name ]; |
|
copy = options[ name ]; |
|
|
|
// Prevent never-ending loop |
|
if ( target === copy ) { |
|
continue; |
|
} |
|
|
|
// Recurse if we're merging plain objects or arrays |
|
if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) { |
|
if ( copyIsArray ) { |
|
copyIsArray = false; |
|
clone = src && jQuery.isArray(src) ? src : []; |
|
|
|
} else { |
|
clone = src && jQuery.isPlainObject(src) ? src : {}; |
|
} |
|
|
|
// Never move original objects, clone them |
|
target[ name ] = jQuery.extend( deep, clone, copy ); |
|
|
|
// Don't bring in undefined values |
|
} else if ( copy !== undefined ) { |
|
target[ name ] = copy; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Return the modified object |
|
return target; |
|
}; |
|
|
|
jQuery.extend({ |
|
noConflict: function( deep ) { |
|
if ( window.$ === jQuery ) { |
|
window.$ = _$; |
|
} |
|
|
|
if ( deep && window.jQuery === jQuery ) { |
|
window.jQuery = _jQuery; |
|
} |
|
|
|
return jQuery; |
|
}, |
|
|
|
// Is the DOM ready to be used? Set to true once it occurs. |
|
isReady: false, |
|
|
|
// A counter to track how many items to wait for before |
|
// the ready event fires. See #6781 |
|
readyWait: 1, |
|
|
|
// Hold (or release) the ready event |
|
holdReady: function( hold ) { |
|
if ( hold ) { |
|
jQuery.readyWait++; |
|
} else { |
|
jQuery.ready( true ); |
|
} |
|
}, |
|
|
|
// Handle when the DOM is ready |
|
ready: function( wait ) { |
|
|
|
// Abort if there are pending holds or we're already ready |
|
if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { |
|
return; |
|
} |
|
|
|
// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). |
|
if ( !document.body ) { |
|
return setTimeout( jQuery.ready, 1 ); |
|
} |
|
|
|
// Remember that the DOM is ready |
|
jQuery.isReady = true; |
|
|
|
// If a normal DOM Ready event fired, decrement, and wait if need be |
|
if ( wait !== true && --jQuery.readyWait > 0 ) { |
|
return; |
|
} |
|
|
|
// If there are functions bound, to execute |
|
readyList.resolveWith( document, [ jQuery ] ); |
|
|
|
// Trigger any bound ready events |
|
if ( jQuery.fn.trigger ) { |
|
jQuery( document ).trigger("ready").off("ready"); |
|
} |
|
}, |
|
|
|
// 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 ) { |
|
return jQuery.type(obj) === "function"; |
|
}, |
|
|
|
isArray: Array.isArray || function( obj ) { |
|
return jQuery.type(obj) === "array"; |
|
}, |
|
|
|
isWindow: function( obj ) { |
|
return obj != null && obj == obj.window; |
|
}, |
|
|
|
isNumeric: function( obj ) { |
|
return !isNaN( parseFloat(obj) ) && isFinite( obj ); |
|
}, |
|
|
|
type: function( obj ) { |
|
return obj == null ? |
|
String( obj ) : |
|
class2type[ core_toString.call(obj) ] || "object"; |
|
}, |
|
|
|
isPlainObject: function( obj ) { |
|
// Must be an Object. |
|
// Because of IE, we also have to check the presence of the constructor property. |
|
// Make sure that DOM nodes and window objects don't pass through, as well |
|
if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) { |
|
return false; |
|
} |
|
|
|
try { |
|
// Not own constructor property must be Object |
|
if ( obj.constructor && |
|
!core_hasOwn.call(obj, "constructor") && |
|
!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { |
|
return false; |
|
} |
|
} catch ( e ) { |
|
// IE8,9 Will throw exceptions on certain host objects #9897 |
|
return false; |
|
} |
|
|
|
// Own properties are enumerated firstly, so to speed up, |
|
// if last one is own, then all properties are own. |
|
|
|
var key; |
|
for ( key in obj ) {} |
|
|
|
return key === undefined || core_hasOwn.call( obj, key ); |
|
}, |
|
|
|
isEmptyObject: function( obj ) { |
|
var name; |
|
for ( name in obj ) { |
|
return false; |
|
} |
|
return true; |
|
}, |
|
|
|
error: function( msg ) { |
|
throw new Error( msg ); |
|
}, |
|
|
|
// data: string of html |
|
// context (optional): If specified, the fragment will be created in this context, defaults to document |
|
// scripts (optional): If true, will include scripts passed in the html string |
|
parseHTML: function( data, context, scripts ) { |
|
var parsed; |
|
if ( !data || typeof data !== "string" ) { |
|
return null; |
|
} |
|
if ( typeof context === "boolean" ) { |
|
scripts = context; |
|
context = 0; |
|
} |
|
context = context || document; |
|
|
|
// Single tag |
|
if ( (parsed = rsingleTag.exec( data )) ) { |
|
return [ context.createElement( parsed[1] ) ]; |
|
} |
|
|
|
parsed = jQuery.buildFragment( [ data ], context, scripts ? null : [] ); |
|
return jQuery.merge( [], |
|
(parsed.cacheable ? jQuery.clone( parsed.fragment ) : parsed.fragment).childNodes ); |
|
}, |
|
|
|
parseJSON: function( data ) { |
|
if ( !data || typeof data !== "string") { |
|
return null; |
|
} |
|
|
|
// Make sure leading/trailing whitespace is removed (IE can't handle it) |
|
data = jQuery.trim( data ); |
|
|
|
// Attempt to parse using the native JSON parser first |
|
if ( window.JSON && window.JSON.parse ) { |
|
return window.JSON.parse( data ); |
|
} |
|
|
|
// Make sure the incoming data is actual JSON |
|
// Logic borrowed from http://json.org/json2.js |
|
if ( rvalidchars.test( data.replace( rvalidescape, "@" ) |
|
.replace( rvalidtokens, "]" ) |
|
.replace( rvalidbraces, "")) ) { |
|
|
|
return ( new Function( "return " + data ) )(); |
|
|
|
} |
|
jQuery.error( "Invalid JSON: " + data ); |
|
}, |
|
|
|
// Cross-browser xml parsing |
|
parseXML: function( data ) { |
|
var xml, tmp; |
|
if ( !data || typeof data !== "string" ) { |
|
return null; |
|
} |
|
try { |
|
if ( window.DOMParser ) { // Standard |
|
tmp = new DOMParser(); |
|
xml = tmp.parseFromString( data , "text/xml" ); |
|
} else { // IE |
|
xml = new ActiveXObject( "Microsoft.XMLDOM" ); |
|
xml.async = "false"; |
|
xml.loadXML( data ); |
|
} |
|
} catch( e ) { |
|
xml = undefined; |
|
} |
|
if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) { |
|
jQuery.error( "Invalid XML: " + data ); |
|
} |
|
return xml; |
|
}, |
|
|
|
noop: function() {}, |
|
|
|
// Evaluates a script in a global context |
|
// Workarounds based on findings by Jim Driscoll |
|
// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context |
|
globalEval: function( data ) { |
|
if ( data && core_rnotwhite.test( data ) ) { |
|
// We use execScript on Internet Explorer |
|
// We use an anonymous function so that context is window |
|
// rather than jQuery in Firefox |
|
( window.execScript || function( data ) { |
|
window[ "eval" ].call( window, data ); |
|
} )( data ); |
|
} |
|
}, |
|
|
|
// Convert dashed to camelCase; used by the css and data modules |
|
// Microsoft forgot to hump their vendor prefix (#9572) |
|
camelCase: function( string ) { |
|
return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); |
|
}, |
|
|
|
nodeName: function( elem, name ) { |
|
return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase(); |
|
}, |
|
|
|
// args is for internal usage only |
|
each: function( obj, callback, args ) { |
|
var name, |
|
i = 0, |
|
length = obj.length, |
|
isObj = length === undefined || jQuery.isFunction( obj ); |
|
|
|
if ( args ) { |
|
if ( isObj ) { |
|
for ( name in obj ) { |
|
if ( callback.apply( obj[ name ], args ) === false ) { |
|
break; |
|
} |
|
} |
|
} else { |
|
for ( ; i < length; ) { |
|
if ( callback.apply( obj[ i++ ], args ) === false ) { |
|
break; |
|
} |
|
} |
|
} |
|
|
|
// A special, fast, case for the most common use of each |
|
} else { |
|
if ( isObj ) { |
|
for ( name in obj ) { |
|
if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) { |
|
break; |
|
} |
|
} |
|
} else { |
|
for ( ; i < length; ) { |
|
if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) { |
|
break; |
|
} |
|
} |
|
} |
|
} |
|
|
|
return obj; |
|
}, |
|
|
|
// Use native String.trim function wherever possible |
|
trim: core_trim ? |
|
function( text ) { |
|
return text == null ? |
|
"" : |
|
core_trim.call( text ); |
|
} : |
|
|
|
// Otherwise use our own trimming functionality |
|
function( text ) { |
|
return text == null ? |
|
"" : |
|
text.toString().replace( rtrim, "" ); |
|
}, |
|
|
|
// results is for internal usage only |
|
makeArray: function( arr, results ) { |
|
var type, |
|
ret = results || []; |
|
|
|
if ( arr != null ) { |
|
// The window, strings (and functions) also have 'length' |
|
// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930 |
|
type = jQuery.type( arr ); |
|
|
|
if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) { |
|
core_push.call( ret, arr ); |
|
} else { |
|
jQuery.merge( ret, arr ); |
|
} |
|
} |
|
|
|
return ret; |
|
}, |
|
|
|
inArray: function( elem, arr, i ) { |
|
var len; |
|
|
|
if ( arr ) { |
|
if ( core_indexOf ) { |
|
return core_indexOf.call( arr, elem, i ); |
|
} |
|
|
|
len = arr.length; |
|
i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0; |
|
|
|
for ( ; i < len; i++ ) { |
|
// Skip accessing in sparse arrays |
|
if ( i in arr && arr[ i ] === elem ) { |
|
return i; |
|
} |
|
} |
|
} |
|
|
|
return -1; |
|
}, |
|
|
|
merge: function( first, second ) { |
|
var l = second.length, |
|
i = first.length, |
|
j = 0; |
|
|
|
if ( typeof l === "number" ) { |
|
for ( ; j < l; j++ ) { |
|
first[ i++ ] = second[ j ]; |
|
} |
|
|
|
} else { |
|
while ( second[j] !== undefined ) { |
|
first[ i++ ] = second[ j++ ]; |
|
} |
|
} |
|
|
|
first.length = i; |
|
|
|
return first; |
|
}, |
|
|
|
grep: function( elems, callback, inv ) { |
|
var retVal, |
|
ret = [], |
|
i = 0, |
|
length = elems.length; |
|
inv = !!inv; |
|
|
|
// Go through the array, only saving the items |
|
// that pass the validator function |
|
for ( ; i < length; i++ ) { |
|
retVal = !!callback( elems[ i ], i ); |
|
if ( inv !== retVal ) { |
|
ret.push( elems[ i ] ); |
|
} |
|
} |
|
|
|
return ret; |
|
}, |
|
|
|
// arg is for internal usage only |
|
map: function( elems, callback, arg ) { |
|
var value, key, |
|
ret = [], |
|
i = 0, |
|
length = elems.length, |
|
// jquery objects are treated as arrays |
|
isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ; |
|
|
|
// Go through the array, translating each of the items to their |
|
if ( isArray ) { |
|
for ( ; i < length; i++ ) { |
|
value = callback( elems[ i ], i, arg ); |
|
|
|
if ( value != null ) { |
|
ret[ ret.length ] = value; |
|
} |
|
} |
|
|
|
// Go through every key on the object, |
|
} else { |
|
for ( key in elems ) { |
|
value = callback( elems[ key ], key, arg ); |
|
|
|
if ( value != null ) { |
|
ret[ ret.length ] = value; |
|
} |
|
} |
|
} |
|
|
|
// Flatten any nested arrays |
|
return ret.concat.apply( [], ret ); |
|
}, |
|
|
|
// A global GUID counter for objects |
|
guid: 1, |
|
|
|
// Bind a function to a context, optionally partially applying any |
|
// arguments. |
|
proxy: function( fn, context ) { |
|
var tmp, args, proxy; |
|
|
|
if ( typeof context === "string" ) { |
|
tmp = fn[ context ]; |
|
context = fn; |
|
fn = tmp; |
|
} |
|
|
|
// Quick check to determine if target is callable, in the spec |
|
// this throws a TypeError, but we will just return undefined. |
|
if ( !jQuery.isFunction( fn ) ) { |
|
return undefined; |
|
} |
|
|
|
// Simulated bind |
|
args = core_slice.call( arguments, 2 ); |
|
proxy = function() { |
|
return fn.apply( context, args.concat( core_slice.call( arguments ) ) ); |
|
}; |
|
|
|
// Set the guid of unique handler to the same of original handler, so it can be removed |
|
proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++; |
|
|
|
return proxy; |
|
}, |
|
|
|
// Multifunctional method to get and set values of a collection |
|
// The value/s can optionally be executed if it's a function |
|
access: function( elems, fn, key, value, chainable, emptyGet, pass ) { |
|
var exec, |
|
bulk = key == null, |
|
i = 0, |
|
length = elems.length; |
|
|
|
// Sets many values |
|
if ( key && typeof key === "object" ) { |
|
for ( i in key ) { |
|
jQuery.access( elems, fn, i, key[i], 1, emptyGet, value ); |
|
} |
|
chainable = 1; |
|
|
|
// Sets one value |
|
} else if ( value !== undefined ) { |
|
// Optionally, function values get executed if exec is true |
|
exec = pass === undefined && jQuery.isFunction( value ); |
|
|
|
if ( bulk ) { |
|
// Bulk operations only iterate when executing function values |
|
if ( exec ) { |
|
exec = fn; |
|
fn = function( elem, key, value ) { |
|
return exec.call( jQuery( elem ), value ); |
|
}; |
|
|
|
// Otherwise they run against the entire set |
|
} else { |
|
fn.call( elems, value ); |
|
fn = null; |
|
} |
|
} |
|
|
|
if ( fn ) { |
|
for (; i < length; i++ ) { |
|
fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass ); |
|
} |
|
} |
|
|
|
chainable = 1; |
|
} |
|
|
|
return chainable ? |
|
elems : |
|
|
|
// Gets |
|
bulk ? |
|
fn.call( elems ) : |
|
length ? fn( elems[0], key ) : emptyGet; |
|
}, |
|
|
|
now: function() { |
|
return ( new Date() ).getTime(); |
|
} |
|
}); |
|
|
|
jQuery.ready.promise = function( obj ) { |
|
if ( !readyList ) { |
|
|
|
readyList = jQuery.Deferred(); |
|
|
|
// Catch cases where $(document).ready() is called after the |
|
// browser event has already occurred. |
|
if ( document.readyState === "complete" || ( document.readyState !== "loading" && document.addEventListener ) ) { |
|
// Handle it asynchronously to allow scripts the opportunity to delay ready |
|
setTimeout( jQuery.ready, 1 ); |
|
|
|
// Standards-based browsers support DOMContentLoaded |
|
} else if ( document.addEventListener ) { |
|
// Use the handy event callback |
|
document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false ); |
|
|
|
// A fallback to window.onload, that will always work |
|
window.addEventListener( "load", jQuery.ready, false ); |
|
|
|
// If IE event model is used |
|
} else { |
|
// Ensure firing before onload, maybe late but safe also for iframes |
|
document.attachEvent( "onreadystatechange", DOMContentLoaded ); |
|
|
|
// A fallback to window.onload, that will always work |
|
window.attachEvent( "onload", jQuery.ready ); |
|
|
|
// If IE and not a frame |
|
// continually check to see if the document is ready |
|
var top = false; |
|
|
|
try { |
|
top = window.frameElement == null && document.documentElement; |
|
} catch(e) {} |
|
|
|
if ( top && top.doScroll ) { |
|
(function doScrollCheck() { |
|
if ( !jQuery.isReady ) { |
|
|
|
try { |
|
// Use the trick by Diego Perini |
|
// http://javascript.nwbox.com/IEContentLoaded/ |
|
top.doScroll("left"); |
|
} catch(e) { |
|
return setTimeout( doScrollCheck, 50 ); |
|
} |
|
|
|
// and execute any waiting functions |
|
jQuery.ready(); |
|
} |
|
})(); |
|
} |
|
} |
|
} |
|
return readyList.promise( obj ); |
|
}; |
|
|
|
// Populate the class2type map |
|
jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { |
|
class2type[ "[object " + name + "]" ] = name.toLowerCase(); |
|
}); |
|
|
|
// All jQuery objects should point back to these |
|
rootjQuery = jQuery(document); |
|
// String to Object options format cache |
|
var optionsCache = {}; |
|
|
|
// Convert String-formatted options into Object-formatted ones and store in cache |
|
function createOptions( options ) { |
|
var object = optionsCache[ options ] = {}; |
|
jQuery.each( options.split( core_rspace ), function( _, flag ) { |
|
object[ flag ] = true; |
|
}); |
|
return object; |
|
} |
|
|
|
/* |
|
* Create a callback list using the following parameters: |
|
* |
|
* options: an optional list of space-separated options that will change how |
|
* the callback list behaves or a more traditional option object |
|
* |
|
* By default a callback list will act like an event callback list and can be |
|
* "fired" multiple times. |
|
* |
|
* Possible options: |
|
* |
|
* once: will ensure the callback list can only be fired once (like a Deferred) |
|
* |
|
* memory: will keep track of previous values and will call any callback added |
|
* after the list has been fired right away with the latest "memorized" |
|
* values (like a Deferred) |
|
* |
|
* unique: will ensure a callback can only be added once (no duplicate in the list) |
|
* |
|
* stopOnFalse: interrupt callings when a callback returns false |
|
* |
|
*/ |
|
jQuery.Callbacks = function( options ) { |
|
|
|
// Convert options from String-formatted to Object-formatted if needed |
|
// (we check in cache first) |
|
options = typeof options === "string" ? |
|
( optionsCache[ options ] || createOptions( options ) ) : |
|
jQuery.extend( {}, options ); |
|
|
|
var // Last fire value (for non-forgettable lists) |
|
memory, |
|
// Flag to know if list was already fired |
|
fired, |
|
// Flag to know if list is currently firing |
|
firing, |
|
// First callback to fire (used internally by add and fireWith) |
|
firingStart, |
|
// End of the loop when firing |
|
firingLength, |
|
// Index of currently firing callback (modified by remove if needed) |
|
firingIndex, |
|
// Actual callback list |
|
list = [], |
|
// Stack of fire calls for repeatable lists |
|
stack = !options.once && [], |
|
// Fire callbacks |
|
fire = function( data ) { |
|
memory = options.memory && data; |
|
fired = true; |
|
firingIndex = firingStart || 0; |
|
firingStart = 0; |
|
firingLength = list.length; |
|
firing = true; |
|
for ( ; list && firingIndex < firingLength; firingIndex++ ) { |
|
if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) { |
|
memory = false; // To prevent further calls using add |
|
break; |
|
} |
|
} |
|
firing = false; |
|
if ( list ) { |
|
if ( stack ) { |
|
if ( stack.length ) { |
|
fire( stack.shift() ); |
|
} |
|
} else if ( memory ) { |
|
list = []; |
|
} else { |
|
self.disable(); |
|
} |
|
} |
|
}, |
|
// Actual Callbacks object |
|
self = { |
|
// Add a callback or a collection of callbacks to the list |
|
add: function() { |
|
if ( list ) { |
|
// First, we save the current length |
|
var start = list.length; |
|
(function add( args ) { |
|
jQuery.each( args, function( _, arg ) { |
|
if ( jQuery.isFunction( arg ) && ( !options.unique || !self.has( arg ) ) ) { |
|
list.push( arg ); |
|
} else if ( arg && arg.length ) { |
|
// Inspect recursively |
|
add( arg ); |
|
} |
|
}); |
|
})( arguments ); |
|
// Do we need to add the callbacks to the |
|
// current firing batch? |
|
if ( firing ) { |
|
firingLength = list.length; |
|
// With memory, if we're not firing then |
|
// we should call right away |
|
} else if ( memory ) { |
|
firingStart = start; |
|
fire( memory ); |
|
} |
|
} |
|
return this; |
|
}, |
|
// Remove a callback from the list |
|
remove: function() { |
|
if ( list ) { |
|
jQuery.each( arguments, function( _, arg ) { |
|
var index; |
|
while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { |
|
list.splice( index, 1 ); |
|
// Handle firing indexes |
|
if ( firing ) { |
|
if ( index <= firingLength ) { |
|
firingLength--; |
|
} |
|
if ( index <= firingIndex ) { |
|
firingIndex--; |
|
} |
|
} |
|
} |
|
}); |
|
} |
|
return this; |
|
}, |
|
// Control if a given callback is in the list |
|
has: function( fn ) { |
|
return jQuery.inArray( fn, list ) > -1; |
|
}, |
|
// Remove all callbacks from the list |
|
empty: function() { |
|
list = []; |
|
return this; |
|
}, |
|
// Have the list do nothing anymore |
|
disable: function() { |
|
list = stack = memory = undefined; |
|
return this; |
|
}, |
|
// Is it disabled? |
|
disabled: function() { |
|
return !list; |
|
}, |
|
// Lock the list in its current state |
|
lock: function() { |
|
stack = undefined; |
|
if ( !memory ) { |
|
self.disable(); |
|
} |
|
return this; |
|
}, |
|
// Is it locked? |
|
locked: function() { |
|
return !stack; |
|
}, |
|
// Call all callbacks with the given context and arguments |
|
fireWith: function( context, args ) { |
|
args = args || []; |
|
args = [ context, args.slice ? args.slice() : args ]; |
|
if ( list && ( !fired || stack ) ) { |
|
if ( firing ) { |
|
stack.push( args ); |
|
} else { |
|
fire( args ); |
|
} |
|
} |
|
return this; |
|
}, |
|
// Call all the callbacks with the given arguments |
|
fire: function() { |
|
self.fireWith( this, arguments ); |
|
return this; |
|
}, |
|
// To know if the callbacks have already been called at least once |
|
fired: function() { |
|
return !!fired; |
|
} |
|
}; |
|
|
|
return self; |
|
}; |
|
jQuery.extend({ |
|
|
|
Deferred: function( func ) { |
|
var tuples = [ |
|
// action, add listener, listener list, final state |
|
[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ], |
|
[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ], |
|
[ "notify", "progress", jQuery.Callbacks("memory") ] |
|
], |
|
state = "pending", |
|
promise = { |
|
state: function() { |
|
return state; |
|
}, |
|
always: function() { |
|
deferred.done( arguments ).fail( arguments ); |
|
return this; |
|
}, |
|
then: function( /* fnDone, fnFail, fnProgress */ ) { |
|
var fns = arguments; |
|
return jQuery.Deferred(function( newDefer ) { |
|
jQuery.each( tuples, function( i, tuple ) { |
|
var action = tuple[ 0 ], |
|
fn = fns[ i ]; |
|
// deferred[ done | fail | progress ] for forwarding actions to newDefer |
|
deferred[ tuple[1] ]( jQuery.isFunction( fn ) ? |
|
function() { |
|
var returned = fn.apply( this, arguments ); |
|
if ( returned && jQuery.isFunction( returned.promise ) ) { |
|
returned.promise() |
|
.done( newDefer.resolve ) |
|
.fail( newDefer.reject ) |
|
.progress( newDefer.notify ); |
|
} else { |
|
newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] ); |
|
} |
|
} : |
|
newDefer[ action ] |
|
); |
|
}); |
|
fns = null; |
|
}).promise(); |
|
}, |
|
// Get a promise for this deferred |
|
// If obj is provided, the promise aspect is added to the object |
|
promise: function( obj ) { |
|
return typeof obj === "object" ? jQuery.extend( obj, promise ) : promise; |
|
} |
|
}, |
|
deferred = {}; |
|
|
|
// Keep pipe for back-compat |
|
promise.pipe = promise.then; |
|
|
|
// Add list-specific methods |
|
jQuery.each( tuples, function( i, tuple ) { |
|
var list = tuple[ 2 ], |
|
stateString = tuple[ 3 ]; |
|
|
|
// promise[ done | fail | progress ] = list.add |
|
promise[ tuple[1] ] = list.add; |
|
|
|
// Handle state |
|
if ( stateString ) { |
|
list.add(function() { |
|
// state = [ resolved | rejected ] |
|
state = stateString; |
|
|
|
// [ reject_list | resolve_list ].disable; progress_list.lock |
|
}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock ); |
|
} |
|
|
|
// deferred[ resolve | reject | notify ] = list.fire |
|
deferred[ tuple[0] ] = list.fire; |
|
deferred[ tuple[0] + "With" ] = list.fireWith; |
|
}); |
|
|
|
// Make the deferred a promise |
|
promise.promise( deferred ); |
|
|
|
// Call given func if any |
|
if ( func ) { |
|
func.call( deferred, deferred ); |
|
} |
|
|
|
// All done! |
|
return deferred; |
|
}, |
|
|
|
// Deferred helper |
|
when: function( subordinate /* , ..., subordinateN */ ) { |
|
var i = 0, |
|
resolveValues = core_slice.call( arguments ), |
|
length = resolveValues.length, |
|
|
|
// the count of uncompleted subordinates |
|
remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0, |
|
|
|
// the master Deferred. If resolveValues consist of only a single Deferred, just use that. |
|
deferred = remaining === 1 ? subordinate : jQuery.Deferred(), |
|
|
|
// Update function for both resolve and progress values |
|
updateFunc = function( i, contexts, values ) { |
|
return function( value ) { |
|
contexts[ i ] = this; |
|
values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value; |
|
if( values === progressValues ) { |
|
deferred.notifyWith( contexts, values ); |
|
} else if ( !( --remaining ) ) { |
|
deferred.resolveWith( contexts, values ); |
|
} |
|
}; |
|
}, |
|
|
|
progressValues, progressContexts, resolveContexts; |
|
|
|
// add listeners to Deferred subordinates; treat others as resolved |
|
if ( length > 1 ) { |
|
progressValues = new Array( length ); |
|
progressContexts = new Array( length ); |
|
resolveContexts = new Array( length ); |
|
for ( ; i < length; i++ ) { |
|
if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) { |
|
resolveValues[ i ].promise() |
|
.done( updateFunc( i, resolveContexts, resolveValues ) ) |
|
.fail( deferred.reject ) |
|
.progress( updateFunc( i, progressContexts, progressValues ) ); |
|
} else { |
|
--remaining; |
|
} |
|
} |
|
} |
|
|
|
// if we're not waiting on anything, resolve the master |
|
if ( !remaining ) { |
|
deferred.resolveWith( resolveContexts, resolveValues ); |
|
} |
|
|
|
return deferred.promise(); |
|
} |
|
}); |
|
jQuery.support = (function() { |
|
|
|
var support, |
|
all, |
|
a, |
|
select, |
|
opt, |
|
input, |
|
fragment, |
|
eventName, |
|
i, |
|
isSupported, |
|
clickFn, |
|
div = document.createElement("div"); |
|
|
|
// Preliminary tests |
|
div.setAttribute( "className", "t" ); |
|
div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; |
|
|
|
all = div.getElementsByTagName("*"); |
|
a = div.getElementsByTagName("a")[ 0 ]; |
|
a.style.cssText = "top:1px;float:left;opacity:.5"; |
|
|
|
// Can't get basic test support |
|
if ( !all || !all.length || !a ) { |
|
return {}; |
|
} |
|
|
|
// First batch of supports tests |
|
select = document.createElement("select"); |
|
opt = select.appendChild( document.createElement("option") ); |
|
input = div.getElementsByTagName("input")[ 0 ]; |
|
|
|
support = { |
|
// IE strips leading whitespace when .innerHTML is used |
|
leadingWhitespace: ( div.firstChild.nodeType === 3 ), |
|
|
|
// Make sure that tbody elements aren't automatically inserted |
|
// IE will insert them into empty tables |
|
tbody: !div.getElementsByTagName("tbody").length, |
|
|
|
// Make sure that link elements get serialized correctly by innerHTML |
|
// This requires a wrapper element in IE |
|
htmlSerialize: !!div.getElementsByTagName("link").length, |
|
|
|
// Get the style information from getAttribute |
|
// (IE uses .cssText instead) |
|
style: /top/.test( a.getAttribute("style") ), |
|
|
|
// Make sure that URLs aren't manipulated |
|
// (IE normalizes it by default) |
|
hrefNormalized: ( a.getAttribute("href") === "/a" ), |
|
|
|
// Make sure that element opacity exists |
|
// (IE uses filter instead) |
|
// Use a regex to work around a WebKit issue. See #5145 |
|
opacity: /^0.5/.test( a.style.opacity ), |
|
|
|
// Verify style float existence |
|
// (IE uses styleFloat instead of cssFloat) |
|
cssFloat: !!a.style.cssFloat, |
|
|
|
// Make sure that if no value is specified for a checkbox |
|
// that it defaults to "on". |
|
// (WebKit defaults to "" instead) |
|
checkOn: ( input.value === "on" ), |
|
|
|
// Make sure that a selected-by-default option has a working selected property. |
|
// (WebKit defaults to false instead of true, IE too, if it's in an optgroup) |
|
optSelected: opt.selected, |
|
|
|
// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) |
|
getSetAttribute: div.className !== "t", |
|
|
|
// Tests for enctype support on a form(#6743) |
|
enctype: !!document.createElement("form").enctype, |
|
|
|
// Makes sure cloning an html5 element does not cause problems |
|
// Where outerHTML is undefined, this still works |
|
html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>", |
|
|
|
// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode |
|
boxModel: ( document.compatMode === "CSS1Compat" ), |
|
|
|
// Will be defined later |
|
submitBubbles: true, |
|
changeBubbles: true, |
|
focusinBubbles: false, |
|
deleteExpando: true, |
|
noCloneEvent: true, |
|
inlineBlockNeedsLayout: false, |
|
shrinkWrapBlocks: false, |
|
reliableMarginRight: true, |
|
boxSizingReliable: true, |
|
pixelPosition: false |
|
}; |
|
|
|
// Make sure checked status is properly cloned |
|
input.checked = true; |
|
support.noCloneChecked = input.cloneNode( true ).checked; |
|
|
|
// Make sure that the options inside disabled selects aren't marked as disabled |
|
// (WebKit marks them as disabled) |
|
select.disabled = true; |
|
support.optDisabled = !opt.disabled; |
|
|
|
// Test to see if it's possible to delete an expando from an element |
|
// Fails in Internet Explorer |
|
try { |
|
delete div.test; |
|
} catch( e ) { |
|
support.deleteExpando = false; |
|
} |
|
|
|
if ( !div.addEventListener && div.attachEvent && div.fireEvent ) { |
|
div.attachEvent( "onclick", clickFn = function() { |
|
// Cloning a node shouldn't copy over any |
|
// bound event handlers (IE does this) |
|
support.noCloneEvent = false; |
|
}); |
|
div.cloneNode( true ).fireEvent("onclick"); |
|
div.detachEvent( "onclick", clickFn ); |
|
} |
|
|
|
// Check if a radio maintains its value |
|
// after being appended to the DOM |
|
input = document.createElement("input"); |
|
input.value = "t"; |
|
input.setAttribute( "type", "radio" ); |
|
support.radioValue = input.value === "t"; |
|
|
|
input.setAttribute( "checked", "checked" ); |
|
|
|
// #11217 - WebKit loses check when the name is after the checked attribute |
|
input.setAttribute( "name", "t" ); |
|
|
|
div.appendChild( input ); |
|
fragment = document.createDocumentFragment(); |
|
fragment.appendChild( div.lastChild ); |
|
|
|
// WebKit doesn't clone checked state correctly in fragments |
|
support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; |
|
|
|
// Check if a disconnected checkbox will retain its checked |
|
// value of true after appended to the DOM (IE6/7) |
|
support.appendChecked = input.checked; |
|
|
|
fragment.removeChild( input ); |
|
fragment.appendChild( div ); |
|
|
|
// Technique from Juriy Zaytsev |
|
// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/ |
|
// We only care about the case where non-standard event systems |
|
// are used, namely in IE. Short-circuiting here helps us to |
|
// avoid an eval call (in setAttribute) which can cause CSP |
|
// to go haywire. See: https://developer.mozilla.org/en/Security/CSP |
|
if ( div.attachEvent ) { |
|
for ( i in { |
|
submit: true, |
|
change: true, |
|
focusin: true |
|
}) { |
|
eventName = "on" + i; |
|
isSupported = ( eventName in div ); |
|
if ( !isSupported ) { |
|
div.setAttribute( eventName, "return;" ); |
|
isSupported = ( typeof div[ eventName ] === "function" ); |
|
} |
|
support[ i + "Bubbles" ] = isSupported; |
|
} |
|
} |
|
|
|
// Run tests that need a body at doc ready |
|
jQuery(function() { |
|
var container, div, tds, marginDiv, |
|
divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;", |
|
body = document.getElementsByTagName("body")[0]; |
|
|
|
if ( !body ) { |
|
// Return for frameset docs that don't have a body |
|
return; |
|
} |
|
|
|
container = document.createElement("div"); |
|
container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px"; |
|
body.insertBefore( container, body.firstChild ); |
|
|
|
// Construct the test element |
|
div = document.createElement("div"); |
|
container.appendChild( div ); |
|
|
|
// Check if table cells still have offsetWidth/Height when they are set |
|
// to display:none and there are still other visible table cells in a |
|
// table row; if so, offsetWidth/Height are not reliable for use when |
|
// determining if an element has been hidden directly using |
|
// display:none (it is still safe to use offsets if a parent element is |
|
// hidden; don safety goggles and see bug #4512 for more information). |
|
// (only IE 8 fails this test) |
|
div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>"; |
|
tds = div.getElementsByTagName("td"); |
|
tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none"; |
|
isSupported = ( tds[ 0 ].offsetHeight === 0 ); |
|
|
|
tds[ 0 ].style.display = ""; |
|
tds[ 1 ].style.display = "none"; |
|
|
|
// Check if empty table cells still have offsetWidth/Height |
|
// (IE <= 8 fail this test) |
|
support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); |
|
|
|
// Check box-sizing and margin behavior |
|
div.innerHTML = ""; |
|
div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;"; |
|
support.boxSizing = ( div.offsetWidth === 4 ); |
|
support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 ); |
|
|
|
// NOTE: To any future maintainer, window.getComputedStyle was used here |
|
// instead of getComputedStyle because it gave a better gzip size. |
|
// The difference between window.getComputedStyle and getComputedStyle is |
|
// 7 bytes |
|
if ( window.getComputedStyle ) { |
|
support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%"; |
|
support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px"; |
|
|
|
// Check if div with explicit width and no margin-right incorrectly |
|
// gets computed margin-right based on width of container. For more |
|
// info see bug #3333 |
|
// Fails in WebKit before Feb 2011 nightlies |
|
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right |
|
marginDiv = document.createElement("div"); |
|
marginDiv.style.cssText = div.style.cssText = divReset; |
|
marginDiv.style.marginRight = marginDiv.style.width = "0"; |
|
div.style.width = "1px"; |
|
div.appendChild( marginDiv ); |
|
support.reliableMarginRight = |
|
!parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight ); |
|
} |
|
|
|
if ( typeof div.style.zoom !== "undefined" ) { |
|
// Check if natively block-level elements act like inline-block |
|
// elements when setting their display to 'inline' and giving |
|
// them layout |
|
// (IE < 8 does this) |
|
div.innerHTML = ""; |
|
div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1"; |
|
support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 ); |
|
|
|
// Check if elements with layout shrink-wrap their children |
|
// (IE 6 does this) |
|
div.style.display = "block"; |
|
div.style.overflow = "visible"; |
|
div.innerHTML = "<div></div>"; |
|
div.firstChild.style.width = "5px"; |
|
support.shrinkWrapBlocks = ( div.offsetWidth !== 3 ); |
|
|
|
container.style.zoom = 1; |
|
} |
|
|
|
// Null elements to avoid leaks in IE |
|
body.removeChild( container ); |
|
container = div = tds = marginDiv = null; |
|
}); |
|
|
|
// Null elements to avoid leaks in IE |
|
fragment.removeChild( div ); |
|
all = a = select = opt = input = fragment = div = null; |
|
|
|
return support; |
|
})(); |
|
var rbrace = /^(?:\{.*\}|\[.*\])$/, |
|
rmultiDash = /([A-Z])/g; |
|
|
|
jQuery.extend({ |
|
cache: {}, |
|
|
|
deletedIds: [], |
|
|
|
// Please use with caution |
|
uuid: 0, |
|
|
|
// Unique for each copy of jQuery on the page |
|
// Non-digits removed to match rinlinejQuery |
|
expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ), |
|
|
|
// The following elements throw uncatchable exceptions if you |
|
// attempt to add expando properties to them. |
|
noData: { |
|
"embed": true, |
|
// Ban all objects except for Flash (which handle expandos) |
|
"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", |
|
"applet": true |
|
}, |
|
|
|
hasData: function( elem ) { |
|
elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ]; |
|
return !!elem && !isEmptyDataObject( elem ); |
|
}, |
|
|
|
data: function( elem, name, data, pvt /* Internal Use Only */ ) { |
|
if ( !jQuery.acceptData( elem ) ) { |
|
return; |
|
} |
|
|
|
var thisCache, ret, |
|
internalKey = jQuery.expando, |
|
getByName = typeof name === "string", |
|
|
|
// We have to handle DOM nodes and JS objects differently because IE6-7 |
|
// can't GC object references properly across the DOM-JS boundary |
|
isNode = elem.nodeType, |
|
|
|
// Only DOM nodes need the global jQuery cache; JS object data is |
|
// attached directly to the object so GC can occur automatically |
|
cache = isNode ? jQuery.cache : elem, |
|
|
|
// Only defining an ID for JS objects if its cache already exists allows |
|
// the code to shortcut on the same path as a DOM node with no cache |
|
id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey; |
|
|
|
// Avoid doing any more work than we need to when trying to get data on an |
|
// object that has no data at all |
|
if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) { |
|
return; |
|
} |
|
|
|
if ( !id ) { |
|
// Only DOM nodes need a new unique ID for each element since their data |
|
// ends up in the global cache |
|
if ( isNode ) { |
|
elem[ internalKey ] = id = jQuery.deletedIds.pop() || ++jQuery.uuid; |
|
} else { |
|
id = internalKey; |
|
} |
|
} |
|
|
|
if ( !cache[ id ] ) { |
|
cache[ id ] = {}; |
|
|
|
// Avoids exposing jQuery metadata on plain JS objects when the object |
|
// is serialized using JSON.stringify |
|
if ( !isNode ) { |
|
cache[ id ].toJSON = jQuery.noop; |
|
} |
|
} |
|
|
|
// An object can be passed to jQuery.data instead of a key/value pair; this gets |
|
// shallow copied over onto the existing cache |
|
if ( typeof name === "object" || typeof name === "function" ) { |
|
if ( pvt ) { |
|
cache[ id ] = jQuery.extend( cache[ id ], name ); |
|
} else { |
|
cache[ id ].data = jQuery.extend( cache[ id ].data, name ); |
|
} |
|
} |
|
|
|
thisCache = cache[ id ]; |
|
|
|
// jQuery data() is stored in a separate object inside the object's internal data |
|
// cache in order to avoid key collisions between internal data and user-defined |
|
// data. |
|
if ( !pvt ) { |
|
if ( !thisCache.data ) { |
|
thisCache.data = {}; |
|
} |
|
|
|
thisCache = thisCache.data; |
|
} |
|
|
|
if ( data !== undefined ) { |
|
thisCache[ jQuery.camelCase( name ) ] = data; |
|
} |
|
|
|
// Check for both converted-to-camel and non-converted data property names |
|
// If a data property was specified |
|
if ( getByName ) { |
|
|
|
// First Try to find as-is property data |
|
ret = thisCache[ name ]; |
|
|
|
// Test for null|undefined property data |
|
if ( ret == null ) { |
|
|
|
// Try to find the camelCased property |
|
ret = thisCache[ jQuery.camelCase( name ) ]; |
|
} |
|
} else { |
|
ret = thisCache; |
|
} |
|
|
|
return ret; |
|
}, |
|
|
|
removeData: function( elem, name, pvt /* Internal Use Only */ ) { |
|
if ( !jQuery.acceptData( elem ) ) { |
|
return; |
|
} |
|
|
|
var thisCache, i, l, |
|
|
|
isNode = elem.nodeType, |
|
|
|
// See jQuery.data for more information |
|
cache = isNode ? jQuery.cache : elem, |
|
id = isNode ? elem[ jQuery.expando ] : jQuery.expando; |
|
|
|
// If there is already no cache entry for this object, there is no |
|
// purpose in continuing |
|
if ( !cache[ id ] ) { |
|
return; |
|
} |
|
|
|
if ( name ) { |
|
|
|
thisCache = pvt ? cache[ id ] : cache[ id ].data; |
|
|
|
if ( thisCache ) { |
|
|
|
// Support array or space separated string names for data keys |
|
if ( !jQuery.isArray( name ) ) { |
|
|
|
// try the string as a key before any manipulation |
|
if ( name in thisCache ) { |
|
name = [ name ]; |
|
} else { |
|
|
|
// split the camel cased version by spaces unless a key with the spaces exists |
|
name = jQuery.camelCase( name ); |
|
if ( name in thisCache ) { |
|
name = [ name ]; |
|
} else { |
|
name = name.split(" "); |
|
} |
|
} |
|
} |
|
|
|
for ( i = 0, l = name.length; i < l; i++ ) { |
|
delete thisCache[ name[i] ]; |
|
} |
|
|
|
// If there is no data left in the cache, we want to continue |
|
// and let the cache object itself get destroyed |
|
if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) { |
|
return; |
|
} |
|
} |
|
} |
|
|
|
// See jQuery.data for more information |
|
if ( !pvt ) { |
|
delete cache[ id ].data; |
|
|
|
// Don't destroy the parent cache unless the internal data object |
|
// had been the only thing left in it |
|
if ( !isEmptyDataObject( cache[ id ] ) ) { |
|
return; |
|
} |
|
} |
|
|
|
// Destroy the cache |
|
if ( isNode ) { |
|
jQuery.cleanData( [ elem ], true ); |
|
|
|
// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080) |
|
} else if ( jQuery.support.deleteExpando || cache != cache.window ) { |
|
delete cache[ id ]; |
|
|
|
// When all else fails, null |
|
} else { |
|
cache[ id ] = null; |
|
} |
|
}, |
|
|
|
// For internal use only. |
|
_data: function( elem, name, data ) { |
|
return jQuery.data( elem, name, data, true ); |
|
}, |
|
|
|
// A method for determining if a DOM node can handle the data expando |
|
acceptData: function( elem ) { |
|
var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ]; |
|
|
|
// nodes accept data unless otherwise specified; rejection can be conditional |
|
return !noData || noData !== true && elem.getAttribute("classid") === noData; |
|
} |
|
}); |
|
|
|
jQuery.fn.extend({ |
|
data: function( key, value ) { |
|
var parts, part, attr, name, l, |
|
elem = this[0], |
|
i = 0, |
|
data = null; |
|
|
|
// Gets all values |
|
if ( key === undefined ) { |
|
if ( this.length ) { |
|
data = jQuery.data( elem ); |
|
|
|
if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) { |
|
attr = elem.attributes; |
|
for ( l = attr.length; i < l; i++ ) { |
|
name = attr[i].name; |
|
|
|
if ( name.indexOf( "data-" ) === 0 ) { |
|
name = jQuery.camelCase( name.substring(5) ); |
|
|
|
dataAttr( elem, name, data[ name ] ); |
|
} |
|
} |
|
jQuery._data( elem, "parsedAttrs", true ); |
|
} |
|
} |
|
|
|
return data; |
|
} |
|
|
|
// Sets multiple values |
|
if ( typeof key === "object" ) { |
|
return this.each(function() { |
|
jQuery.data( this, key ); |
|
}); |
|
} |
|
|
|
parts = key.split( ".", 2 ); |
|
parts[1] = parts[1] ? "." + parts[1] : ""; |
|
part = parts[1] + "!"; |
|
|
|
return jQuery.access( this, function( value ) { |
|
|
|
if ( value === undefined ) { |
|
data = this.triggerHandler( "getData" + part, [ parts[0] ] ); |
|
|
|
// Try to fetch any internally stored data first |
|
if ( data === undefined && elem ) { |
|
data = jQuery.data( elem, key ); |
|
data = dataAttr( elem, key, data ); |
|
} |
|
|
|
return data === undefined && parts[1] ? |
|
this.data( parts[0] ) : |
|
data; |
|
} |
|
|
|
parts[1] = value; |
|
this.each(function() { |
|
var self = jQuery( this ); |
|
|
|
self.triggerHandler( "setData" + part, parts ); |
|
jQuery.data( this, key, value ); |
|
self.triggerHandler( "changeData" + part, parts ); |
|
}); |
|
}, null, value, arguments.length > 1, null, false ); |
|
}, |
|
|
|
removeData: function( key ) { |
|
return this.each(function() { |
|
jQuery.removeData( this, key ); |
|
}); |
|
} |
|
}); |
|
|
|
function dataAttr( elem, key, data ) { |
|
// If nothing was found internally, try to fetch any |
|
// data from the HTML5 data-* attribute |
|
if ( data === undefined && elem.nodeType === 1 ) { |
|
|
|
var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase(); |
|
|
|
data = elem.getAttribute( name ); |
|
|
|
if ( typeof data === "string" ) { |
|
try { |
|
data = data === "true" ? true : |
|
data === "false" ? false : |
|
data === "null" ? null : |
|
// Only convert to a number if it doesn't change the string |
|
+data + "" === data ? +data : |
|
rbrace.test( data ) ? jQuery.parseJSON( data ) : |
|
data; |
|
} catch( e ) {} |
|
|
|
// Make sure we set the data so it isn't changed later |
|
jQuery.data( elem, key, data ); |
|
|
|
} else { |
|
data = undefined; |
|
} |
|
} |
|
|
|
return data; |
|
} |
|
|
|
// checks a cache object for emptiness |
|
function isEmptyDataObject( obj ) { |
|
var name; |
|
for ( name in obj ) { |
|
|
|
// if the public data object is empty, the private is still empty |
|
if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) { |
|
continue; |
|
} |
|
if ( name !== "toJSON" ) { |
|
return false; |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
jQuery.extend({ |
|
queue: function( elem, type, data ) { |
|
var queue; |
|
|
|
if ( elem ) { |
|
type = ( type || "fx" ) + "queue"; |
|
queue = jQuery._data( elem, type ); |
|
|
|
// Speed up dequeue by getting out quickly if this is just a lookup |
|
if ( data ) { |
|
if ( !queue || jQuery.isArray(data) ) { |
|
queue = jQuery._data( elem, type, jQuery.makeArray(data) ); |
|
} else { |
|
queue.push( data ); |
|
} |
|
} |
|
return queue || []; |
|
} |
|
}, |
|
|
|
dequeue: function( elem, type ) { |
|
type = type || "fx"; |
|
|
|
var queue = jQuery.queue( elem, type ), |
|
fn = queue.shift(), |
|
hooks = jQuery._queueHooks( elem, type ), |
|
next = function() { |
|
jQuery.dequeue( elem, type ); |
|
}; |
|
|
|
// If the fx queue is dequeued, always remove the progress sentinel |
|
if ( fn === "inprogress" ) { |
|
fn = queue.shift(); |
|
} |
|
|
|
if ( fn ) { |
|
|
|
// Add a progress sentinel to prevent the fx queue from being |
|
// automatically dequeued |
|
if ( type === "fx" ) { |
|
queue.unshift( "inprogress" ); |
|
} |
|
|
|
// clear up the last queue stop function |
|
delete hooks.stop; |
|
fn.call( elem, next, hooks ); |
|
} |
|
if ( !queue.length && hooks ) { |
|
hooks.empty.fire(); |
|
} |
|
}, |
|
|
|
// not intended for public consumption - generates a queueHooks object, or returns the current one |
|
_queueHooks: function( elem, type ) { |
|
var key = type + "queueHooks"; |
|
return jQuery._data( elem, key ) || jQuery._data( elem, key, { |
|
empty: jQuery.Callbacks("once memory").add(function() { |
|
jQuery.removeData( elem, type + "queue", true ); |
|
jQuery.removeData( elem, key, true ); |
|
}) |
|
}); |
|
} |
|
}); |
|
|
|
jQuery.fn.extend({ |
|
queue: function( type, data ) { |
|
var setter = 2; |
|
|
|
if ( typeof type !== "string" ) { |
|
data = type; |
|
type = "fx"; |
|
setter--; |
|
} |
|
|
|
if ( arguments.length < setter ) { |
|
return jQuery.queue( this[0], type ); |
|
} |
|
|
|
return data === undefined ? |
|
this : |
|
this.each(function() { |
|
var queue = jQuery.queue( this, type, data ); |
|
|
|
// ensure a hooks for this queue |
|
jQuery._queueHooks( this, type ); |
|
|
|
if ( type === "fx" && queue[0] !== "inprogress" ) { |
|
jQuery.dequeue( this, type ); |
|
} |
|
}); |
|
}, |
|
dequeue: function( type ) { |
|
return this.each(function() { |
|
jQuery.dequeue( this, type ); |
|
}); |
|
}, |
|
// Based off of the plugin by Clint Helfers, with permission. |
|
// http://blindsignals.com/index.php/2009/07/jquery-delay/ |
|
delay: function( time, type ) { |
|
time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; |
|
type = type || "fx"; |
|
|
|
return this.queue( type, function( next, hooks ) { |
|
var timeout = setTimeout( next, time ); |
|
hooks.stop = function() { |
|
clearTimeout( timeout ); |
|
}; |
|
}); |
|
}, |
|
clearQueue: function( type ) { |
|
return this.queue( type || "fx", [] ); |
|
}, |
|
// Get a promise resolved when queues of a certain type |
|
// are emptied (fx is the type by default) |
|
promise: function( type, obj ) { |
|
var tmp, |
|
count = 1, |
|
defer = jQuery.Deferred(), |
|
elements = this, |
|
i = this.length, |
|
resolve = function() { |
|
if ( !( --count ) ) { |
|
defer.resolveWith( elements, [ elements ] ); |
|
} |
|
}; |
|
|
|
if ( typeof type !== "string" ) { |
|
obj = type; |
|
type = undefined; |
|
} |
|
type = type || "fx"; |
|
|
|
while( i-- ) { |
|
if ( (tmp = jQuery._data( elements[ i ], type + "queueHooks" )) && tmp.empty ) { |
|
count++; |
|
tmp.empty.add( resolve ); |
|
} |
|
} |
|
resolve(); |
|
return defer.promise( obj ); |
|
} |
|
}); |
|
var nodeHook, boolHook, fixSpecified, |
|
rclass = /[\t\r\n]/g, |
|
rreturn = /\r/g, |
|
rtype = /^(?:button|input)$/i, |
|
rfocusable = /^(?:button|input|object|select|textarea)$/i, |
|
rclickable = /^a(?:rea|)$/i, |
|
rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, |
|
getSetAttribute = jQuery.support.getSetAttribute; |
|
|
|
jQuery.fn.extend({ |
|
attr: function( name, value ) { |
|
return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 ); |
|
}, |
|
|
|
removeAttr: function( name ) { |
|
return this.each(function() { |
|
jQuery.removeAttr( this, name ); |
|
}); |
|
}, |
|
|
|
prop: function( name, value ) { |
|
return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 ); |
|
}, |
|
|
|
removeProp: function( name ) { |
|
name = jQuery.propFix[ name ] || name; |
|
return this.each(function() { |
|
// try/catch handles cases where IE balks (such as removing a property on window) |
|
try { |
|
this[ name ] = undefined; |
|
delete this[ name ]; |
|
} catch( e ) {} |
|
}); |
|
}, |
|
|
|
addClass: function( value ) { |
|
var classNames, i, l, elem, |
|
setClass, c, cl; |
|
|
|
if ( jQuery.isFunction( value ) ) { |
|
return this.each(function( j ) { |
|
jQuery( this ).addClass( value.call(this, j, this.className) ); |
|
}); |
|
} |
|
|
|
if ( value && typeof value === "string" ) { |
|
classNames = value.split( core_rspace ); |
|
|
|
for ( i = 0, l = this.length; i < l; i++ ) { |
|
elem = this[ i ]; |
|
|
|
if ( elem.nodeType === 1 ) { |
|
if ( !elem.className && classNames.length === 1 ) { |
|
elem.className = value; |
|
|
|
} else { |
|
setClass = " " + elem.className + " "; |
|
|
|
for ( c = 0, cl = classNames.length; c < cl; c++ ) { |
|
if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) { |
|
setClass += classNames[ c ] + " "; |
|
} |
|
} |
|
elem.className = jQuery.trim( setClass ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
return this; |
|
}, |
|
|
|
removeClass: function( value ) { |
|
var removes, className, elem, c, cl, i, l; |
|
|
|
if ( jQuery.isFunction( value ) ) { |
|
return this.each(function( j ) { |
|
jQuery( this ).removeClass( value.call(this, j, this.className) ); |
|
}); |
|
} |
|
if ( (value && typeof value === "string") || value === undefined ) { |
|
removes = ( value || "" ).split( core_rspace ); |
|
|
|
for ( i = 0, l = this.length; i < l; i++ ) { |
|
elem = this[ i ]; |
|
if ( elem.nodeType === 1 && elem.className ) { |
|
|
|
className = (" " + elem.className + " ").replace( rclass, " " ); |
|
|
|
// loop over each item in the removal list |
|
for ( c = 0, cl = removes.length; c < cl; c++ ) { |
|
// Remove until there is nothing to remove, |
|
while ( className.indexOf(" " + removes[ c ] + " ") > -1 ) { |
|
className = className.replace( " " + removes[ c ] + " " , " " ); |
|
} |
|
} |
|
elem.className = value ? jQuery.trim( className ) : ""; |
|
} |
|
} |
|
} |
|
|
|
return this; |
|
}, |
|
|
|
toggleClass: function( value, stateVal ) { |
|
var type = typeof value, |
|
isBool = typeof stateVal === "boolean"; |
|
|
|
if ( jQuery.isFunction( value ) ) { |
|
return this.each(function( i ) { |
|
jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal ); |
|
}); |
|
} |
|
|
|
return this.each(function() { |
|
if ( type === "string" ) { |
|
// toggle individual class names |
|
var className, |
|
i = 0, |
|
self = jQuery( this ), |
|
state = stateVal, |
|
classNames = value.split( core_rspace ); |
|
|
|
while ( (className = classNames[ i++ ]) ) { |
|
// check each className given, space separated list |
|
state = isBool ? state : !self.hasClass( className ); |
|
self[ state ? "addClass" : "removeClass" ]( className ); |
|
} |
|
|
|
} else if ( type === "undefined" || type === "boolean" ) { |
|
if ( this.className ) { |
|
// store className if set |
|
jQuery._data( this, "__className__", this.className ); |
|
} |
|
|
|
// toggle whole className |
|
this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || ""; |
|
} |
|
}); |
|
}, |
|
|
|
hasClass: function( selector ) { |
|
var className = " " + selector + " ", |
|
i = 0, |
|
l = this.length; |
|
for ( ; i < l; i++ ) { |
|
if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) { |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
}, |
|
|
|
val: function( value ) { |
|
var hooks, ret, isFunction, |
|
elem = this[0]; |
|
|
|
if ( !arguments.length ) { |
|
if ( elem ) { |
|
hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ]; |
|
|
|
if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) { |
|
return ret; |
|
} |
|
|
|
ret = elem.value; |
|
|
|
return typeof ret === "string" ? |
|
// handle most common string cases |
|
ret.replace(rreturn, "") : |
|
// handle cases where value is null/undef or number |
|
ret == null ? "" : ret; |
|
} |
|
|
|
return; |
|
} |
|
|
|
isFunction = jQuery.isFunction( value ); |
|
|
|
return this.each(function( i ) { |
|
var val, |
|
self = jQuery(this); |
|
|
|
if ( this.nodeType !== 1 ) { |
|
return; |
|
} |
|
|
|
if ( isFunction ) { |
|
val = value.call( this, i, self.val() ); |
|
} else { |
|
val = value; |
|
} |
|
|
|
// Treat null/undefined as ""; convert numbers to string |
|
if ( val == null ) { |
|
val = ""; |
|
} else if ( typeof val === "number" ) { |
|
val += ""; |
|
} else if ( jQuery.isArray( val ) ) { |
|
val = jQuery.map(val, function ( value ) { |
|
return value == null ? "" : value + ""; |
|
}); |
|
} |
|
|
|
hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; |
|
|
|
// If set returns undefined, fall back to normal setting |
|
if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) { |
|
this.value = val; |
|
} |
|
}); |
|
} |
|
}); |
|
|
|
jQuery.extend({ |
|
valHooks: { |
|
option: { |
|
get: function( elem ) { |
|
// attributes.value is undefined in Blackberry 4.7 but |
|
// uses .value. See #6932 |
|
var val = elem.attributes.value; |
|
return !val || val.specified ? elem.value : elem.text; |
|
} |
|
}, |
|
select: { |
|
get: function( elem ) { |
|
var value, i, max, option, |
|
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 |
|
i = one ? index : 0; |
|
max = one ? index + 1 : options.length; |
|
for ( ; i < max; i++ ) { |
|
option = options[ i ]; |
|
|
|
// Don't return options that are disabled or in a disabled optgroup |
|
if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) && |
|
(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) { |
|
|
|
// Get the specific 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 ); |
|
} |
|
} |
|
|
|
// Fixes Bug #2551 -- select.val() broken in IE after form.reset() |
|
if ( one && !values.length && options.length ) { |
|
return jQuery( options[ index ] ).val(); |
|
} |
|
|
|
return values; |
|
}, |
|
|
|
set: function( elem, value ) { |
|
var values = jQuery.makeArray( value ); |
|
|
|
jQuery(elem).find("option").each(function() { |
|
this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0; |
|
}); |
|
|
|
if ( !values.length ) { |
|
elem.selectedIndex = -1; |
|
} |
|
return values; |
|
} |
|
} |
|
}, |
|
|
|
// Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9 |
|
attrFn: {}, |
|
|
|
attr: function( elem, name, value, pass ) { |
|
var ret, hooks, notxml, |
|
nType = elem.nodeType; |
|
|
|
// don't get/set attributes on text, comment and attribute nodes |
|
if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { |
|
return; |
|
} |
|
|
|
if ( pass && jQuery.isFunction( jQuery.fn[ name ] ) ) { |
|
return jQuery( elem )[ name ]( value ); |
|
} |
|
|
|
// Fallback to prop when attributes are not supported |
|
if ( typeof elem.getAttribute === "undefined" ) { |
|
return jQuery.prop( elem, name, value ); |
|
} |
|
|
|
notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); |
|
|
|
// All attributes are lowercase |
|
// Grab necessary hook if one is defined |
|
if ( notxml ) { |
|
name = name.toLowerCase(); |
|
hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook ); |
|
} |
|
|
|
if ( value !== undefined ) { |
|
|
|
if ( value === null ) { |
|
jQuery.removeAttr( elem, name ); |
|
return; |
|
|
|
} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) { |
|
return ret; |
|
|
|
} else { |
|
elem.setAttribute( name, "" + value ); |
|
return value; |
|
} |
|
|
|
} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) { |
|
return ret; |
|
|
|
} else { |
|
|
|
ret = elem.getAttribute( name ); |
|
|
|
// Non-existent attributes return null, we normalize to undefined |
|
return ret === null ? |
|
undefined : |
|
ret; |
|
} |
|
}, |
|
|
|
removeAttr: function( elem, value ) { |
|
var propName, attrNames, name, isBool, |
|
i = 0; |
|
|
|
if ( value && elem.nodeType === 1 ) { |
|
|
|
attrNames = value.split( core_rspace ); |
|
|
|
for ( ; i < attrNames.length; i++ ) { |
|
name = attrNames[ i ]; |
|
|
|
if ( name ) { |
|
propName = jQuery.propFix[ name ] || name; |
|
isBool = rboolean.test( name ); |
|
|
|
// See #9699 for explanation of this approach (setting first, then removal) |
|
// Do not do this for boolean attributes (see #10870) |
|
if ( !isBool ) { |
|
jQuery.attr( elem, name, "" ); |
|
} |
|
elem.removeAttribute( getSetAttribute ? name : propName ); |
|
|
|
// Set corresponding property to false for boolean attributes |
|
if ( isBool && propName in elem ) { |
|
elem[ propName ] = false; |
|
} |
|
} |
|
} |
|
} |
|
}, |
|
|
|
attrHooks: { |
|
type: { |
|
set: function( elem, value ) { |
|
// We can't allow the type property to be changed (since it causes problems in IE) |
|
if ( rtype.test( elem.nodeName ) && elem.parentNode ) { |
|
jQuery.error( "type property can't be changed" ); |
|
} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) { |
|
// Setting the type on a radio button after the value resets the value in IE6-9 |
|
// Reset value to it's default in case type is set after value |
|
// This is for element creation |
|
var val = elem.value; |
|
elem.setAttribute( "type", value ); |
|
if ( val ) { |
|
elem.value = val; |
|
} |
|
return value; |
|
} |
|
} |
|
}, |
|
// Use the value property for back compat |
|
// Use the nodeHook for button elements in IE6/7 (#1954) |
|
value: { |
|
get: function( elem, name ) { |
|
if ( nodeHook && jQuery.nodeName( elem, "button" ) ) { |
|
return nodeHook.get( elem, name ); |
|
} |
|
return name in elem ? |
|
elem.value : |
|
null; |
|
}, |
|
set: function( elem, value, name ) { |
|
if ( nodeHook && jQuery.nodeName( elem, "button" ) ) { |
|
return nodeHook.set( elem, value, name ); |
|
} |
|
// Does not return so that setAttribute is also used |
|
elem.value = value; |
|
} |
|
} |
|
}, |
|
|
|
propFix: { |
|
tabindex: "tabIndex", |
|
readonly: "readOnly", |
|
"for": "htmlFor", |
|
"class": "className", |
|
maxlength: "maxLength", |
|
cellspacing: "cellSpacing", |
|
cellpadding: "cellPadding", |
|
rowspan: "rowSpan", |
|
colspan: "colSpan", |
|
usemap: "useMap", |
|
frameborder: "frameBorder", |
|
contenteditable: "contentEditable" |
|
}, |
|
|
|
prop: function( elem, name, value ) { |
|
var ret, hooks, notxml, |
|
nType = elem.nodeType; |
|
|
|
// don't get/set properties on text, comment and attribute nodes |
|
if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { |
|
return; |
|
} |
|
|
|
notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); |
|
|
|
if ( notxml ) { |
|
// Fix name and attach hooks |
|
name = jQuery.propFix[ name ] || name; |
|
hooks = jQuery.propHooks[ name ]; |
|
} |
|
|
|
if ( value !== undefined ) { |
|
if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { |
|
return ret; |
|
|
|
} else { |
|
return ( elem[ name ] = value ); |
|
} |
|
|
|
} else { |
|
if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { |
|
return ret; |
|
|
|
} else { |
|
return elem[ name ]; |
|
} |
|
} |
|
}, |
|
|
|
propHooks: { |
|
tabIndex: { |
|
get: function( elem ) { |
|
// 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/ |
|
var attributeNode = elem.getAttributeNode("tabindex"); |
|
|
|
return attributeNode && attributeNode.specified ? |
|
parseInt( attributeNode.value, 10 ) : |
|
rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? |
|
0 : |
|
undefined; |
|
} |
|
} |
|
} |
|
}); |
|
|
|
// Hook for boolean attributes |
|
boolHook = { |
|
get: function( elem, name ) { |
|
// Align boolean attributes with corresponding properties |
|
// Fall back to attribute presence where some booleans are not supported |
|
var attrNode, |
|
property = jQuery.prop( elem, name ); |
|
return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ? |
|
name.toLowerCase() : |
|
undefined; |
|
}, |
|
set: function( elem, value, name ) { |
|
var propName; |
|
if ( value === false ) { |
|
// Remove boolean attributes when set to false |
|
jQuery.removeAttr( elem, name ); |
|
} else { |
|
// value is true since we know at this point it's type boolean and not false |
|
// Set boolean attributes to the same name and set the DOM property |
|
propName = jQuery.propFix[ name ] || name; |
|
if ( propName in elem ) { |
|
// Only set the IDL specifically if it already exists on the element |
|
elem[ propName ] = true; |
|
} |
|
|
|
elem.setAttribute( name, name.toLowerCase() ); |
|
} |
|
return name; |
|
} |
|
}; |
|
|
|
// IE6/7 do not support getting/setting some attributes with get/setAttribute |
|
if ( !getSetAttribute ) { |
|
|
|
fixSpecified = { |
|
name: true, |
|
id: true, |
|
coords: true |
|
}; |
|
|
|
// Use this for any attribute in IE6/7 |
|
// This fixes almost every IE6/7 issue |
|
nodeHook = jQuery.valHooks.button = { |
|
get: function( elem, name ) { |
|
var ret; |
|
ret = elem.getAttributeNode( name ); |
|
return ret && ( fixSpecified[ name ] ? ret.value !== "" : ret.specified ) ? |
|
ret.value : |
|
undefined; |
|
}, |
|
set: function( elem, value, name ) { |
|
// Set the existing or create a new attribute node |
|
var ret = elem.getAttributeNode( name ); |
|
if ( !ret ) { |
|
ret = document.createAttribute( name ); |
|
elem.setAttributeNode( ret ); |
|
} |
|
return ( ret.value = value + "" ); |
|
} |
|
}; |
|
|
|
// Set width and height to auto instead of 0 on empty string( Bug #8150 ) |
|
// This is for removals |
|
jQuery.each([ "width", "height" ], function( i, name ) { |
|
jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { |
|
set: function( elem, value ) { |
|
if ( value === "" ) { |
|
elem.setAttribute( name, "auto" ); |
|
return value; |
|
} |
|
} |
|
}); |
|
}); |
|
|
|
// Set contenteditable to false on removals(#10429) |
|
// Setting to empty string throws an error as an invalid value |
|
jQuery.attrHooks.contenteditable = { |
|
get: nodeHook.get, |
|
set: function( elem, value, name ) { |
|
if ( value === "" ) { |
|
value = "false"; |
|
} |
|
nodeHook.set( elem, value, name ); |
|
} |
|
}; |
|
} |
|
|
|
|
|
// Some attributes require a special call on IE |
|
if ( !jQuery.support.hrefNormalized ) { |
|
jQuery.each([ "href", "src", "width", "height" ], function( i, name ) { |
|
jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], { |
|
get: function( elem ) { |
|
var ret = elem.getAttribute( name, 2 ); |
|
return ret === null ? undefined : ret; |
|
} |
|
}); |
|
}); |
|
} |
|
|
|
if ( !jQuery.support.style ) { |
|
jQuery.attrHooks.style = { |
|
get: function( elem ) { |
|
// Return undefined in the case of empty string |
|
// Normalize to lowercase since IE uppercases css property names |
|
return elem.style.cssText.toLowerCase() || undefined; |
|
}, |
|
set: function( elem, value ) { |
|
return ( elem.style.cssText = "" + value ); |
|
} |
|
}; |
|
} |
|
|
|
// Safari mis-reports the default selected property of an option |
|
// Accessing the parent's selectedIndex property fixes it |
|
if ( !jQuery.support.optSelected ) { |
|
jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, { |
|
get: function( elem ) { |
|
var parent = elem.parentNode; |
|
|
|
if ( parent ) { |
|
parent.selectedIndex; |
|
|
|
// Make sure that it also works with optgroups, see #5701 |
|
if ( parent.parentNode ) { |
|
parent.parentNode.selectedIndex; |
|
} |
|
} |
|
return null; |
|
} |
|
}); |
|
} |
|
|
|
// IE6/7 call enctype encoding |
|
if ( !jQuery.support.enctype ) { |
|
jQuery.propFix.enctype = "encoding"; |
|
} |
|
|
|
// Radios and checkboxes getter/setter |
|
if ( !jQuery.support.checkOn ) { |
|
jQuery.each([ "radio", "checkbox" ], function() { |
|
jQuery.valHooks[ this ] = { |
|
get: function( elem ) { |
|
// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified |
|
return elem.getAttribute("value") === null ? "on" : elem.value; |
|
} |
|
}; |
|
}); |
|
} |
|
jQuery.each([ "radio", "checkbox" ], function() { |
|
jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], { |
|
set: function( elem, value ) { |
|
if ( jQuery.isArray( value ) ) { |
|
return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 ); |
|
} |
|
} |
|
}); |
|
}); |
|
var rformElems = /^(?:textarea|input|select)$/i, |
|
rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/, |
|
rhoverHack = /(?:^|\s)hover(\.\S+|)\b/, |
|
rkeyEvent = /^key/, |
|
rmouseEvent = /^(?:mouse|contextmenu)|click/, |
|
rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, |
|
hoverHack = function( events ) { |
|
return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" ); |
|
}; |
|
|
|
/* |
|
* Helper functions for managing events -- not part of the public interface. |
|
* Props to Dean Edwards' addEvent library for many of the ideas. |
|
*/ |
|
jQuery.event = { |
|
|
|
add: function( elem, types, handler, data, selector ) { |
|
|
|
var elemData, eventHandle, events, |
|
t, tns, type, namespaces, handleObj, |
|
handleObjIn, handlers, special; |
|
|
|
// Don't attach events to noData or text/comment nodes (allow plain objects tho) |
|
if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) { |
|
return; |
|
} |
|
|
|
// Caller can pass in an object of custom data in lieu of the handler |
|
if ( handler.handler ) { |
|
handleObjIn = handler; |
|
handler = handleObjIn.handler; |
|
selector = handleObjIn.selector; |
|
} |
|
|
|
// Make sure that the handler has a unique ID, used to find/remove it later |
|
if ( !handler.guid ) { |
|
handler.guid = jQuery.guid++; |
|
} |
|
|
|
// Init the element's event structure and main handler, if this is the first |
|
events = elemData.events; |
|
if ( !events ) { |
|
elemData.events = events = {}; |
|
} |
|
eventHandle = elemData.handle; |
|
if ( !eventHandle ) { |
|
elemData.handle = eventHandle = function( e ) { |
|
// Discard the second event of a jQuery.event.trigger() and |
|
// when an event is called after a page has unloaded |
|
return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ? |
|
jQuery.event.dispatch.apply( eventHandle.elem, arguments ) : |
|
undefined; |
|
}; |
|
// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events |
|
eventHandle.elem = elem; |
|
} |
|
|
|
// Handle multiple events separated by a space |
|
// jQuery(...).bind("mouseover mouseout", fn); |
|
types = jQuery.trim( hoverHack(types) ).split( " " ); |
|
for ( t = 0; t < types.length; t++ ) { |
|
|
|
tns = rtypenamespace.exec( types[t] ) || []; |
|
type = tns[1]; |
|
namespaces = ( tns[2] || "" ).split( "." ).sort(); |
|
|
|
// If event changes its type, use the special event handlers for the changed type |
|
special = jQuery.event.special[ type ] || {}; |
|
|
|
// If selector defined, determine special event api type, otherwise given type |
|
type = ( selector ? special.delegateType : special.bindType ) || type; |
|
|
|
// Update special based on newly reset type |
|
special = jQuery.event.special[ type ] || {}; |
|
|
|
// handleObj is passed to all event handlers |
|
handleObj = jQuery.extend({ |
|
type: type, |
|
origType: tns[1], |
|
data: data, |
|
handler: handler, |
|
guid: handler.guid, |
|
selector: selector, |
|
namespace: namespaces.join(".") |
|
}, handleObjIn ); |
|
|
|
// Init the event handler queue if we're the first |
|
handlers = events[ type ]; |
|
if ( !handlers ) { |
|
handlers = events[ type ] = []; |
|
handlers.delegateCount = 0; |
|
|
|
// Only use addEventListener/attachEvent if the special events handler returns false |
|
if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { |
|
// Bind the global event handler to the element |
|
if ( elem.addEventListener ) { |
|
elem.addEventListener( type, eventHandle, false ); |
|
|
|
} else if ( elem.attachEvent ) { |
|
elem.attachEvent( "on" + type, eventHandle ); |
|
} |
|
} |
|
} |
|
|
|
if ( special.add ) { |
|
special.add.call( elem, handleObj ); |
|
|
|
if ( !handleObj.handler.guid ) { |
|
handleObj.handler.guid = handler.guid; |
|
} |
|
} |
|
|
|
// Add to the element's handler list, delegates in front |
|
if ( selector ) { |
|
handlers.splice( handlers.delegateCount++, 0, handleObj ); |
|
} else { |
|
handlers.push( handleObj ); |
|
} |
|
|
|
// Keep track of which events have ever been used, for event optimization |
|
jQuery.event.global[ type ] = true; |
|
} |
|
|
|
// Nullify elem to prevent memory leaks in IE |
|
elem = null; |
|
}, |
|
|
|
global: {}, |
|
|
|
// Detach an event or set of events from an element |
|
remove: function( elem, types, handler, selector, mappedTypes ) { |
|
|
|
var t, tns, type, origType, namespaces, origCount, |
|
j, events, special, eventType, handleObj, |
|
elemData = jQuery.hasData( elem ) && jQuery._data( elem ); |
|
|
|
if ( !elemData || !(events = elemData.events) ) { |
|
return; |
|
} |
|
|
|
// Once for each type.namespace in types; type may be omitted |
|
types = jQuery.trim( hoverHack( types || "" ) ).split(" "); |
|
for ( t = 0; t < types.length; t++ ) { |
|
tns = rtypenamespace.exec( types[t] ) || []; |
|
type = origType = tns[1]; |
|
namespaces = tns[2]; |
|
|
|
// Unbind all events (on this namespace, if provided) for the element |
|
if ( !type ) { |
|
for ( type in events ) { |
|
jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); |
|
} |
|
continue; |
|
} |
|
|
|
special = jQuery.event.special[ type ] || {}; |
|
type = ( selector? special.delegateType : special.bindType ) || type; |
|
eventType = events[ type ] || []; |
|
origCount = eventType.length; |
|
namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null; |
|
|
|
// Remove matching events |
|
for ( j = 0; j < eventType.length; j++ ) { |
|
handleObj = eventType[ j ]; |
|
|
|
if ( ( mappedTypes || origType === handleObj.origType ) && |
|
( !handler || handler.guid === handleObj.guid ) && |
|
( !namespaces || namespaces.test( handleObj.namespace ) ) && |
|
( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { |
|
eventType.splice( j--, 1 ); |
|
|
|
if ( handleObj.selector ) { |
|
eventType.delegateCount--; |
|
} |
|
if ( special.remove ) { |
|
special.remove.call( elem, handleObj ); |
|
} |
|
} |
|
} |
|
|
|
// Remove generic event handler if we removed something and no more handlers exist |
|
// (avoids potential for endless recursion during removal of special event handlers) |
|
if ( eventType.length === 0 && origCount !== eventType.length ) { |
|
if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) { |
|
jQuery.removeEvent( elem, type, elemData.handle ); |
|
} |
|
|
|
delete events[ type ]; |
|
} |
|
} |
|
|
|
// Remove the expando if it's no longer used |
|
if ( jQuery.isEmptyObject( events ) ) { |
|
delete elemData.handle; |
|
|
|
// removeData also checks for emptiness and clears the expando if empty |
|
// so use it instead of delete |
|
jQuery.removeData( elem, "events", true ); |
|
} |
|
}, |
|
|
|
// Events that are safe to short-circuit if no handlers are attached. |
|
// Native DOM events should not be added, they may have inline handlers. |
|
customEvent: { |
|
"getData": true, |
|
"setData": true, |
|
"changeData": true |
|
}, |
|
|
|
trigger: function( event, data, elem, onlyHandlers ) { |
|
// Don't do events on text and comment nodes |
|
if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) { |
|
return; |
|
} |
|
|
|
// Event object or event type |
|
var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType, |
|
type = event.type || event, |
|
namespaces = []; |
|
|
|
// focus/blur morphs to focusin/out; ensure we're not firing them right now |
|
if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { |
|
return; |
|
} |
|
|
|
if ( type.indexOf( "!" ) >= 0 ) { |
|
// Exclusive events trigger only for the exact event (no namespaces) |
|
type = type.slice(0, -1); |
|
exclusive = true; |
|
} |
|
|
|
if ( type.indexOf( "." ) >= 0 ) { |
|
// Namespaced trigger; create a regexp to match event type in handle() |
|
namespaces = type.split("."); |
|
type = namespaces.shift(); |
|
namespaces.sort(); |
|
} |
|
|
|
if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) { |
|
// No jQuery handlers for this event type, and it can't have inline handlers |
|
return; |
|
} |
|
|
|
// Caller can pass in an Event, Object, or just an event type string |
|
event = typeof event === "object" ? |
|
// jQuery.Event object |
|
event[ jQuery.expando ] ? event : |
|
// Object literal |
|
new jQuery.Event( type, event ) : |
|
// Just the event type (string) |
|
new jQuery.Event( type ); |
|
|
|
event.type = type; |
|
event.isTrigger = true; |
|
event.exclusive = exclusive; |
|
event.namespace = namespaces.join( "." ); |
|
event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null; |
|
ontype = type.indexOf( ":" ) < 0 ? "on" + type : ""; |
|
|
|
// Handle a global trigger |
|
if ( !elem ) { |
|
|
|
// TODO: Stop taunting the data cache; remove global events and always attach to document |
|
cache = jQuery.cache; |
|
for ( i in cache ) { |
|
if ( cache[ i ].events && cache[ i ].events[ type ] ) { |
|
jQuery.event.trigger( event, data, cache[ i ].handle.elem, true ); |
|
} |
|
} |
|
return; |
|
} |
|
|
|
// Clean up the event in case it is being reused |
|
event.result = undefined; |
|
if ( !event.target ) { |
|
event.target = elem; |
|
} |
|
|
|
// Clone any incoming data and prepend the event, creating the handler arg list |
|
data = data != null ? jQuery.makeArray( data ) : []; |
|
data.unshift( event ); |
|
|
|
// Allow special events to draw outside the lines |
|
special = jQuery.event.special[ type ] || {}; |
|
if ( special.trigger && special.trigger.apply( elem, data ) === false ) { |
|
return; |
|
} |
|
|
|
// Determine event propagation path in advance, per W3C events spec (#9951) |
|
// Bubble up to document, then to window; watch for a global ownerDocument var (#9724) |
|
eventPath = [[ elem, special.bindType || type ]]; |
|
if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { |
|
|
|
bubbleType = special.delegateType || type; |
|
cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode; |
|
for ( old = elem; cur; cur = cur.parentNode ) { |
|
eventPath.push([ cur, bubbleType ]); |
|
old = cur; |
|
} |
|
|
|
// Only add window if we got to document (e.g., not plain obj or detached DOM) |
|
if ( old === (elem.ownerDocument || document) ) { |
|
eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]); |
|
} |
|
} |
|
|
|
// Fire handlers on the event path |
|
for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) { |
|
|
|
cur = eventPath[i][0]; |
|
event.type = eventPath[i][1]; |
|
|
|
handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" ); |
|
if ( handle ) { |
|
handle.apply( cur, data ); |
|
} |
|
// Note that this is a bare JS function and not a jQuery handler |
|
handle = ontype && cur[ ontype ]; |
|
if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) { |
|
event.preventDefault(); |
|
} |
|
} |
|
event.type = type; |
|
|
|
// If nobody prevented the default action, do it now |
|
if ( !onlyHandlers && !event.isDefaultPrevented() ) { |
|
|
|
if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) && |
|
!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) { |
|
|
|
// Call a native DOM method on the target with the same name name as the event. |
|
// Can't use an .isFunction() check here because IE6/7 fails that test. |
|
// Don't do default actions on window, that's where global variables be (#6170) |
|
// IE<9 dies on focus/blur to hidden element (#1486) |
|
if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) { |
|
|
|
// Don't re-trigger an onFOO event when we call its FOO() method |
|
old = elem[ ontype ]; |
|
|
|
if ( old ) { |
|
elem[ ontype ] = null; |
|
} |
|
|
|
// Prevent re-triggering of the same event, since we already bubbled it above |
|
jQuery.event.triggered = type; |
|
elem[ type ](); |
|
jQuery.event.triggered = undefined; |
|
|
|
if ( old ) { |
|
elem[ ontype ] = old; |
|
} |
|
} |
|
} |
|
} |
|
|
|
return event.result; |
|
}, |
|
|
|
dispatch: function( event ) { |
|
|
|
// Make a writable jQuery.Event from the native event object |
|
event = jQuery.event.fix( event || window.event ); |
|
|
|
var i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related, |
|
handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []), |
|
delegateCount = handlers.delegateCount, |
|
args = [].slice.call( arguments ), |
|
run_all = !event.exclusive && !event.namespace, |
|
special = jQuery.event.special[ event.type ] || {}, |
|
handlerQueue = []; |
|
|
|
// Use the fix-ed jQuery.Event rather than the (read-only) native event |
|
args[0] = event; |
|
event.delegateTarget = this; |
|
|
|
// Call the preDispatch hook for the mapped type, and let it bail if desired |
|
if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { |
|
return; |
|
} |
|
|
|
// Determine handlers that should run if there are delegated events |
|
// Avoid non-left-click bubbling in Firefox (#3861) |
|
if ( delegateCount && !(event.button && event.type === "click") ) { |
|
|
|
// Pregenerate a single jQuery object for reuse with .is() |
|
jqcur = jQuery(this); |
|
jqcur.context = this; |
|
|
|
for ( cur = event.target; cur != this; cur = cur.parentNode || this ) { |
|
|
|
// Don't process clicks (ONLY) on disabled elements (#6911, #8165, #xxxx) |
|
if ( cur.disabled !== true || event.type !== "click" ) { |
|
selMatch = {}; |
|
matches = []; |
|
jqcur[0] = cur; |
|
for ( i = 0; i < delegateCount; i++ ) { |
|
handleObj = handlers[ i ]; |
|
sel = handleObj.selector; |
|
|
|
if ( selMatch[ sel ] === undefined ) { |
|
selMatch[ sel ] = jqcur.is( sel ); |
|
} |
|
if ( selMatch[ sel ] ) { |
|
matches.push( handleObj ); |
|
} |
|
} |
|
if ( matches.length ) { |
|
handlerQueue.push({ elem: cur, matches: matches }); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Add the remaining (directly-bound) handlers |
|
if ( handlers.length > delegateCount ) { |
|
handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) }); |
|
} |
|
|
|
// Run delegates first; they may want to stop propagation beneath us |
|
for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) { |
|
matched = handlerQueue[ i ]; |
|
event.currentTarget = matched.elem; |
|
|
|
for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) { |
