|
0
|
1 define( [
|
|
|
2 "./core",
|
|
|
3 "./core/camelCase",
|
|
|
4 "./var/document",
|
|
|
5 "./var/isFunction",
|
|
|
6 "./var/rcssNum",
|
|
|
7 "./var/rnothtmlwhite",
|
|
|
8 "./css/var/cssExpand",
|
|
|
9 "./css/var/isHiddenWithinTree",
|
|
|
10 "./css/var/swap",
|
|
|
11 "./css/adjustCSS",
|
|
|
12 "./data/var/dataPriv",
|
|
|
13 "./css/showHide",
|
|
|
14
|
|
|
15 "./core/init",
|
|
|
16 "./queue",
|
|
|
17 "./deferred",
|
|
|
18 "./traversing",
|
|
|
19 "./manipulation",
|
|
|
20 "./css",
|
|
|
21 "./effects/Tween"
|
|
|
22 ], function( jQuery, camelCase, document, isFunction, rcssNum, rnothtmlwhite, cssExpand,
|
|
|
23 isHiddenWithinTree, swap, adjustCSS, dataPriv, showHide ) {
|
|
|
24
|
|
|
25 "use strict";
|
|
|
26
|
|
|
27 var
|
|
|
28 fxNow, inProgress,
|
|
|
29 rfxtypes = /^(?:toggle|show|hide)$/,
|
|
|
30 rrun = /queueHooks$/;
|
|
|
31
|
|
|
32 function schedule() {
|
|
|
33 if ( inProgress ) {
|
|
|
34 if ( document.hidden === false && window.requestAnimationFrame ) {
|
|
|
35 window.requestAnimationFrame( schedule );
|
|
|
36 } else {
|
|
|
37 window.setTimeout( schedule, jQuery.fx.interval );
|
|
|
38 }
|
|
|
39
|
|
|
40 jQuery.fx.tick();
|
|
|
41 }
|
|
|
42 }
|
|
|
43
|
|
|
44 // Animations created synchronously will run synchronously
|
|
|
45 function createFxNow() {
|
|
|
46 window.setTimeout( function() {
|
|
|
47 fxNow = undefined;
|
|
|
48 } );
|
|
|
49 return ( fxNow = Date.now() );
|
|
|
50 }
|
|
|
51
|
|
|
52 // Generate parameters to create a standard animation
|
|
|
53 function genFx( type, includeWidth ) {
|
|
|
54 var which,
|
|
|
55 i = 0,
|
|
|
56 attrs = { height: type };
|
|
|
57
|
|
|
58 // If we include width, step value is 1 to do all cssExpand values,
|
|
|
59 // otherwise step value is 2 to skip over Left and Right
|
|
|
60 includeWidth = includeWidth ? 1 : 0;
|
|
|
61 for ( ; i < 4; i += 2 - includeWidth ) {
|
|
|
62 which = cssExpand[ i ];
|
|
|
63 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
|
|
|
64 }
|
|
|
65
|
|
|
66 if ( includeWidth ) {
|
|
|
67 attrs.opacity = attrs.width = type;
|
|
|
68 }
|
|
|
69
|
|
|
70 return attrs;
|
|
|
71 }
|
|
|
72
|
|
|
73 function createTween( value, prop, animation ) {
|
|
|
74 var tween,
|
|
|
75 collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
|
|
|
76 index = 0,
|
|
|
77 length = collection.length;
|
|
|
78 for ( ; index < length; index++ ) {
|
|
|
79 if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
|
|
|
80
|
|
|
81 // We're done with this property
|
|
|
82 return tween;
|
|
|
83 }
|
|
|
84 }
|
|
|
85 }
|
|
|
86
|
|
|
87 function defaultPrefilter( elem, props, opts ) {
|
|
|
88 var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
|
|
|
89 isBox = "width" in props || "height" in props,
|
|
|
90 anim = this,
|
|
|
91 orig = {},
|
|
|
92 style = elem.style,
|
|
|
93 hidden = elem.nodeType && isHiddenWithinTree( elem ),
|
|
|
94 dataShow = dataPriv.get( elem, "fxshow" );
|
|
|
95
|
|
|
96 // Queue-skipping animations hijack the fx hooks
|
|
|
97 if ( !opts.queue ) {
|
|
|
98 hooks = jQuery._queueHooks( elem, "fx" );
|
|
|
99 if ( hooks.unqueued == null ) {
|
|
|
100 hooks.unqueued = 0;
|
|
|
101 oldfire = hooks.empty.fire;
|
|
|
102 hooks.empty.fire = function() {
|
|
|
103 if ( !hooks.unqueued ) {
|
|
|
104 oldfire();
|
|
|
105 }
|
|
|
106 };
|
|
|
107 }
|
|
|
108 hooks.unqueued++;
|
|
|
109
|
|
|
110 anim.always( function() {
|
|
|
111
|
|
|
112 // Ensure the complete handler is called before this completes
|
|
|
113 anim.always( function() {
|
|
|
114 hooks.unqueued--;
|
|
|
115 if ( !jQuery.queue( elem, "fx" ).length ) {
|
|
|
116 hooks.empty.fire();
|
|
|
117 }
|
|
|
118 } );
|
|
|
119 } );
|
|
|
120 }
|
|
|
121
|
|
|
122 // Detect show/hide animations
|
|
|
123 for ( prop in props ) {
|
|
|
124 value = props[ prop ];
|
|
|
125 if ( rfxtypes.test( value ) ) {
|
|
|
126 delete props[ prop ];
|
|
|
127 toggle = toggle || value === "toggle";
|
|
|
128 if ( value === ( hidden ? "hide" : "show" ) ) {
|
|
|
129
|
|
|
130 // Pretend to be hidden if this is a "show" and
|
|
|
131 // there is still data from a stopped show/hide
|
|
|
132 if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
|
|
|
133 hidden = true;
|
|
|
134
|
|
|
135 // Ignore all other no-op show/hide data
|
|
|
136 } else {
|
|
|
137 continue;
|
|
|
138 }
|
|
|
139 }
|
|
|
140 orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
|
|
|
141 }
|
|
|
142 }
|
|
|
143
|
|
|
144 // Bail out if this is a no-op like .hide().hide()
|
|
|
145 propTween = !jQuery.isEmptyObject( props );
|
|
|
146 if ( !propTween && jQuery.isEmptyObject( orig ) ) {
|
|
|
147 return;
|
|
|
148 }
|
|
|
149
|
|
|
150 // Restrict "overflow" and "display" styles during box animations
|
|
|
151 if ( isBox && elem.nodeType === 1 ) {
|
|
|
152
|
|
|
153 // Support: IE <=9 - 11, Edge 12 - 15
|
|
|
154 // Record all 3 overflow attributes because IE does not infer the shorthand
|
|
|
155 // from identically-valued overflowX and overflowY and Edge just mirrors
|
|
|
156 // the overflowX value there.
|
|
|
157 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
|
|
|
158
|
|
|
159 // Identify a display type, preferring old show/hide data over the CSS cascade
|
|
|
160 restoreDisplay = dataShow && dataShow.display;
|
|
|
161 if ( restoreDisplay == null ) {
|
|
|
162 restoreDisplay = dataPriv.get( elem, "display" );
|
|
|
163 }
|
|
|
164 display = jQuery.css( elem, "display" );
|
|
|
165 if ( display === "none" ) {
|
|
|
166 if ( restoreDisplay ) {
|
|
|
167 display = restoreDisplay;
|
|
|
168 } else {
|
|
|
169
|
|
|
170 // Get nonempty value(s) by temporarily forcing visibility
|
|
|
171 showHide( [ elem ], true );
|
|
|
172 restoreDisplay = elem.style.display || restoreDisplay;
|
|
|
173 display = jQuery.css( elem, "display" );
|
|
|
174 showHide( [ elem ] );
|
|
|
175 }
|
|
|
176 }
|
|
|
177
|
|
|
178 // Animate inline elements as inline-block
|
|
|
179 if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
|
|
|
180 if ( jQuery.css( elem, "float" ) === "none" ) {
|
|
|
181
|
|
|
182 // Restore the original display value at the end of pure show/hide animations
|
|
|
183 if ( !propTween ) {
|
|
|
184 anim.done( function() {
|
|
|
185 style.display = restoreDisplay;
|
|
|
186 } );
|
|
|
187 if ( restoreDisplay == null ) {
|
|
|
188 display = style.display;
|
|
|
189 restoreDisplay = display === "none" ? "" : display;
|
|
|
190 }
|
|
|
191 }
|
|
|
192 style.display = "inline-block";
|
|
|
193 }
|
|
|
194 }
|
|
|
195 }
|
|
|
196
|
|
|
197 if ( opts.overflow ) {
|
|
|
198 style.overflow = "hidden";
|
|
|
199 anim.always( function() {
|
|
|
200 style.overflow = opts.overflow[ 0 ];
|
|
|
201 style.overflowX = opts.overflow[ 1 ];
|
|
|
202 style.overflowY = opts.overflow[ 2 ];
|
|
|
203 } );
|
|
|
204 }
|
|
|
205
|
|
|
206 // Implement show/hide animations
|
|
|
207 propTween = false;
|
|
|
208 for ( prop in orig ) {
|
|
|
209
|
|
|
210 // General show/hide setup for this element animation
|
|
|
211 if ( !propTween ) {
|
|
|
212 if ( dataShow ) {
|
|
|
213 if ( "hidden" in dataShow ) {
|
|
|
214 hidden = dataShow.hidden;
|
|
|
215 }
|
|
|
216 } else {
|
|
|
217 dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
|
|
|
218 }
|
|
|
219
|
|
|
220 // Store hidden/visible for toggle so `.stop().toggle()` "reverses"
|
|
|
221 if ( toggle ) {
|
|
|
222 dataShow.hidden = !hidden;
|
|
|
223 }
|
|
|
224
|
|
|
225 // Show elements before animating them
|
|
|
226 if ( hidden ) {
|
|
|
227 showHide( [ elem ], true );
|
|
|
228 }
|
|
|
229
|
|
|
230 /* eslint-disable no-loop-func */
|
|
|
231
|
|
|
232 anim.done( function() {
|
|
|
233
|
|
|
234 /* eslint-enable no-loop-func */
|
|
|
235
|
|
|
236 // The final step of a "hide" animation is actually hiding the element
|
|
|
237 if ( !hidden ) {
|
|
|
238 showHide( [ elem ] );
|
|
|
239 }
|
|
|
240 dataPriv.remove( elem, "fxshow" );
|
|
|
241 for ( prop in orig ) {
|
|
|
242 jQuery.style( elem, prop, orig[ prop ] );
|
|
|
243 }
|
|
|
244 } );
|
|
|
245 }
|
|
|
246
|
|
|
247 // Per-property setup
|
|
|
248 propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
|
|
|
249 if ( !( prop in dataShow ) ) {
|
|
|
250 dataShow[ prop ] = propTween.start;
|
|
|
251 if ( hidden ) {
|
|
|
252 propTween.end = propTween.start;
|
|
|
253 propTween.start = 0;
|
|
|
254 }
|
|
|
255 }
|
|
|
256 }
|
|
|
257 }
|
|
|
258
|
|
|
259 function propFilter( props, specialEasing ) {
|
|
|
260 var index, name, easing, value, hooks;
|
|
|
261
|
|
|
262 // camelCase, specialEasing and expand cssHook pass
|
|
|
263 for ( index in props ) {
|
|
|
264 name = camelCase( index );
|
|
|
265 easing = specialEasing[ name ];
|
|
|
266 value = props[ index ];
|
|
|
267 if ( Array.isArray( value ) ) {
|
|
|
268 easing = value[ 1 ];
|
|
|
269 value = props[ index ] = value[ 0 ];
|
|
|
270 }
|
|
|
271
|
|
|
272 if ( index !== name ) {
|
|
|
273 props[ name ] = value;
|
|
|
274 delete props[ index ];
|
|
|
275 }
|
|
|
276
|
|
|
277 hooks = jQuery.cssHooks[ name ];
|
|
|
278 if ( hooks && "expand" in hooks ) {
|
|
|
279 value = hooks.expand( value );
|
|
|
280 delete props[ name ];
|
|
|
281
|
|
|
282 // Not quite $.extend, this won't overwrite existing keys.
|
|
|
283 // Reusing 'index' because we have the correct "name"
|
|
|
284 for ( index in value ) {
|
|
|
285 if ( !( index in props ) ) {
|
|
|
286 props[ index ] = value[ index ];
|
|
|
287 specialEasing[ index ] = easing;
|
|
|
288 }
|
|
|
289 }
|
|
|
290 } else {
|
|
|
291 specialEasing[ name ] = easing;
|
|
|
292 }
|
|
|
293 }
|
|
|
294 }
|
|
|
295
|
|
|
296 function Animation( elem, properties, options ) {
|
|
|
297 var result,
|
|
|
298 stopped,
|
|
|
299 index = 0,
|
|
|
300 length = Animation.prefilters.length,
|
|
|
301 deferred = jQuery.Deferred().always( function() {
|
|
|
302
|
|
|
303 // Don't match elem in the :animated selector
|
|
|
304 delete tick.elem;
|
|
|
305 } ),
|
|
|
306 tick = function() {
|
|
|
307 if ( stopped ) {
|
|
|
308 return false;
|
|
|
309 }
|
|
|
310 var currentTime = fxNow || createFxNow(),
|
|
|
311 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
|
|
|
312
|
|
|
313 // Support: Android 2.3 only
|
|
|
314 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
|
|
|
315 temp = remaining / animation.duration || 0,
|
|
|
316 percent = 1 - temp,
|
|
|
317 index = 0,
|
|
|
318 length = animation.tweens.length;
|
|
|
319
|
|
|
320 for ( ; index < length; index++ ) {
|
|
|
321 animation.tweens[ index ].run( percent );
|
|
|
322 }
|
|
|
323
|
|
|
324 deferred.notifyWith( elem, [ animation, percent, remaining ] );
|
|
|
325
|
|
|
326 // If there's more to do, yield
|
|
|
327 if ( percent < 1 && length ) {
|
|
|
328 return remaining;
|
|
|
329 }
|
|
|
330
|
|
|
331 // If this was an empty animation, synthesize a final progress notification
|
|
|
332 if ( !length ) {
|
|
|
333 deferred.notifyWith( elem, [ animation, 1, 0 ] );
|
|
|
334 }
|
|
|
335
|
|
|
336 // Resolve the animation and report its conclusion
|
|
|
337 deferred.resolveWith( elem, [ animation ] );
|
|
|
338 return false;
|
|
|
339 },
|
|
|
340 animation = deferred.promise( {
|
|
|
341 elem: elem,
|
|
|
342 props: jQuery.extend( {}, properties ),
|
|
|
343 opts: jQuery.extend( true, {
|
|
|
344 specialEasing: {},
|
|
|
345 easing: jQuery.easing._default
|
|
|
346 }, options ),
|
|
|
347 originalProperties: properties,
|
|
|
348 originalOptions: options,
|
|
|
349 startTime: fxNow || createFxNow(),
|
|
|
350 duration: options.duration,
|
|
|
351 tweens: [],
|
|
|
352 createTween: function( prop, end ) {
|
|
|
353 var tween = jQuery.Tween( elem, animation.opts, prop, end,
|
|
|
354 animation.opts.specialEasing[ prop ] || animation.opts.easing );
|
|
|
355 animation.tweens.push( tween );
|
|
|
356 return tween;
|
|
|
357 },
|
|
|
358 stop: function( gotoEnd ) {
|
|
|
359 var index = 0,
|
|
|
360
|
|
|
361 // If we are going to the end, we want to run all the tweens
|
|
|
362 // otherwise we skip this part
|
|
|
363 length = gotoEnd ? animation.tweens.length : 0;
|
|
|
364 if ( stopped ) {
|
|
|
365 return this;
|
|
|
366 }
|
|
|
367 stopped = true;
|
|
|
368 for ( ; index < length; index++ ) {
|
|
|
369 animation.tweens[ index ].run( 1 );
|
|
|
370 }
|
|
|
371
|
|
|
372 // Resolve when we played the last frame; otherwise, reject
|
|
|
373 if ( gotoEnd ) {
|
|
|
374 deferred.notifyWith( elem, [ animation, 1, 0 ] );
|
|
|
375 deferred.resolveWith( elem, [ animation, gotoEnd ] );
|
|
|
376 } else {
|
|
|
377 deferred.rejectWith( elem, [ animation, gotoEnd ] );
|
|
|
378 }
|
|
|
379 return this;
|
|
|
380 }
|
|
|
381 } ),
|
|
|
382 props = animation.props;
|
|
|
383
|
|
|
384 propFilter( props, animation.opts.specialEasing );
|
|
|
385
|
|
|
386 for ( ; index < length; index++ ) {
|
|
|
387 result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
|
|
|
388 if ( result ) {
|
|
|
389 if ( isFunction( result.stop ) ) {
|
|
|
390 jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
|
|
|
391 result.stop.bind( result );
|
|
|
392 }
|
|
|
393 return result;
|
|
|
394 }
|
|
|
395 }
|
|
|
396
|
|
|
397 jQuery.map( props, createTween, animation );
|
|
|
398
|
|
|
399 if ( isFunction( animation.opts.start ) ) {
|
|
|
400 animation.opts.start.call( elem, animation );
|
|
|
401 }
|
|
|
402
|
|
|
403 // Attach callbacks from options
|
|
|
404 animation
|
|
|
405 .progress( animation.opts.progress )
|
|
|
406 .done( animation.opts.done, animation.opts.complete )
|
|
|
407 .fail( animation.opts.fail )
|
|
|
408 .always( animation.opts.always );
|
|
|
409
|
|
|
410 jQuery.fx.timer(
|
|
|
411 jQuery.extend( tick, {
|
|
|
412 elem: elem,
|
|
|
413 anim: animation,
|
|
|
414 queue: animation.opts.queue
|
|
|
415 } )
|
|
|
416 );
|
|
|
417
|
|
|
418 return animation;
|
|
|
419 }
|
|
|
420
|
|
|
421 jQuery.Animation = jQuery.extend( Animation, {
|
|
|
422
|
|
|
423 tweeners: {
|
|
|
424 "*": [ function( prop, value ) {
|
|
|
425 var tween = this.createTween( prop, value );
|
|
|
426 adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
|
|
|
427 return tween;
|
|
|
428 } ]
|
|
|
429 },
|
|
|
430
|
|
|
431 tweener: function( props, callback ) {
|
|
|
432 if ( isFunction( props ) ) {
|
|
|
433 callback = props;
|
|
|
434 props = [ "*" ];
|
|
|
435 } else {
|
|
|
436 props = props.match( rnothtmlwhite );
|
|
|
437 }
|
|
|
438
|
|
|
439 var prop,
|
|
|
440 index = 0,
|
|
|
441 length = props.length;
|
|
|
442
|
|
|
443 for ( ; index < length; index++ ) {
|
|
|
444 prop = props[ index ];
|
|
|
445 Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
|
|
|
446 Animation.tweeners[ prop ].unshift( callback );
|
|
|
447 }
|
|
|
448 },
|
|
|
449
|
|
|
450 prefilters: [ defaultPrefilter ],
|
|
|
451
|
|
|
452 prefilter: function( callback, prepend ) {
|
|
|
453 if ( prepend ) {
|
|
|
454 Animation.prefilters.unshift( callback );
|
|
|
455 } else {
|
|
|
456 Animation.prefilters.push( callback );
|
|
|
457 }
|
|
|
458 }
|
|
|
459 } );
|
|
|
460
|
|
|
461 jQuery.speed = function( speed, easing, fn ) {
|
|
|
462 var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
|
|
|
463 complete: fn || !fn && easing ||
|
|
|
464 isFunction( speed ) && speed,
|
|
|
465 duration: speed,
|
|
|
466 easing: fn && easing || easing && !isFunction( easing ) && easing
|
|
|
467 };
|
|
|
468
|
|
|
469 // Go to the end state if fx are off
|
|
|
470 if ( jQuery.fx.off ) {
|
|
|
471 opt.duration = 0;
|
|
|
472
|
|
|
473 } else {
|
|
|
474 if ( typeof opt.duration !== "number" ) {
|
|
|
475 if ( opt.duration in jQuery.fx.speeds ) {
|
|
|
476 opt.duration = jQuery.fx.speeds[ opt.duration ];
|
|
|
477
|
|
|
478 } else {
|
|
|
479 opt.duration = jQuery.fx.speeds._default;
|
|
|
480 }
|
|
|
481 }
|
|
|
482 }
|
|
|
483
|
|
|
484 // Normalize opt.queue - true/undefined/null -> "fx"
|
|
|
485 if ( opt.queue == null || opt.queue === true ) {
|
|
|
486 opt.queue = "fx";
|
|
|
487 }
|
|
|
488
|
|
|
489 // Queueing
|
|
|
490 opt.old = opt.complete;
|
|
|
491
|
|
|
492 opt.complete = function() {
|
|
|
493 if ( isFunction( opt.old ) ) {
|
|
|
494 opt.old.call( this );
|
|
|
495 }
|
|
|
496
|
|
|
497 if ( opt.queue ) {
|
|
|
498 jQuery.dequeue( this, opt.queue );
|
|
|
499 }
|
|
|
500 };
|
|
|
501
|
|
|
502 return opt;
|
|
|
503 };
|
|
|
504
|
|
|
505 jQuery.fn.extend( {
|
|
|
506 fadeTo: function( speed, to, easing, callback ) {
|
|
|
507
|
|
|
508 // Show any hidden elements after setting opacity to 0
|
|
|
509 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
|
|
|
510
|
|
|
511 // Animate to the value specified
|
|
|
512 .end().animate( { opacity: to }, speed, easing, callback );
|
|
|
513 },
|
|
|
514 animate: function( prop, speed, easing, callback ) {
|
|
|
515 var empty = jQuery.isEmptyObject( prop ),
|
|
|
516 optall = jQuery.speed( speed, easing, callback ),
|
|
|
517 doAnimation = function() {
|
|
|
518
|
|
|
519 // Operate on a copy of prop so per-property easing won't be lost
|
|
|
520 var anim = Animation( this, jQuery.extend( {}, prop ), optall );
|
|
|
521
|
|
|
522 // Empty animations, or finishing resolves immediately
|
|
|
523 if ( empty || dataPriv.get( this, "finish" ) ) {
|
|
|
524 anim.stop( true );
|
|
|
525 }
|
|
|
526 };
|
|
|
527 doAnimation.finish = doAnimation;
|
|
|
528
|
|
|
529 return empty || optall.queue === false ?
|
|
|
530 this.each( doAnimation ) :
|
|
|
531 this.queue( optall.queue, doAnimation );
|
|
|
532 },
|
|
|
533 stop: function( type, clearQueue, gotoEnd ) {
|
|
|
534 var stopQueue = function( hooks ) {
|
|
|
535 var stop = hooks.stop;
|
|
|
536 delete hooks.stop;
|
|
|
537 stop( gotoEnd );
|
|
|
538 };
|
|
|
539
|
|
|
540 if ( typeof type !== "string" ) {
|
|
|
541 gotoEnd = clearQueue;
|
|
|
542 clearQueue = type;
|
|
|
543 type = undefined;
|
|
|
544 }
|
|
|
545 if ( clearQueue && type !== false ) {
|
|
|
546 this.queue( type || "fx", [] );
|
|
|
547 }
|
|
|
548
|
|
|
549 return this.each( function() {
|
|
|
550 var dequeue = true,
|
|
|
551 index = type != null && type + "queueHooks",
|
|
|
552 timers = jQuery.timers,
|
|
|
553 data = dataPriv.get( this );
|
|
|
554
|
|
|
555 if ( index ) {
|
|
|
556 if ( data[ index ] && data[ index ].stop ) {
|
|
|
557 stopQueue( data[ index ] );
|
|
|
558 }
|
|
|
559 } else {
|
|
|
560 for ( index in data ) {
|
|
|
561 if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
|
|
|
562 stopQueue( data[ index ] );
|
|
|
563 }
|
|
|
564 }
|
|
|
565 }
|
|
|
566
|
|
|
567 for ( index = timers.length; index--; ) {
|
|
|
568 if ( timers[ index ].elem === this &&
|
|
|
569 ( type == null || timers[ index ].queue === type ) ) {
|
|
|
570
|
|
|
571 timers[ index ].anim.stop( gotoEnd );
|
|
|
572 dequeue = false;
|
|
|
573 timers.splice( index, 1 );
|
|
|
574 }
|
|
|
575 }
|
|
|
576
|
|
|
577 // Start the next in the queue if the last step wasn't forced.
|
|
|
578 // Timers currently will call their complete callbacks, which
|
|
|
579 // will dequeue but only if they were gotoEnd.
|
|
|
580 if ( dequeue || !gotoEnd ) {
|
|
|
581 jQuery.dequeue( this, type );
|
|
|
582 }
|
|
|
583 } );
|
|
|
584 },
|
|
|
585 finish: function( type ) {
|
|
|
586 if ( type !== false ) {
|
|
|
587 type = type || "fx";
|
|
|
588 }
|
|
|
589 return this.each( function() {
|
|
|
590 var index,
|
|
|
591 data = dataPriv.get( this ),
|
|
|
592 queue = data[ type + "queue" ],
|
|
|
593 hooks = data[ type + "queueHooks" ],
|
|
|
594 timers = jQuery.timers,
|
|
|
595 length = queue ? queue.length : 0;
|
|
|
596
|
|
|
597 // Enable finishing flag on private data
|
|
|
598 data.finish = true;
|
|
|
599
|
|
|
600 // Empty the queue first
|
|
|
601 jQuery.queue( this, type, [] );
|
|
|
602
|
|
|
603 if ( hooks && hooks.stop ) {
|
|
|
604 hooks.stop.call( this, true );
|
|
|
605 }
|
|
|
606
|
|
|
607 // Look for any active animations, and finish them
|
|
|
608 for ( index = timers.length; index--; ) {
|
|
|
609 if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
|
|
|
610 timers[ index ].anim.stop( true );
|
|
|
611 timers.splice( index, 1 );
|
|
|
612 }
|
|
|
613 }
|
|
|
614
|
|
|
615 // Look for any animations in the old queue and finish them
|
|
|
616 for ( index = 0; index < length; index++ ) {
|
|
|
617 if ( queue[ index ] && queue[ index ].finish ) {
|
|
|
618 queue[ index ].finish.call( this );
|
|
|
619 }
|
|
|
620 }
|
|
|
621
|
|
|
622 // Turn off finishing flag
|
|
|
623 delete data.finish;
|
|
|
624 } );
|
|
|
625 }
|
|
|
626 } );
|
|
|
627
|
|
|
628 jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
|
|
|
629 var cssFn = jQuery.fn[ name ];
|
|
|
630 jQuery.fn[ name ] = function( speed, easing, callback ) {
|
|
|
631 return speed == null || typeof speed === "boolean" ?
|
|
|
632 cssFn.apply( this, arguments ) :
|
|
|
633 this.animate( genFx( name, true ), speed, easing, callback );
|
|
|
634 };
|
|
|
635 } );
|
|
|
636
|
|
|
637 // Generate shortcuts for custom animations
|
|
|
638 jQuery.each( {
|
|
|
639 slideDown: genFx( "show" ),
|
|
|
640 slideUp: genFx( "hide" ),
|
|
|
641 slideToggle: genFx( "toggle" ),
|
|
|
642 fadeIn: { opacity: "show" },
|
|
|
643 fadeOut: { opacity: "hide" },
|
|
|
644 fadeToggle: { opacity: "toggle" }
|
|
|
645 }, function( name, props ) {
|
|
|
646 jQuery.fn[ name ] = function( speed, easing, callback ) {
|
|
|
647 return this.animate( props, speed, easing, callback );
|
|
|
648 };
|
|
|
649 } );
|
|
|
650
|
|
|
651 jQuery.timers = [];
|
|
|
652 jQuery.fx.tick = function() {
|
|
|
653 var timer,
|
|
|
654 i = 0,
|
|
|
655 timers = jQuery.timers;
|
|
|
656
|
|
|
657 fxNow = Date.now();
|
|
|
658
|
|
|
659 for ( ; i < timers.length; i++ ) {
|
|
|
660 timer = timers[ i ];
|
|
|
661
|
|
|
662 // Run the timer and safely remove it when done (allowing for external removal)
|
|
|
663 if ( !timer() && timers[ i ] === timer ) {
|
|
|
664 timers.splice( i--, 1 );
|
|
|
665 }
|
|
|
666 }
|
|
|
667
|
|
|
668 if ( !timers.length ) {
|
|
|
669 jQuery.fx.stop();
|
|
|
670 }
|
|
|
671 fxNow = undefined;
|
|
|
672 };
|
|
|
673
|
|
|
674 jQuery.fx.timer = function( timer ) {
|
|
|
675 jQuery.timers.push( timer );
|
|
|
676 jQuery.fx.start();
|
|
|
677 };
|
|
|
678
|
|
|
679 jQuery.fx.interval = 13;
|
|
|
680 jQuery.fx.start = function() {
|
|
|
681 if ( inProgress ) {
|
|
|
682 return;
|
|
|
683 }
|
|
|
684
|
|
|
685 inProgress = true;
|
|
|
686 schedule();
|
|
|
687 };
|
|
|
688
|
|
|
689 jQuery.fx.stop = function() {
|
|
|
690 inProgress = null;
|
|
|
691 };
|
|
|
692
|
|
|
693 jQuery.fx.speeds = {
|
|
|
694 slow: 600,
|
|
|
695 fast: 200,
|
|
|
696
|
|
|
697 // Default speed
|
|
|
698 _default: 400
|
|
|
699 };
|
|
|
700
|
|
|
701 return jQuery;
|
|
|
702 } );
|
