~ubuntu-branches/ubuntu/trusty/varnish/trusty-proposed
» Revision
35
: doc/sphinx/=build/html/_static/jquery.js
« back to all changes in this revision
Viewing changes to doc/sphinx/=build/html/_static/jquery.js
- browse files at revision 35
- compare with another revision
- download diff
- download tarball
- view history from revision 35
- Committer: Package Import Robot
- Author(s): Stig Sandbeck Mathisen, Stig Sandbeck Mathisen, Tollef Fog Heen
- Date: 2013-05-05 15:53:14 UTC
- mfrom: (0.1.16)
- Revision ID: package-import@ubuntu.com-20130505155314-i99wuol99cfwzrtv
Tags: 3.0.3-1
[ Stig Sandbeck Mathisen ]
* New upstream release
[ Tollef Fog Heen ]
* Make varnishlog's and varnishncsa's init script exit with the exit
status of status_of_proc to make them useful. Fixes upstream trac
#1226.
[ Stig Sandbeck Mathisen ]
* Do not rewrite /etc/default/varnish on upgrade.
Thanks to Andreas Beckmann <anbe@debian.org> (Closes: 698577)
* Undo mangling of /etc/default/varnish that happened during lenny->squeeze
upgrade.
Thanks to Andreas Beckmann <anbe@debian.org> (Closes: 698577)
* New upstream release
[ Tollef Fog Heen ]
* Make varnishlog's and varnishncsa's init script exit with the exit
status of status_of_proc to make them useful. Fixes upstream trac
#1226.
[ Stig Sandbeck Mathisen ]
* Do not rewrite /etc/default/varnish on upgrade.
Thanks to Andreas Beckmann <anbe@debian.org> (Closes: 698577)
* Undo mangling of /etc/default/varnish that happened during lenny->squeeze
upgrade.
Thanks to Andreas Beckmann <anbe@debian.org> (Closes: 698577)
- files added:
- .pc
- files removed:
- debian/libvarnishapi-dev.dirs
- files modified:
- Makefile.in
added
removed
doc/sphinx/=build/html/_static/jquery.js
1
1
/*!
2
* jQuery JavaScript Library v1.6.4
2
* jQuery JavaScript Library v1.7.1
3
3
* http://jquery.com/
4
4
*
5
5
* Copyright 2011, John Resig
11
11
* Copyright 2011, The Dojo Foundation
12
12
* Released under the MIT, BSD, and GPL Licenses.
13
13
*
14
* Date: Mon Sep 12 18:54:48 2011 -0400
14
* Date: Mon Nov 21 21:11:03 2011 -0500
15
15
*/
16
16
(function( window, undefined ) {
17
17
47
47
trimLeft = /^\s+/,
48
48
trimRight = /\s+$/,
49
49
50
// Check for digits
51
rdigit = /\d/,
52
53
50
// Match a standalone tag
54
51
rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
55
52
140
137
// HANDLE: $(html) -> $(array)
141
138
if ( match[1] ) {
142
139
context = context instanceof jQuery ? context[0] : context;
143
doc = (context ? context.ownerDocument || context : document);
140
doc = ( context ? context.ownerDocument || context : document );
144
141
145
142
// If a single string is passed in and it's a single tag
146
143
// just do a createElement and skip the rest
157
154
158
155
} else {
159
156
ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
160
selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
157
selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
161
158
}
162
159
163
160
return jQuery.merge( this, selector );
187
184
188
185
// HANDLE: $(expr, $(...))
189
186
} else if ( !context || context.jquery ) {
190
return (context || rootjQuery).find( selector );
187
return ( context || rootjQuery ).find( selector );
191
188
192
189
// HANDLE: $(expr, context)
193
190
// (which is just equivalent to: $(context).find(expr)
201
198
return rootjQuery.ready( selector );
202
199
}
203
200
204
if (selector.selector !== undefined) {
201
if ( selector.selector !== undefined ) {
205
202
this.selector = selector.selector;
206
203
this.context = selector.context;
207
204
}
213
210
selector: "",
214
211
215
212
// The current version of jQuery being used
216
jquery: "1.6.4",
213
jquery: "1.7.1",
217
214
218
215
// The default length of a jQuery object is 0
219
216
length: 0,
258
255
ret.context = this.context;
259
256
260
257
if ( name === "find" ) {
261
ret.selector = this.selector + (this.selector ? " " : "") + selector;
258
ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
262
259
} else if ( name ) {
263
260
ret.selector = this.selector + "." + name + "(" + selector + ")";
264
261
}
279
276
jQuery.bindReady();
280
277
281
278
// Add the callback
282
readyList.done( fn );
279
readyList.add( fn );
283
280
284
281
return this;
285
282
},
286
283
287
284
eq: function( i ) {
285
i = +i;
288
286
return i === -1 ?
289
287
this.slice( i ) :
290
this.slice( i, +i + 1 );
288
this.slice( i, i + 1 );
291
289
},
292
290
293
291
first: function() {
434
432
}
435
433
436
434
// If there are functions bound, to execute
437
readyList.resolveWith( document, [ jQuery ] );
435
readyList.fireWith( document, [ jQuery ] );
438
436
439
437
// Trigger any bound ready events
440
438
if ( jQuery.fn.trigger ) {
441
jQuery( document ).trigger( "ready" ).unbind( "ready" );
439
jQuery( document ).trigger( "ready" ).off( "ready" );
442
440
}
443
441
}
444
442
},
448
446
return;
449
447
}
450
448
451
readyList = jQuery._Deferred();
449
readyList = jQuery.Callbacks( "once memory" );
452
450
453
451
// Catch cases where $(document).ready() is called after the
454
452
// browser event has already occurred.
504
502
return obj && typeof obj === "object" && "setInterval" in obj;
505
503
},
506
504
507
isNaN: function( obj ) {
508
return obj == null || !rdigit.test( obj ) || isNaN( obj );
505
isNumeric: function( obj ) {
506
return !isNaN( parseFloat(obj) ) && isFinite( obj );
509
507
},
510
508
511
509
type: function( obj ) {
551
549
},
552
550
553
551
error: function( msg ) {
554
throw msg;
552
throw new Error( msg );
555
553
},
556
554
557
555
parseJSON: function( data ) {
573
571
.replace( rvalidtokens, "]" )
574
572
.replace( rvalidbraces, "")) ) {
575
573
576
return (new Function( "return " + data ))();
574
return ( new Function( "return " + data ) )();
577
575
578
576
}
579
577
jQuery.error( "Invalid JSON: " + data );
688
686
689
687
if ( array != null ) {
690
688
// The window, strings (and functions) also have 'length'
691
// The extra typeof function check is to prevent crashes
692
// in Safari 2 (See: #3039)
693
689
// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
694
690
var type = jQuery.type( array );
695
691
703
699
return ret;
704
700
},
705
701
706
inArray: function( elem, array ) {
707
if ( !array ) {
708
return -1;
709
}
710
711
if ( indexOf ) {
712
return indexOf.call( array, elem );
713
}
714
715
for ( var i = 0, length = array.length; i < length; i++ ) {
716
if ( array[ i ] === elem ) {
717
return i;
702
inArray: function( elem, array, i ) {
703
var len;
704
705
if ( array ) {
706
if ( indexOf ) {
707
return indexOf.call( array, elem, i );
708
}
709
710
len = array.length;
711
i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
712
713
for ( ; i < len; i++ ) {
714
// Skip accessing in sparse arrays
715
if ( i in array && array[ i ] === elem ) {
716
return i;
717
}
718
718
}
719
719
}
720
720
850
850
},
851
851
852
852
now: function() {
853
return (new Date()).getTime();
853
return ( new Date() ).getTime();
854
854
},
855
855
856
856
// Use of jQuery.browser is frowned upon.
957
957
})();
958
958
959
959
960
var // Promise methods
961
promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
962
// Static reference to slice
960
// String to Object flags format cache
961
var flagsCache = {};
962
963
// Convert String-formatted flags into Object-formatted ones and store in cache
964
function createFlags( flags ) {
965
var object = flagsCache[ flags ] = {},
966
i, length;
967
flags = flags.split( /\s+/ );
968
for ( i = 0, length = flags.length; i < length; i++ ) {
969
object[ flags[i] ] = true;
970
}
971
return object;
972
}
973
974
/*
975
* Create a callback list using the following parameters:
976
*
977
* flags: an optional list of space-separated flags that will change how
978
* the callback list behaves
979
*
980
* By default a callback list will act like an event callback list and can be
981
* "fired" multiple times.
982
*
983
* Possible flags:
984
*
985
* once: will ensure the callback list can only be fired once (like a Deferred)
986
*
987
* memory: will keep track of previous values and will call any callback added
988
* after the list has been fired right away with the latest "memorized"
989
* values (like a Deferred)
990
*
991
* unique: will ensure a callback can only be added once (no duplicate in the list)
992
*
993
* stopOnFalse: interrupt callings when a callback returns false
994
*
995
*/
996
jQuery.Callbacks = function( flags ) {
997
998
// Convert flags from String-formatted to Object-formatted
999
// (we check in cache first)
1000
flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};
1001
1002
var // Actual callback list
1003
list = [],
1004
// Stack of fire calls for repeatable lists
1005
stack = [],
1006
// Last fire value (for non-forgettable lists)
1007
memory,
1008
// Flag to know if list is currently firing
1009
firing,
1010
// First callback to fire (used internally by add and fireWith)
1011
firingStart,
1012
// End of the loop when firing
1013
firingLength,
1014
// Index of currently firing callback (modified by remove if needed)
1015
firingIndex,
1016
// Add one or several callbacks to the list
1017
add = function( args ) {
1018
var i,
1019
length,
1020
elem,
1021
type,
1022
actual;
1023
for ( i = 0, length = args.length; i < length; i++ ) {
1024
elem = args[ i ];
1025
type = jQuery.type( elem );
1026
if ( type === "array" ) {
1027
// Inspect recursively
1028
add( elem );
1029
} else if ( type === "function" ) {
1030
// Add if not in unique mode and callback is not in
1031
if ( !flags.unique || !self.has( elem ) ) {
1032
list.push( elem );
1033
}
1034
}
1035
}
1036
},
1037
// Fire callbacks
1038
fire = function( context, args ) {
1039
args = args || [];
1040
memory = !flags.memory || [ context, args ];
1041
firing = true;
1042
firingIndex = firingStart || 0;
1043
firingStart = 0;
1044
firingLength = list.length;
1045
for ( ; list && firingIndex < firingLength; firingIndex++ ) {
1046
if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
1047
memory = true; // Mark as halted
1048
break;
1049
}
1050
}
1051
firing = false;
1052
if ( list ) {
1053
if ( !flags.once ) {
1054
if ( stack && stack.length ) {
1055
memory = stack.shift();
1056
self.fireWith( memory[ 0 ], memory[ 1 ] );
1057
}
1058
} else if ( memory === true ) {
1059
self.disable();
1060
} else {
1061
list = [];
1062
}
1063
}
1064
},
1065
// Actual Callbacks object
1066
self = {
1067
// Add a callback or a collection of callbacks to the list
1068
add: function() {
1069
if ( list ) {
1070
var length = list.length;
1071
add( arguments );
1072
// Do we need to add the callbacks to the
1073
// current firing batch?
1074
if ( firing ) {
1075
firingLength = list.length;
1076
// With memory, if we're not firing then
1077
// we should call right away, unless previous
1078
// firing was halted (stopOnFalse)
1079
} else if ( memory && memory !== true ) {
1080
firingStart = length;
1081
fire( memory[ 0 ], memory[ 1 ] );
1082
}
1083
}
1084
return this;
1085
},
1086
// Remove a callback from the list
1087
remove: function() {
1088
if ( list ) {
1089
var args = arguments,
1090
argIndex = 0,
1091
argLength = args.length;
1092
for ( ; argIndex < argLength ; argIndex++ ) {
1093
for ( var i = 0; i < list.length; i++ ) {
1094
if ( args[ argIndex ] === list[ i ] ) {
1095
// Handle firingIndex and firingLength
1096
if ( firing ) {
1097
if ( i <= firingLength ) {
1098
firingLength--;
1099
if ( i <= firingIndex ) {
1100
firingIndex--;
1101
}
1102
}
1103
}
1104
// Remove the element
1105
list.splice( i--, 1 );
1106
// If we have some unicity property then
1107
// we only need to do this once
1108
if ( flags.unique ) {
1109
break;
1110
}
1111
}
1112
}
1113
}
1114
}
1115
return this;
1116
},
1117
// Control if a given callback is in the list
1118
has: function( fn ) {
1119
if ( list ) {
1120
var i = 0,
1121
length = list.length;
1122
for ( ; i < length; i++ ) {
1123
if ( fn === list[ i ] ) {
1124
return true;
1125
}
1126
}
1127
}
1128
return false;
1129
},
1130
// Remove all callbacks from the list
1131
empty: function() {
1132
list = [];
1133
return this;
1134
},
1135
// Have the list do nothing anymore
1136
disable: function() {
1137
list = stack = memory = undefined;
1138
return this;
1139
},
1140
// Is it disabled?
1141
disabled: function() {
1142
return !list;
1143
},
1144
// Lock the list in its current state
1145
lock: function() {
1146
stack = undefined;
1147
if ( !memory || memory === true ) {
1148
self.disable();
1149
}
1150
return this;
1151
},
1152
// Is it locked?
1153
locked: function() {
1154
return !stack;
1155
},
1156
// Call all callbacks with the given context and arguments
1157
fireWith: function( context, args ) {
1158
if ( stack ) {
1159
if ( firing ) {
1160
if ( !flags.once ) {
1161
stack.push( [ context, args ] );
1162
}
1163
} else if ( !( flags.once && memory ) ) {
1164
fire( context, args );
1165
}
1166
}
1167
return this;
1168
},
1169
// Call all the callbacks with the given arguments
1170
fire: function() {
1171
self.fireWith( this, arguments );
1172
return this;
1173
},
1174
// To know if the callbacks have already been called at least once
1175
fired: function() {
1176
return !!memory;
1177
}
1178
};
1179
1180
return self;
1181
};
1182
1183
1184
1185
1186
var // Static reference to slice
963
1187
sliceDeferred = [].slice;
964
1188
965
1189
jQuery.extend({
966
// Create a simple deferred (one callbacks list)
967
_Deferred: function() {
968
var // callbacks list
969
callbacks = [],
970
// stored [ context , args ]
971
fired,
972
// to avoid firing when already doing so
973
firing,
974
// flag to know if the deferred has been cancelled
975
cancelled,
976
// the deferred itself
977
deferred = {
978
979
// done( f1, f2, ...)
980
done: function() {
981
if ( !cancelled ) {
982
var args = arguments,
983
i,
984
length,
985
elem,
986
type,
987
_fired;
988
if ( fired ) {
989
_fired = fired;
990
fired = 0;
991
}
992
for ( i = 0, length = args.length; i < length; i++ ) {
993
elem = args[ i ];
994
type = jQuery.type( elem );
995
if ( type === "array" ) {
996
deferred.done.apply( deferred, elem );
997
} else if ( type === "function" ) {
998
callbacks.push( elem );
999
}
1000
}
1001
if ( _fired ) {
1002
deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
1003
}
1004
}
1005
return this;
1006
},
1007
1008
// resolve with given context and args
1009
resolveWith: function( context, args ) {
1010
if ( !cancelled && !fired && !firing ) {
1011
// make sure args are available (#8421)
1012
args = args || [];
1013
firing = 1;
1014
try {
1015
while( callbacks[ 0 ] ) {
1016
callbacks.shift().apply( context, args );
1017
}
1018
}
1019
finally {
1020
fired = [ context, args ];
1021
firing = 0;
1022
}
1023
}
1024
return this;
1025
},
1026
1027
// resolve with this as context and given arguments
1028
resolve: function() {
1029
deferred.resolveWith( this, arguments );
1030
return this;
1031
},
1032
1033
// Has this deferred been resolved?
1034
isResolved: function() {
1035
return !!( firing || fired );
1036
},
1037
1038
// Cancel
1039
cancel: function() {
1040
cancelled = 1;
1041
callbacks = [];
1042
return this;
1043
}
1044
};
1045
1046
return deferred;
1047
},
1048
1049
// Full fledged deferred (two callbacks list)
1190
1050
1191
Deferred: function( func ) {
1051
var deferred = jQuery._Deferred(),
1052
failDeferred = jQuery._Deferred(),
1053
promise;
1054
// Add errorDeferred methods, then and promise
1055
jQuery.extend( deferred, {
1056
then: function( doneCallbacks, failCallbacks ) {
1057
deferred.done( doneCallbacks ).fail( failCallbacks );
1058
return this;
1059
},
1060
always: function() {
1061
return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
1062
},
1063
fail: failDeferred.done,
1064
rejectWith: failDeferred.resolveWith,
1065
reject: failDeferred.resolve,
1066
isRejected: failDeferred.isResolved,
1067
pipe: function( fnDone, fnFail ) {
1068
return jQuery.Deferred(function( newDefer ) {
1069
jQuery.each( {
1070
done: [ fnDone, "resolve" ],
1071
fail: [ fnFail, "reject" ]
1072
}, function( handler, data ) {
1073
var fn = data[ 0 ],
1074
action = data[ 1 ],
1075
returned;
1076
if ( jQuery.isFunction( fn ) ) {
1077
deferred[ handler ](function() {
1078
returned = fn.apply( this, arguments );
1079
if ( returned && jQuery.isFunction( returned.promise ) ) {
1080
returned.promise().then( newDefer.resolve, newDefer.reject );
1081
} else {
1082
newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1083
}
1084
});
1085
} else {
1086
deferred[ handler ]( newDefer[ action ] );
1192
var doneList = jQuery.Callbacks( "once memory" ),
1193
failList = jQuery.Callbacks( "once memory" ),
1194
progressList = jQuery.Callbacks( "memory" ),
1195
state = "pending",
1196
lists = {
1197
resolve: doneList,
1198
reject: failList,
1199
notify: progressList
1200
},
1201
promise = {
1202
done: doneList.add,
1203
fail: failList.add,
1204
progress: progressList.add,
1205
1206
state: function() {
1207
return state;
1208
},
1209
1210
// Deprecated
1211
isResolved: doneList.fired,
1212
isRejected: failList.fired,
1213
1214
then: function( doneCallbacks, failCallbacks, progressCallbacks ) {
1215
deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks );
1216
return this;
1217
},
1218
always: function() {
1219
deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
1220
return this;
1221
},
1222
pipe: function( fnDone, fnFail, fnProgress ) {
1223
return jQuery.Deferred(function( newDefer ) {
1224
jQuery.each( {
1225
done: [ fnDone, "resolve" ],
1226
fail: [ fnFail, "reject" ],
1227
progress: [ fnProgress, "notify" ]
1228
}, function( handler, data ) {
1229
var fn = data[ 0 ],
1230
action = data[ 1 ],
1231
returned;
1232
if ( jQuery.isFunction( fn ) ) {
1233
deferred[ handler ](function() {
1234
returned = fn.apply( this, arguments );
1235
if ( returned && jQuery.isFunction( returned.promise ) ) {
1236
returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify );
1237
} else {
1238
newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
1239
}
1240
});
1241
} else {
1242
deferred[ handler ]( newDefer[ action ] );
1243
}
1244
});
1245
}).promise();
1246
},
1247
// Get a promise for this deferred
1248
// If obj is provided, the promise aspect is added to the object
1249
promise: function( obj ) {
1250
if ( obj == null ) {
1251
obj = promise;
1252
} else {
1253
for ( var key in promise ) {
1254
obj[ key ] = promise[ key ];
1087
1255
}
1088
});
1089
}).promise();
1090
},
1091
// Get a promise for this deferred
1092
// If obj is provided, the promise aspect is added to the object
1093
promise: function( obj ) {
1094
if ( obj == null ) {
1095
if ( promise ) {
1096
return promise;
1097
1256
}
1098
promise = obj = {};
1099
}
1100
var i = promiseMethods.length;
1101
while( i-- ) {
1102
obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
1103
}
1104
return obj;
1105
}
1106
});
1107
// Make sure only one callback list will be used
1108
deferred.done( failDeferred.cancel ).fail( deferred.cancel );
1109
// Unexpose cancel
1110
delete deferred.cancel;
1257
return obj;
1258
}
1259
},
1260
deferred = promise.promise({}),
1261
key;
1262
1263
for ( key in lists ) {
1264
deferred[ key ] = lists[ key ].fire;
1265
deferred[ key + "With" ] = lists[ key ].fireWith;
1266
}
1267
1268
// Handle state
1269
deferred.done( function() {
1270
state = "resolved";
1271
}, failList.disable, progressList.lock ).fail( function() {
1272
state = "rejected";
1273
}, doneList.disable, progressList.lock );
1274
1111
1275
// Call given func if any
1112
1276
if ( func ) {
1113
1277
func.call( deferred, deferred );
1114
1278
}
1279
1280
// All done!
1115
1281
return deferred;
1116
1282
},
1117
1283
1118
1284
// Deferred helper
1119
1285
when: function( firstParam ) {
1120
var args = arguments,
1286
var args = sliceDeferred.call( arguments, 0 ),
1121
1287
i = 0,
1122
1288
length = args.length,
1289
pValues = new Array( length ),
1123
1290
count = length,
1291
pCount = length,
1124
1292
deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1125
1293
firstParam :
1126
jQuery.Deferred();
1294
jQuery.Deferred(),
1295
promise = deferred.promise();
1127
1296
function resolveFunc( i ) {
1128
1297
return function( value ) {
1129
1298
args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1130
1299
if ( !( --count ) ) {
1131
// Strange bug in FF4:
1132
// Values changed onto the arguments object sometimes end up as undefined values
1133
// outside the $.when method. Cloning the object into a fresh array solves the issue
1134
deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
1300
deferred.resolveWith( deferred, args );
1135
1301
}
1136
1302
};
1137
1303
}
1304
function progressFunc( i ) {
1305
return function( value ) {
1306
pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1307
deferred.notifyWith( promise, pValues );
1308
};
1309
}
1138
1310
if ( length > 1 ) {
1139
for( ; i < length; i++ ) {
1140
if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
1141
args[ i ].promise().then( resolveFunc(i), deferred.reject );
1311
for ( ; i < length; i++ ) {
1312
if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
1313
args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) );
1142
1314
} else {
1143
1315
--count;
1144
1316
}
1149
1321
} else if ( deferred !== firstParam ) {
1150
1322
deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1151
1323
}
1152
return deferred.promise();
1324
return promise;
1153
1325
}
1154
1326
});
1155
1327
1156
1328
1157
1329
1330
1158
1331
jQuery.support = (function() {
1159
1332
1160
var div = document.createElement( "div" ),
1161
documentElement = document.documentElement,
1333
var support,
1162
1334
all,
1163
1335
a,
1164
1336
select,
1165
1337
opt,
1166
1338
input,
1167
1339
marginDiv,
1168
support,
1169
1340
fragment,
1170
body,
1171
testElementParent,
1172
testElement,
1173
testElementStyle,
1174
1341
tds,
1175
1342
events,
1176
1343
eventName,
1177
1344
i,
1178
isSupported;
1345
isSupported,
1346
div = document.createElement( "div" ),
1347
documentElement = document.documentElement;
1179
1348
1180
1349
// Preliminary tests
1181
1350
div.setAttribute("className", "t");
1182
1351
div.innerHTML = " <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1183
1352
1184
1185
1353
all = div.getElementsByTagName( "*" );
1186
1354
a = div.getElementsByTagName( "a" )[ 0 ];
1187
1355
1201
1369
1202
1370
// Make sure that tbody elements aren't automatically inserted
1203
1371
// IE will insert them into empty tables
1204
tbody: !div.getElementsByTagName( "tbody" ).length,
1372
tbody: !div.getElementsByTagName("tbody").length,
1205
1373
1206
1374
// Make sure that link elements get serialized correctly by innerHTML
1207
1375
// This requires a wrapper element in IE
1208
htmlSerialize: !!div.getElementsByTagName( "link" ).length,
1376
htmlSerialize: !!div.getElementsByTagName("link").length,
1209
1377
1210
1378
// Get the style information from getAttribute
1211
1379
// (IE uses .cssText instead)
1213
1381
1214
1382
// Make sure that URLs aren't manipulated
1215
1383
// (IE normalizes it by default)
1216
hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
1384
hrefNormalized: ( a.getAttribute("href") === "/a" ),
1217
1385
1218
1386
// Make sure that element opacity exists
1219
1387
// (IE uses filter instead)
1220
1388
// Use a regex to work around a WebKit issue. See #5145
1221
opacity: /^0.55$/.test( a.style.opacity ),
1389
opacity: /^0.55/.test( a.style.opacity ),
1222
1390
1223
1391
// Verify style float existence
1224
1392
// (IE uses styleFloat instead of cssFloat)
1236
1404
// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1237
1405
getSetAttribute: div.className !== "t",
1238
1406
1407
// Tests for enctype support on a form(#6743)
1408
enctype: !!document.createElement("form").enctype,
1409
1410
// Makes sure cloning an html5 element does not cause problems
1411
// Where outerHTML is undefined, this still works
1412
html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
1413
1239
1414
// Will be defined later
1240
1415
submitBubbles: true,
1241
1416
changeBubbles: true,
1273
1448
div.cloneNode( true ).fireEvent( "onclick" );
1274
1449
}
1275
1450
1276
// Check if a radio maintains it's value
1451
// Check if a radio maintains its value
1277
1452
// after being appended to the DOM
1278
1453
input = document.createElement("input");
1279
1454
input.value = "t";
1283
1458
input.setAttribute("checked", "checked");
1284
1459
div.appendChild( input );
1285
1460
fragment = document.createDocumentFragment();
1286
fragment.appendChild( div.firstChild );
1461
fragment.appendChild( div.lastChild );
1287
1462
1288
1463
// WebKit doesn't clone checked state correctly in fragments
1289
1464
support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1290
1465
1291
div.innerHTML = "";
1292
1293
// Figure out if the W3C box model works as expected
1294
div.style.width = div.style.paddingLeft = "1px";
1295
1296
body = document.getElementsByTagName( "body" )[ 0 ];
1297
// We use our own, invisible, body unless the body is already present
1298
// in which case we use a div (#9239)
1299
testElement = document.createElement( body ? "div" : "body" );
1300
testElementStyle = {
1301
visibility: "hidden",
1302
width: 0,
1303
height: 0,
1304
border: 0,
1305
margin: 0,
1306
background: "none"
1307
};
1308
if ( body ) {
1309
jQuery.extend( testElementStyle, {
1310
position: "absolute",
1311
left: "-1000px",
1312
top: "-1000px"
1313
});
1314
}
1315
for ( i in testElementStyle ) {
1316
testElement.style[ i ] = testElementStyle[ i ];
1317
}
1318
testElement.appendChild( div );
1319
testElementParent = body || documentElement;
1320
testElementParent.insertBefore( testElement, testElementParent.firstChild );
1321
1322
1466
// Check if a disconnected checkbox will retain its checked
1323
1467
// value of true after appended to the DOM (IE6/7)
1324
1468
support.appendChecked = input.checked;
1325
1469
1326
support.boxModel = div.offsetWidth === 2;
1327
1328
if ( "zoom" in div.style ) {
1329
// Check if natively block-level elements act like inline-block
1330
// elements when setting their display to 'inline' and giving
1331
// them layout
1332
// (IE < 8 does this)
1333
div.style.display = "inline";
1334
div.style.zoom = 1;
1335
support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1336
1337
// Check if elements with layout shrink-wrap their children
1338
// (IE 6 does this)
1339
div.style.display = "";
1340
div.innerHTML = "<div style='width:4px;'></div>";
1341
support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1342
}
1343
1344
div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1345
tds = div.getElementsByTagName( "td" );
1346
1347
// Check if table cells still have offsetWidth/Height when they are set
1348
// to display:none and there are still other visible table cells in a
1349
// table row; if so, offsetWidth/Height are not reliable for use when
1350
// determining if an element has been hidden directly using
1351
// display:none (it is still safe to use offsets if a parent element is
1352
// hidden; don safety goggles and see bug #4512 for more information).
1353
// (only IE 8 fails this test)
1354
isSupported = ( tds[ 0 ].offsetHeight === 0 );
1355
1356
tds[ 0 ].style.display = "";
1357
tds[ 1 ].style.display = "none";
1358
1359
// Check if empty table cells still have offsetWidth/Height
1360
// (IE < 8 fail this test)
1361
support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1470
fragment.removeChild( input );
1471
fragment.appendChild( div );
1472
1362
1473
div.innerHTML = "";
1363
1474
1364
1475
// Check if div with explicit width and no margin-right incorrectly
1366
1477
// info see bug #3333
1367
1478
// Fails in WebKit before Feb 2011 nightlies
1368
1479
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1369
if ( document.defaultView && document.defaultView.getComputedStyle ) {
1480
if ( window.getComputedStyle ) {
1370
1481
marginDiv = document.createElement( "div" );
1371
1482
marginDiv.style.width = "0";
1372
1483
marginDiv.style.marginRight = "0";
1484
div.style.width = "2px";
1373
1485
div.appendChild( marginDiv );
1374
1486
support.reliableMarginRight =
1375
( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1487
( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1376
1488
}
1377
1489
1378
// Remove the body element we added
1379
testElement.innerHTML = "";
1380
testElementParent.removeChild( testElement );
1381
1382
1490
// Technique from Juriy Zaytsev
1383
// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1491
// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
1384
1492
// We only care about the case where non-standard event systems
1385
1493
// are used, namely in IE. Short-circuiting here helps us to
1386
1494
// avoid an eval call (in setAttribute) which can cause CSP
1390
1498
submit: 1,
1391
1499
change: 1,
1392
1500
focusin: 1
1393
} ) {
1501
}) {
1394
1502
eventName = "on" + i;
1395
1503
isSupported = ( eventName in div );
1396
1504
if ( !isSupported ) {
1401
1509
}
1402
1510
}
1403
1511
1404
// Null connected elements to avoid leaks in IE
1405
testElement = fragment = select = opt = body = marginDiv = div = input = null;
1512
fragment.removeChild( div );
1513
1514
// Null elements to avoid leaks in IE
1515
fragment = select = opt = marginDiv = div = input = null;
1516
1517
// Run tests that need a body at doc ready
1518
jQuery(function() {
1519
var container, outer, inner, table, td, offsetSupport,
1520
conMarginTop, ptlm, vb, style, html,
1521
body = document.getElementsByTagName("body")[0];
1522
1523
if ( !body ) {
1524
// Return for frameset docs that don't have a body
1525
return;
1526
}
1527
1528
conMarginTop = 1;
1529
ptlm = "position:absolute;top:0;left:0;width:1px;height:1px;margin:0;";
1530
vb = "visibility:hidden;border:0;";
1531
style = "style='" + ptlm + "border:5px solid #000;padding:0;'";
1532
html = "<div " + style + "><div></div></div>" +
1533
"<table " + style + " cellpadding='0' cellspacing='0'>" +
1534
"<tr><td></td></tr></table>";
1535
1536
container = document.createElement("div");
1537
container.style.cssText = vb + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
1538
body.insertBefore( container, body.firstChild );
1539
1540
// Construct the test element
1541
div = document.createElement("div");
1542
container.appendChild( div );
1543
1544
// Check if table cells still have offsetWidth/Height when they are set
1545
// to display:none and there are still other visible table cells in a
1546
// table row; if so, offsetWidth/Height are not reliable for use when
1547
// determining if an element has been hidden directly using
1548
// display:none (it is still safe to use offsets if a parent element is
1549
// hidden; don safety goggles and see bug #4512 for more information).
1550
// (only IE 8 fails this test)
1551
div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1552
tds = div.getElementsByTagName( "td" );
1553
isSupported = ( tds[ 0 ].offsetHeight === 0 );
1554
1555
tds[ 0 ].style.display = "";
1556
tds[ 1 ].style.display = "none";
1557
1558
// Check if empty table cells still have offsetWidth/Height
1559
// (IE <= 8 fail this test)
1560
support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1561
1562
// Figure out if the W3C box model works as expected
1563
div.innerHTML = "";
1564
div.style.width = div.style.paddingLeft = "1px";
1565
jQuery.boxModel = support.boxModel = div.offsetWidth === 2;
1566
1567
if ( typeof div.style.zoom !== "undefined" ) {
1568
// Check if natively block-level elements act like inline-block
1569
// elements when setting their display to 'inline' and giving
1570
// them layout
1571
// (IE < 8 does this)
1572
div.style.display = "inline";
1573
div.style.zoom = 1;
1574
support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1575
1576
// Check if elements with layout shrink-wrap their children
1577
// (IE 6 does this)
1578
div.style.display = "";
1579
div.innerHTML = "<div style='width:4px;'></div>";
1580
support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1581
}
1582
1583
div.style.cssText = ptlm + vb;
1584
div.innerHTML = html;
1585
1586
outer = div.firstChild;
1587
inner = outer.firstChild;
1588
td = outer.nextSibling.firstChild.firstChild;
1589
1590
offsetSupport = {
1591
doesNotAddBorder: ( inner.offsetTop !== 5 ),
1592
doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
1593
};
1594
1595
inner.style.position = "fixed";
1596
inner.style.top = "20px";
1597
1598
// safari subtracts parent border width here which is 5px
1599
offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
1600
inner.style.position = inner.style.top = "";
1601
1602
outer.style.overflow = "hidden";
1603
outer.style.position = "relative";
1604
1605
offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
1606
offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );
1607
1608
body.removeChild( container );
1609
div = container = null;
1610
1611
jQuery.extend( support, offsetSupport );
1612
});
1406
1613
1407
1614
return support;
1408
1615
})();
1409
1616
1410
// Keep track of boxModel
1411
jQuery.boxModel = jQuery.support.boxModel;
1412
1413
1617
1414
1618
1415
1619
1437
1641
1438
1642
hasData: function( elem ) {
1439
1643
elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1440
1441
1644
return !!elem && !isEmptyDataObject( elem );
1442
1645
},
1443
1646
1446
1649
return;
1447
1650
}
1448
1651
1449
var thisCache, ret,
1652
var privateCache, thisCache, ret,
1450
1653
internalKey = jQuery.expando,
1451
1654
getByName = typeof name === "string",
1452
1655
1460
1663
1461
1664
// Only defining an ID for JS objects if its cache already exists allows
1462
1665
// the code to shortcut on the same path as a DOM node with no cache
1463
id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
1666
id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
1667
isEvents = name === "events";
1464
1668
1465
1669
// Avoid doing any more work than we need to when trying to get data on an
1466
1670
// object that has no data at all
1467
if ( (!id || (pvt && id && (cache[ id ] && !cache[ id ][ internalKey ]))) && getByName && data === undefined ) {
1671
if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) {
1468
1672
return;
1469
1673
}
1470
1674
1472
1676
// Only DOM nodes need a new unique ID for each element since their data
1473
1677
// ends up in the global cache
1474
1678
if ( isNode ) {
1475
elem[ jQuery.expando ] = id = ++jQuery.uuid;
1679
elem[ internalKey ] = id = ++jQuery.uuid;
1476
1680
} else {
1477
id = jQuery.expando;
1681
id = internalKey;
1478
1682
}
1479
1683
}
1480
1684
1481
1685
if ( !cache[ id ] ) {
1482
1686
cache[ id ] = {};
1483
1687
1484
// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1485
// metadata on plain JS objects when the object is serialized using
1486
// JSON.stringify
1688
// Avoids exposing jQuery metadata on plain JS objects when the object
1689
// is serialized using JSON.stringify
1487
1690
if ( !isNode ) {
1488
1691
cache[ id ].toJSON = jQuery.noop;
1489
1692
}
1493
1696
// shallow copied over onto the existing cache
1494
1697
if ( typeof name === "object" || typeof name === "function" ) {
1495
1698
if ( pvt ) {
1496
cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
1699
cache[ id ] = jQuery.extend( cache[ id ], name );
1497
1700
} else {
1498
cache[ id ] = jQuery.extend(cache[ id ], name);
1701
cache[ id ].data = jQuery.extend( cache[ id ].data, name );
1499
1702
}
1500
1703
}
1501
1704
1502
thisCache = cache[ id ];
1705
privateCache = thisCache = cache[ id ];
1503
1706
1504
// Internal jQuery data is stored in a separate object inside the object's data
1707
// jQuery data() is stored in a separate object inside the object's internal data
1505
1708
// cache in order to avoid key collisions between internal data and user-defined
1506
// data
1507
if ( pvt ) {
1508
if ( !thisCache[ internalKey ] ) {
1509
thisCache[ internalKey ] = {};
1709
// data.
1710
if ( !pvt ) {
1711
if ( !thisCache.data ) {
1712
thisCache.data = {};
1510
1713
}
1511
1714
1512
thisCache = thisCache[ internalKey ];
1715
thisCache = thisCache.data;
1513
1716
}
1514
1717
1515
1718
if ( data !== undefined ) {
1516
1719
thisCache[ jQuery.camelCase( name ) ] = data;
1517
1720
}
1518
1721
1519
// TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
1520
// not attempt to inspect the internal events object using jQuery.data, as this
1521
// internal data object is undocumented and subject to change.
1522
if ( name === "events" && !thisCache[name] ) {
1523
return thisCache[ internalKey ] && thisCache[ internalKey ].events;
1722
// Users should not attempt to inspect the internal events object using jQuery.data,
1723
// it is undocumented and subject to change. But does anyone listen? No.
1724
if ( isEvents && !thisCache[ name ] ) {
1725
return privateCache.events;
1524
1726
}
1525
1727
1526
1728
// Check for both converted-to-camel and non-converted data property names
1548
1750
return;
1549
1751
}
1550
1752
1551
var thisCache,
1753
var thisCache, i, l,
1552
1754
1553
1755
// Reference to internal data cache key
1554
1756
internalKey = jQuery.expando,
1559
1761
cache = isNode ? jQuery.cache : elem,
1560
1762
1561
1763
// See jQuery.data for more information
1562
id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1764
id = isNode ? elem[ internalKey ] : internalKey;
1563
1765
1564
1766
// If there is already no cache entry for this object, there is no
1565
1767
// purpose in continuing
1569
1771
1570
1772
if ( name ) {
1571
1773
1572
thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
1774
thisCache = pvt ? cache[ id ] : cache[ id ].data;
1573
1775
1574
1776
if ( thisCache ) {
1575
1777
1576
// Support interoperable removal of hyphenated or camelcased keys
1577
if ( !thisCache[ name ] ) {
1578
name = jQuery.camelCase( name );
1579
}
1580
1581
delete thisCache[ name ];
1778
// Support array or space separated string names for data keys
1779
if ( !jQuery.isArray( name ) ) {
1780
1781
// try the string as a key before any manipulation
1782
if ( name in thisCache ) {
1783
name = [ name ];
1784
} else {
1785
1786
// split the camel cased version by spaces unless a key with the spaces exists
1787
name = jQuery.camelCase( name );
1788
if ( name in thisCache ) {
1789
name = [ name ];
1790
} else {
1791
name = name.split( " " );
1792
}
1793
}
1794
}
1795
1796
for ( i = 0, l = name.length; i < l; i++ ) {
1797
delete thisCache[ name[i] ];
1798
}
1582
1799
1583
1800
// If there is no data left in the cache, we want to continue
1584
1801
// and let the cache object itself get destroyed
1585
if ( !isEmptyDataObject(thisCache) ) {
1802
if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
1586
1803
return;
1587
1804
}
1588
1805
}
1589
1806
}
1590
1807
1591
1808
// See jQuery.data for more information
1592
if ( pvt ) {
1593
delete cache[ id ][ internalKey ];
1809
if ( !pvt ) {
1810
delete cache[ id ].data;
1594
1811
1595
1812
// Don't destroy the parent cache unless the internal data object
1596
1813
// had been the only thing left in it
1599
1816
}
1600
1817
}
1601
1818
1602
var internalCache = cache[ id ][ internalKey ];
1603
1604
1819
// Browsers that fail expando deletion also refuse to delete expandos on
1605
1820
// the window, but it will allow it on all other JS objects; other browsers
1606
1821
// don't care
1611
1826
cache[ id ] = null;
1612
1827
}
1613
1828
1614
// We destroyed the entire user cache at once because it's faster than
1615
// iterating through each key, but we need to continue to persist internal
1616
// data if it existed
1617
if ( internalCache ) {
1618
cache[ id ] = {};
1619
// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1620
// metadata on plain JS objects when the object is serialized using
1621
// JSON.stringify
1622
if ( !isNode ) {
1623
cache[ id ].toJSON = jQuery.noop;
1624
}
1625
1626
cache[ id ][ internalKey ] = internalCache;
1627
1628
// Otherwise, we need to eliminate the expando on the node to avoid
1829
// We destroyed the cache and need to eliminate the expando on the node to avoid
1629
1830
// false lookups in the cache for entries that no longer exist
1630
} else if ( isNode ) {
1831
if ( isNode ) {
1631
1832
// IE does not allow us to delete expando properties from nodes,
1632
1833
// nor does it have a removeAttribute function on Document nodes;
1633
1834
// we must handle all of these cases
1634
1835
if ( jQuery.support.deleteExpando ) {
1635
delete elem[ jQuery.expando ];
1836
delete elem[ internalKey ];
1636
1837
} else if ( elem.removeAttribute ) {
1637
elem.removeAttribute( jQuery.expando );
1838
elem.removeAttribute( internalKey );
1638
1839
} else {
1639
elem[ jQuery.expando ] = null;
1840
elem[ internalKey ] = null;
1640
1841
}
1641
1842
}
1642
1843
},
1662
1863
1663
1864
jQuery.fn.extend({
1664
1865
data: function( key, value ) {
1665
var data = null;
1866
var parts, attr, name,
1867
data = null;
1666
1868
1667
1869
if ( typeof key === "undefined" ) {
1668
1870
if ( this.length ) {
1669
1871
data = jQuery.data( this[0] );
1670
1872
1671
if ( this[0].nodeType === 1 ) {
1672
var attr = this[0].attributes, name;
1873
if ( this[0].nodeType === 1 && !jQuery._data( this[0], "parsedAttrs" ) ) {
1874
attr = this[0].attributes;
1673
1875
for ( var i = 0, l = attr.length; i < l; i++ ) {
1674
1876
name = attr[i].name;
1675
1877
1679
1881
dataAttr( this[0], name, data[ name ] );
1680
1882
}
1681
1883
}
1884
jQuery._data( this[0], "parsedAttrs", true );
1682
1885
}
1683
1886
}
1684
1887
1690
1893
});
1691
1894
}
1692
1895
1693
var parts = key.split(".");
1896
parts = key.split(".");
1694
1897
parts[1] = parts[1] ? "." + parts[1] : "";
1695
1898
1696
1899
if ( value === undefined ) {
1708
1911
1709
1912
} else {
1710
1913
return this.each(function() {
1711
var $this = jQuery( this ),
1914
var self = jQuery( this ),
1712
1915
args = [ parts[0], value ];
1713
1916
1714
$this.triggerHandler( "setData" + parts[1] + "!", args );
1917
self.triggerHandler( "setData" + parts[1] + "!", args );
1715
1918
jQuery.data( this, key, value );
1716
$this.triggerHandler( "changeData" + parts[1] + "!", args );
1919
self.triggerHandler( "changeData" + parts[1] + "!", args );
1717
1920
});
1718
1921
}
1719
1922
},
1739
1942
data = data === "true" ? true :
1740
1943
data === "false" ? false :
1741
1944
data === "null" ? null :
1742
!jQuery.isNaN( data ) ? parseFloat( data ) :
1945
jQuery.isNumeric( data ) ? parseFloat( data ) :
1743
1946
rbrace.test( data ) ? jQuery.parseJSON( data ) :
1744
1947
data;
1745
1948
} catch( e ) {}
1755
1958
return data;
1756
1959
}
1757
1960
1758
// TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
1759
// property to be considered empty objects; this property always exists in
1760
// order to make sure JSON.stringify does not expose internal metadata
1961
// checks a cache object for emptiness
1761
1962
function isEmptyDataObject( obj ) {
1762
1963
for ( var name in obj ) {
1964
1965
// if the public data object is empty, the private is still empty
1966
if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
1967
continue;
1968
}
1763
1969
if ( name !== "toJSON" ) {
1764
1970
return false;
1765
1971
}
1775
1981
var deferDataKey = type + "defer",
1776
1982
queueDataKey = type + "queue",
1777
1983
markDataKey = type + "mark",
1778
defer = jQuery.data( elem, deferDataKey, undefined, true );
1984
defer = jQuery._data( elem, deferDataKey );
1779
1985
if ( defer &&
1780
( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
1781
( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
1986
( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
1987
( src === "mark" || !jQuery._data(elem, markDataKey) ) ) {
1782
1988
// Give room for hard-coded callbacks to fire first
1783
1989
// and eventually mark/queue something else on the element
1784
1990
setTimeout( function() {
1785
if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
1786
!jQuery.data( elem, markDataKey, undefined, true ) ) {
1991
if ( !jQuery._data( elem, queueDataKey ) &&
1992
!jQuery._data( elem, markDataKey ) ) {
1787
1993
jQuery.removeData( elem, deferDataKey, true );
1788
defer.resolve();
1994
defer.fire();
1789
1995
}
1790
1996
}, 0 );
1791
1997
}
1795
2001
1796
2002
_mark: function( elem, type ) {
1797
2003
if ( elem ) {
1798
type = (type || "fx") + "mark";
1799
jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
2004
type = ( type || "fx" ) + "mark";
2005
jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 );
1800
2006
}
1801
2007
},
1802
2008
1809
2015
if ( elem ) {
1810
2016
type = type || "fx";
1811
2017
var key = type + "mark",
1812
count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
2018
count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 );
1813
2019
if ( count ) {
1814
jQuery.data( elem, key, count, true );
2020
jQuery._data( elem, key, count );
1815
2021
} else {
1816
2022
jQuery.removeData( elem, key, true );
1817
2023
handleQueueMarkDefer( elem, type, "mark" );
1820
2026
},
1821
2027
1822
2028
queue: function( elem, type, data ) {
2029
var q;
1823
2030
if ( elem ) {
1824
type = (type || "fx") + "queue";
1825
var q = jQuery.data( elem, type, undefined, true );
2031
type = ( type || "fx" ) + "queue";
2032
q = jQuery._data( elem, type );
2033
1826
2034
// Speed up dequeue by getting out quickly if this is just a lookup
1827
2035
if ( data ) {
1828
2036
if ( !q || jQuery.isArray(data) ) {
1829
q = jQuery.data( elem, type, jQuery.makeArray(data), true );
2037
q = jQuery._data( elem, type, jQuery.makeArray(data) );
1830
2038
} else {
1831
2039
q.push( data );
1832
2040
}
1840
2048
1841
2049
var queue = jQuery.queue( elem, type ),
1842
2050
fn = queue.shift(),
1843
defer;
2051
hooks = {};
1844
2052
1845
2053
// If the fx queue is dequeued, always remove the progress sentinel
1846
2054
if ( fn === "inprogress" ) {
1851
2059
// Add a progress sentinel to prevent the fx queue from being
1852
2060
// automatically dequeued
1853
2061
if ( type === "fx" ) {
1854
queue.unshift("inprogress");
2062
queue.unshift( "inprogress" );
1855
2063
}
1856
2064
1857
fn.call(elem, function() {
1858
jQuery.dequeue(elem, type);
1859
});
2065
jQuery._data( elem, type + ".run", hooks );
2066
fn.call( elem, function() {
2067
jQuery.dequeue( elem, type );
2068
}, hooks );
1860
2069
}
1861
2070
1862
2071
if ( !queue.length ) {
1863
jQuery.removeData( elem, type + "queue", true );
2072
jQuery.removeData( elem, type + "queue " + type + ".run", true );
1864
2073
handleQueueMarkDefer( elem, type, "queue" );
1865
2074
}
1866
2075
}
1892
2101
// Based off of the plugin by Clint Helfers, with permission.
1893
2102
// http://blindsignals.com/index.php/2009/07/jquery-delay/
1894
2103
delay: function( time, type ) {
1895
time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
2104
time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
1896
2105
type = type || "fx";
1897
2106
1898
return this.queue( type, function() {
1899
var elem = this;
1900
setTimeout(function() {
1901
jQuery.dequeue( elem, type );
1902
}, time );
2107
return this.queue( type, function( next, hooks ) {
2108
var timeout = setTimeout( next, time );
2109
hooks.stop = function() {
2110
clearTimeout( timeout );
2111
};
1903
2112
});
1904
2113
},
1905
2114
clearQueue: function( type ) {
1930
2139
if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
1931
2140
( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
1932
2141
jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
1933
jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
2142
jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
1934
2143
count++;
1935
tmp.done( resolve );
2144
tmp.add( resolve );
1936
2145
}
1937
2146
}
1938
2147
resolve();
1950
2159
rfocusable = /^(?:button|input|object|select|textarea)$/i,
1951
2160
rclickable = /^a(?:rea)?$/i,
1952
2161
rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
1953
nodeHook, boolHook;
2162
getSetAttribute = jQuery.support.getSetAttribute,
2163
nodeHook, boolHook, fixSpecified;
1954
2164
1955
2165
jQuery.fn.extend({
1956
2166
attr: function( name, value ) {
1962
2172
jQuery.removeAttr( this, name );
1963
2173
});
1964
2174
},
1965
2175
1966
2176
prop: function( name, value ) {
1967
2177
return jQuery.access( this, name, value, true, jQuery.prop );
1968
2178
},
1969
2179
1970
2180
removeProp: function( name ) {
1971
2181
name = jQuery.propFix[ name ] || name;
1972
2182
return this.each(function() {
2025
2235
}
2026
2236
2027
2237
if ( (value && typeof value === "string") || value === undefined ) {
2028
classNames = (value || "").split( rspace );
2238
classNames = ( value || "" ).split( rspace );
2029
2239
2030
2240
for ( i = 0, l = this.length; i < l; i++ ) {
2031
2241
elem = this[ i ];
2086
2296
},
2087
2297
2088
2298
hasClass: function( selector ) {
2089
var className = " " + selector + " ";
2090
for ( var i = 0, l = this.length; i < l; i++ ) {
2299
var className = " " + selector + " ",
2300
i = 0,
2301
l = this.length;
2302
for ( ; i < l; i++ ) {
2091
2303
if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2092
2304
return true;
2093
2305
}
2097
2309
},
2098
2310
2099
2311
val: function( value ) {
2100
var hooks, ret,
2312
var hooks, ret, isFunction,
2101
2313
elem = this[0];
2102
2314
2103
2315
if ( !arguments.length ) {
2104
2316
if ( elem ) {
2105
2317
hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
2110
2322
2111
2323
ret = elem.value;
2112
2324
2113
return typeof ret === "string" ?
2325
return typeof ret === "string" ?
2114
2326
// handle most common string cases
2115
ret.replace(rreturn, "") :
2327
ret.replace(rreturn, "") :
2116
2328
// handle cases where value is null/undef or number
2117
2329
ret == null ? "" : ret;
2118
2330
}
2119
2331
2120
return undefined;
2332
return;
2121
2333
}
2122
2334
2123
var isFunction = jQuery.isFunction( value );
2335
isFunction = jQuery.isFunction( value );
2124
2336
2125
2337
return this.each(function( i ) {
2126
2338
var self = jQuery(this), val;
2168
2380
},
2169
2381
select: {
2170
2382
get: function( elem ) {
2171
var value,
2383
var value, i, max, option,
2172
2384
index = elem.selectedIndex,
2173
2385
values = [],
2174
2386
options = elem.options,
2180
2392
}
2181
2393
2182
2394
// Loop through all the selected options
2183
for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
2184
var option = options[ i ];
2395
i = one ? index : 0;
2396
max = one ? index + 1 : options.length;
2397
for ( ; i < max; i++ ) {
2398
option = options[ i ];
2185
2399
2186
2400
// Don't return options that are disabled or in a disabled optgroup
2187
2401
if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2233
2447
height: true,
2234
2448
offset: true
2235
2449
},
2236
2237
attrFix: {
2238
// Always normalize to ensure hook usage
2239
tabindex: "tabIndex"
2240
},
2241
2450
2242
2451
attr: function( elem, name, value, pass ) {
2243
var nType = elem.nodeType;
2244
2452
var ret, hooks, notxml,
2453
nType = elem.nodeType;
2454
2245
2455
// don't get/set attributes on text, comment and attribute nodes
2246
2456
if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2247
return undefined;
2457
return;
2248
2458
}
2249
2459
2250
2460
if ( pass && name in jQuery.attrFn ) {
2252
2462
}
2253
2463
2254
2464
// Fallback to prop when attributes are not supported
2255
if ( !("getAttribute" in elem) ) {
2465
if ( typeof elem.getAttribute === "undefined" ) {
2256
2466
return jQuery.prop( elem, name, value );
2257
2467
}
2258
2468
2259
var ret, hooks,
2260
notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2469
notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2261
2470
2262
// Normalize the name if needed
2471
// All attributes are lowercase
2472
// Grab necessary hook if one is defined
2263
2473
if ( notxml ) {
2264
name = jQuery.attrFix[ name ] || name;
2265
2266
hooks = jQuery.attrHooks[ name ];
2267
2268
if ( !hooks ) {
2269
// Use boolHook for boolean attributes
2270
if ( rboolean.test( name ) ) {
2271
hooks = boolHook;
2272
2273
// Use nodeHook if available( IE6/7 )
2274
} else if ( nodeHook ) {
2275
hooks = nodeHook;
2276
}
2277
}
2474
name = name.toLowerCase();
2475
hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
2278
2476
}
2279
2477
2280
2478
if ( value !== undefined ) {
2281
2479
2282
2480
if ( value === null ) {
2283
2481
jQuery.removeAttr( elem, name );
2284
return undefined;
2482
return;
2285
2483
2286
2484
} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2287
2485
return ret;
2305
2503
}
2306
2504
},
2307
2505
2308
removeAttr: function( elem, name ) {
2309
var propName;
2310
if ( elem.nodeType === 1 ) {
2311
name = jQuery.attrFix[ name ] || name;
2312
2313
jQuery.attr( elem, name, "" );
2314
elem.removeAttribute( name );
2315
2316
// Set corresponding property to false for boolean attributes
2317
if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) {
2318
elem[ propName ] = false;
2506
removeAttr: function( elem, value ) {
2507
var propName, attrNames, name, l,
2508
i = 0;
2509
2510
if ( value && elem.nodeType === 1 ) {
2511
attrNames = value.toLowerCase().split( rspace );
2512
l = attrNames.length;
2513
2514
for ( ; i < l; i++ ) {
2515
name = attrNames[ i ];
2516
2517
if ( name ) {
2518
propName = jQuery.propFix[ name ] || name;
2519
2520
// See #9699 for explanation of this approach (setting first, then removal)
2521
jQuery.attr( elem, name, "" );
2522
elem.removeAttribute( getSetAttribute ? name : propName );
2523
2524
// Set corresponding property to false for boolean attributes
2525
if ( rboolean.test( name ) && propName in elem ) {
2526
elem[ propName ] = false;
2527
}
2528
}
2319
2529
}
2320
2530
}
2321
2531
},
2374
2584
frameborder: "frameBorder",
2375
2585
contenteditable: "contentEditable"
2376
2586
},
2377
2587
2378
2588
prop: function( elem, name, value ) {
2379
var nType = elem.nodeType;
2589
var ret, hooks, notxml,
2590
nType = elem.nodeType;
2380
2591
2381
2592
// don't get/set properties on text, comment and attribute nodes
2382
2593
if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2383
return undefined;
2594
return;
2384
2595
}
2385
2596
2386
var ret, hooks,
2387
notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2597
notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2388
2598
2389
2599
if ( notxml ) {
2390
2600
// Fix name and attach hooks
2397
2607
return ret;
2398
2608
2399
2609
} else {
2400
return (elem[ name ] = value);
2610
return ( elem[ name ] = value );
2401
2611
}
2402
2612
2403
2613
} else {
2409
2619
}
2410
2620
}
2411
2621
},
2412
2622
2413
2623
propHooks: {
2414
2624
tabIndex: {
2415
2625
get: function( elem ) {
2427
2637
}
2428
2638
});
2429
2639
2430
// Add the tabindex propHook to attrHooks for back-compat
2431
jQuery.attrHooks.tabIndex = jQuery.propHooks.tabIndex;
2640
// Add the tabIndex propHook to attrHooks for back-compat (different case is intentional)
2641
jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;
2432
2642
2433
2643
// Hook for boolean attributes
2434
2644
boolHook = {
2435
2645
get: function( elem, name ) {
2436
2646
// Align boolean attributes with corresponding properties
2437
2647
// Fall back to attribute presence where some booleans are not supported
2438
var attrNode;
2439
return jQuery.prop( elem, name ) === true || ( attrNode = elem.getAttributeNode( name ) ) && attrNode.nodeValue !== false ?
2648
var attrNode,
2649
property = jQuery.prop( elem, name );
2650
return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
2440
2651
name.toLowerCase() :
2441
2652
undefined;
2442
2653
},
2461
2672
};
2462
2673
2463
2674
// IE6/7 do not support getting/setting some attributes with get/setAttribute
2464
if ( !jQuery.support.getSetAttribute ) {
2465
2675
if ( !getSetAttribute ) {
2676
2677
fixSpecified = {
2678
name: true,
2679
id: true
2680
};
2681
2466
2682
// Use this for any attribute in IE6/7
2467
2683
// This fixes almost every IE6/7 issue
2468
2684
nodeHook = jQuery.valHooks.button = {
2469
2685
get: function( elem, name ) {
2470
2686
var ret;
2471
2687
ret = elem.getAttributeNode( name );
2472
// Return undefined if nodeValue is empty string
2473
return ret && ret.nodeValue !== "" ?
2688
return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ?
2474
2689
ret.nodeValue :
2475
2690
undefined;
2476
2691
},
2481
2696
ret = document.createAttribute( name );
2482
2697
elem.setAttributeNode( ret );
2483
2698
}
2484
return (ret.nodeValue = value + "");
2699
return ( ret.nodeValue = value + "" );
2485
2700
}
2486
2701
};
2487
2702
2703
// Apply the nodeHook to tabindex
2704
jQuery.attrHooks.tabindex.set = nodeHook.set;
2705
2488
2706
// Set width and height to auto instead of 0 on empty string( Bug #8150 )
2489
2707
// This is for removals
2490
2708
jQuery.each([ "width", "height" ], function( i, name ) {
2497
2715
}
2498
2716
});
2499
2717
});
2718
2719
// Set contenteditable to false on removals(#10429)
2720
// Setting to empty string throws an error as an invalid value
2721
jQuery.attrHooks.contenteditable = {
2722
get: nodeHook.get,
2723
set: function( elem, value, name ) {
2724
if ( value === "" ) {
2725
value = "false";
2726
}
2727
nodeHook.set( elem, value, name );
2728
}
2729
};
2500
2730
}
2501
2731
2502
2732
2520
2750
return elem.style.cssText.toLowerCase() || undefined;
2521
2751
},
2522
2752
set: function( elem, value ) {
2523
return (elem.style.cssText = "" + value);
2753
return ( elem.style.cssText = "" + value );
2524
2754
}
2525
2755
};
2526
2756
}
2545
2775
});
2546
2776
}
2547
2777
2778
// IE6/7 call enctype encoding
2779
if ( !jQuery.support.enctype ) {
2780
jQuery.propFix.enctype = "encoding";
2781
}
2782
2548
2783
// Radios and checkboxes getter/setter
2549
2784
if ( !jQuery.support.checkOn ) {
2550
2785
jQuery.each([ "radio", "checkbox" ], function() {
2560
2795
jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2561
2796
set: function( elem, value ) {
2562
2797
if ( jQuery.isArray( value ) ) {
2563
return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
2798
return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
2564
2799
}
2565
2800
}
2566
2801
});
2569
2804
2570
2805
2571
2806
2572
var rnamespaces = /\.(.*)$/,
2573
rformElems = /^(?:textarea|input|select)$/i,
2574
rperiod = /\./g,
2575
rspaces = / /g,
2576
rescape = /[^\w\s.|`]/g,
2577
fcleanup = function( nm ) {
2578
return nm.replace(rescape, "\\$&");
2807
var rformElems = /^(?:textarea|input|select)$/i,
2808
rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
2809
rhoverHack = /\bhover(\.\S+)?\b/,
2810
rkeyEvent = /^key/,
2811
rmouseEvent = /^(?:mouse|contextmenu)|click/,
2812
rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
2813
rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
2814
quickParse = function( selector ) {
2815
var quick = rquickIs.exec( selector );
2816
if ( quick ) {
2817
// 0 1 2 3
2818
// [ _, tag, id, class ]
2819
quick[1] = ( quick[1] || "" ).toLowerCase();
2820
quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" );
2821
}
2822
return quick;
2823
},
2824
quickIs = function( elem, m ) {
2825
var attrs = elem.attributes || {};
2826
return (
2827
(!m[1] || elem.nodeName.toLowerCase() === m[1]) &&
2828
(!m[2] || (attrs.id || {}).value === m[2]) &&
2829
(!m[3] || m[3].test( (attrs[ "class" ] || {}).value ))
2830
);
2831
},
2832
hoverHack = function( events ) {
2833
return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
2579
2834
};
2580
2835
2581
2836
/*
2582
* A number of helper functions used for managing events.
2583
* Many of the ideas behind this code originated from
2584
* Dean Edwards' addEvent library.
2837
* Helper functions for managing events -- not part of the public interface.
2838
* Props to Dean Edwards' addEvent library for many of the ideas.
2585
2839
*/
2586
2840
jQuery.event = {
2587
2841
2588
// Bind an event to an element
2589
// Original by Dean Edwards
2590
add: function( elem, types, handler, data ) {
2591
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2592
return;
2593
}
2594
2595
if ( handler === false ) {
2596
handler = returnFalse;
2597
} else if ( !handler ) {
2598
// Fixes bug #7229. Fix recommended by jdalton
2599
return;
2600
}
2601
2602
var handleObjIn, handleObj;
2603
2842
add: function( elem, types, handler, data, selector ) {
2843
2844
var elemData, eventHandle, events,
2845
t, tns, type, namespaces, handleObj,
2846
handleObjIn, quick, handlers, special;
2847
2848
// Don't attach events to noData or text/comment nodes (allow plain objects tho)
2849
if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
2850
return;
2851
}
2852
2853
// Caller can pass in an object of custom data in lieu of the handler
2604
2854
if ( handler.handler ) {
2605
2855
handleObjIn = handler;
2606
2856
handler = handleObjIn.handler;
2607
2857
}
2608
2858
2609
// Make sure that the function being executed has a unique ID
2859
// Make sure that the handler has a unique ID, used to find/remove it later
2610
2860
if ( !handler.guid ) {
2611
2861
handler.guid = jQuery.guid++;
2612
2862
}
2613
2863
2614
// Init the element's event structure
2615
var elemData = jQuery._data( elem );
2616
2617
// If no elemData is found then we must be trying to bind to one of the
2618
// banned noData elements
2619
if ( !elemData ) {
2620
return;
2621
}
2622
2623
var events = elemData.events,
2624
eventHandle = elemData.handle;
2625
2864
// Init the element's event structure and main handler, if this is the first
2865
events = elemData.events;
2626
2866
if ( !events ) {
2627
2867
elemData.events = events = {};
2628
2868
}
2629
2869
eventHandle = elemData.handle;
2630
2870
if ( !eventHandle ) {
2631
2871
elemData.handle = eventHandle = function( e ) {
2632
2872
// Discard the second event of a jQuery.event.trigger() and
2633
2873
// when an event is called after a page has unloaded
2634
2874
return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2635
jQuery.event.handle.apply( eventHandle.elem, arguments ) :
2875
jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
2636
2876
undefined;
2637
2877
};
2878
// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
2879
eventHandle.elem = elem;
2638
2880
}
2639
2881
2640
// Add elem as a property of the handle function
2641
// This is to prevent a memory leak with non-native events in IE.
2642
eventHandle.elem = elem;
2643
2644
2882
// Handle multiple events separated by a space
2645
2883
// jQuery(...).bind("mouseover mouseout", fn);
2646
types = types.split(" ");
2647
2648
var type, i = 0, namespaces;
2649
2650
while ( (type = types[ i++ ]) ) {
2651
handleObj = handleObjIn ?
2652
jQuery.extend({}, handleObjIn) :
2653
{ handler: handler, data: data };
2654
2655
// Namespaced event handlers
2656
if ( type.indexOf(".") > -1 ) {
2657
namespaces = type.split(".");
2658
type = namespaces.shift();
2659
handleObj.namespace = namespaces.slice(0).sort().join(".");
2660
2661
} else {
2662
namespaces = [];
2663
handleObj.namespace = "";
2664
}
2665
2666
handleObj.type = type;
2667
if ( !handleObj.guid ) {
2668
handleObj.guid = handler.guid;
2669
}
2670
2671
// Get the current list of functions bound to this event
2672
var handlers = events[ type ],
2673
special = jQuery.event.special[ type ] || {};
2674
2675
// Init the event handler queue
2884
types = jQuery.trim( hoverHack(types) ).split( " " );
2885
for ( t = 0; t < types.length; t++ ) {
2886
2887
tns = rtypenamespace.exec( types[t] ) || [];
2888
type = tns[1];
2889
namespaces = ( tns[2] || "" ).split( "." ).sort();
2890
2891
// If event changes its type, use the special event handlers for the changed type
2892
special = jQuery.event.special[ type ] || {};
2893
2894
// If selector defined, determine special event api type, otherwise given type
2895
type = ( selector ? special.delegateType : special.bindType ) || type;
2896
2897
// Update special based on newly reset type
2898
special = jQuery.event.special[ type ] || {};
2899
2900
// handleObj is passed to all event handlers
2901
handleObj = jQuery.extend({
2902
type: type,
2903
origType: tns[1],
2904
data: data,
2905
handler: handler,
2906
guid: handler.guid,
2907
selector: selector,
2908
quick: quickParse( selector ),
2909
namespace: namespaces.join(".")
2910
}, handleObjIn );
2911
2912
// Init the event handler queue if we're the first
2913
handlers = events[ type ];
2676
2914
if ( !handlers ) {
2677
2915
handlers = events[ type ] = [];
2916
handlers.delegateCount = 0;
2678
2917
2679
// Check for a special event handler
2680
// Only use addEventListener/attachEvent if the special
2681
// events handler returns false
2918
// Only use addEventListener/attachEvent if the special events handler returns false
2682
2919
if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2683
2920
// Bind the global event handler to the element
2684
2921
if ( elem.addEventListener ) {
2698
2935
}
2699
2936
}
2700
2937
2701
// Add the function to the element's handler list
2702
handlers.push( handleObj );
2938
// Add to the element's handler list, delegates in front
2939
if ( selector ) {
2940
handlers.splice( handlers.delegateCount++, 0, handleObj );
2941
} else {
2942
handlers.push( handleObj );
2943
}
2703
2944
2704
// Keep track of which events have been used, for event optimization
2945
// Keep track of which events have ever been used, for event optimization
2705
2946
jQuery.event.global[ type ] = true;
2706
2947
}
2707
2948
2712
2953
global: {},
2713
2954
2714
2955
// Detach an event or set of events from an element
2715
remove: function( elem, types, handler, pos ) {
2716
// don't do events on text and comment nodes
2717
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2718
return;
2719
}
2720
2721
if ( handler === false ) {
2722
handler = returnFalse;
2723
}
2724
2725
var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
2726
elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2727
events = elemData && elemData.events;
2728
2729
if ( !elemData || !events ) {
2730
return;
2731
}
2732
2733
// types is actually an event object here
2734
if ( types && types.type ) {
2735
handler = types.handler;
2736
types = types.type;
2737
}
2738
2739
// Unbind all events for the element
2740
if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
2741
types = types || "";
2742
2743
for ( type in events ) {
2744
jQuery.event.remove( elem, type + types );
2745
}
2746
2747
return;
2748
}
2749
2750
// Handle multiple events separated by a space
2751
// jQuery(...).unbind("mouseover mouseout", fn);
2752
types = types.split(" ");
2753
2754
while ( (type = types[ i++ ]) ) {
2755
origType = type;
2756
handleObj = null;
2757
all = type.indexOf(".") < 0;
2758
namespaces = [];
2759
2760
if ( !all ) {
2761
// Namespaced event handlers
2762
namespaces = type.split(".");
2763
type = namespaces.shift();
2764
2765
namespace = new RegExp("(^|\\.)" +
2766
jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
2767
}
2768
2769
eventType = events[ type ];
2770
2771
if ( !eventType ) {
2772
continue;
2773
}
2774
2775
if ( !handler ) {
2776
for ( j = 0; j < eventType.length; j++ ) {
2777
handleObj = eventType[ j ];
2778
2779
if ( all || namespace.test( handleObj.namespace ) ) {
2780
jQuery.event.remove( elem, origType, handleObj.handler, j );
2781
eventType.splice( j--, 1 );
2782
}
2956
remove: function( elem, types, handler, selector, mappedTypes ) {
2957
2958
var elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2959
t, tns, type, origType, namespaces, origCount,
2960
j, events, special, handle, eventType, handleObj;
2961
2962
if ( !elemData || !(events = elemData.events) ) {
2963
return;
2964
}
2965
2966
// Once for each type.namespace in types; type may be omitted
2967
types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
2968
for ( t = 0; t < types.length; t++ ) {
2969
tns = rtypenamespace.exec( types[t] ) || [];
2970
type = origType = tns[1];
2971
namespaces = tns[2];
2972
2973
// Unbind all events (on this namespace, if provided) for the element
2974
if ( !type ) {
2975
for ( type in events ) {
2976
jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
2783
2977
}
2784
2785
2978
continue;
2786
2979
}
2787
2980
2788
2981
special = jQuery.event.special[ type ] || {};
2982
type = ( selector? special.delegateType : special.bindType ) || type;
2983
eventType = events[ type ] || [];
2984
origCount = eventType.length;
2985
namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
2789
2986
2790
for ( j = pos || 0; j < eventType.length; j++ ) {
2987
// Remove matching events
2988
for ( j = 0; j < eventType.length; j++ ) {
2791
2989
handleObj = eventType[ j ];
2792
2990
2793
if ( handler.guid === handleObj.guid ) {
2794
// remove the given handler for the given type
2795
if ( all || namespace.test( handleObj.namespace ) ) {
2796
if ( pos == null ) {
2797
eventType.splice( j--, 1 );
2798
}
2991
if ( ( mappedTypes || origType === handleObj.origType ) &&
2992
( !handler || handler.guid === handleObj.guid ) &&
2993
( !namespaces || namespaces.test( handleObj.namespace ) ) &&
2994
( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
2995
eventType.splice( j--, 1 );
2799
2996
2800
if ( special.remove ) {
2801
special.remove.call( elem, handleObj );
2802
}
2997
if ( handleObj.selector ) {
2998
eventType.delegateCount--;
2803
2999
}
2804
2805
if ( pos != null ) {
2806
break;
3000
if ( special.remove ) {
3001
special.remove.call( elem, handleObj );
2807
3002
}
2808
3003
}
2809
3004
}
2810
3005
2811
// remove generic event handler if no more handlers exist
2812
if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
3006
// Remove generic event handler if we removed something and no more handlers exist
3007
// (avoids potential for endless recursion during removal of special event handlers)
3008
if ( eventType.length === 0 && origCount !== eventType.length ) {
2813
3009
if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
2814
3010
jQuery.removeEvent( elem, type, elemData.handle );
2815
3011
}
2816
3012
2817
ret = null;
2818
3013
delete events[ type ];
2819
3014
}
2820
3015
}
2821
3016
2822
3017
// Remove the expando if it's no longer used
2823
3018
if ( jQuery.isEmptyObject( events ) ) {
2824
var handle = elemData.handle;
3019
handle = elemData.handle;
2825
3020
if ( handle ) {
2826
3021
handle.elem = null;
2827
3022
}
2828
3023
2829
delete elemData.events;
2830
delete elemData.handle;
2831
2832
if ( jQuery.isEmptyObject( elemData ) ) {
2833
jQuery.removeData( elem, undefined, true );
2834
}
3024
// removeData also checks for emptiness and clears the expando if empty
3025
// so use it instead of delete
3026
jQuery.removeData( elem, [ "events", "handle" ], true );
2835
3027
}
2836
3028
},
2837
3029
2838
3030
// Events that are safe to short-circuit if no handlers are attached.
2839
3031
// Native DOM events should not be added, they may have inline handlers.
2840
3032
customEvent: {
2844
3036
},
2845
3037
2846
3038
trigger: function( event, data, elem, onlyHandlers ) {
3039
// Don't do events on text and comment nodes
3040
if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
3041
return;
3042
}
3043
2847
3044
// Event object or event type
2848
3045
var type = event.type || event,
2849
3046
namespaces = [],
2850
exclusive;
2851
2852
if ( type.indexOf("!") >= 0 ) {
3047
cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType;
3048
3049
// focus/blur morphs to focusin/out; ensure we're not firing them right now
3050
if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
3051
return;
3052
}
3053
3054
if ( type.indexOf( "!" ) >= 0 ) {
2853
3055
// Exclusive events trigger only for the exact event (no namespaces)
2854
3056
type = type.slice(0, -1);
2855
3057
exclusive = true;
2856
3058
}
2857
3059
2858
if ( type.indexOf(".") >= 0 ) {
3060
if ( type.indexOf( "." ) >= 0 ) {
2859
3061
// Namespaced trigger; create a regexp to match event type in handle()
2860
3062
namespaces = type.split(".");
2861
3063
type = namespaces.shift();
2877
3079
new jQuery.Event( type );
2878
3080
2879
3081
event.type = type;
3082
event.isTrigger = true;
2880
3083
event.exclusive = exclusive;
2881
event.namespace = namespaces.join(".");
2882
event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
2883
2884
// triggerHandler() and global events don't bubble or run the default action
2885
if ( onlyHandlers || !elem ) {
2886
event.preventDefault();
2887
event.stopPropagation();
2888
}
3084
event.namespace = namespaces.join( "." );
3085
event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
3086
ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
2889
3087
2890
3088
// Handle a global trigger
2891
3089
if ( !elem ) {
3090
2892
3091
// TODO: Stop taunting the data cache; remove global events and always attach to document
2893
jQuery.each( jQuery.cache, function() {
2894
// internalKey variable is just used to make it easier to find
2895
// and potentially change this stuff later; currently it just
2896
// points to jQuery.expando
2897
var internalKey = jQuery.expando,
2898
internalCache = this[ internalKey ];
2899
if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
2900
jQuery.event.trigger( event, data, internalCache.handle.elem );
3092
cache = jQuery.cache;
3093
for ( i in cache ) {
3094
if ( cache[ i ].events && cache[ i ].events[ type ] ) {
3095
jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
2901
3096
}
2902
});
2903
return;
2904
}
2905
2906
// Don't do events on text and comment nodes
2907
if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
3097
}
2908
3098
return;
2909
3099
}
2910
3100
2911
3101
// Clean up the event in case it is being reused
2912
3102
event.result = undefined;
2913
event.target = elem;
3103
if ( !event.target ) {
3104
event.target = elem;
3105
}
2914
3106
2915
3107
// Clone any incoming data and prepend the event, creating the handler arg list
2916
3108
data = data != null ? jQuery.makeArray( data ) : [];
2917
3109
data.unshift( event );
2918
3110
2919
var cur = elem,
2920
// IE doesn't like method names with a colon (#3533, #8272)
2921
ontype = type.indexOf(":") < 0 ? "on" + type : "";
2922
2923
// Fire event on the current element, then bubble up the DOM tree
2924
do {
2925
var handle = jQuery._data( cur, "handle" );
2926
2927
event.currentTarget = cur;
3111
// Allow special events to draw outside the lines
3112
special = jQuery.event.special[ type ] || {};
3113
if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
3114
return;
3115
}
3116
3117
// Determine event propagation path in advance, per W3C events spec (#9951)
3118
// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
3119
eventPath = [[ elem, special.bindType || type ]];
3120
if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
3121
3122
bubbleType = special.delegateType || type;
3123
cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
3124
old = null;
3125
for ( ; cur; cur = cur.parentNode ) {
3126
eventPath.push([ cur, bubbleType ]);
3127
old = cur;
3128
}
3129
3130
// Only add window if we got to document (e.g., not plain obj or detached DOM)
3131
if ( old && old === elem.ownerDocument ) {
3132
eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
3133
}
3134
}
3135
3136
// Fire handlers on the event path
3137
for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
3138
3139
cur = eventPath[i][0];
3140
event.type = eventPath[i][1];
3141
3142
handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
2928
3143
if ( handle ) {
2929
3144
handle.apply( cur, data );
2930
3145
}
2931
2932
// Trigger an inline bound script
2933
if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
2934
event.result = false;
3146
// Note that this is a bare JS function and not a jQuery handler
3147
handle = ontype && cur[ ontype ];
3148
if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
2935
3149
event.preventDefault();
2936
3150
}
2937
2938
// Bubble up to document, then to window
2939
cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
2940
} while ( cur && !event.isPropagationStopped() );
3151
}
3152
event.type = type;
2941
3153
2942
3154
// If nobody prevented the default action, do it now
2943
if ( !event.isDefaultPrevented() ) {
2944
var old,
2945
special = jQuery.event.special[ type ] || {};
3155
if ( !onlyHandlers && !event.isDefaultPrevented() ) {
2946
3156
2947
if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
3157
if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
2948
3158
!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
2949
3159
2950
3160
// Call a native DOM method on the target with the same name name as the event.
2951
// Can't use an .isFunction)() check here because IE6/7 fails that test.
2952
// IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
2953
try {
2954
if ( ontype && elem[ type ] ) {
2955
// Don't re-trigger an onFOO event when we call its FOO() method
2956
old = elem[ ontype ];
2957
2958
if ( old ) {
2959
elem[ ontype ] = null;
2960
}
2961
2962
jQuery.event.triggered = type;
2963
elem[ type ]();
2964
}
2965
} catch ( ieError ) {}
2966
2967
if ( old ) {
2968
elem[ ontype ] = old;
3161
// Can't use an .isFunction() check here because IE6/7 fails that test.
3162
// Don't do default actions on window, that's where global variables be (#6170)
3163
// IE<9 dies on focus/blur to hidden element (#1486)
3164
if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
3165
3166
// Don't re-trigger an onFOO event when we call its FOO() method
3167
old = elem[ ontype ];
3168
3169
if ( old ) {
3170
elem[ ontype ] = null;
3171
}
3172
3173
// Prevent re-triggering of the same event, since we already bubbled it above
3174
jQuery.event.triggered = type;
3175
elem[ type ]();
3176
jQuery.event.triggered = undefined;
3177
3178
if ( old ) {
3179
elem[ ontype ] = old;
3180
}
2969
3181
}
2970
2971
jQuery.event.triggered = undefined;
2972
3182
}
2973
3183
}
2974
3184
2975
3185
return event.result;
2976
3186
},
2977
3187
2978
handle: function( event ) {
3188
dispatch: function( event ) {
3189
3190
// Make a writable jQuery.Event from the native event object
2979
3191
event = jQuery.event.fix( event || window.event );
2980
// Snapshot the handlers list since a called handler may add/remove events.
2981
var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
3192
3193
var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
3194
delegateCount = handlers.delegateCount,
3195
args = [].slice.call( arguments, 0 ),
2982
3196
run_all = !event.exclusive && !event.namespace,
2983
args = Array.prototype.slice.call( arguments, 0 );
3197
handlerQueue = [],
3198
i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;
2984
3199
2985
// Use the fix-ed Event rather than the (read-only) native event
3200
// Use the fix-ed jQuery.Event rather than the (read-only) native event
2986
3201
args[0] = event;
2987
event.currentTarget = this;
2988
2989
for ( var j = 0, l = handlers.length; j < l; j++ ) {
2990
var handleObj = handlers[ j ];
2991
2992
// Triggered event must 1) be non-exclusive and have no namespace, or
2993
// 2) have namespace(s) a subset or equal to those in the bound event.
2994
if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {
2995
// Pass in a reference to the handler function itself
2996
// So that we can later remove it
2997
event.handler = handleObj.handler;
2998
event.data = handleObj.data;
2999
event.handleObj = handleObj;
3000
3001
var ret = handleObj.handler.apply( this, args );
3002
3003
if ( ret !== undefined ) {
3004
event.result = ret;
3005
if ( ret === false ) {
3006
event.preventDefault();
3007
event.stopPropagation();
3008
}
3009
}
3010
3011
if ( event.isImmediatePropagationStopped() ) {
3012
break;
3013
}
3014
}
3015
}
3202
event.delegateTarget = this;
3203
3204
// Determine handlers that should run if there are delegated events
3205
// Avoid disabled elements in IE (#6911) and non-left-click bubbling in Firefox (#3861)
3206
if ( delegateCount && !event.target.disabled && !(event.button && event.type === "click") ) {
3207
3208
// Pregenerate a single jQuery object for reuse with .is()
3209
jqcur = jQuery(this);
3210
jqcur.context = this.ownerDocument || this;
3211
3212
for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
3213
selMatch = {};
3214
matches = [];
3215
jqcur[0] = cur;
3216
for ( i = 0; i < delegateCount; i++ ) {
3217
handleObj = handlers[ i ];
3218
sel = handleObj.selector;
3219
3220
if ( selMatch[ sel ] === undefined ) {
3221
selMatch[ sel ] = (
3222
handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel )
3223
);
3224
}
3225
if ( selMatch[ sel ] ) {
3226
matches.push( handleObj );
3227
}
3228
}
3229
if ( matches.length ) {
3230
handlerQueue.push({ elem: cur, matches: matches });
3231
}
3232
}
3233
}
3234
3235
// Add the remaining (directly-bound) handlers
3236
if ( handlers.length > delegateCount ) {
3237
handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
3238
}
3239
3240
// Run delegates first; they may want to stop propagation beneath us
3241
for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
3242
matched = handlerQueue[ i ];
3243
event.currentTarget = matched.elem;
3244
3245
for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
3246
handleObj = matched.matches[ j ];
3247
3248
// Triggered event must either 1) be non-exclusive and have no namespace, or
3249
// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
3250
if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
3251
3252
event.data = handleObj.data;
3253
event.handleObj = handleObj;
3254
3255
ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
3256
.apply( matched.elem, args );
3257
3258
if ( ret !== undefined ) {
3259
event.result = ret;
3260
if ( ret === false ) {
3261
event.preventDefault();
3262
event.stopPropagation();
3263
}
3264
}
3265
}
3266
}
3267
}
3268
3016
3269
return event.result;
3017
3270
},
3018
3271
3019
props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
3272
// Includes some event props shared by KeyEvent and MouseEvent
3273
// *** attrChange attrName relatedNode srcElement are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
3274
props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
3275
3276
fixHooks: {},
3277
3278
keyHooks: {
3279
props: "char charCode key keyCode".split(" "),
3280
filter: function( event, original ) {
3281
3282
// Add which for key events
3283
if ( event.which == null ) {
3284
event.which = original.charCode != null ? original.charCode : original.keyCode;
3285
}
3286
3287
return event;
3288
}
3289
},
3290
3291
mouseHooks: {
3292
props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
3293
filter: function( event, original ) {
3294
var eventDoc, doc, body,
3295
button = original.button,
3296
fromElement = original.fromElement;
3297
3298
// Calculate pageX/Y if missing and clientX/Y available
3299
if ( event.pageX == null && original.clientX != null ) {
3300
eventDoc = event.target.ownerDocument || document;
3301
doc = eventDoc.documentElement;
3302
body = eventDoc.body;
3303
3304
event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
3305
event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 );
3306
}
3307
3308
// Add relatedTarget, if necessary
3309
if ( !event.relatedTarget && fromElement ) {
3310
event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
3311
}
3312
3313
// Add which for click: 1 === left; 2 === middle; 3 === right
3314
// Note: button is not normalized, so don't use it
3315
if ( !event.which && button !== undefined ) {
3316
event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
3317
}
3318
3319
return event;
3320
}
3321
},
3020
3322
3021
3323
fix: function( event ) {
3022
3324
if ( event[ jQuery.expando ] ) {
3023
3325
return event;
3024
3326
}
3025
3327
3026
// store a copy of the original event object
3027
// and "clone" to set read-only properties
3028
var originalEvent = event;
3328
// Create a writable copy of the event object and normalize some properties
3329
var i, prop,
3330
originalEvent = event,
3331
fixHook = jQuery.event.fixHooks[ event.type ] || {},
3332
copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
3333
3029
3334
event = jQuery.Event( originalEvent );
3030
3335
3031
for ( var i = this.props.length, prop; i; ) {
3032
prop = this.props[ --i ];
3336
for ( i = copy.length; i; ) {
3337
prop = copy[ --i ];
3033
3338
event[ prop ] = originalEvent[ prop ];
3034
3339
}
3035
3340
3036
// Fix target property, if necessary
3341
// Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
3037
3342
if ( !event.target ) {
3038
// Fixes #1925 where srcElement might not be defined either
3039
event.target = event.srcElement || document;
3343
event.target = originalEvent.srcElement || document;
3040
3344
}
3041
3345
3042
// check if target is a textnode (safari)
3346
// Target should not be a text node (#504, Safari)
3043
3347
if ( event.target.nodeType === 3 ) {
3044
3348
event.target = event.target.parentNode;
3045
3349
}
3046
3350
3047
// Add relatedTarget, if necessary
3048
if ( !event.relatedTarget && event.fromElement ) {
3049
event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
3050
}
3051
3052
// Calculate pageX/Y if missing and clientX/Y available
3053
if ( event.pageX == null && event.clientX != null ) {
3054
var eventDocument = event.target.ownerDocument || document,
3055
doc = eventDocument.documentElement,
3056
body = eventDocument.body;
3057
3058
event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
3059
event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
3060
}
3061
3062
// Add which for key events
3063
if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
3064
event.which = event.charCode != null ? event.charCode : event.keyCode;
3065
}
3066
3067
// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
3068
if ( !event.metaKey && event.ctrlKey ) {
3351
// For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8)
3352
if ( event.metaKey === undefined ) {
3069
3353
event.metaKey = event.ctrlKey;
3070
3354
}
3071
3355
3072
// Add which for click: 1 === left; 2 === middle; 3 === right
3073
// Note: button is not normalized, so don't use it
3074
if ( !event.which && event.button !== undefined ) {
3075
event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
3076
}
3077
3078
return event;
3356
return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
3079
3357
},
3080
3358
3081
// Deprecated, use jQuery.guid instead
3082
guid: 1E8,
3083
3084
// Deprecated, use jQuery.proxy instead
3085
proxy: jQuery.proxy,
3086
3087
3359
special: {
3088
3360
ready: {
3089
3361
// Make sure the ready event is setup
3090
setup: jQuery.bindReady,
3091
teardown: jQuery.noop
3092
},
3093
3094
live: {
3095
add: function( handleObj ) {
3096
jQuery.event.add( this,
3097
liveConvert( handleObj.origType, handleObj.selector ),
3098
jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
3099
},
3100
3101
remove: function( handleObj ) {
3102
jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
3103
}
3362
setup: jQuery.bindReady
3363
},
3364
3365
load: {
3366
// Prevent triggered image.load events from bubbling to window.load
3367
noBubble: true
3368
},
3369
3370
focus: {
3371
delegateType: "focusin"
3372
},
3373
blur: {
3374
delegateType: "focusout"
3104
3375
},
3105
3376
3106
3377
beforeunload: {
3117
3388
}
3118
3389
}
3119
3390
}
3391
},
3392
3393
simulate: function( type, elem, event, bubble ) {
3394
// Piggyback on a donor event to simulate a different one.
3395
// Fake originalEvent to avoid donor's stopPropagation, but if the
3396
// simulated event prevents default then we do the same on the donor.
3397
var e = jQuery.extend(
3398
new jQuery.Event(),
3399
event,
3400
{ type: type,
3401
isSimulated: true,
3402
originalEvent: {}
3403
}
3404
);
3405
if ( bubble ) {
3406
jQuery.event.trigger( e, null, elem );
3407
} else {
3408
jQuery.event.dispatch.call( elem, e );
3409
}
3410
if ( e.isDefaultPrevented() ) {
3411
event.preventDefault();
3412
}
3120
3413
}
3121
3414
};
3122
3415
3416
// Some plugins are using, but it's undocumented/deprecated and will be removed.
3417
// The 1.7 special event interface should provide all the hooks needed now.
3418
jQuery.event.handle = jQuery.event.dispatch;
3419
3123
3420
jQuery.removeEvent = document.removeEventListener ?
3124
3421
function( elem, type, handle ) {
3125
3422
if ( elem.removeEventListener ) {
3134
3431
3135
3432
jQuery.Event = function( src, props ) {
3136
3433
// Allow instantiation without the 'new' keyword
3137
if ( !this.preventDefault ) {
3434
if ( !(this instanceof jQuery.Event) ) {
3138
3435
return new jQuery.Event( src, props );
3139
3436
}
3140
3437
3145
3442
3146
3443
// Events bubbling up the document may have been marked as prevented
3147
3444
// by a handler lower down the tree; reflect the correct value.
3148
this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
3149
src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
3445
this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
3446
src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
3150
3447
3151
3448
// Event type
3152
3449
} else {
3158
3455
jQuery.extend( this, props );
3159
3456
}
3160
3457
3161
// timeStamp is buggy for some events on Firefox(#3843)
3162
// So we won't rely on the native value
3163
this.timeStamp = jQuery.now();
3458
// Create a timestamp if incoming event doesn't have one
3459
this.timeStamp = src && src.timeStamp || jQuery.now();
3164
3460
3165
3461
// Mark it as fixed
3166
3462
this[ jQuery.expando ] = true;
3216
3512
isImmediatePropagationStopped: returnFalse
3217
3513
};
3218
3514
3219
// Checks if an event happened on an element within another element
3220
// Used in jQuery.event.special.mouseenter and mouseleave handlers
3221
var withinElement = function( event ) {
3222
3223
// Check if mouse(over|out) are still within the same parent element
3224
var related = event.relatedTarget,
3225
inside = false,
3226
eventType = event.type;
3227
3228
event.type = event.data;
3229
3230
if ( related !== this ) {
3231
3232
if ( related ) {
3233
inside = jQuery.contains( this, related );
3234
}
3235
3236
if ( !inside ) {
3237
3238
jQuery.event.handle.apply( this, arguments );
3239
3240
event.type = eventType;
3241
}
3242
}
3243
},
3244
3245
// In case of event delegation, we only need to rename the event.type,
3246
// liveHandler will take care of the rest.
3247
delegate = function( event ) {
3248
event.type = event.data;
3249
jQuery.event.handle.apply( this, arguments );
3250
};
3251
3252
// Create mouseenter and mouseleave events
3515
// Create mouseenter/leave events using mouseover/out and event-time checks
3253
3516
jQuery.each({
3254
3517
mouseenter: "mouseover",
3255
3518
mouseleave: "mouseout"
3256
3519
}, function( orig, fix ) {
3257
3520
jQuery.event.special[ orig ] = {
3258
setup: function( data ) {
3259
jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
3260
},
3261
teardown: function( data ) {
3262
jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
3521
delegateType: fix,
3522
bindType: fix,
3523
3524
handle: function( event ) {
3525
var target = this,
3526
related = event.relatedTarget,
3527
handleObj = event.handleObj,
3528
selector = handleObj.selector,
3529
ret;
3530
3531
// For mousenter/leave call the handler if related is outside the target.
3532
// NB: No relatedTarget if the mouse left/entered the browser window
3533
if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
3534
event.type = handleObj.origType;
3535
ret = handleObj.handler.apply( this, arguments );
3536
event.type = fix;
3537
}
3538
return ret;
3263
3539
}
3264
3540
};
3265
3541
});
3266
3542
3267
// submit delegation
3543
// IE submit delegation
3268
3544
if ( !jQuery.support.submitBubbles ) {
3269
3545
3270
3546
jQuery.event.special.submit = {
3271
setup: function( data, namespaces ) {
3272
if ( !jQuery.nodeName( this, "form" ) ) {
3273
jQuery.event.add(this, "click.specialSubmit", function( e ) {
3274
// Avoid triggering error on non-existent type attribute in IE VML (#7071)
3275
var elem = e.target,
3276
type = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.type : "";
3277
3278
if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
3279
trigger( "submit", this, arguments );
3280
}
3281
});
3282
3283
jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
3284
var elem = e.target,
3285
type = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.type : "";
3286
3287
if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
3288
trigger( "submit", this, arguments );
3289
}
3290
});
3291
3292
} else {
3547
setup: function() {
3548
// Only need this for delegated form submit events
3549
if ( jQuery.nodeName( this, "form" ) ) {
3293
3550
return false;
3294
3551
}
3552
3553
// Lazy-add a submit handler when a descendant form may potentially be submitted
3554
jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
3555
// Node name check avoids a VML-related crash in IE (#9807)
3556
var elem = e.target,
3557
form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
3558
if ( form && !form._submit_attached ) {
3559
jQuery.event.add( form, "submit._submit", function( event ) {
3560
// If form was submitted by the user, bubble the event up the tree
3561
if ( this.parentNode && !event.isTrigger ) {
3562
jQuery.event.simulate( "submit", this.parentNode, event, true );
3563
}
3564
});
3565
form._submit_attached = true;
3566
}
3567
});
3568
// return undefined since we don't need an event listener
3295
3569
},
3296
3570
3297
teardown: function( namespaces ) {
3298
jQuery.event.remove( this, ".specialSubmit" );
3571
teardown: function() {
3572
// Only need this for delegated form submit events
3573
if ( jQuery.nodeName( this, "form" ) ) {
3574
return false;
3575
}
3576
3577
// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
3578
jQuery.event.remove( this, "._submit" );
3299
3579
}
3300
3580
};
3301
3302
3581
}
3303
3582
3304
// change delegation, happens here so we have bind.
3583
// IE change delegation and checkbox/radio fix
3305
3584
if ( !jQuery.support.changeBubbles ) {
3306
3585
3307
var changeFilters,
3308
3309
getVal = function( elem ) {
3310
var type = jQuery.nodeName( elem, "input" ) ? elem.type : "",
3311
val = elem.value;
3312
3313
if ( type === "radio" || type === "checkbox" ) {
3314
val = elem.checked;
3315
3316
} else if ( type === "select-multiple" ) {
3317
val = elem.selectedIndex > -1 ?
3318
jQuery.map( elem.options, function( elem ) {
3319
return elem.selected;
3320
}).join("-") :
3321
"";
3322
3323
} else if ( jQuery.nodeName( elem, "select" ) ) {
3324
val = elem.selectedIndex;
3325
}
3326
3327
return val;
3328
},
3329
3330
testChange = function testChange( e ) {
3331
var elem = e.target, data, val;
3332
3333
if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
3334
return;
3335
}
3336
3337
data = jQuery._data( elem, "_change_data" );
3338
val = getVal(elem);
3339
3340
// the current data will be also retrieved by beforeactivate
3341
if ( e.type !== "focusout" || elem.type !== "radio" ) {
3342
jQuery._data( elem, "_change_data", val );
3343
}
3344
3345
if ( data === undefined || val === data ) {
3346
return;
3347
}
3348
3349
if ( data != null || val ) {
3350
e.type = "change";
3351
e.liveFired = undefined;
3352
jQuery.event.trigger( e, arguments[1], elem );
3353
}
3354
};
3355
3356
3586
jQuery.event.special.change = {
3357
filters: {
3358
focusout: testChange,
3359
3360
beforedeactivate: testChange,
3361
3362
click: function( e ) {
3363
var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
3364
3365
if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) {
3366
testChange.call( this, e );
3367
}
3368
},
3369
3370
// Change has to be called before submit
3371
// Keydown will be called before keypress, which is used in submit-event delegation
3372
keydown: function( e ) {
3373
var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
3374
3375
if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) ||
3376
(e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
3377
type === "select-multiple" ) {
3378
testChange.call( this, e );
3379
}
3380
},
3381
3382
// Beforeactivate happens also before the previous element is blurred
3383
// with this event you can't trigger a change event, but you can store
3384
// information
3385
beforeactivate: function( e ) {
3587
3588
setup: function() {
3589
3590
if ( rformElems.test( this.nodeName ) ) {
3591
// IE doesn't fire change on a check/radio until blur; trigger it on click
3592
// after a propertychange. Eat the blur-change in special.change.handle.
3593
// This still fires onchange a second time for check/radio after blur.
3594
if ( this.type === "checkbox" || this.type === "radio" ) {
3595
jQuery.event.add( this, "propertychange._change", function( event ) {
3596
if ( event.originalEvent.propertyName === "checked" ) {
3597
this._just_changed = true;
3598
}
3599
});
3600
jQuery.event.add( this, "click._change", function( event ) {
3601
if ( this._just_changed && !event.isTrigger ) {
3602
this._just_changed = false;
3603
jQuery.event.simulate( "change", this, event, true );
3604
}
3605
});
3606
}
3607
return false;
3608
}
3609
// Delegated event; lazy-add a change handler on descendant inputs
3610
jQuery.event.add( this, "beforeactivate._change", function( e ) {
3386
3611
var elem = e.target;
3387
jQuery._data( elem, "_change_data", getVal(elem) );
3388
}
3389
},
3390
3391
setup: function( data, namespaces ) {
3392
if ( this.type === "file" ) {
3393
return false;
3394
}
3395
3396
for ( var type in changeFilters ) {
3397
jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
3398
}
3399
3400
return rformElems.test( this.nodeName );
3401
},
3402
3403
teardown: function( namespaces ) {
3404
jQuery.event.remove( this, ".specialChange" );
3612
3613
if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) {
3614
jQuery.event.add( elem, "change._change", function( event ) {
3615
if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
3616
jQuery.event.simulate( "change", this.parentNode, event, true );
3617
}
3618
});
3619
elem._change_attached = true;
3620
}
3621
});
3622
},
3623
3624
handle: function( event ) {
3625
var elem = event.target;
3626
3627
// Swallow native change events from checkbox/radio, we already triggered them above
3628
if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
3629
return event.handleObj.handler.apply( this, arguments );
3630
}
3631
},
3632
3633
teardown: function() {
3634
jQuery.event.remove( this, "._change" );
3405
3635
3406
3636
return rformElems.test( this.nodeName );
3407
3637
}
3408
3638
};
3409
3410
changeFilters = jQuery.event.special.change.filters;
3411
3412
// Handle when the input is .focus()'d
3413
changeFilters.focus = changeFilters.beforeactivate;
3414
}
3415
3416
function trigger( type, elem, args ) {
3417
// Piggyback on a donor event to simulate a different one.
3418
// Fake originalEvent to avoid donor's stopPropagation, but if the
3419
// simulated event prevents default then we do the same on the donor.
3420
// Don't pass args or remember liveFired; they apply to the donor event.
3421
var event = jQuery.extend( {}, args[ 0 ] );
3422
event.type = type;
3423
event.originalEvent = {};
3424
event.liveFired = undefined;
3425
jQuery.event.handle.call( elem, event );
3426
if ( event.isDefaultPrevented() ) {
3427
args[ 0 ].preventDefault();
3428
}
3429
3639
}
3430
3640
3431
3641
// Create "bubbling" focus and blur events
3433
3643
jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
3434
3644
3435
3645
// Attach a single capturing handler while someone wants focusin/focusout
3436
var attaches = 0;
3646
var attaches = 0,
3647
handler = function( event ) {
3648
jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
3649
};
3437
3650
3438
3651
jQuery.event.special[ fix ] = {
3439
3652
setup: function() {
3447
3660
}
3448
3661
}
3449
3662
};
3450
3451
function handler( donor ) {
3452
// Donor event is always a native one; fix it and switch its type.
3453
// Let focusin/out handler cancel the donor focus/blur event.
3454
var e = jQuery.event.fix( donor );
3455
e.type = fix;
3456
e.originalEvent = {};
3457
jQuery.event.trigger( e, null, e.target );
3458
if ( e.isDefaultPrevented() ) {
3459
donor.preventDefault();
3460
}
3461
}
3462
3663
});
3463
3664
}
3464
3665
3465
jQuery.each(["bind", "one"], function( i, name ) {
3466
jQuery.fn[ name ] = function( type, data, fn ) {
3467
var handler;
3468
3469
// Handle object literals
3470
if ( typeof type === "object" ) {
3471
for ( var key in type ) {
3472
this[ name ](key, data, type[key], fn);
3473
}
3474
return this;
3475
}
3476
3477
if ( arguments.length === 2 || data === false ) {
3478
fn = data;
3479
data = undefined;
3480
}
3481
3482
if ( name === "one" ) {
3483
handler = function( event ) {
3484
jQuery( this ).unbind( event, handler );
3485
return fn.apply( this, arguments );
3666
jQuery.fn.extend({
3667
3668
on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
3669
var origFn, type;
3670
3671
// Types can be a map of types/handlers
3672
if ( typeof types === "object" ) {
3673
// ( types-Object, selector, data )
3674
if ( typeof selector !== "string" ) {
3675
// ( types-Object, data )
3676
data = selector;
3677
selector = undefined;
3678
}
3679
for ( type in types ) {
3680
this.on( type, selector, data, types[ type ], one );
3681
}
3682
return this;
3683
}
3684
3685
if ( data == null && fn == null ) {
3686
// ( types, fn )
3687
fn = selector;
3688
data = selector = undefined;
3689
} else if ( fn == null ) {
3690
if ( typeof selector === "string" ) {
3691
// ( types, selector, fn )
3692
fn = data;
3693
data = undefined;
3694
} else {
3695
// ( types, data, fn )
3696
fn = data;
3697
data = selector;
3698
selector = undefined;
3699
}
3700
}
3701
if ( fn === false ) {
3702
fn = returnFalse;
3703
} else if ( !fn ) {
3704
return this;
3705
}
3706
3707
if ( one === 1 ) {
3708
origFn = fn;
3709
fn = function( event ) {
3710
// Can use an empty set, since event contains the info
3711
jQuery().off( event );
3712
return origFn.apply( this, arguments );
3486
3713
};
3487
handler.guid = fn.guid || jQuery.guid++;
3488
} else {
3489
handler = fn;
3490
}
3491
3492
if ( type === "unload" && name !== "one" ) {
3493
this.one( type, data, fn );
3494
3495
} else {
3496
for ( var i = 0, l = this.length; i < l; i++ ) {
3497
jQuery.event.add( this[i], type, handler, data );
3714
// Use same guid so caller can remove using origFn
3715
fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
3716
}
3717
return this.each( function() {
3718
jQuery.event.add( this, types, fn, data, selector );
3719
});
3720
},
3721
one: function( types, selector, data, fn ) {
3722
return this.on.call( this, types, selector, data, fn, 1 );
3723
},
3724
off: function( types, selector, fn ) {
3725
if ( types && types.preventDefault && types.handleObj ) {
3726
// ( event ) dispatched jQuery.Event
3727
var handleObj = types.handleObj;
3728
jQuery( types.delegateTarget ).off(
3729
handleObj.namespace? handleObj.type + "." + handleObj.namespace : handleObj.type,
3730
handleObj.selector,
3731
handleObj.handler
3732
);
3733
return this;
3734
}
3735
if ( typeof types === "object" ) {
3736
// ( types-object [, selector] )
3737
for ( var type in types ) {
3738
this.off( type, selector, types[ type ] );
3498
3739
}
3499
}
3500
3740
return this;
3741
}
3742
if ( selector === false || typeof selector === "function" ) {
3743
// ( types [, fn] )
3744
fn = selector;
3745
selector = undefined;
3746
}
3747
if ( fn === false ) {
3748
fn = returnFalse;
3749
}
3750
return this.each(function() {
3751
jQuery.event.remove( this, types, fn, selector );
3752
});
3753
},
3754
3755
bind: function( types, data, fn ) {
3756
return this.on( types, null, data, fn );
3757
},
3758
unbind: function( types, fn ) {
3759
return this.off( types, null, fn );
3760
},
3761
3762
live: function( types, data, fn ) {
3763
jQuery( this.context ).on( types, this.selector, data, fn );
3501
3764
return this;
3502
};
3503
});
3504
3505
jQuery.fn.extend({
3506
unbind: function( type, fn ) {
3507
// Handle object literals
3508
if ( typeof type === "object" && !type.preventDefault ) {
3509
for ( var key in type ) {
3510
this.unbind(key, type[key]);
3511
}
3512
3513
} else {
3514
for ( var i = 0, l = this.length; i < l; i++ ) {
3515
jQuery.event.remove( this[i], type, fn );
3516
}
3517
}
3518
3765
},
3766
die: function( types, fn ) {
3767
jQuery( this.context ).off( types, this.selector || "**", fn );
3519
3768
return this;
3520
3769
},
3521
3770
3522
3771
delegate: function( selector, types, data, fn ) {
3523
return this.live( types, data, fn, selector );
3772
return this.on( types, selector, data, fn );
3524
3773
},
3525
3526
3774
undelegate: function( selector, types, fn ) {
3527
if ( arguments.length === 0 ) {
3528
return this.unbind( "live" );
3529
3530
} else {
3531
return this.die( types, null, fn, selector );
3532
}
3775
// ( namespace ) or ( selector, types [, fn] )
3776
return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn );
3533
3777
},
3534
3778
3535
3779
trigger: function( type, data ) {
3537
3781
jQuery.event.trigger( type, data, this );
3538
3782
});
3539
3783
},
3540
3541
3784
triggerHandler: function( type, data ) {
3542
3785
if ( this[0] ) {
3543
3786
return jQuery.event.trigger( type, data, this[0], true );
3551
3794
i = 0,
3552
3795
toggler = function( event ) {
3553
3796
// Figure out which function to execute
3554
var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
3555
jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3797
var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
3798
jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3556
3799
3557
3800
// Make sure that clicks stop
3558
3801
event.preventDefault();
3575
3818
}
3576
3819
});
3577
3820
3578
var liveMap = {
3579
focus: "focusin",
3580
blur: "focusout",
3581
mouseenter: "mouseover",
3582
mouseleave: "mouseout"
3583
};
3584
3585
jQuery.each(["live", "die"], function( i, name ) {
3586
jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
3587
var type, i = 0, match, namespaces, preType,
3588
selector = origSelector || this.selector,
3589
context = origSelector ? this : jQuery( this.context );
3590
3591
if ( typeof types === "object" && !types.preventDefault ) {
3592
for ( var key in types ) {
3593
context[ name ]( key, data, types[key], selector );
3594
}
3595
3596
return this;
3597
}
3598
3599
if ( name === "die" && !types &&
3600
origSelector && origSelector.charAt(0) === "." ) {
3601
3602
context.unbind( origSelector );
3603
3604
return this;
3605
}
3606
3607
if ( data === false || jQuery.isFunction( data ) ) {
3608
fn = data || returnFalse;
3609
data = undefined;
3610
}
3611
3612
types = (types || "").split(" ");
3613
3614
while ( (type = types[ i++ ]) != null ) {
3615
match = rnamespaces.exec( type );
3616
namespaces = "";
3617
3618
if ( match ) {
3619
namespaces = match[0];
3620
type = type.replace( rnamespaces, "" );
3621
}
3622
3623
if ( type === "hover" ) {
3624
types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
3625
continue;
3626
}
3627
3628
preType = type;
3629
3630
if ( liveMap[ type ] ) {
3631
types.push( liveMap[ type ] + namespaces );
3632
type = type + namespaces;
3633
3634
} else {
3635
type = (liveMap[ type ] || type) + namespaces;
3636
}
3637
3638
if ( name === "live" ) {
3639
// bind live handler
3640
for ( var j = 0, l = context.length; j < l; j++ ) {
3641
jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
3642
{ data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
3643
}
3644
3645
} else {
3646
// unbind live handler
3647
context.unbind( "live." + liveConvert( type, selector ), fn );
3648
}
3649
}
3650
3651
return this;
3652
};
3653
});
3654
3655
function liveHandler( event ) {
3656
var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
3657
elems = [],
3658
selectors = [],
3659
events = jQuery._data( this, "events" );
3660
3661
// Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
3662
if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
3663
return;
3664
}
3665
3666
if ( event.namespace ) {
3667
namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
3668
}
3669
3670
event.liveFired = this;
3671
3672
var live = events.live.slice(0);
3673
3674
for ( j = 0; j < live.length; j++ ) {
3675
handleObj = live[j];
3676
3677
if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
3678
selectors.push( handleObj.selector );
3679
3680
} else {
3681
live.splice( j--, 1 );
3682
}
3683
}
3684
3685
match = jQuery( event.target ).closest( selectors, event.currentTarget );
3686
3687
for ( i = 0, l = match.length; i < l; i++ ) {
3688
close = match[i];
3689
3690
for ( j = 0; j < live.length; j++ ) {
3691
handleObj = live[j];
3692
3693
if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
3694
elem = close.elem;
3695
related = null;
3696
3697
// Those two events require additional checking
3698
if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
3699
event.type = handleObj.preType;
3700
related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
3701
3702
// Make sure not to accidentally match a child element with the same selector
3703
if ( related && jQuery.contains( elem, related ) ) {
3704
related = elem;
3705
}
3706
}
3707
3708
if ( !related || related !== elem ) {
3709
elems.push({ elem: elem, handleObj: handleObj, level: close.level });
3710
}
3711
}
3712
}
3713
}
3714
3715
for ( i = 0, l = elems.length; i < l; i++ ) {
3716
match = elems[i];
3717
3718
if ( maxLevel && match.level > maxLevel ) {
3719
break;
3720
}
3721
3722
event.currentTarget = match.elem;
3723
event.data = match.handleObj.data;
3724
event.handleObj = match.handleObj;
3725
3726
ret = match.handleObj.origHandler.apply( match.elem, arguments );
3727
3728
if ( ret === false || event.isPropagationStopped() ) {
3729
maxLevel = match.level;
3730
3731
if ( ret === false ) {
3732
stop = false;
3733
}
3734
if ( event.isImmediatePropagationStopped() ) {
3735
break;
3736
}
3737
}
3738
}
3739
3740
return stop;
3741
}
3742
3743
function liveConvert( type, selector ) {
3744
return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
3745
}
3746
3747
3821
jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3748
3822
"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3749
"change select submit keydown keypress keyup error").split(" "), function( i, name ) {
3823
"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
3750
3824
3751
3825
// Handle event binding
3752
3826
jQuery.fn[ name ] = function( data, fn ) {
3756
3830
}
3757
3831
3758
3832
return arguments.length > 0 ?
3759
this.bind( name, data, fn ) :
3833
this.on( name, null, data, fn ) :
3760
3834
this.trigger( name );
3761
3835
};
3762
3836
3763
3837
if ( jQuery.attrFn ) {
3764
3838
jQuery.attrFn[ name ] = true;
3765
3839
}
3840
3841
if ( rkeyEvent.test( name ) ) {
3842
jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
3843
}
3844
3845
if ( rmouseEvent.test( name ) ) {
3846
jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
3847
}
3766
3848
});
3767
3849
3768
3850
3776
3858
(function(){
3777
3859
3778
3860
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
3861
expando = "sizcache" + (Math.random() + '').replace('.', ''),
3779
3862
done = 0,
3780
3863
toString = Object.prototype.toString,
3781
3864
hasDuplicate = false,
3782
3865
baseHasDuplicate = true,
3783
3866
rBackslash = /\\/g,
3867
rReturn = /\r\n/g,
3784
3868
rNonWord = /\W/;
3785
3869
3786
3870
// Here we check if the JavaScript engine is using some sort of
3832
3916
if ( parts.length > 1 && origPOS.exec( selector ) ) {
3833
3917
3834
3918
if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3835
set = posProcess( parts[0] + parts[1], context );
3919
set = posProcess( parts[0] + parts[1], context, seed );
3836
3920
3837
3921
} else {
3838
3922
set = Expr.relative[ parts[0] ] ?
3846
3930
selector += parts.shift();
3847
3931
}
3848
3932
3849
set = posProcess( selector, set );
3933
set = posProcess( selector, set, seed );
3850
3934
}
3851
3935
}
3852
3936
3965
4049
};
3966
4050
3967
4051
Sizzle.find = function( expr, context, isXML ) {
3968
var set;
4052
var set, i, len, match, type, left;
3969
4053
3970
4054
if ( !expr ) {
3971
4055
return [];
3972
4056
}
3973
4057
3974
for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
3975
var match,
3976
type = Expr.order[i];
4058
for ( i = 0, len = Expr.order.length; i < len; i++ ) {
4059
type = Expr.order[i];
3977
4060
3978
4061
if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
3979
var left = match[1];
4062
left = match[1];
3980
4063
match.splice( 1, 1 );
3981
4064
3982
4065
if ( left.substr( left.length - 1 ) !== "\\" ) {
4002
4085
4003
4086
Sizzle.filter = function( expr, set, inplace, not ) {
4004
4087
var match, anyFound,
4088
type, found, item, filter, left,
4089
i, pass,
4005
4090
old = expr,
4006
4091
result = [],
4007
4092
curLoop = set,
4008
4093
isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
4009
4094
4010
4095
while ( expr && set.length ) {
4011
for ( var type in Expr.filter ) {
4096
for ( type in Expr.filter ) {
4012
4097
if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
4013
var found, item,
4014
filter = Expr.filter[ type ],
4015
left = match[1];
4098
filter = Expr.filter[ type ];
4099
left = match[1];
4016
4100
4017
4101
anyFound = false;
4018
4102
4038
4122
}
4039
4123
4040
4124
if ( match ) {
4041
for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
4125
for ( i = 0; (item = curLoop[i]) != null; i++ ) {
4042
4126
if ( item ) {
4043
4127
found = filter( item, match, i, curLoop );
4044
var pass = not ^ !!found;
4128
pass = not ^ found;
4045
4129
4046
4130
if ( inplace && found != null ) {
4047
4131
if ( pass ) {
4092
4176
};
4093
4177
4094
4178
Sizzle.error = function( msg ) {
4095
throw "Syntax error, unrecognized expression: " + msg;
4179
throw new Error( "Syntax error, unrecognized expression: " + msg );
4180
};
4181
4182
/**
4183
* Utility function for retreiving the text value of an array of DOM nodes
4184
* @param {Array|Element} elem
4185
*/
4186
var getText = Sizzle.getText = function( elem ) {
4187
var i, node,
4188
nodeType = elem.nodeType,
4189
ret = "";
4190
4191
if ( nodeType ) {
4192
if ( nodeType === 1 || nodeType === 9 ) {
4193
// Use textContent || innerText for elements
4194
if ( typeof elem.textContent === 'string' ) {
4195
return elem.textContent;
4196
} else if ( typeof elem.innerText === 'string' ) {
4197
// Replace IE's carriage returns
4198
return elem.innerText.replace( rReturn, '' );
4199
} else {
4200
// Traverse it's children
4201
for ( elem = elem.firstChild; elem; elem = elem.nextSibling) {
4202
ret += getText( elem );
4203
}
4204
}
4205
} else if ( nodeType === 3 || nodeType === 4 ) {
4206
return elem.nodeValue;
4207
}
4208
} else {
4209
4210
// If no nodeType, this is expected to be an array
4211
for ( i = 0; (node = elem[i]); i++ ) {
4212
// Do not traverse comment nodes
4213
if ( node.nodeType !== 8 ) {
4214
ret += getText( node );
4215
}
4216
}
4217
}
4218
return ret;
4096
4219
};
4097
4220
4098
4221
var Expr = Sizzle.selectors = {
4482
4605
return filter( elem, i, match, array );
4483
4606
4484
4607
} else if ( name === "contains" ) {
4485
return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
4608
return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
4486
4609
4487
4610
} else if ( name === "not" ) {
4488
4611
var not = match[3];
4501
4624
},
4502
4625
4503
4626
CHILD: function( elem, match ) {
4504
var type = match[1],
4627
var first, last,
4628
doneName, parent, cache,
4629
count, diff,
4630
type = match[1],
4505
4631
node = elem;
4506
4632
4507
4633
switch ( type ) {
4529
4655
return true;
4530
4656
4531
4657
case "nth":
4532
var first = match[2],
4533
last = match[3];
4658
first = match[2];
4659
last = match[3];
4534
4660
4535
4661
if ( first === 1 && last === 0 ) {
4536
4662
return true;
4537
4663
}
4538
4664
4539
var doneName = match[0],
4540
parent = elem.parentNode;
4665
doneName = match[0];
4666
parent = elem.parentNode;
4541
4667
4542
if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
4543
var count = 0;
4668
if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) {
4669
count = 0;
4544
4670
4545
4671
for ( node = parent.firstChild; node; node = node.nextSibling ) {
4546
4672
if ( node.nodeType === 1 ) {
4548
4674
}
4549
4675
}
4550
4676
4551
parent.sizcache = doneName;
4677
parent[ expando ] = doneName;
4552
4678
}
4553
4679
4554
var diff = elem.nodeIndex - last;
4680
diff = elem.nodeIndex - last;
4555
4681
4556
4682
if ( first === 0 ) {
4557
4683
return diff === 0;
4567
4693
},
4568
4694
4569
4695
TAG: function( elem, match ) {
4570
return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
4696
return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match;
4571
4697
},
4572
4698
4573
4699
CLASS: function( elem, match ) {
4577
4703
4578
4704
ATTR: function( elem, match ) {
4579
4705
var name = match[1],
4580
result = Expr.attrHandle[ name ] ?
4706
result = Sizzle.attr ?
4707
Sizzle.attr( elem, name ) :
4708
Expr.attrHandle[ name ] ?
4581
4709
Expr.attrHandle[ name ]( elem ) :
4582
4710
elem[ name ] != null ?
4583
4711
elem[ name ] :
4588
4716
4589
4717
return result == null ?
4590
4718
type === "!=" :
4719
!type && Sizzle.attr ?
4720
result != null :
4591
4721
type === "=" ?
4592
4722
value === check :
4593
4723
type === "*=" ?
4768
4898
};
4769
4899
}
4770
4900
4771
// Utility function for retreiving the text value of an array of DOM nodes
4772
Sizzle.getText = function( elems ) {
4773
var ret = "", elem;
4774
4775
for ( var i = 0; elems[i]; i++ ) {
4776
elem = elems[i];
4777
4778
// Get the text from text nodes and CDATA nodes
4779
if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
4780
ret += elem.nodeValue;
4781
4782
// Traverse everything else, except comment nodes
4783
} else if ( elem.nodeType !== 8 ) {
4784
ret += Sizzle.getText( elem.childNodes );
4785
}
4786
}
4787
4788
return ret;
4789
};
4790
4791
4901
// Check to see if the browser returns elements by name when
4792
4902
// querying by getElementById (and provide a workaround)
4793
4903
(function(){
5065
5175
elem = elem[dir];
5066
5176
5067
5177
while ( elem ) {
5068
if ( elem.sizcache === doneName ) {
5178
if ( elem[ expando ] === doneName ) {
5069
5179
match = checkSet[elem.sizset];
5070
5180
break;
5071
5181
}
5072
5182
5073
5183
if ( elem.nodeType === 1 && !isXML ){
5074
elem.sizcache = doneName;
5184
elem[ expando ] = doneName;
5075
5185
elem.sizset = i;
5076
5186
}
5077
5187
5098
5208
elem = elem[dir];
5099
5209
5100
5210
while ( elem ) {
5101
if ( elem.sizcache === doneName ) {
5211
if ( elem[ expando ] === doneName ) {
5102
5212
match = checkSet[elem.sizset];
5103
5213
break;
5104
5214
}
5105
5215
5106
5216
if ( elem.nodeType === 1 ) {
5107
5217
if ( !isXML ) {
5108
elem.sizcache = doneName;
5218
elem[ expando ] = doneName;
5109
5219
elem.sizset = i;
5110
5220
}
5111
5221
5153
5263
return documentElement ? documentElement.nodeName !== "HTML" : false;
5154
5264
};
5155
5265
5156
var posProcess = function( selector, context ) {
5266
var posProcess = function( selector, context, seed ) {
5157
5267
var match,
5158
5268
tmpSet = [],
5159
5269
later = "",
5169
5279
selector = Expr.relative[selector] ? selector + "*" : selector;
5170
5280
5171
5281
for ( var i = 0, l = root.length; i < l; i++ ) {
5172
Sizzle( selector, root[i], tmpSet );
5282
Sizzle( selector, root[i], tmpSet, seed );
5173
5283
}
5174
5284
5175
5285
return Sizzle.filter( later, tmpSet );
5176
5286
};
5177
5287
5178
5288
// EXPOSE
5289
// Override sizzle attribute retrieval
5290
Sizzle.attr = jQuery.attr;
5291
Sizzle.selectors.attrMap = {};
5179
5292
jQuery.find = Sizzle;
5180
5293
jQuery.expr = Sizzle.selectors;
5181
5294
jQuery.expr[":"] = jQuery.expr.filters;
5261
5374
},
5262
5375
5263
5376
is: function( selector ) {
5264
return !!selector && ( typeof selector === "string" ?
5265
jQuery.filter( selector, this ).length > 0 :
5266
this.filter( selector ).length > 0 );
5377
return !!selector && (
5378
typeof selector === "string" ?
5379
// If this is a positional selector, check membership in the returned set
5380
// so $("p:first").is("p:last") won't return true for a doc with two "p".
5381
POS.test( selector ) ?
5382
jQuery( selector, this.context ).index( this[0] ) >= 0 :
5383
jQuery.filter( selector, this ).length > 0 :
5384
this.filter( selector ).length > 0 );
5267
5385
},
5268
5386
5269
5387
closest: function( selectors, context ) {
5270
5388
var ret = [], i, l, cur = this[0];
5271
5389
5272
// Array
5390
// Array (deprecated as of jQuery 1.7)
5273
5391
if ( jQuery.isArray( selectors ) ) {
5274
var match, selector,
5275
matches = {},
5276
level = 1;
5277
5278
if ( cur && selectors.length ) {
5279
for ( i = 0, l = selectors.length; i < l; i++ ) {
5280
selector = selectors[i];
5281
5282
if ( !matches[ selector ] ) {
5283
matches[ selector ] = POS.test( selector ) ?
5284
jQuery( selector, context || this.context ) :
5285
selector;
5286
}
5287
}
5288
5289
while ( cur && cur.ownerDocument && cur !== context ) {
5290
for ( selector in matches ) {
5291
match = matches[ selector ];
5292
5293
if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
5294
ret.push({ selector: selector, elem: cur, level: level });
5295
}
5296
}
5297
5298
cur = cur.parentNode;
5299
level++;
5300
}
5392
var level = 1;
5393
5394
while ( cur && cur.ownerDocument && cur !== context ) {
5395
for ( i = 0; i < selectors.length; i++ ) {
5396
5397
if ( jQuery( cur ).is( selectors[ i ] ) ) {
5398
ret.push({ selector: selectors[ i ], elem: cur, level: level });
5399
}
5400
}
5401
5402
cur = cur.parentNode;
5403
level++;
5301
5404
}
5302
5405
5303
5406
return ret;
5414
5517
}
5415
5518
}, function( name, fn ) {
5416
5519
jQuery.fn[ name ] = function( until, selector ) {
5417
var ret = jQuery.map( this, fn, until ),
5418
// The variable 'args' was introduced in
5419
// https://github.com/jquery/jquery/commit/52a0238
5420
// to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
5421
// http://code.google.com/p/v8/issues/detail?id=1050
5422
args = slice.call(arguments);
5520
var ret = jQuery.map( this, fn, until );
5423
5521
5424
5522
if ( !runtil.test( name ) ) {
5425
5523
selector = until;
5435
5533
ret = ret.reverse();
5436
5534
}
5437
5535
5438
return this.pushStack( ret, name, args.join(",") );
5536
return this.pushStack( ret, name, slice.call( arguments ).join(",") );
5439
5537
};
5440
5538
});
5441
5539
5504
5602
5505
5603
} else if ( qualifier.nodeType ) {
5506
5604
return jQuery.grep(elements, function( elem, i ) {
5507
return (elem === qualifier) === keep;
5605
return ( elem === qualifier ) === keep;
5508
5606
});
5509
5607
5510
5608
} else if ( typeof qualifier === "string" ) {
5520
5618
}
5521
5619
5522
5620
return jQuery.grep(elements, function( elem, i ) {
5523
return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
5621
return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
5524
5622
});
5525
5623
}
5526
5624
5527
5625
5528
5626
5529
5627
5530
var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
5628
function createSafeFragment( document ) {
5629
var list = nodeNames.split( "|" ),
5630
safeFrag = document.createDocumentFragment();
5631
5632
if ( safeFrag.createElement ) {
5633
while ( list.length ) {
5634
safeFrag.createElement(
5635
list.pop()
5636
);
5637
}
5638
}
5639
return safeFrag;
5640
}
5641
5642
var nodeNames = "abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|" +
5643
"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
5644
rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
5531
5645
rleadingWhitespace = /^\s+/,
5532
5646
rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
5533
5647
rtagName = /<([\w:]+)/,
5534
5648
rtbody = /<tbody/i,
5535
5649
rhtml = /<|&#?\w+;/,
5650
rnoInnerhtml = /<(?:script|style)/i,
5536
5651
rnocache = /<(?:script|object|embed|option|style)/i,
5652
rnoshimcache = new RegExp("<(?:" + nodeNames + ")", "i"),
5537
5653
// checked="checked" or checked
5538
5654
rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5539
5655
rscriptType = /\/(java|ecma)script/i,
5547
5663
col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
5548
5664
area: [ 1, "<map>", "</map>" ],
5549
5665
_default: [ 0, "", "" ]
5550
};
5666
},
5667
safeFragment = createSafeFragment( document );
5551
5668
5552
5669
wrapMap.optgroup = wrapMap.option;
5553
5670
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5625
5742
},
5626
5743
5627
5744
wrap: function( html ) {
5628
return this.each(function() {
5629
jQuery( this ).wrapAll( html );
5745
var isFunction = jQuery.isFunction( html );
5746
5747
return this.each(function(i) {
5748
jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
5630
5749
});
5631
5750
},
5632
5751
5660
5779
this.parentNode.insertBefore( elem, this );
5661
5780
});
5662
5781
} else if ( arguments.length ) {
5663
var set = jQuery(arguments[0]);
5782
var set = jQuery.clean( arguments );
5664
5783
set.push.apply( set, this.toArray() );
5665
5784
return this.pushStack( set, "before", arguments );
5666
5785
}
5673
5792
});
5674
5793
} else if ( arguments.length ) {
5675
5794
var set = this.pushStack( this, "after", arguments );
5676
set.push.apply( set, jQuery(arguments[0]).toArray() );
5795
set.push.apply( set, jQuery.clean(arguments) );
5677
5796
return set;
5678
5797
}
5679
5798
},
5728
5847
null;
5729
5848
5730
5849
// See if we can take a shortcut and just use innerHTML
5731
} else if ( typeof value === "string" && !rnocache.test( value ) &&
5850
} else if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
5732
5851
(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
5733
5852
!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
5734
5853
5854
5973
// in certain situations (Bug #8070).
5855
5974
// Fragments from the fragment cache must always be cloned and never used
5856
5975
// in place.
5857
results.cacheable || (l > 1 && i < lastIndex) ?
5976
results.cacheable || ( l > 1 && i < lastIndex ) ?
5858
5977
jQuery.clone( fragment, true, true ) :
5859
5978
fragment
5860
5979
);
5883
6002
return;
5884
6003
}
5885
6004
5886
var internalKey = jQuery.expando,
5887
oldData = jQuery.data( src ),
5888
curData = jQuery.data( dest, oldData );
5889
5890
// Switch to use the internal data object, if it exists, for the next
5891
// stage of data copying
5892
if ( (oldData = oldData[ internalKey ]) ) {
5893
var events = oldData.events;
5894
curData = curData[ internalKey ] = jQuery.extend({}, oldData);
5895
5896
if ( events ) {
5897
delete curData.handle;
5898
curData.events = {};
5899
5900
for ( var type in events ) {
5901
for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
5902
jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
5903
}
6005
var type, i, l,
6006
oldData = jQuery._data( src ),
6007
curData = jQuery._data( dest, oldData ),
6008
events = oldData.events;
6009
6010
if ( events ) {
6011
delete curData.handle;
6012
curData.events = {};
6013
6014
for ( type in events ) {
6015
for ( i = 0, l = events[ type ].length; i < l; i++ ) {
6016
jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
5904
6017
}
5905
6018
}
5906
6019
}
6020
6021
// make the cloned public data object a copy from the original
6022
if ( curData.data ) {
6023
curData.data = jQuery.extend( {}, curData.data );
6024
}
5907
6025
}
5908
6026
5909
6027
function cloneFixAttributes( src, dest ) {
5965
6083
}
5966
6084
5967
6085
jQuery.buildFragment = function( args, nodes, scripts ) {
5968
var fragment, cacheable, cacheresults, doc;
5969
5970
// nodes may contain either an explicit document object,
5971
// a jQuery collection or context object.
5972
// If nodes[0] contains a valid object to assign to doc
5973
if ( nodes && nodes[0] ) {
5974
doc = nodes[0].ownerDocument || nodes[0];
5975
}
5976
5977
// Ensure that an attr object doesn't incorrectly stand in as a document object
6086
var fragment, cacheable, cacheresults, doc,
6087
first = args[ 0 ];
6088
6089
// nodes may contain either an explicit document object,
6090
// a jQuery collection or context object.
6091
// If nodes[0] contains a valid object to assign to doc
6092
if ( nodes && nodes[0] ) {
6093
doc = nodes[0].ownerDocument || nodes[0];
6094
}
6095
6096
// Ensure that an attr object doesn't incorrectly stand in as a document object
5978
6097
// Chrome and Firefox seem to allow this to occur and will throw exception
5979
6098
// Fixes #8950
5980
6099
if ( !doc.createDocumentFragment ) {
5985
6104
// Cloning options loses the selected state, so don't cache them
5986
6105
// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
5987
6106
// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
5988
if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
5989
args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
6107
// Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501
6108
if ( args.length === 1 && typeof first === "string" && first.length < 512 && doc === document &&
6109
first.charAt(0) === "<" && !rnocache.test( first ) &&
6110
(jQuery.support.checkClone || !rchecked.test( first )) &&
6111
(jQuery.support.html5Clone || !rnoshimcache.test( first )) ) {
5990
6112
5991
6113
cacheable = true;
5992
6114
5993
cacheresults = jQuery.fragments[ args[0] ];
6115
cacheresults = jQuery.fragments[ first ];
5994
6116
if ( cacheresults && cacheresults !== 1 ) {
5995
6117
fragment = cacheresults;
5996
6118
}
6002
6124
}
6003
6125
6004
6126
if ( cacheable ) {
6005
jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
6127
jQuery.fragments[ first ] = cacheresults ? fragment : 1;
6006
6128
}
6007
6129
6008
6130
return { fragment: fragment, cacheable: cacheable };
6028
6150
6029
6151
} else {
6030
6152
for ( var i = 0, l = insert.length; i < l; i++ ) {
6031
var elems = (i > 0 ? this.clone(true) : this).get();
6153
var elems = ( i > 0 ? this.clone(true) : this ).get();
6032
6154
jQuery( insert[i] )[ original ]( elems );
6033
6155
ret = ret.concat( elems );
6034
6156
}
6039
6161
});
6040
6162
6041
6163
function getAll( elem ) {
6042
if ( "getElementsByTagName" in elem ) {
6164
if ( typeof elem.getElementsByTagName !== "undefined" ) {
6043
6165
return elem.getElementsByTagName( "*" );
6044
6166
6045
} else if ( "querySelectorAll" in elem ) {
6167
} else if ( typeof elem.querySelectorAll !== "undefined" ) {
6046
6168
return elem.querySelectorAll( "*" );
6047
6169
6048
6170
} else {
6058
6180
}
6059
6181
// Finds all inputs and passes them to fixDefaultChecked
6060
6182
function findInputs( elem ) {
6061
if ( jQuery.nodeName( elem, "input" ) ) {
6183
var nodeName = ( elem.nodeName || "" ).toLowerCase();
6184
if ( nodeName === "input" ) {
6062
6185
fixDefaultChecked( elem );
6063
} else if ( "getElementsByTagName" in elem ) {
6186
// Skip scripts, get other children
6187
} else if ( nodeName !== "script" && typeof elem.getElementsByTagName !== "undefined" ) {
6064
6188
jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
6065
6189
}
6066
6190
}
6067
6191
6192
// Derived From: http://www.iecss.com/shimprove/javascript/shimprove.1-0-1.js
6193
function shimCloneNode( elem ) {
6194
var div = document.createElement( "div" );
6195
safeFragment.appendChild( div );
6196
6197
div.innerHTML = elem.outerHTML;
6198
return div.firstChild;
6199
}
6200
6068
6201
jQuery.extend({
6069
6202
clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6070
var clone = elem.cloneNode(true),
6071
srcElements,
6072
destElements,
6073
i;
6203
var srcElements,
6204
destElements,
6205
i,
6206
// IE<=8 does not properly clone detached, unknown element nodes
6207
clone = jQuery.support.html5Clone || !rnoshimcache.test( "<" + elem.nodeName ) ?
6208
elem.cloneNode( true ) :
6209
shimCloneNode( elem );
6074
6210
6075
6211
if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
6076
6212
(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
6082
6218
6083
6219
cloneFixAttributes( elem, clone );
6084
6220
6085
// Using Sizzle here is crazy slow, so we use getElementsByTagName
6086
// instead
6221
// Using Sizzle here is crazy slow, so we use getElementsByTagName instead
6087
6222
srcElements = getAll( elem );
6088
6223
destElements = getAll( clone );
6089
6224
6148
6283
elem = elem.replace(rxhtmlTag, "<$1></$2>");
6149
6284
6150
6285
// Trim whitespace, otherwise indexOf won't work as expected
6151
var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
6286
var tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase(),
6152
6287
wrap = wrapMap[ tag ] || wrapMap._default,
6153
6288
depth = wrap[0],
6154
6289
div = context.createElement("div");
6155
6290
6291
// Append wrapper element to unknown element safe doc fragment
6292
if ( context === document ) {
6293
// Use the fragment we've already created for this document
6294
safeFragment.appendChild( div );
6295
} else {
6296
// Use a fragment created with the owner document
6297
createSafeFragment( context ).appendChild( div );
6298
}
6299
6156
6300
// Go to html and back, then peel off extra wrappers
6157
6301
div.innerHTML = wrap[1] + elem + wrap[2];
6158
6302
6233
6377
},
6234
6378
6235
6379
cleanData: function( elems ) {
6236
var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
6380
var data, id,
6381
cache = jQuery.cache,
6382
special = jQuery.event.special,
6237
6383
deleteExpando = jQuery.support.deleteExpando;
6238
6384
6239
6385
for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6244
6390
id = elem[ jQuery.expando ];
6245
6391
6246
6392
if ( id ) {
6247
data = cache[ id ] && cache[ id ][ internalKey ];
6393
data = cache[ id ];
6248
6394
6249
6395
if ( data && data.events ) {
6250
6396
for ( var type in data.events ) {
6506
6652
set: function( elem, value ) {
6507
6653
var style = elem.style,
6508
6654
currentStyle = elem.currentStyle,
6509
opacity = jQuery.isNaN( value ) ? "" : "alpha(opacity=" + value * 100 + ")",
6655
opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
6510
6656
filter = currentStyle && currentStyle.filter || style.filter || "";
6511
6657
6512
6658
// IE has trouble with opacity if it does not have layout
6563
6709
6564
6710
name = name.replace( rupper, "-$1" ).toLowerCase();
6565
6711
6566
if ( !(defaultView = elem.ownerDocument.defaultView) ) {
6567
return undefined;
6568
}
6569
6570
if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
6712
if ( (defaultView = elem.ownerDocument.defaultView) &&
6713
(computedStyle = defaultView.getComputedStyle( elem, null )) ) {
6571
6714
ret = computedStyle.getPropertyValue( name );
6572
6715
if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
6573
6716
ret = jQuery.style( elem, name );
6580
6723
6581
6724
if ( document.documentElement.currentStyle ) {
6582
6725
currentStyle = function( elem, name ) {
6583
var left,
6726
var left, rsLeft, uncomputed,
6584
6727
ret = elem.currentStyle && elem.currentStyle[ name ],
6585
rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
6586
6728
style = elem.style;
6587
6729
6730
// Avoid setting ret to empty string here
6731
// so we don't default to auto
6732
if ( ret === null && style && (uncomputed = style[ name ]) ) {
6733
ret = uncomputed;
6734
}
6735
6588
6736
// From the awesome hack by Dean Edwards
6589
6737
// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6590
6738
6591
6739
// If we're not dealing with a regular pixel number
6592
6740
// but a number that has a weird ending, we need to convert it to pixels
6593
6741
if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
6742
6594
6743
// Remember the original values
6595
6744
left = style.left;
6745
rsLeft = elem.runtimeStyle && elem.runtimeStyle.left;
6596
6746
6597
6747
// Put in the new values to get a computed value out
6598
6748
if ( rsLeft ) {
6599
6749
elem.runtimeStyle.left = elem.currentStyle.left;
6600
6750
}
6601
style.left = name === "fontSize" ? "1em" : (ret || 0);
6751
style.left = name === "fontSize" ? "1em" : ( ret || 0 );
6602
6752
ret = style.pixelLeft + "px";
6603
6753
6604
6754
// Revert the changed values
6618
6768
6619
6769
// Start with offset property
6620
6770
var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
6621
which = name === "width" ? cssWidth : cssHeight;
6771
which = name === "width" ? cssWidth : cssHeight,
6772
i = 0,
6773
len = which.length;
6622
6774
6623
6775
if ( val > 0 ) {
6624
6776
if ( extra !== "border" ) {
6625
jQuery.each( which, function() {
6777
for ( ; i < len; i++ ) {
6626
6778
if ( !extra ) {
6627
val -= parseFloat( jQuery.css( elem, "padding" + this ) ) || 0;
6779
val -= parseFloat( jQuery.css( elem, "padding" + which[ i ] ) ) || 0;
6628
6780
}
6629
6781
if ( extra === "margin" ) {
6630
val += parseFloat( jQuery.css( elem, extra + this ) ) || 0;
6782
val += parseFloat( jQuery.css( elem, extra + which[ i ] ) ) || 0;
6631
6783
} else {
6632
val -= parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0;
6784
val -= parseFloat( jQuery.css( elem, "border" + which[ i ] + "Width" ) ) || 0;
6633
6785
}
6634
});
6786
}
6635
6787
}
6636
6788
6637
6789
return val + "px";
6647
6799
6648
6800
// Add padding, border, margin
6649
6801
if ( extra ) {
6650
jQuery.each( which, function() {
6651
val += parseFloat( jQuery.css( elem, "padding" + this ) ) || 0;
6802
for ( ; i < len; i++ ) {
6803
val += parseFloat( jQuery.css( elem, "padding" + which[ i ] ) ) || 0;
6652
6804
if ( extra !== "padding" ) {
6653
val += parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0;
6805
val += parseFloat( jQuery.css( elem, "border" + which[ i ] + "Width" ) ) || 0;
6654
6806
}
6655
6807
if ( extra === "margin" ) {
6656
val += parseFloat( jQuery.css( elem, extra + this ) ) || 0;
6808
val += parseFloat( jQuery.css( elem, extra + which[ i ] ) ) || 0;
6657
6809
}
6658
});
6810
}
6659
6811
}
6660
6812
6661
6813
return val + "px";
6666
6818
var width = elem.offsetWidth,
6667
6819
height = elem.offsetHeight;
6668
6820
6669
return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
6821
return ( width === 0 && height === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
6670
6822
};
6671
6823
6672
6824
jQuery.expr.filters.visible = function( elem ) {
6720
6872
6721
6873
// Document location segments
6722
6874
ajaxLocParts,
6723
6875
6724
6876
// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
6725
6877
allTypes = ["*/"] + ["*"];
6726
6878
6759
6911
placeBefore;
6760
6912
6761
6913
// For each dataType in the dataTypeExpression
6762
for(; i < length; i++ ) {
6914
for ( ; i < length; i++ ) {
6763
6915
dataType = dataTypes[ i ];
6764
6916
// We control if we're asked to add before
6765
6917
// any existing element
6790
6942
executeOnly = ( structure === prefilters ),
6791
6943
selection;
6792
6944
6793
for(; i < length && ( executeOnly || !selection ); i++ ) {
6945
for ( ; i < length && ( executeOnly || !selection ); i++ ) {
6794
6946
selection = list[ i ]( options, originalOptions, jqXHR );
6795
6947
// If we got redirected to another dataType
6796
6948
// we try there if executing only and not done already
6821
6973
function ajaxExtend( target, src ) {
6822
6974
var key, deep,
6823
6975
flatOptions = jQuery.ajaxSettings.flatOptions || {};
6824
for( key in src ) {
6976
for ( key in src ) {
6825
6977
if ( src[ key ] !== undefined ) {
6826
6978
( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
6827
6979
}
6938
7090
// Attach a bunch of functions for handling common AJAX events
6939
7091
jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
6940
7092
jQuery.fn[ o ] = function( f ){
6941
return this.bind( o, f );
7093
return this.on( o, f );
6942
7094
};
6943
7095
});
6944
7096
7080
7232
jQuery( callbackContext ) : jQuery.event,
7081
7233
// Deferreds
7082
7234
deferred = jQuery.Deferred(),
7083
completeDeferred = jQuery._Deferred(),
7235
completeDeferred = jQuery.Callbacks( "once memory" ),
7084
7236
// Status-dependent callbacks
7085
7237
statusCode = s.statusCode || {},
7086
7238
// ifModified key
7230
7382
// We extract error from statusText
7231
7383
// then normalize statusText and status for non-aborts
7232
7384
error = statusText;
7233
if( !statusText || status ) {
7385
if ( !statusText || status ) {
7234
7386
statusText = "error";
7235
7387
if ( status < 0 ) {
7236
7388
status = 0;
7259
7411
}
7260
7412
7261
7413
// Complete
7262
completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
7414
completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
7263
7415
7264
7416
if ( fireGlobals ) {
7265
7417
globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
7274
7426
deferred.promise( jqXHR );
7275
7427
jqXHR.success = jqXHR.done;
7276
7428
jqXHR.error = jqXHR.fail;
7277
jqXHR.complete = completeDeferred.done;
7429
jqXHR.complete = completeDeferred.add;
7278
7430
7279
7431
// Status-dependent callbacks
7280
7432
jqXHR.statusCode = function( map ) {
7281
7433
if ( map ) {
7282
7434
var tmp;
7283
7435
if ( state < 2 ) {
7284
for( tmp in map ) {
7436
for ( tmp in map ) {
7285
7437
statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
7286
7438
}
7287
7439
} else {
7358
7510
ret = s.url.replace( rts, "$1_=" + ts );
7359
7511
7360
7512
// if nothing was replaced, add timestamp to the end
7361
s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
7513
s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
7362
7514
}
7363
7515
}
7364
7516
7432
7584
done( -1, e );
7433
7585
// Simply rethrow otherwise
7434
7586
} else {
7435
jQuery.error( e );
7587
throw e;
7436
7588
}
7437
7589
}
7438
7590
}
7536
7688
firstDataType;
7537
7689
7538
7690
// Fill responseXXX fields
7539
for( type in responseFields ) {
7691
for ( type in responseFields ) {
7540
7692
if ( type in responses ) {
7541
7693
jqXHR[ responseFields[type] ] = responses[ type ];
7542
7694
}
7615
7767
conv2;
7616
7768
7617
7769
// For each dataType in the chain
7618
for( i = 1; i < length; i++ ) {
7770
for ( i = 1; i < length; i++ ) {
7619
7771
7620
7772
// Create converters map
7621
7773
// with lowercased keys
7622
7774
if ( i === 1 ) {
7623
for( key in s.converters ) {
7624
if( typeof key === "string" ) {
7775
for ( key in s.converters ) {
7776
if ( typeof key === "string" ) {
7625
7777
converters[ key.toLowerCase() ] = s.converters[ key ];
7626
7778
}
7627
7779
}
7632
7784
current = dataTypes[ i ];
7633
7785
7634
7786
// If current is auto dataType, update it to prev
7635
if( current === "*" ) {
7787
if ( current === "*" ) {
7636
7788
current = prev;
7637
7789
// If no auto and dataTypes are actually different
7638
7790
} else if ( prev !== "*" && prev !== current ) {
7644
7796
// If there is no direct converter, search transitively
7645
7797
if ( !conv ) {
7646
7798
conv2 = undefined;
7647
for( conv1 in converters ) {
7799
for ( conv1 in converters ) {
7648
7800
tmp = conv1.split( " " );
7649
7801
if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
7650
7802
conv2 = converters[ tmp[1] + " " + current ];
8083
8235
var elem, display;
8084
8236
8085
8237
if ( speed || speed === 0 ) {
8086
return this.animate( genFx("show", 3), speed, easing, callback);
8238
return this.animate( genFx("show", 3), speed, easing, callback );
8087
8239
8088
8240
} else {
8089
8241
for ( var i = 0, j = this.length; i < j; i++ ) {
8090
elem = this[i];
8242
elem = this[ i ];
8091
8243
8092
8244
if ( elem.style ) {
8093
8245
display = elem.style.display;
8101
8253
// Set elements which have been overridden with display: none
8102
8254
// in a stylesheet to whatever the default browser style is
8103
8255
// for such an element
8104
if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
8105
jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
8256
if ( display === "" && jQuery.css(elem, "display") === "none" ) {
8257
jQuery._data( elem, "olddisplay", defaultDisplay(elem.nodeName) );
8106
8258
}
8107
8259
}
8108
8260
}
8110
8262
// Set the display of most of the elements in a second loop
8111
8263
// to avoid the constant reflow
8112
8264
for ( i = 0; i < j; i++ ) {
8113
elem = this[i];
8265
elem = this[ i ];
8114
8266
8115
8267
if ( elem.style ) {
8116
8268
display = elem.style.display;
8117
8269
8118
8270
if ( display === "" || display === "none" ) {
8119
elem.style.display = jQuery._data(elem, "olddisplay") || "";
8271
elem.style.display = jQuery._data( elem, "olddisplay" ) || "";
8120
8272
}
8121
8273
}
8122
8274
}
8130
8282
return this.animate( genFx("hide", 3), speed, easing, callback);
8131
8283
8132
8284
} else {
8133
for ( var i = 0, j = this.length; i < j; i++ ) {
8134
if ( this[i].style ) {
8135
var display = jQuery.css( this[i], "display" );
8136
8137
if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
8138
jQuery._data( this[i], "olddisplay", display );
8285
var elem, display,
8286
i = 0,
8287
j = this.length;
8288
8289
for ( ; i < j; i++ ) {
8290
elem = this[i];
8291
if ( elem.style ) {
8292
display = jQuery.css( elem, "display" );
8293
8294
if ( display !== "none" && !jQuery._data( elem, "olddisplay" ) ) {
8295
jQuery._data( elem, "olddisplay", display );
8139
8296
}
8140
8297
}
8141
8298
}
8180
8337
},
8181
8338
8182
8339
animate: function( prop, speed, easing, callback ) {
8183
var optall = jQuery.speed(speed, easing, callback);
8340
var optall = jQuery.speed( speed, easing, callback );
8184
8341
8185
8342
if ( jQuery.isEmptyObject( prop ) ) {
8186
8343
return this.each( optall.complete, [ false ] );
8189
8346
// Do not change referenced properties as per-property easing will be lost
8190
8347
prop = jQuery.extend( {}, prop );
8191
8348
8192
return this[ optall.queue === false ? "each" : "queue" ](function() {
8349
function doAnimation() {
8193
8350
// XXX 'this' does not always have a nodeName when running the
8194
8351
// test suite
8195
8352
8200
8357
var opt = jQuery.extend( {}, optall ),
8201
8358
isElement = this.nodeType === 1,
8202
8359
hidden = isElement && jQuery(this).is(":hidden"),
8203
name, val, p,
8204
display, e,
8205
parts, start, end, unit;
8360
name, val, p, e,
8361
parts, start, end, unit,
8362
method;
8206
8363
8207
8364
// will store per property easing and be used to determine when an animation is complete
8208
8365
opt.animatedProperties = {};
8238
8395
opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
8239
8396
8240
8397
// Set display property to inline-block for height/width
8241
// animations on inline elements that are having width/height
8242
// animated
8398
// animations on inline elements that are having width/height animated
8243
8399
if ( jQuery.css( this, "display" ) === "inline" &&
8244
8400
jQuery.css( this, "float" ) === "none" ) {
8245
if ( !jQuery.support.inlineBlockNeedsLayout ) {
8401
8402
// inline-level elements accept inline-block;
8403
// block-level elements need to be inline with layout
8404
if ( !jQuery.support.inlineBlockNeedsLayout || defaultDisplay( this.nodeName ) === "inline" ) {
8246
8405
this.style.display = "inline-block";
8247
8406
8248
8407
} else {
8249
display = defaultDisplay( this.nodeName );
8250
8251
// inline-level elements accept inline-block;
8252
// block-level elements need to be inline with layout
8253
if ( display === "inline" ) {
8254
this.style.display = "inline-block";
8255
8256
} else {
8257
this.style.display = "inline";
8258
this.style.zoom = 1;
8259
}
8408
this.style.zoom = 1;
8260
8409
}
8261
8410
}
8262
8411
}
8270
8419
e = new jQuery.fx( this, opt, p );
8271
8420
val = prop[ p ];
8272
8421
8273
if ( rfxtypes.test(val) ) {
8274
e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
8422
if ( rfxtypes.test( val ) ) {
8423
8424
// Tracks whether to show or hide based on private
8425
// data attached to the element
8426
method = jQuery._data( this, "toggle" + p ) || ( val === "toggle" ? hidden ? "show" : "hide" : 0 );
8427
if ( method ) {
8428
jQuery._data( this, "toggle" + p, method === "show" ? "hide" : "show" );
8429
e[ method ]();
8430
} else {
8431
e[ val ]();
8432
}
8275
8433
8276
8434
} else {
8277
8435
parts = rfxnum.exec( val );
8284
8442
// We need to compute starting value
8285
8443
if ( unit !== "px" ) {
8286
8444
jQuery.style( this, p, (end || 1) + unit);
8287
start = ((end || 1) / e.cur()) * start;
8445
start = ( (end || 1) / e.cur() ) * start;
8288
8446
jQuery.style( this, p, start + unit);
8289
8447
}
8290
8448
8303
8461
8304
8462
// For JS strict compliance
8305
8463
return true;
8306
});
8464
}
8465
8466
return optall.queue === false ?
8467
this.each( doAnimation ) :
8468
this.queue( optall.queue, doAnimation );
8307
8469
},
8308
8470
8309
stop: function( clearQueue, gotoEnd ) {
8310
if ( clearQueue ) {
8311
this.queue([]);
8312
}
8313
8314
this.each(function() {
8315
var timers = jQuery.timers,
8316
i = timers.length;
8471
stop: function( type, clearQueue, gotoEnd ) {
8472
if ( typeof type !== "string" ) {
8473
gotoEnd = clearQueue;
8474
clearQueue = type;
8475
type = undefined;
8476
}
8477
if ( clearQueue && type !== false ) {
8478
this.queue( type || "fx", [] );
8479
}
8480
8481
return this.each(function() {
8482
var index,
8483
hadTimers = false,
8484
timers = jQuery.timers,
8485
data = jQuery._data( this );
8486
8317
8487
// clear marker counters if we know they won't be
8318
8488
if ( !gotoEnd ) {
8319
8489
jQuery._unmark( true, this );
8320
8490
}
8321
while ( i-- ) {
8322
if ( timers[i].elem === this ) {
8323
if (gotoEnd) {
8491
8492
function stopQueue( elem, data, index ) {
8493
var hooks = data[ index ];
8494
jQuery.removeData( elem, index, true );
8495
hooks.stop( gotoEnd );
8496
}
8497
8498
if ( type == null ) {
8499
for ( index in data ) {
8500
if ( data[ index ] && data[ index ].stop && index.indexOf(".run") === index.length - 4 ) {
8501
stopQueue( this, data, index );
8502
}
8503
}
8504
} else if ( data[ index = type + ".run" ] && data[ index ].stop ){
8505
stopQueue( this, data, index );
8506
}
8507
8508
for ( index = timers.length; index--; ) {
8509
if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
8510
if ( gotoEnd ) {
8511
8324
8512
// force the next step to be the last
8325
timers[i](true);
8513
timers[ index ]( true );
8514
} else {
8515
timers[ index ].saveState();
8326
8516
}
8327
8328
timers.splice(i, 1);
8517
hadTimers = true;
8518
timers.splice( index, 1 );
8329
8519
}
8330
8520
}
8521
8522
// start the next in the queue if the last step wasn't forced
8523
// timers currently will call their complete callbacks, which will dequeue
8524
// but only if they were gotoEnd
8525
if ( !( gotoEnd && hadTimers ) ) {
8526
jQuery.dequeue( this, type );
8527
}
8331
8528
});
8332
8333
// start the next in the queue if the last step wasn't forced
8334
if ( !gotoEnd ) {
8335
this.dequeue();
8336
}
8337
8338
return this;
8339
8529
}
8340
8530
8341
8531
});
8354
8544
function genFx( type, num ) {
8355
8545
var obj = {};
8356
8546
8357
jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
8547
jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice( 0, num )), function() {
8358
8548
obj[ this ] = type;
8359
8549
});
8360
8550
8363
8553
8364
8554
// Generate shortcuts for custom animations
8365
8555
jQuery.each({
8366
slideDown: genFx("show", 1),
8367
slideUp: genFx("hide", 1),
8368
slideToggle: genFx("toggle", 1),
8556
slideDown: genFx( "show", 1 ),
8557
slideUp: genFx( "hide", 1 ),
8558
slideToggle: genFx( "toggle", 1 ),
8369
8559
fadeIn: { opacity: "show" },
8370
8560
fadeOut: { opacity: "hide" },
8371
8561
fadeToggle: { opacity: "toggle" }
8377
8567
8378
8568
jQuery.extend({
8379
8569
speed: function( speed, easing, fn ) {
8380
var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
8570
var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
8381
8571
complete: fn || !fn && easing ||
8382
8572
jQuery.isFunction( speed ) && speed,
8383
8573
duration: speed,
8384
easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
8574
easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
8385
8575
};
8386
8576
8387
8577
opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
8388
opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
8578
opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
8579
8580
// normalize opt.queue - true/undefined/null -> "fx"
8581
if ( opt.queue == null || opt.queue === true ) {
8582
opt.queue = "fx";
8583
}
8389
8584
8390
8585
// Queueing
8391
8586
opt.old = opt.complete;
8587
8392
8588
opt.complete = function( noUnmark ) {
8393
8589
if ( jQuery.isFunction( opt.old ) ) {
8394
8590
opt.old.call( this );
8395
8591
}
8396
8592
8397
if ( opt.queue !== false ) {
8398
jQuery.dequeue( this );
8593
if ( opt.queue ) {
8594
jQuery.dequeue( this, opt.queue );
8399
8595
} else if ( noUnmark !== false ) {
8400
8596
jQuery._unmark( this );
8401
8597
}
8409
8605
return firstNum + diff * p;
8410
8606
},
8411
8607
swing: function( p, n, firstNum, diff ) {
8412
return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
8608
return ( ( -Math.cos( p*Math.PI ) / 2 ) + 0.5 ) * diff + firstNum;
8413
8609
}
8414
8610
},
8415
8611
8432
8628
this.options.step.call( this.elem, this.now, this );
8433
8629
}
8434
8630
8435
(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
8631
( jQuery.fx.step[ this.prop ] || jQuery.fx.step._default )( this );
8436
8632
},
8437
8633
8438
8634
// Get the current size
8439
8635
cur: function() {
8440
if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
8636
if ( this.elem[ this.prop ] != null && (!this.elem.style || this.elem.style[ this.prop ] == null) ) {
8441
8637
return this.elem[ this.prop ];
8442
8638
}
8443
8639
8455
8651
fx = jQuery.fx;
8456
8652
8457
8653
this.startTime = fxNow || createFxNow();
8458
this.start = from;
8459
8654
this.end = to;
8655
this.now = this.start = from;
8656
this.pos = this.state = 0;
8460
8657
this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
8461
this.now = this.start;
8462
this.pos = this.state = 0;
8463
8658
8464
8659
function t( gotoEnd ) {
8465
return self.step(gotoEnd);
8660
return self.step( gotoEnd );
8466
8661
}
8467
8662
8663
t.queue = this.options.queue;
8468
8664
t.elem = this.elem;
8665
t.saveState = function() {
8666
if ( self.options.hide && jQuery._data( self.elem, "fxshow" + self.prop ) === undefined ) {
8667
jQuery._data( self.elem, "fxshow" + self.prop, self.start );
8668
}
8669
};
8469
8670
8470
8671
if ( t() && jQuery.timers.push(t) && !timerId ) {
8471
8672
timerId = setInterval( fx.tick, fx.interval );
8474
8675
8475
8676
// Simple 'show' function
8476
8677
show: function() {
8678
var dataShow = jQuery._data( this.elem, "fxshow" + this.prop );
8679
8477
8680
// Remember where we started, so that we can go back to it later
8478
this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
8681
this.options.orig[ this.prop ] = dataShow || jQuery.style( this.elem, this.prop );
8479
8682
this.options.show = true;
8480
8683
8481
8684
// Begin the animation
8482
// Make sure that we start at a small width/height to avoid any
8483
// flash of content
8484
this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
8685
// Make sure that we start at a small width/height to avoid any flash of content
8686
if ( dataShow !== undefined ) {
8687
// This show is picking up where a previous hide or show left off
8688
this.custom( this.cur(), dataShow );
8689
} else {
8690
this.custom( this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur() );
8691
}
8485
8692
8486
8693
// Start by showing the element
8487
8694
jQuery( this.elem ).show();
8490
8697
// Simple 'hide' function
8491
8698
hide: function() {
8492
8699
// Remember where we started, so that we can go back to it later
8493
this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
8700
this.options.orig[ this.prop ] = jQuery._data( this.elem, "fxshow" + this.prop ) || jQuery.style( this.elem, this.prop );
8494
8701
this.options.hide = true;
8495
8702
8496
8703
// Begin the animation
8497
this.custom(this.cur(), 0);
8704
this.custom( this.cur(), 0 );
8498
8705
},
8499
8706
8500
8707
// Each step of an animation
8501
8708
step: function( gotoEnd ) {
8502
var t = fxNow || createFxNow(),
8709
var p, n, complete,
8710
t = fxNow || createFxNow(),
8503
8711
done = true,
8504
8712
elem = this.elem,
8505
options = this.options,
8506
i, n;
8713
options = this.options;
8507
8714
8508
8715
if ( gotoEnd || t >= options.duration + this.startTime ) {
8509
8716
this.now = this.end;
8512
8719
8513
8720
options.animatedProperties[ this.prop ] = true;
8514
8721
8515
for ( i in options.animatedProperties ) {
8516
if ( options.animatedProperties[i] !== true ) {
8722
for ( p in options.animatedProperties ) {
8723
if ( options.animatedProperties[ p ] !== true ) {
8517
8724
done = false;
8518
8725
}
8519
8726
}
8522
8729
// Reset the overflow
8523
8730
if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
8524
8731
8525
jQuery.each( [ "", "X", "Y" ], function (index, value) {
8526
elem.style[ "overflow" + value ] = options.overflow[index];
8732
jQuery.each( [ "", "X", "Y" ], function( index, value ) {
8733
elem.style[ "overflow" + value ] = options.overflow[ index ];
8527
8734
});
8528
8735
}
8529
8736
8530
8737
// Hide the element if the "hide" operation was done
8531
8738
if ( options.hide ) {
8532
jQuery(elem).hide();
8739
jQuery( elem ).hide();
8533
8740
}
8534
8741
8535
8742
// Reset the properties, if the item has been hidden or shown
8536
8743
if ( options.hide || options.show ) {
8537
for ( var p in options.animatedProperties ) {
8538
jQuery.style( elem, p, options.orig[p] );
8744
for ( p in options.animatedProperties ) {
8745
jQuery.style( elem, p, options.orig[ p ] );
8746
jQuery.removeData( elem, "fxshow" + p, true );
8747
// Toggle data is no longer needed
8748
jQuery.removeData( elem, "toggle" + p, true );
8539
8749
}
8540
8750
}
8541
8751
8542
8752
// Execute the complete function
8543
options.complete.call( elem );
8753
// in the event that the complete function throws an exception
8754
// we must ensure it won't be called twice. #5684
8755
8756
complete = options.complete;
8757
if ( complete ) {
8758
8759
options.complete = false;
8760
complete.call( elem );
8761
}
8544
8762
}
8545
8763
8546
8764
return false;
8554
8772
this.state = n / options.duration;
8555
8773
8556
8774
// Perform the easing function, defaults to swing
8557
this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration );
8558
this.now = this.start + ((this.end - this.start) * this.pos);
8775
this.pos = jQuery.easing[ options.animatedProperties[this.prop] ]( this.state, n, 0, 1, options.duration );
8776
this.now = this.start + ( (this.end - this.start) * this.pos );
8559
8777
}
8560
8778
// Perform the next step of the animation
8561
8779
this.update();
8567
8785
8568
8786
jQuery.extend( jQuery.fx, {
8569
8787
tick: function() {
8570
for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) {
8571
if ( !timers[i]() ) {
8572
timers.splice(i--, 1);
8788
var timer,
8789
timers = jQuery.timers,
8790
i = 0;
8791
8792
for ( ; i < timers.length; i++ ) {
8793
timer = timers[ i ];
8794
// Checks the timer has not already been removed
8795
if ( !timer() && timers[ i ] === timer ) {
8796
timers.splice( i--, 1 );
8573
8797
}
8574
8798
}
8575
8799
8599
8823
8600
8824
_default: function( fx ) {
8601
8825
if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
8602
fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
8826
fx.elem.style[ fx.prop ] = fx.now + fx.unit;
8603
8827
} else {
8604
8828
fx.elem[ fx.prop ] = fx.now;
8605
8829
}
8607
8831
}
8608
8832
});
8609
8833
8834
// Adds width/height step functions
8835
// Do not set anything below 0
8836
jQuery.each([ "width", "height" ], function( i, prop ) {
8837
jQuery.fx.step[ prop ] = function( fx ) {
8838
jQuery.style( fx.elem, prop, Math.max(0, fx.now) + fx.unit );
8839
};
8840
});
8841
8610
8842
if ( jQuery.expr && jQuery.expr.filters ) {
8611
8843
jQuery.expr.filters.animated = function( elem ) {
8612
8844
return jQuery.grep(jQuery.timers, function( fn ) {
8623
8855
var body = document.body,
8624
8856
elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
8625
8857
display = elem.css( "display" );
8626
8627
8858
elem.remove();
8628
8859
8629
8860
// If the simple way fails,
8651
8882
iframeDoc.body.appendChild( elem );
8652
8883
8653
8884
display = jQuery.css( elem, "display" );
8654
8655
8885
body.removeChild( iframe );
8656
8886
}
8657
8887
8728
8958
return jQuery.offset.bodyOffset( elem );
8729
8959
}
8730
8960
8731
jQuery.offset.initialize();
8732
8733
8961
var computedStyle,
8734
8962
offsetParent = elem.offsetParent,
8735
8963
prevOffsetParent = elem,
8742
8970
left = elem.offsetLeft;
8743
8971
8744
8972
while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
8745
if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
8973
if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
8746
8974
break;
8747
8975
}
8748
8976
8754
8982
top += elem.offsetTop;
8755
8983
left += elem.offsetLeft;
8756
8984
8757
if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
8985
if ( jQuery.support.doesNotAddBorder && !(jQuery.support.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
8758
8986
top += parseFloat( computedStyle.borderTopWidth ) || 0;
8759
8987
left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8760
8988
}
8763
8991
offsetParent = elem.offsetParent;
8764
8992
}
8765
8993
8766
if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
8994
if ( jQuery.support.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
8767
8995
top += parseFloat( computedStyle.borderTopWidth ) || 0;
8768
8996
left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8769
8997
}
8776
9004
left += body.offsetLeft;
8777
9005
}
8778
9006
8779
if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
9007
if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
8780
9008
top += Math.max( docElem.scrollTop, body.scrollTop );
8781
9009
left += Math.max( docElem.scrollLeft, body.scrollLeft );
8782
9010
}
8786
9014
}
8787
9015
8788
9016
jQuery.offset = {
8789
initialize: function() {
8790
var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
8791
html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
8792
8793
jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
8794
8795
container.innerHTML = html;
8796
body.insertBefore( container, body.firstChild );
8797
innerDiv = container.firstChild;
8798
checkDiv = innerDiv.firstChild;
8799
td = innerDiv.nextSibling.firstChild.firstChild;
8800
8801
this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
8802
this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
8803
8804
checkDiv.style.position = "fixed";
8805
checkDiv.style.top = "20px";
8806
8807
// safari subtracts parent border width here which is 5px
8808
this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
8809
checkDiv.style.position = checkDiv.style.top = "";
8810
8811
innerDiv.style.overflow = "hidden";
8812
innerDiv.style.position = "relative";
8813
8814
this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
8815
8816
this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
8817
8818
body.removeChild( container );
8819
jQuery.offset.initialize = jQuery.noop;
8820
},
8821
9017
8822
9018
bodyOffset: function( body ) {
8823
9019
var top = body.offsetTop,
8824
9020
left = body.offsetLeft;
8825
9021
8826
jQuery.offset.initialize();
8827
8828
if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
9022
if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) {
8829
9023
top += parseFloat( jQuery.css(body, "marginTop") ) || 0;
8830
9024
left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
8831
9025
}
8845
9039
curOffset = curElem.offset(),
8846
9040
curCSSTop = jQuery.css( elem, "top" ),
8847
9041
curCSSLeft = jQuery.css( elem, "left" ),
8848
calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
9042
calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
8849
9043
props = {}, curPosition = {}, curTop, curLeft;
8850
9044
8851
9045
// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
8862
9056
options = options.call( elem, i, curOffset );
8863
9057
}
8864
9058
8865
if (options.top != null) {
8866
props.top = (options.top - curOffset.top) + curTop;
9059
if ( options.top != null ) {
9060
props.top = ( options.top - curOffset.top ) + curTop;
8867
9061
}
8868
if (options.left != null) {
8869
props.left = (options.left - curOffset.left) + curLeft;
9062
if ( options.left != null ) {
9063
props.left = ( options.left - curOffset.left ) + curLeft;
8870
9064
}
8871
9065
8872
9066
if ( "using" in options ) {
8879
9073
8880
9074
8881
9075
jQuery.fn.extend({
9076
8882
9077
position: function() {
8883
9078
if ( !this[0] ) {
8884
9079
return null;
8981
9176
// innerHeight and innerWidth
8982
9177
jQuery.fn[ "inner" + name ] = function() {
8983
9178
var elem = this[0];
8984
return elem && elem.style ?
9179
return elem ?
9180
elem.style ?
8985
9181
parseFloat( jQuery.css( elem, type, "padding" ) ) :
9182
this[ type ]() :
8986
9183
null;
8987
9184
};
8988
9185
8989
9186
// outerHeight and outerWidth
8990
9187
jQuery.fn[ "outer" + name ] = function( margin ) {
8991
9188
var elem = this[0];
8992
return elem && elem.style ?
9189
return elem ?
9190
elem.style ?
8993
9191
parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
9192
this[ type ]() :
8994
9193
null;
8995
9194
};
8996
9195
9030
9229
var orig = jQuery.css( elem, type ),
9031
9230
ret = parseFloat( orig );
9032
9231
9033
return jQuery.isNaN( ret ) ? orig : ret;
9232
return jQuery.isNumeric( ret ) ? ret : orig;
9034
9233
9035
9234
// Set the width or height on the element (default to pixels if value is unitless)
9036
9235
} else {
9041
9240
});
9042
9241
9043
9242
9243
9244
9044
9245
// Expose jQuery to the global object
9045
9246
window.jQuery = window.$ = jQuery;
9046
})(window);
9247
9248
// Expose jQuery as an AMD module, but only for AMD loaders that
9249
// understand the issues with loading multiple versions of jQuery
9250
// in a page that all might call define(). The loader will indicate
9251
// they have special allowances for multiple jQuery versions by
9252
// specifying define.amd.jQuery = true. Register as a named module,
9253
// since jQuery can be concatenated with other files that may use define,
9254
// but not use a proper concatenation script that understands anonymous
9255
// AMD modules. A named AMD is safest and most robust way to register.
9256
// Lowercase jquery is used because AMD module names are derived from
9257
// file names, and jQuery is normally delivered in a lowercase file name.
9258
// Do this after creating the global so that if an AMD module wants to call
9259
// noConflict to hide this version of jQuery, it will work.
9260
if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
9261
define( "jquery", [], function () { return jQuery; } );
9262
}
9263
9264
9265
9266
})( window );
Loggerhead is a web-based interface for Breezy
Version: 2.0.1