| 14217 |
anikendra |
1 |
define([
|
|
|
2 |
"./core",
|
|
|
3 |
"./var/pnum",
|
|
|
4 |
"./css/var/cssExpand",
|
|
|
5 |
"./css/var/isHidden",
|
|
|
6 |
"./css/defaultDisplay",
|
|
|
7 |
"./data/var/data_priv",
|
|
|
8 |
|
|
|
9 |
"./core/init",
|
|
|
10 |
"./effects/Tween",
|
|
|
11 |
"./queue",
|
|
|
12 |
"./css",
|
|
|
13 |
"./deferred",
|
|
|
14 |
"./traversing"
|
|
|
15 |
], function( jQuery, pnum, cssExpand, isHidden, defaultDisplay, data_priv ) {
|
|
|
16 |
|
|
|
17 |
var
|
|
|
18 |
fxNow, timerId,
|
|
|
19 |
rfxtypes = /^(?:toggle|show|hide)$/,
|
|
|
20 |
rfxnum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ),
|
|
|
21 |
rrun = /queueHooks$/,
|
|
|
22 |
animationPrefilters = [ defaultPrefilter ],
|
|
|
23 |
tweeners = {
|
|
|
24 |
"*": [ function( prop, value ) {
|
|
|
25 |
var tween = this.createTween( prop, value ),
|
|
|
26 |
target = tween.cur(),
|
|
|
27 |
parts = rfxnum.exec( value ),
|
|
|
28 |
unit = parts && parts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
|
|
|
29 |
|
|
|
30 |
// Starting value computation is required for potential unit mismatches
|
|
|
31 |
start = ( jQuery.cssNumber[ prop ] || unit !== "px" && +target ) &&
|
|
|
32 |
rfxnum.exec( jQuery.css( tween.elem, prop ) ),
|
|
|
33 |
scale = 1,
|
|
|
34 |
maxIterations = 20;
|
|
|
35 |
|
|
|
36 |
if ( start && start[ 3 ] !== unit ) {
|
|
|
37 |
// Trust units reported by jQuery.css
|
|
|
38 |
unit = unit || start[ 3 ];
|
|
|
39 |
|
|
|
40 |
// Make sure we update the tween properties later on
|
|
|
41 |
parts = parts || [];
|
|
|
42 |
|
|
|
43 |
// Iteratively approximate from a nonzero starting point
|
|
|
44 |
start = +target || 1;
|
|
|
45 |
|
|
|
46 |
do {
|
|
|
47 |
// If previous iteration zeroed out, double until we get *something*.
|
|
|
48 |
// Use string for doubling so we don't accidentally see scale as unchanged below
|
|
|
49 |
scale = scale || ".5";
|
|
|
50 |
|
|
|
51 |
// Adjust and apply
|
|
|
52 |
start = start / scale;
|
|
|
53 |
jQuery.style( tween.elem, prop, start + unit );
|
|
|
54 |
|
|
|
55 |
// Update scale, tolerating zero or NaN from tween.cur(),
|
|
|
56 |
// break the loop if scale is unchanged or perfect, or if we've just had enough
|
|
|
57 |
} while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
|
|
|
58 |
}
|
|
|
59 |
|
|
|
60 |
// Update tween properties
|
|
|
61 |
if ( parts ) {
|
|
|
62 |
start = tween.start = +start || +target || 0;
|
|
|
63 |
tween.unit = unit;
|
|
|
64 |
// If a +=/-= token was provided, we're doing a relative animation
|
|
|
65 |
tween.end = parts[ 1 ] ?
|
|
|
66 |
start + ( parts[ 1 ] + 1 ) * parts[ 2 ] :
|
|
|
67 |
+parts[ 2 ];
|
|
|
68 |
}
|
|
|
69 |
|
|
|
70 |
return tween;
|
|
|
71 |
} ]
|
|
|
72 |
};
|
|
|
73 |
|
|
|
74 |
// Animations created synchronously will run synchronously
|
|
|
75 |
function createFxNow() {
|
|
|
76 |
setTimeout(function() {
|
|
|
77 |
fxNow = undefined;
|
|
|
78 |
});
|
|
|
79 |
return ( fxNow = jQuery.now() );
|
|
|
80 |
}
|
|
|
81 |
|
|
|
82 |
// Generate parameters to create a standard animation
|
|
|
83 |
function genFx( type, includeWidth ) {
|
|
|
84 |
var which,
|
|
|
85 |
i = 0,
|
|
|
86 |
attrs = { height: type };
|
|
|
87 |
|
|
|
88 |
// If we include width, step value is 1 to do all cssExpand values,
|
|
|
89 |
// otherwise step value is 2 to skip over Left and Right
|
|
|
90 |
includeWidth = includeWidth ? 1 : 0;
|
|
|
91 |
for ( ; i < 4 ; i += 2 - includeWidth ) {
|
|
|
92 |
which = cssExpand[ i ];
|
|
|
93 |
attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
|
|
|
94 |
}
|
|
|
95 |
|
|
|
96 |
if ( includeWidth ) {
|
|
|
97 |
attrs.opacity = attrs.width = type;
|
|
|
98 |
}
|
|
|
99 |
|
|
|
100 |
return attrs;
|
|
|
101 |
}
|
|
|
102 |
|
|
|
103 |
function createTween( value, prop, animation ) {
|
|
|
104 |
var tween,
|
|
|
105 |
collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
|
|
|
106 |
index = 0,
|
|
|
107 |
length = collection.length;
|
|
|
108 |
for ( ; index < length; index++ ) {
|
|
|
109 |
if ( (tween = collection[ index ].call( animation, prop, value )) ) {
|
|
|
110 |
|
|
|
111 |
// We're done with this property
|
|
|
112 |
return tween;
|
|
|
113 |
}
|
|
|
114 |
}
|
|
|
115 |
}
|
|
|
116 |
|
|
|
117 |
function defaultPrefilter( elem, props, opts ) {
|
|
|
118 |
/* jshint validthis: true */
|
|
|
119 |
var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
|
|
|
120 |
anim = this,
|
|
|
121 |
orig = {},
|
|
|
122 |
style = elem.style,
|
|
|
123 |
hidden = elem.nodeType && isHidden( elem ),
|
|
|
124 |
dataShow = data_priv.get( elem, "fxshow" );
|
|
|
125 |
|
|
|
126 |
// Handle queue: false promises
|
|
|
127 |
if ( !opts.queue ) {
|
|
|
128 |
hooks = jQuery._queueHooks( elem, "fx" );
|
|
|
129 |
if ( hooks.unqueued == null ) {
|
|
|
130 |
hooks.unqueued = 0;
|
|
|
131 |
oldfire = hooks.empty.fire;
|
|
|
132 |
hooks.empty.fire = function() {
|
|
|
133 |
if ( !hooks.unqueued ) {
|
|
|
134 |
oldfire();
|
|
|
135 |
}
|
|
|
136 |
};
|
|
|
137 |
}
|
|
|
138 |
hooks.unqueued++;
|
|
|
139 |
|
|
|
140 |
anim.always(function() {
|
|
|
141 |
// Ensure the complete handler is called before this completes
|
|
|
142 |
anim.always(function() {
|
|
|
143 |
hooks.unqueued--;
|
|
|
144 |
if ( !jQuery.queue( elem, "fx" ).length ) {
|
|
|
145 |
hooks.empty.fire();
|
|
|
146 |
}
|
|
|
147 |
});
|
|
|
148 |
});
|
|
|
149 |
}
|
|
|
150 |
|
|
|
151 |
// Height/width overflow pass
|
|
|
152 |
if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
|
|
|
153 |
// Make sure that nothing sneaks out
|
|
|
154 |
// Record all 3 overflow attributes because IE9-10 do not
|
|
|
155 |
// change the overflow attribute when overflowX and
|
|
|
156 |
// overflowY are set to the same value
|
|
|
157 |
opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
|
|
|
158 |
|
|
|
159 |
// Set display property to inline-block for height/width
|
|
|
160 |
// animations on inline elements that are having width/height animated
|
|
|
161 |
display = jQuery.css( elem, "display" );
|
|
|
162 |
|
|
|
163 |
// Test default display if display is currently "none"
|
|
|
164 |
checkDisplay = display === "none" ?
|
|
|
165 |
data_priv.get( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
|
|
|
166 |
|
|
|
167 |
if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
|
|
|
168 |
style.display = "inline-block";
|
|
|
169 |
}
|
|
|
170 |
}
|
|
|
171 |
|
|
|
172 |
if ( opts.overflow ) {
|
|
|
173 |
style.overflow = "hidden";
|
|
|
174 |
anim.always(function() {
|
|
|
175 |
style.overflow = opts.overflow[ 0 ];
|
|
|
176 |
style.overflowX = opts.overflow[ 1 ];
|
|
|
177 |
style.overflowY = opts.overflow[ 2 ];
|
|
|
178 |
});
|
|
|
179 |
}
|
|
|
180 |
|
|
|
181 |
// show/hide pass
|
|
|
182 |
for ( prop in props ) {
|
|
|
183 |
value = props[ prop ];
|
|
|
184 |
if ( rfxtypes.exec( value ) ) {
|
|
|
185 |
delete props[ prop ];
|
|
|
186 |
toggle = toggle || value === "toggle";
|
|
|
187 |
if ( value === ( hidden ? "hide" : "show" ) ) {
|
|
|
188 |
|
|
|
189 |
// If there is dataShow left over from a stopped hide or show and we are going to proceed with show, we should pretend to be hidden
|
|
|
190 |
if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
|
|
|
191 |
hidden = true;
|
|
|
192 |
} else {
|
|
|
193 |
continue;
|
|
|
194 |
}
|
|
|
195 |
}
|
|
|
196 |
orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
|
|
|
197 |
|
|
|
198 |
// Any non-fx value stops us from restoring the original display value
|
|
|
199 |
} else {
|
|
|
200 |
display = undefined;
|
|
|
201 |
}
|
|
|
202 |
}
|
|
|
203 |
|
|
|
204 |
if ( !jQuery.isEmptyObject( orig ) ) {
|
|
|
205 |
if ( dataShow ) {
|
|
|
206 |
if ( "hidden" in dataShow ) {
|
|
|
207 |
hidden = dataShow.hidden;
|
|
|
208 |
}
|
|
|
209 |
} else {
|
|
|
210 |
dataShow = data_priv.access( elem, "fxshow", {} );
|
|
|
211 |
}
|
|
|
212 |
|
|
|
213 |
// Store state if its toggle - enables .stop().toggle() to "reverse"
|
|
|
214 |
if ( toggle ) {
|
|
|
215 |
dataShow.hidden = !hidden;
|
|
|
216 |
}
|
|
|
217 |
if ( hidden ) {
|
|
|
218 |
jQuery( elem ).show();
|
|
|
219 |
} else {
|
|
|
220 |
anim.done(function() {
|
|
|
221 |
jQuery( elem ).hide();
|
|
|
222 |
});
|
|
|
223 |
}
|
|
|
224 |
anim.done(function() {
|
|
|
225 |
var prop;
|
|
|
226 |
|
|
|
227 |
data_priv.remove( elem, "fxshow" );
|
|
|
228 |
for ( prop in orig ) {
|
|
|
229 |
jQuery.style( elem, prop, orig[ prop ] );
|
|
|
230 |
}
|
|
|
231 |
});
|
|
|
232 |
for ( prop in orig ) {
|
|
|
233 |
tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
|
|
|
234 |
|
|
|
235 |
if ( !( prop in dataShow ) ) {
|
|
|
236 |
dataShow[ prop ] = tween.start;
|
|
|
237 |
if ( hidden ) {
|
|
|
238 |
tween.end = tween.start;
|
|
|
239 |
tween.start = prop === "width" || prop === "height" ? 1 : 0;
|
|
|
240 |
}
|
|
|
241 |
}
|
|
|
242 |
}
|
|
|
243 |
|
|
|
244 |
// If this is a noop like .hide().hide(), restore an overwritten display value
|
|
|
245 |
} else if ( (display === "none" ? defaultDisplay( elem.nodeName ) : display) === "inline" ) {
|
|
|
246 |
style.display = display;
|
|
|
247 |
}
|
|
|
248 |
}
|
|
|
249 |
|
|
|
250 |
function propFilter( props, specialEasing ) {
|
|
|
251 |
var index, name, easing, value, hooks;
|
|
|
252 |
|
|
|
253 |
// camelCase, specialEasing and expand cssHook pass
|
|
|
254 |
for ( index in props ) {
|
|
|
255 |
name = jQuery.camelCase( index );
|
|
|
256 |
easing = specialEasing[ name ];
|
|
|
257 |
value = props[ index ];
|
|
|
258 |
if ( jQuery.isArray( value ) ) {
|
|
|
259 |
easing = value[ 1 ];
|
|
|
260 |
value = props[ index ] = value[ 0 ];
|
|
|
261 |
}
|
|
|
262 |
|
|
|
263 |
if ( index !== name ) {
|
|
|
264 |
props[ name ] = value;
|
|
|
265 |
delete props[ index ];
|
|
|
266 |
}
|
|
|
267 |
|
|
|
268 |
hooks = jQuery.cssHooks[ name ];
|
|
|
269 |
if ( hooks && "expand" in hooks ) {
|
|
|
270 |
value = hooks.expand( value );
|
|
|
271 |
delete props[ name ];
|
|
|
272 |
|
|
|
273 |
// Not quite $.extend, this won't overwrite existing keys.
|
|
|
274 |
// Reusing 'index' because we have the correct "name"
|
|
|
275 |
for ( index in value ) {
|
|
|
276 |
if ( !( index in props ) ) {
|
|
|
277 |
props[ index ] = value[ index ];
|
|
|
278 |
specialEasing[ index ] = easing;
|
|
|
279 |
}
|
|
|
280 |
}
|
|
|
281 |
} else {
|
|
|
282 |
specialEasing[ name ] = easing;
|
|
|
283 |
}
|
|
|
284 |
}
|
|
|
285 |
}
|
|
|
286 |
|
|
|
287 |
function Animation( elem, properties, options ) {
|
|
|
288 |
var result,
|
|
|
289 |
stopped,
|
|
|
290 |
index = 0,
|
|
|
291 |
length = animationPrefilters.length,
|
|
|
292 |
deferred = jQuery.Deferred().always( function() {
|
|
|
293 |
// Don't match elem in the :animated selector
|
|
|
294 |
delete tick.elem;
|
|
|
295 |
}),
|
|
|
296 |
tick = function() {
|
|
|
297 |
if ( stopped ) {
|
|
|
298 |
return false;
|
|
|
299 |
}
|
|
|
300 |
var currentTime = fxNow || createFxNow(),
|
|
|
301 |
remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
|
|
|
302 |
// Support: Android 2.3
|
|
|
303 |
// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
|
|
|
304 |
temp = remaining / animation.duration || 0,
|
|
|
305 |
percent = 1 - temp,
|
|
|
306 |
index = 0,
|
|
|
307 |
length = animation.tweens.length;
|
|
|
308 |
|
|
|
309 |
for ( ; index < length ; index++ ) {
|
|
|
310 |
animation.tweens[ index ].run( percent );
|
|
|
311 |
}
|
|
|
312 |
|
|
|
313 |
deferred.notifyWith( elem, [ animation, percent, remaining ]);
|
|
|
314 |
|
|
|
315 |
if ( percent < 1 && length ) {
|
|
|
316 |
return remaining;
|
|
|
317 |
} else {
|
|
|
318 |
deferred.resolveWith( elem, [ animation ] );
|
|
|
319 |
return false;
|
|
|
320 |
}
|
|
|
321 |
},
|
|
|
322 |
animation = deferred.promise({
|
|
|
323 |
elem: elem,
|
|
|
324 |
props: jQuery.extend( {}, properties ),
|
|
|
325 |
opts: jQuery.extend( true, { specialEasing: {} }, options ),
|
|
|
326 |
originalProperties: properties,
|
|
|
327 |
originalOptions: options,
|
|
|
328 |
startTime: fxNow || createFxNow(),
|
|
|
329 |
duration: options.duration,
|
|
|
330 |
tweens: [],
|
|
|
331 |
createTween: function( prop, end ) {
|
|
|
332 |
var tween = jQuery.Tween( elem, animation.opts, prop, end,
|
|
|
333 |
animation.opts.specialEasing[ prop ] || animation.opts.easing );
|
|
|
334 |
animation.tweens.push( tween );
|
|
|
335 |
return tween;
|
|
|
336 |
},
|
|
|
337 |
stop: function( gotoEnd ) {
|
|
|
338 |
var index = 0,
|
|
|
339 |
// If we are going to the end, we want to run all the tweens
|
|
|
340 |
// otherwise we skip this part
|
|
|
341 |
length = gotoEnd ? animation.tweens.length : 0;
|
|
|
342 |
if ( stopped ) {
|
|
|
343 |
return this;
|
|
|
344 |
}
|
|
|
345 |
stopped = true;
|
|
|
346 |
for ( ; index < length ; index++ ) {
|
|
|
347 |
animation.tweens[ index ].run( 1 );
|
|
|
348 |
}
|
|
|
349 |
|
|
|
350 |
// Resolve when we played the last frame; otherwise, reject
|
|
|
351 |
if ( gotoEnd ) {
|
|
|
352 |
deferred.resolveWith( elem, [ animation, gotoEnd ] );
|
|
|
353 |
} else {
|
|
|
354 |
deferred.rejectWith( elem, [ animation, gotoEnd ] );
|
|
|
355 |
}
|
|
|
356 |
return this;
|
|
|
357 |
}
|
|
|
358 |
}),
|
|
|
359 |
props = animation.props;
|
|
|
360 |
|
|
|
361 |
propFilter( props, animation.opts.specialEasing );
|
|
|
362 |
|
|
|
363 |
for ( ; index < length ; index++ ) {
|
|
|
364 |
result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
|
|
|
365 |
if ( result ) {
|
|
|
366 |
return result;
|
|
|
367 |
}
|
|
|
368 |
}
|
|
|
369 |
|
|
|
370 |
jQuery.map( props, createTween, animation );
|
|
|
371 |
|
|
|
372 |
if ( jQuery.isFunction( animation.opts.start ) ) {
|
|
|
373 |
animation.opts.start.call( elem, animation );
|
|
|
374 |
}
|
|
|
375 |
|
|
|
376 |
jQuery.fx.timer(
|
|
|
377 |
jQuery.extend( tick, {
|
|
|
378 |
elem: elem,
|
|
|
379 |
anim: animation,
|
|
|
380 |
queue: animation.opts.queue
|
|
|
381 |
})
|
|
|
382 |
);
|
|
|
383 |
|
|
|
384 |
// attach callbacks from options
|
|
|
385 |
return animation.progress( animation.opts.progress )
|
|
|
386 |
.done( animation.opts.done, animation.opts.complete )
|
|
|
387 |
.fail( animation.opts.fail )
|
|
|
388 |
.always( animation.opts.always );
|
|
|
389 |
}
|
|
|
390 |
|
|
|
391 |
jQuery.Animation = jQuery.extend( Animation, {
|
|
|
392 |
|
|
|
393 |
tweener: function( props, callback ) {
|
|
|
394 |
if ( jQuery.isFunction( props ) ) {
|
|
|
395 |
callback = props;
|
|
|
396 |
props = [ "*" ];
|
|
|
397 |
} else {
|
|
|
398 |
props = props.split(" ");
|
|
|
399 |
}
|
|
|
400 |
|
|
|
401 |
var prop,
|
|
|
402 |
index = 0,
|
|
|
403 |
length = props.length;
|
|
|
404 |
|
|
|
405 |
for ( ; index < length ; index++ ) {
|
|
|
406 |
prop = props[ index ];
|
|
|
407 |
tweeners[ prop ] = tweeners[ prop ] || [];
|
|
|
408 |
tweeners[ prop ].unshift( callback );
|
|
|
409 |
}
|
|
|
410 |
},
|
|
|
411 |
|
|
|
412 |
prefilter: function( callback, prepend ) {
|
|
|
413 |
if ( prepend ) {
|
|
|
414 |
animationPrefilters.unshift( callback );
|
|
|
415 |
} else {
|
|
|
416 |
animationPrefilters.push( callback );
|
|
|
417 |
}
|
|
|
418 |
}
|
|
|
419 |
});
|
|
|
420 |
|
|
|
421 |
jQuery.speed = function( speed, easing, fn ) {
|
|
|
422 |
var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
|
|
|
423 |
complete: fn || !fn && easing ||
|
|
|
424 |
jQuery.isFunction( speed ) && speed,
|
|
|
425 |
duration: speed,
|
|
|
426 |
easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
|
|
|
427 |
};
|
|
|
428 |
|
|
|
429 |
opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
|
|
|
430 |
opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
|
|
|
431 |
|
|
|
432 |
// Normalize opt.queue - true/undefined/null -> "fx"
|
|
|
433 |
if ( opt.queue == null || opt.queue === true ) {
|
|
|
434 |
opt.queue = "fx";
|
|
|
435 |
}
|
|
|
436 |
|
|
|
437 |
// Queueing
|
|
|
438 |
opt.old = opt.complete;
|
|
|
439 |
|
|
|
440 |
opt.complete = function() {
|
|
|
441 |
if ( jQuery.isFunction( opt.old ) ) {
|
|
|
442 |
opt.old.call( this );
|
|
|
443 |
}
|
|
|
444 |
|
|
|
445 |
if ( opt.queue ) {
|
|
|
446 |
jQuery.dequeue( this, opt.queue );
|
|
|
447 |
}
|
|
|
448 |
};
|
|
|
449 |
|
|
|
450 |
return opt;
|
|
|
451 |
};
|
|
|
452 |
|
|
|
453 |
jQuery.fn.extend({
|
|
|
454 |
fadeTo: function( speed, to, easing, callback ) {
|
|
|
455 |
|
|
|
456 |
// Show any hidden elements after setting opacity to 0
|
|
|
457 |
return this.filter( isHidden ).css( "opacity", 0 ).show()
|
|
|
458 |
|
|
|
459 |
// Animate to the value specified
|
|
|
460 |
.end().animate({ opacity: to }, speed, easing, callback );
|
|
|
461 |
},
|
|
|
462 |
animate: function( prop, speed, easing, callback ) {
|
|
|
463 |
var empty = jQuery.isEmptyObject( prop ),
|
|
|
464 |
optall = jQuery.speed( speed, easing, callback ),
|
|
|
465 |
doAnimation = function() {
|
|
|
466 |
// Operate on a copy of prop so per-property easing won't be lost
|
|
|
467 |
var anim = Animation( this, jQuery.extend( {}, prop ), optall );
|
|
|
468 |
|
|
|
469 |
// Empty animations, or finishing resolves immediately
|
|
|
470 |
if ( empty || data_priv.get( this, "finish" ) ) {
|
|
|
471 |
anim.stop( true );
|
|
|
472 |
}
|
|
|
473 |
};
|
|
|
474 |
doAnimation.finish = doAnimation;
|
|
|
475 |
|
|
|
476 |
return empty || optall.queue === false ?
|
|
|
477 |
this.each( doAnimation ) :
|
|
|
478 |
this.queue( optall.queue, doAnimation );
|
|
|
479 |
},
|
|
|
480 |
stop: function( type, clearQueue, gotoEnd ) {
|
|
|
481 |
var stopQueue = function( hooks ) {
|
|
|
482 |
var stop = hooks.stop;
|
|
|
483 |
delete hooks.stop;
|
|
|
484 |
stop( gotoEnd );
|
|
|
485 |
};
|
|
|
486 |
|
|
|
487 |
if ( typeof type !== "string" ) {
|
|
|
488 |
gotoEnd = clearQueue;
|
|
|
489 |
clearQueue = type;
|
|
|
490 |
type = undefined;
|
|
|
491 |
}
|
|
|
492 |
if ( clearQueue && type !== false ) {
|
|
|
493 |
this.queue( type || "fx", [] );
|
|
|
494 |
}
|
|
|
495 |
|
|
|
496 |
return this.each(function() {
|
|
|
497 |
var dequeue = true,
|
|
|
498 |
index = type != null && type + "queueHooks",
|
|
|
499 |
timers = jQuery.timers,
|
|
|
500 |
data = data_priv.get( this );
|
|
|
501 |
|
|
|
502 |
if ( index ) {
|
|
|
503 |
if ( data[ index ] && data[ index ].stop ) {
|
|
|
504 |
stopQueue( data[ index ] );
|
|
|
505 |
}
|
|
|
506 |
} else {
|
|
|
507 |
for ( index in data ) {
|
|
|
508 |
if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
|
|
|
509 |
stopQueue( data[ index ] );
|
|
|
510 |
}
|
|
|
511 |
}
|
|
|
512 |
}
|
|
|
513 |
|
|
|
514 |
for ( index = timers.length; index--; ) {
|
|
|
515 |
if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
|
|
|
516 |
timers[ index ].anim.stop( gotoEnd );
|
|
|
517 |
dequeue = false;
|
|
|
518 |
timers.splice( index, 1 );
|
|
|
519 |
}
|
|
|
520 |
}
|
|
|
521 |
|
|
|
522 |
// Start the next in the queue if the last step wasn't forced.
|
|
|
523 |
// Timers currently will call their complete callbacks, which
|
|
|
524 |
// will dequeue but only if they were gotoEnd.
|
|
|
525 |
if ( dequeue || !gotoEnd ) {
|
|
|
526 |
jQuery.dequeue( this, type );
|
|
|
527 |
}
|
|
|
528 |
});
|
|
|
529 |
},
|
|
|
530 |
finish: function( type ) {
|
|
|
531 |
if ( type !== false ) {
|
|
|
532 |
type = type || "fx";
|
|
|
533 |
}
|
|
|
534 |
return this.each(function() {
|
|
|
535 |
var index,
|
|
|
536 |
data = data_priv.get( this ),
|
|
|
537 |
queue = data[ type + "queue" ],
|
|
|
538 |
hooks = data[ type + "queueHooks" ],
|
|
|
539 |
timers = jQuery.timers,
|
|
|
540 |
length = queue ? queue.length : 0;
|
|
|
541 |
|
|
|
542 |
// Enable finishing flag on private data
|
|
|
543 |
data.finish = true;
|
|
|
544 |
|
|
|
545 |
// Empty the queue first
|
|
|
546 |
jQuery.queue( this, type, [] );
|
|
|
547 |
|
|
|
548 |
if ( hooks && hooks.stop ) {
|
|
|
549 |
hooks.stop.call( this, true );
|
|
|
550 |
}
|
|
|
551 |
|
|
|
552 |
// Look for any active animations, and finish them
|
|
|
553 |
for ( index = timers.length; index--; ) {
|
|
|
554 |
if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
|
|
|
555 |
timers[ index ].anim.stop( true );
|
|
|
556 |
timers.splice( index, 1 );
|
|
|
557 |
}
|
|
|
558 |
}
|
|
|
559 |
|
|
|
560 |
// Look for any animations in the old queue and finish them
|
|
|
561 |
for ( index = 0; index < length; index++ ) {
|
|
|
562 |
if ( queue[ index ] && queue[ index ].finish ) {
|
|
|
563 |
queue[ index ].finish.call( this );
|
|
|
564 |
}
|
|
|
565 |
}
|
|
|
566 |
|
|
|
567 |
// Turn off finishing flag
|
|
|
568 |
delete data.finish;
|
|
|
569 |
});
|
|
|
570 |
}
|
|
|
571 |
});
|
|
|
572 |
|
|
|
573 |
jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
|
|
|
574 |
var cssFn = jQuery.fn[ name ];
|
|
|
575 |
jQuery.fn[ name ] = function( speed, easing, callback ) {
|
|
|
576 |
return speed == null || typeof speed === "boolean" ?
|
|
|
577 |
cssFn.apply( this, arguments ) :
|
|
|
578 |
this.animate( genFx( name, true ), speed, easing, callback );
|
|
|
579 |
};
|
|
|
580 |
});
|
|
|
581 |
|
|
|
582 |
// Generate shortcuts for custom animations
|
|
|
583 |
jQuery.each({
|
|
|
584 |
slideDown: genFx("show"),
|
|
|
585 |
slideUp: genFx("hide"),
|
|
|
586 |
slideToggle: genFx("toggle"),
|
|
|
587 |
fadeIn: { opacity: "show" },
|
|
|
588 |
fadeOut: { opacity: "hide" },
|
|
|
589 |
fadeToggle: { opacity: "toggle" }
|
|
|
590 |
}, function( name, props ) {
|
|
|
591 |
jQuery.fn[ name ] = function( speed, easing, callback ) {
|
|
|
592 |
return this.animate( props, speed, easing, callback );
|
|
|
593 |
};
|
|
|
594 |
});
|
|
|
595 |
|
|
|
596 |
jQuery.timers = [];
|
|
|
597 |
jQuery.fx.tick = function() {
|
|
|
598 |
var timer,
|
|
|
599 |
i = 0,
|
|
|
600 |
timers = jQuery.timers;
|
|
|
601 |
|
|
|
602 |
fxNow = jQuery.now();
|
|
|
603 |
|
|
|
604 |
for ( ; i < timers.length; i++ ) {
|
|
|
605 |
timer = timers[ i ];
|
|
|
606 |
// Checks the timer has not already been removed
|
|
|
607 |
if ( !timer() && timers[ i ] === timer ) {
|
|
|
608 |
timers.splice( i--, 1 );
|
|
|
609 |
}
|
|
|
610 |
}
|
|
|
611 |
|
|
|
612 |
if ( !timers.length ) {
|
|
|
613 |
jQuery.fx.stop();
|
|
|
614 |
}
|
|
|
615 |
fxNow = undefined;
|
|
|
616 |
};
|
|
|
617 |
|
|
|
618 |
jQuery.fx.timer = function( timer ) {
|
|
|
619 |
jQuery.timers.push( timer );
|
|
|
620 |
if ( timer() ) {
|
|
|
621 |
jQuery.fx.start();
|
|
|
622 |
} else {
|
|
|
623 |
jQuery.timers.pop();
|
|
|
624 |
}
|
|
|
625 |
};
|
|
|
626 |
|
|
|
627 |
jQuery.fx.interval = 13;
|
|
|
628 |
|
|
|
629 |
jQuery.fx.start = function() {
|
|
|
630 |
if ( !timerId ) {
|
|
|
631 |
timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
|
|
|
632 |
}
|
|
|
633 |
};
|
|
|
634 |
|
|
|
635 |
jQuery.fx.stop = function() {
|
|
|
636 |
clearInterval( timerId );
|
|
|
637 |
timerId = null;
|
|
|
638 |
};
|
|
|
639 |
|
|
|
640 |
jQuery.fx.speeds = {
|
|
|
641 |
slow: 600,
|
|
|
642 |
fast: 200,
|
|
|
643 |
// Default speed
|
|
|
644 |
_default: 400
|
|
|
645 |
};
|
|
|
646 |
|
|
|
647 |
return jQuery;
|
|
|
648 |
});
|