we'll keep animation around for now
This commit is contained in:
Matt Claypotch
Родитель
d5a064140c
Коммит
395a5814dd
|
|
@ -1,5 +1,5 @@
|
|||
/*!
|
||||
* jQuery JavaScript Library v1.8.0pre -deprecated,-effects
|
||||
* jQuery JavaScript Library v1.8.0pre
|
||||
* http://jquery.com/
|
||||
*
|
||||
* Includes Sizzle.js
|
||||
|
|
@ -9,7 +9,7 @@
|
|||
* Released under the MIT license
|
||||
* http://jquery.org/license
|
||||
*
|
||||
* Date: Thu Aug 09 2012 16:39:20 GMT-0700 (PDT)
|
||||
* Date: Wed Aug 29 2012 16:15:46 GMT-0700 (PDT)
|
||||
*/
|
||||
(function( window, undefined ) {
|
||||
var
|
||||
|
|
@ -186,7 +186,7 @@ jQuery.fn = jQuery.prototype = {
|
|||
selector: "",
|
||||
|
||||
// The current version of jQuery being used
|
||||
jquery: "1.8.0pre -deprecated,-effects",
|
||||
jquery: "1.8.0pre",
|
||||
|
||||
// The default length of a jQuery object is 0
|
||||
length: 0,
|
||||
|
|
@ -6262,6 +6262,68 @@ jQuery.extend({
|
|||
}
|
||||
}
|
||||
});
|
||||
// Limit scope pollution from any deprecated API
|
||||
(function() {
|
||||
|
||||
var matched, browser;
|
||||
|
||||
// Use of jQuery.browser is frowned upon.
|
||||
// More details: http://api.jquery.com/jQuery.browser
|
||||
// jQuery.uaMatch maintained for back-compat
|
||||
jQuery.uaMatch = function( ua ) {
|
||||
ua = ua.toLowerCase();
|
||||
|
||||
var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) ||
|
||||
/(webkit)[ \/]([\w.]+)/.exec( ua ) ||
|
||||
/(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
|
||||
/(msie) ([\w.]+)/.exec( ua ) ||
|
||||
ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||
|
||||
[];
|
||||
|
||||
return {
|
||||
browser: match[ 1 ] || "",
|
||||
version: match[ 2 ] || "0"
|
||||
};
|
||||
};
|
||||
|
||||
matched = jQuery.uaMatch( navigator.userAgent );
|
||||
browser = {};
|
||||
|
||||
if ( matched.browser ) {
|
||||
browser[ matched.browser ] = true;
|
||||
browser.version = matched.version;
|
||||
}
|
||||
|
||||
// Deprecated, use jQuery.browser.webkit instead
|
||||
// Maintained for back-compat only
|
||||
if ( browser.webkit ) {
|
||||
browser.safari = true;
|
||||
}
|
||||
|
||||
jQuery.browser = browser;
|
||||
|
||||
jQuery.sub = function() {
|
||||
function jQuerySub( selector, context ) {
|
||||
return new jQuerySub.fn.init( selector, context );
|
||||
}
|
||||
jQuery.extend( true, jQuerySub, this );
|
||||
jQuerySub.superclass = this;
|
||||
jQuerySub.fn = jQuerySub.prototype = this();
|
||||
jQuerySub.fn.constructor = jQuerySub;
|
||||
jQuerySub.sub = this.sub;
|
||||
jQuerySub.fn.init = function init( selector, context ) {
|
||||
if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
|
||||
context = jQuerySub( context );
|
||||
}
|
||||
|
||||
return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
|
||||
};
|
||||
jQuerySub.fn.init.prototype = jQuerySub.fn;
|
||||
var rootjQuerySub = jQuerySub(document);
|
||||
return jQuerySub;
|
||||
};
|
||||
|
||||
})();
|
||||
var curCSS, iframe, iframeDoc,
|
||||
ralpha = /alpha\([^)]*\)/i,
|
||||
ropacity = /opacity=([^)]*)/,
|
||||
|
|
@ -8269,6 +8331,659 @@ if ( jQuery.support.ajax ) {
|
|||
}
|
||||
});
|
||||
}
|
||||
var fxNow, timerId,
|
||||
rfxtypes = /^(?:toggle|show|hide)$/,
|
||||
rfxnum = new RegExp( "^(?:([-+])=|)(" + core_pnum + ")([a-z%]*)$", "i" ),
|
||||
rrun = /queueHooks$/,
|
||||
animationPrefilters = [ defaultPrefilter ],
|
||||
tweeners = {
|
||||
"*": [function( prop, value ) {
|
||||
var end, unit, prevScale,
|
||||
tween = this.createTween( prop, value ),
|
||||
parts = rfxnum.exec( value ),
|
||||
target = tween.cur(),
|
||||
start = +target || 0,
|
||||
scale = 1;
|
||||
|
||||
if ( parts ) {
|
||||
end = +parts[2];
|
||||
unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" );
|
||||
|
||||
// We need to compute starting value
|
||||
if ( unit !== "px" && start ) {
|
||||
// Iteratively approximate from a nonzero starting point
|
||||
// Prefer the current property, because this process will be trivial if it uses the same units
|
||||
// Fallback to end or a simple constant
|
||||
start = jQuery.css( tween.elem, prop, true ) || end || 1;
|
||||
|
||||
do {
|
||||
// If previous iteration zeroed out, double until we get *something*
|
||||
// Use a string for doubling factor so we don't accidentally see scale as unchanged below
|
||||
prevScale = scale = scale || ".5";
|
||||
|
||||
// Adjust and apply
|
||||
start = start / scale;
|
||||
jQuery.style( tween.elem, prop, start + unit );
|
||||
|
||||
// Update scale, tolerating zeroes from tween.cur()
|
||||
scale = tween.cur() / target;
|
||||
|
||||
// Stop looping if we've hit the mark or scale is unchanged
|
||||
} while ( scale !== 1 && scale !== prevScale );
|
||||
}
|
||||
|
||||
tween.unit = unit;
|
||||
tween.start = start;
|
||||
// If a +=/-= token was provided, we're doing a relative animation
|
||||
tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end;
|
||||
}
|
||||
return tween;
|
||||
}]
|
||||
};
|
||||
|
||||
// Animations created synchronously will run synchronously
|
||||
function createFxNow() {
|
||||
setTimeout(function() {
|
||||
fxNow = undefined;
|
||||
}, 0 );
|
||||
return ( fxNow = jQuery.now() );
|
||||
}
|
||||
|
||||
function createTweens( animation, props ) {
|
||||
jQuery.each( props, function( prop, value ) {
|
||||
var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
|
||||
index = 0,
|
||||
length = collection.length;
|
||||
for ( ; index < length; index++ ) {
|
||||
if ( collection[ index ].call( animation, prop, value ) ) {
|
||||
|
||||
// we're done with this property
|
||||
return;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function Animation( elem, properties, options ) {
|
||||
var result,
|
||||
index = 0,
|
||||
tweenerIndex = 0,
|
||||
length = animationPrefilters.length,
|
||||
deferred = jQuery.Deferred().always( function() {
|
||||
// don't match elem in the :animated selector
|
||||
delete tick.elem;
|
||||
}),
|
||||
tick = function() {
|
||||
var currentTime = fxNow || createFxNow(),
|
||||
remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
|
||||
percent = 1 - ( remaining / animation.duration || 0 ),
|
||||
index = 0,
|
||||
length = animation.tweens.length;
|
||||
|
||||
for ( ; index < length ; index++ ) {
|
||||
animation.tweens[ index ].run( percent );
|
||||
}
|
||||
|
||||
deferred.notifyWith( elem, [ animation, percent, remaining ]);
|
||||
|
||||
if ( percent < 1 && length ) {
|
||||
return remaining;
|
||||
} else {
|
||||
deferred.resolveWith( elem, [ animation ] );
|
||||
return false;
|
||||
}
|
||||
},
|
||||
animation = deferred.promise({
|
||||
elem: elem,
|
||||
props: jQuery.extend( {}, properties ),
|
||||
opts: jQuery.extend( true, { specialEasing: {} }, options ),
|
||||
originalProperties: properties,
|
||||
originalOptions: options,
|
||||
startTime: fxNow || createFxNow(),
|
||||
duration: options.duration,
|
||||
tweens: [],
|
||||
createTween: function( prop, end, easing ) {
|
||||
var tween = jQuery.Tween( elem, animation.opts, prop, end,
|
||||
animation.opts.specialEasing[ prop ] || animation.opts.easing );
|
||||
animation.tweens.push( tween );
|
||||
return tween;
|
||||
},
|
||||
stop: function( gotoEnd ) {
|
||||
var index = 0,
|
||||
// if we are going to the end, we want to run all the tweens
|
||||
// otherwise we skip this part
|
||||
length = gotoEnd ? animation.tweens.length : 0;
|
||||
|
||||
for ( ; index < length ; index++ ) {
|
||||
animation.tweens[ index ].run( 1 );
|
||||
}
|
||||
|
||||
// resolve when we played the last frame
|
||||
// otherwise, reject
|
||||
if ( gotoEnd ) {
|
||||
deferred.resolveWith( elem, [ animation, gotoEnd ] );
|
||||
} else {
|
||||
deferred.rejectWith( elem, [ animation, gotoEnd ] );
|
||||
}
|
||||
return this;
|
||||
}
|
||||
}),
|
||||
props = animation.props;
|
||||
|
||||
propFilter( props, animation.opts.specialEasing );
|
||||
|
||||
for ( ; index < length ; index++ ) {
|
||||
result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
|
||||
if ( result ) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
createTweens( animation, props );
|
||||
|
||||
if ( jQuery.isFunction( animation.opts.start ) ) {
|
||||
animation.opts.start.call( elem, animation );
|
||||
}
|
||||
|
||||
jQuery.fx.timer(
|
||||
jQuery.extend( tick, {
|
||||
anim: animation,
|
||||
queue: animation.opts.queue,
|
||||
elem: elem
|
||||
})
|
||||
);
|
||||
|
||||
// attach callbacks from options
|
||||
return animation.progress( animation.opts.progress )
|
||||
.done( animation.opts.done, animation.opts.complete )
|
||||
.fail( animation.opts.fail )
|
||||
.always( animation.opts.always );
|
||||
}
|
||||
|
||||
function propFilter( props, specialEasing ) {
|
||||
var index, name, easing, value, hooks;
|
||||
|
||||
// camelCase, specialEasing and expand cssHook pass
|
||||
for ( index in props ) {
|
||||
name = jQuery.camelCase( index );
|
||||
easing = specialEasing[ name ];
|
||||
value = props[ index ];
|
||||
if ( jQuery.isArray( value ) ) {
|
||||
easing = value[ 1 ];
|
||||
value = props[ index ] = value[ 0 ];
|
||||
}
|
||||
|
||||
if ( index !== name ) {
|
||||
props[ name ] = value;
|
||||
delete props[ index ];
|
||||
}
|
||||
|
||||
hooks = jQuery.cssHooks[ name ];
|
||||
if ( hooks && "expand" in hooks ) {
|
||||
value = hooks.expand( value );
|
||||
delete props[ name ];
|
||||
|
||||
// not quite $.extend, this wont overwrite keys already present.
|
||||
// also - reusing 'index' from above because we have the correct "name"
|
||||
for ( index in value ) {
|
||||
if ( !( index in props ) ) {
|
||||
props[ index ] = value[ index ];
|
||||
specialEasing[ index ] = easing;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
specialEasing[ name ] = easing;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
jQuery.Animation = jQuery.extend( Animation, {
|
||||
|
||||
tweener: function( props, callback ) {
|
||||
if ( jQuery.isFunction( props ) ) {
|
||||
callback = props;
|
||||
props = [ "*" ];
|
||||
} else {
|
||||
props = props.split(" ");
|
||||
}
|
||||
|
||||
var prop,
|
||||
index = 0,
|
||||
length = props.length;
|
||||
|
||||
for ( ; index < length ; index++ ) {
|
||||
prop = props[ index ];
|
||||
tweeners[ prop ] = tweeners[ prop ] || [];
|
||||
tweeners[ prop ].unshift( callback );
|
||||
}
|
||||
},
|
||||
|
||||
prefilter: function( callback, prepend ) {
|
||||
if ( prepend ) {
|
||||
animationPrefilters.unshift( callback );
|
||||
} else {
|
||||
animationPrefilters.push( callback );
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
function defaultPrefilter( elem, props, opts ) {
|
||||
var index, prop, value, length, dataShow, tween, hooks, oldfire,
|
||||
anim = this,
|
||||
style = elem.style,
|
||||
orig = {},
|
||||
handled = [],
|
||||
hidden = elem.nodeType && isHidden( elem );
|
||||
|
||||
// handle queue: false promises
|
||||
if ( !opts.queue ) {
|
||||
hooks = jQuery._queueHooks( elem, "fx" );
|
||||
if ( hooks.unqueued == null ) {
|
||||
hooks.unqueued = 0;
|
||||
oldfire = hooks.empty.fire;
|
||||
hooks.empty.fire = function() {
|
||||
if ( !hooks.unqueued ) {
|
||||
oldfire();
|
||||
}
|
||||
};
|
||||
}
|
||||
hooks.unqueued++;
|
||||
|
||||
anim.always(function() {
|
||||
// doing this makes sure that the complete handler will be called
|
||||
// before this completes
|
||||
anim.always(function() {
|
||||
hooks.unqueued--;
|
||||
if ( !jQuery.queue( elem, "fx" ).length ) {
|
||||
hooks.empty.fire();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// height/width overflow pass
|
||||
if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
|
||||
// Make sure that nothing sneaks out
|
||||
// Record all 3 overflow attributes because IE does not
|
||||
// change the overflow attribute when overflowX and
|
||||
// overflowY are set to the same value
|
||||
opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
|
||||
|
||||
// Set display property to inline-block for height/width
|
||||
// animations on inline elements that are having width/height animated
|
||||
if ( jQuery.css( elem, "display" ) === "inline" &&
|
||||
jQuery.css( elem, "float" ) === "none" ) {
|
||||
|
||||
// inline-level elements accept inline-block;
|
||||
// block-level elements need to be inline with layout
|
||||
if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) {
|
||||
style.display = "inline-block";
|
||||
|
||||
} else {
|
||||
style.zoom = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( opts.overflow ) {
|
||||
style.overflow = "hidden";
|
||||
if ( !jQuery.support.shrinkWrapBlocks ) {
|
||||
anim.done(function() {
|
||||
style.overflow = opts.overflow[ 0 ];
|
||||
style.overflowX = opts.overflow[ 1 ];
|
||||
style.overflowY = opts.overflow[ 2 ];
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// show/hide pass
|
||||
for ( index in props ) {
|
||||
value = props[ index ];
|
||||
if ( rfxtypes.exec( value ) ) {
|
||||
delete props[ index ];
|
||||
if ( value === ( hidden ? "hide" : "show" ) ) {
|
||||
continue;
|
||||
}
|
||||
handled.push( index );
|
||||
}
|
||||
}
|
||||
|
||||
length = handled.length;
|
||||
if ( length ) {
|
||||
dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} );
|
||||
if ( hidden ) {
|
||||
jQuery( elem ).show();
|
||||
} else {
|
||||
anim.done(function() {
|
||||
jQuery( elem ).hide();
|
||||
});
|
||||
}
|
||||
anim.done(function() {
|
||||
var prop;
|
||||
jQuery.removeData( elem, "fxshow", true );
|
||||
for ( prop in orig ) {
|
||||
jQuery.style( elem, prop, orig[ prop ] );
|
||||
}
|
||||
});
|
||||
for ( index = 0 ; index < length ; index++ ) {
|
||||
prop = handled[ index ];
|
||||
tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 );
|
||||
orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop );
|
||||
|
||||
if ( !( prop in dataShow ) ) {
|
||||
dataShow[ prop ] = tween.start;
|
||||
if ( hidden ) {
|
||||
tween.end = tween.start;
|
||||
tween.start = prop === "width" || prop === "height" ? 1 : 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function Tween( elem, options, prop, end, easing ) {
|
||||
return new Tween.prototype.init( elem, options, prop, end, easing );
|
||||
}
|
||||
jQuery.Tween = Tween;
|
||||
|
||||
Tween.prototype = {
|
||||
constructor: Tween,
|
||||
init: function( elem, options, prop, end, easing, unit ) {
|
||||
this.elem = elem;
|
||||
this.prop = prop;
|
||||
this.easing = easing || "swing";
|
||||
this.options = options;
|
||||
this.start = this.now = this.cur();
|
||||
this.end = end;
|
||||
this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
|
||||
},
|
||||
cur: function() {
|
||||
var hooks = Tween.propHooks[ this.prop ];
|
||||
|
||||
return hooks && hooks.get ?
|
||||
hooks.get( this ) :
|
||||
Tween.propHooks._default.get( this );
|
||||
},
|
||||
run: function( percent ) {
|
||||
var eased,
|
||||
hooks = Tween.propHooks[ this.prop ];
|
||||
|
||||
this.pos = eased = jQuery.easing[ this.easing ]( percent, this.options.duration * percent, 0, 1, this.options.duration );
|
||||
this.now = ( this.end - this.start ) * eased + this.start;
|
||||
|
||||
if ( this.options.step ) {
|
||||
this.options.step.call( this.elem, this.now, this );
|
||||
}
|
||||
|
||||
if ( hooks && hooks.set ) {
|
||||
hooks.set( this );
|
||||
} else {
|
||||
Tween.propHooks._default.set( this );
|
||||
}
|
||||
return this;
|
||||
}
|
||||
};
|
||||
|
||||
Tween.prototype.init.prototype = Tween.prototype;
|
||||
|
||||
Tween.propHooks = {
|
||||
_default: {
|
||||
get: function( tween ) {
|
||||
var result;
|
||||
|
||||
if ( tween.elem[ tween.prop ] != null &&
|
||||
(!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
|
||||
return tween.elem[ tween.prop ];
|
||||
}
|
||||
|
||||
// passing any value as a 4th parameter to .css will automatically
|
||||
// attempt a parseFloat and fallback to a string if the parse fails
|
||||
// so, simple values such as "10px" are parsed to Float.
|
||||
// complex values such as "rotate(1rad)" are returned as is.
|
||||
result = jQuery.css( tween.elem, tween.prop, false, "" );
|
||||
// Empty strings, null, undefined and "auto" are converted to 0.
|
||||
return !result || result === "auto" ? 0 : result;
|
||||
},
|
||||
set: function( tween ) {
|
||||
// use step hook for back compat - use cssHook if its there - use .style if its
|
||||
// available and use plain properties where available
|
||||
if ( jQuery.fx.step[ tween.prop ] ) {
|
||||
jQuery.fx.step[ tween.prop ]( tween );
|
||||
} else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
|
||||
jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
|
||||
} else {
|
||||
tween.elem[ tween.prop ] = tween.now;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Remove in 2.0 - this supports IE8's panic based approach
|
||||
// to setting things on disconnected nodes
|
||||
|
||||
Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
|
||||
set: function( tween ) {
|
||||
if ( tween.elem.nodeType && tween.elem.parentNode ) {
|
||||
tween.elem[ tween.prop ] = tween.now;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
|
||||
var cssFn = jQuery.fn[ name ];
|
||||
jQuery.fn[ name ] = function( speed, easing, callback ) {
|
||||
return speed == null || typeof speed === "boolean" ||
|
||||
// special check for .toggle( handler, handler, ... )
|
||||
( !i && jQuery.isFunction( speed ) && jQuery.isFunction( easing ) ) ?
|
||||
cssFn.apply( this, arguments ) :
|
||||
this.animate( genFx( name, true ), speed, easing, callback );
|
||||
};
|
||||
});
|
||||
|
||||
jQuery.fn.extend({
|
||||
fadeTo: function( speed, to, easing, callback ) {
|
||||
|
||||
// show any hidden elements after setting opacity to 0
|
||||
return this.filter( isHidden ).css( "opacity", 0 ).show()
|
||||
|
||||
// animate to the value specified
|
||||
.end().animate({ opacity: to }, speed, easing, callback );
|
||||
},
|
||||
animate: function( prop, speed, easing, callback ) {
|
||||
var empty = jQuery.isEmptyObject( prop ),
|
||||
optall = jQuery.speed( speed, easing, callback ),
|
||||
doAnimation = function() {
|
||||
// Operate on a copy of prop so per-property easing won't be lost
|
||||
var anim = Animation( this, jQuery.extend( {}, prop ), optall );
|
||||
|
||||
// Empty animations resolve immediately
|
||||
if ( empty ) {
|
||||
anim.stop( true );
|
||||
}
|
||||
};
|
||||
|
||||
return empty || optall.queue === false ?
|
||||
this.each( doAnimation ) :
|
||||
this.queue( optall.queue, doAnimation );
|
||||
},
|
||||
stop: function( type, clearQueue, gotoEnd ) {
|
||||
var stopQueue = function( hooks ) {
|
||||
var stop = hooks.stop;
|
||||
delete hooks.stop;
|
||||
stop( gotoEnd );
|
||||
};
|
||||
|
||||
if ( typeof type !== "string" ) {
|
||||
gotoEnd = clearQueue;
|
||||
clearQueue = type;
|
||||
type = undefined;
|
||||
}
|
||||
if ( clearQueue && type !== false ) {
|
||||
this.queue( type || "fx", [] );
|
||||
}
|
||||
|
||||
return this.each(function() {
|
||||
var dequeue = true,
|
||||
index = type != null && type + "queueHooks",
|
||||
timers = jQuery.timers,
|
||||
data = jQuery._data( this );
|
||||
|
||||
if ( index ) {
|
||||
if ( data[ index ] && data[ index ].stop ) {
|
||||
stopQueue( data[ index ] );
|
||||
}
|
||||
} else {
|
||||
for ( index in data ) {
|
||||
if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
|
||||
stopQueue( data[ index ] );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for ( index = timers.length; index--; ) {
|
||||
if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
|
||||
timers[ index ].anim.stop( gotoEnd );
|
||||
dequeue = false;
|
||||
timers.splice( index, 1 );
|
||||
}
|
||||
}
|
||||
|
||||
// start the next in the queue if the last step wasn't forced
|
||||
// timers currently will call their complete callbacks, which will dequeue
|
||||
// but only if they were gotoEnd
|
||||
if ( dequeue || !gotoEnd ) {
|
||||
jQuery.dequeue( this, type );
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
// Generate parameters to create a standard animation
|
||||
function genFx( type, includeWidth ) {
|
||||
var which,
|
||||
attrs = { height: type },
|
||||
i = 0;
|
||||
|
||||
// if we include width, step value is 1 to do all cssExpand values,
|
||||
// if we don't include width, step value is 2 to skip over Left and Right
|
||||
for( ; i < 4 ; i += 2 - includeWidth ) {
|
||||
which = cssExpand[ i ];
|
||||
attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
|
||||
}
|
||||
|
||||
if ( includeWidth ) {
|
||||
attrs.opacity = attrs.width = type;
|
||||
}
|
||||
|
||||
return attrs;
|
||||
}
|
||||
|
||||
// Generate shortcuts for custom animations
|
||||
jQuery.each({
|
||||
slideDown: genFx("show"),
|
||||
slideUp: genFx("hide"),
|
||||
slideToggle: genFx("toggle"),
|
||||
fadeIn: { opacity: "show" },
|
||||
fadeOut: { opacity: "hide" },
|
||||
fadeToggle: { opacity: "toggle" }
|
||||
}, function( name, props ) {
|
||||
jQuery.fn[ name ] = function( speed, easing, callback ) {
|
||||
return this.animate( props, speed, easing, callback );
|
||||
};
|
||||
});
|
||||
|
||||
jQuery.speed = function( speed, easing, fn ) {
|
||||
var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
|
||||
complete: fn || !fn && easing ||
|
||||
jQuery.isFunction( speed ) && speed,
|
||||
duration: speed,
|
||||
easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
|
||||
};
|
||||
|
||||
opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
|
||||
opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
|
||||
|
||||
// normalize opt.queue - true/undefined/null -> "fx"
|
||||
if ( opt.queue == null || opt.queue === true ) {
|
||||
opt.queue = "fx";
|
||||
}
|
||||
|
||||
// Queueing
|
||||
opt.old = opt.complete;
|
||||
|
||||
opt.complete = function() {
|
||||
if ( jQuery.isFunction( opt.old ) ) {
|
||||
opt.old.call( this );
|
||||
}
|
||||
|
||||
if ( opt.queue ) {
|
||||
jQuery.dequeue( this, opt.queue );
|
||||
}
|
||||
};
|
||||
|
||||
return opt;
|
||||
};
|
||||
|
||||
jQuery.easing = {
|
||||
linear: function( p ) {
|
||||
return p;
|
||||
},
|
||||
swing: function( p ) {
|
||||
return 0.5 - Math.cos( p*Math.PI ) / 2;
|
||||
}
|
||||
};
|
||||
|
||||
jQuery.timers = [];
|
||||
jQuery.fx = Tween.prototype.init;
|
||||
jQuery.fx.tick = function() {
|
||||
var timer,
|
||||
timers = jQuery.timers,
|
||||
i = 0;
|
||||
|
||||
for ( ; i < timers.length; i++ ) {
|
||||
timer = timers[ i ];
|
||||
// Checks the timer has not already been removed
|
||||
if ( !timer() && timers[ i ] === timer ) {
|
||||
timers.splice( i--, 1 );
|
||||
}
|
||||
}
|
||||
|
||||
if ( !timers.length ) {
|
||||
jQuery.fx.stop();
|
||||
}
|
||||
};
|
||||
|
||||
jQuery.fx.timer = function( timer ) {
|
||||
if ( timer() && jQuery.timers.push( timer ) && !timerId ) {
|
||||
timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
|
||||
}
|
||||
};
|
||||
|
||||
jQuery.fx.interval = 13;
|
||||
|
||||
jQuery.fx.stop = function() {
|
||||
clearInterval( timerId );
|
||||
timerId = null;
|
||||
};
|
||||
|
||||
jQuery.fx.speeds = {
|
||||
slow: 600,
|
||||
fast: 200,
|
||||
// Default speed
|
||||
_default: 400
|
||||
};
|
||||
|
||||
// Back Compat <1.8 extension point
|
||||
jQuery.fx.step = {};
|
||||
|
||||
if ( jQuery.expr && jQuery.expr.filters ) {
|
||||
jQuery.expr.filters.animated = function( elem ) {
|
||||
return jQuery.grep(jQuery.timers, function( fn ) {
|
||||
return elem === fn.elem;
|
||||
}).length;
|
||||
};
|
||||
}
|
||||
var rroot = /^(?:body|html)$/i;
|
||||
|
||||
jQuery.fn.offset = function( options ) {
|
||||
|
|
@ -211,7 +211,7 @@ JS = {
|
|||
'js/zamboni/validator.js',
|
||||
),
|
||||
'mkt/consumer': (
|
||||
'js/lib/jquery-1.8-nofx.js',
|
||||
'js/lib/jquery-1.8.js',
|
||||
'js/lib/webtrends.js',
|
||||
'js/lib/underscore.js',
|
||||
'js/lib/format.js',
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче