]>
Commit | Line | Data |
---|---|---|
24c7594d BB |
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 | }); |