angelovcom.net

effect-size.js (5315B)

---

 /*!
  * jQuery UI Effects Size 1.12.1
  * http://jqueryui.com
  *
  * Copyright jQuery Foundation and other contributors
  * Released under the MIT license.
  * http://jquery.org/license
  */
 
 //>>label: Size Effect
 //>>group: Effects
 //>>description: Resize an element to a specified width and height.
 //>>docs: http://api.jqueryui.com/size-effect/
 //>>demos: http://jqueryui.com/effect/
 
 ( function( factory ) {
 	if ( typeof define === "function" && define.amd ) {
 
 		// AMD. Register as an anonymous module.
 		define( [
 			"jquery",
 			"./effect"
 		], factory );
 	} else {
 
 		// Browser globals
 		factory( jQuery );
 	}
 }( function( $ ) {
 
 return $.effects.define( "size", function( options, done ) {
 
 	// Create element
 	var baseline, factor, temp,
 		element = $( this ),
 
 		// Copy for children
 		cProps = [ "fontSize" ],
 		vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
 		hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
 
 		// Set options
 		mode = options.mode,
 		restore = mode !== "effect",
 		scale = options.scale || "both",
 		origin = options.origin || [ "middle", "center" ],
 		position = element.css( "position" ),
 		pos = element.position(),
 		original = $.effects.scaledDimensions( element ),
 		from = options.from || original,
 		to = options.to || $.effects.scaledDimensions( element, 0 );
 
 	$.effects.createPlaceholder( element );
 
 	if ( mode === "show" ) {
 		temp = from;
 		from = to;
 		to = temp;
 	}
 
 	// Set scaling factor
 	factor = {
 		from: {
 			y: from.height / original.height,
 			x: from.width / original.width
 		},
 		to: {
 			y: to.height / original.height,
 			x: to.width / original.width
 		}
 	};
 
 	// Scale the css box
 	if ( scale === "box" || scale === "both" ) {
 
 		// Vertical props scaling
 		if ( factor.from.y !== factor.to.y ) {
 			from = $.effects.setTransition( element, vProps, factor.from.y, from );
 			to = $.effects.setTransition( element, vProps, factor.to.y, to );
 		}
 
 		// Horizontal props scaling
 		if ( factor.from.x !== factor.to.x ) {
 			from = $.effects.setTransition( element, hProps, factor.from.x, from );
 			to = $.effects.setTransition( element, hProps, factor.to.x, to );
 		}
 	}
 
 	// Scale the content
 	if ( scale === "content" || scale === "both" ) {
 
 		// Vertical props scaling
 		if ( factor.from.y !== factor.to.y ) {
 			from = $.effects.setTransition( element, cProps, factor.from.y, from );
 			to = $.effects.setTransition( element, cProps, factor.to.y, to );
 		}
 	}
 
 	// Adjust the position properties based on the provided origin points
 	if ( origin ) {
 		baseline = $.effects.getBaseline( origin, original );
 		from.top = ( original.outerHeight - from.outerHeight ) * baseline.y + pos.top;
 		from.left = ( original.outerWidth - from.outerWidth ) * baseline.x + pos.left;
 		to.top = ( original.outerHeight - to.outerHeight ) * baseline.y + pos.top;
 		to.left = ( original.outerWidth - to.outerWidth ) * baseline.x + pos.left;
 	}
 	element.css( from );
 
 	// Animate the children if desired
 	if ( scale === "content" || scale === "both" ) {
 
 		vProps = vProps.concat( [ "marginTop", "marginBottom" ] ).concat( cProps );
 		hProps = hProps.concat( [ "marginLeft", "marginRight" ] );
 
 		// Only animate children with width attributes specified
 		// TODO: is this right? should we include anything with css width specified as well
 		element.find( "*[width]" ).each( function() {
 			var child = $( this ),
 				childOriginal = $.effects.scaledDimensions( child ),
 				childFrom = {
 					height: childOriginal.height * factor.from.y,
 					width: childOriginal.width * factor.from.x,
 					outerHeight: childOriginal.outerHeight * factor.from.y,
 					outerWidth: childOriginal.outerWidth * factor.from.x
 				},
 				childTo = {
 					height: childOriginal.height * factor.to.y,
 					width: childOriginal.width * factor.to.x,
 					outerHeight: childOriginal.height * factor.to.y,
 					outerWidth: childOriginal.width * factor.to.x
 				};
 
 			// Vertical props scaling
 			if ( factor.from.y !== factor.to.y ) {
 				childFrom = $.effects.setTransition( child, vProps, factor.from.y, childFrom );
 				childTo = $.effects.setTransition( child, vProps, factor.to.y, childTo );
 			}
 
 			// Horizontal props scaling
 			if ( factor.from.x !== factor.to.x ) {
 				childFrom = $.effects.setTransition( child, hProps, factor.from.x, childFrom );
 				childTo = $.effects.setTransition( child, hProps, factor.to.x, childTo );
 			}
 
 			if ( restore ) {
 				$.effects.saveStyle( child );
 			}
 
 			// Animate children
 			child.css( childFrom );
 			child.animate( childTo, options.duration, options.easing, function() {
 
 				// Restore children
 				if ( restore ) {
 					$.effects.restoreStyle( child );
 				}
 			} );
 		} );
 	}
 
 	// Animate
 	element.animate( to, {
 		queue: false,
 		duration: options.duration,
 		easing: options.easing,
 		complete: function() {
 
 			var offset = element.offset();
 
 			if ( to.opacity === 0 ) {
 				element.css( "opacity", from.opacity );
 			}
 
 			if ( !restore ) {
 				element
 					.css( "position", position === "static" ? "relative" : position )
 					.offset( offset );
 
 				// Need to save style here so that automatic style restoration
 				// doesn't restore to the original styles from before the animation.
 				$.effects.saveStyle( element );
 			}
 
 			done();
 		}
 	} );
 
 } );
 
 } ) );