ru-se.com

resizable.js (29924B)

---

 /*!
  * jQuery UI Resizable 1.12.1
  * http://jqueryui.com
  *
  * Copyright jQuery Foundation and other contributors
  * Released under the MIT license.
  * http://jquery.org/license
  */
 
 //>>label: Resizable
 //>>group: Interactions
 //>>description: Enables resize functionality for any element.
 //>>docs: http://api.jqueryui.com/resizable/
 //>>demos: http://jqueryui.com/resizable/
 //>>css.structure: ../../themes/base/core.css
 //>>css.structure: ../../themes/base/resizable.css
 //>>css.theme: ../../themes/base/theme.css
 
 ( function( factory ) {
 	if ( typeof define === "function" && define.amd ) {
 
 		// AMD. Register as an anonymous module.
 		define( [
 			"jquery",
 			"./mouse",
 			"./core"
 		], factory );
 	} else {
 
 		// Browser globals
 		factory( jQuery );
 	}
 }( function( $ ) {
 
 $.widget( "ui.resizable", $.ui.mouse, {
 	version: "1.12.1",
 	widgetEventPrefix: "resize",
 	options: {
 		alsoResize: false,
 		animate: false,
 		animateDuration: "slow",
 		animateEasing: "swing",
 		aspectRatio: false,
 		autoHide: false,
 		classes: {
 			"ui-resizable-se": "ui-icon ui-icon-gripsmall-diagonal-se"
 		},
 		containment: false,
 		ghost: false,
 		grid: false,
 		handles: "e,s,se",
 		helper: false,
 		maxHeight: null,
 		maxWidth: null,
 		minHeight: 10,
 		minWidth: 10,
 
 		// See #7960
 		zIndex: 90,
 
 		// Callbacks
 		resize: null,
 		start: null,
 		stop: null
 	},
 
 	_num: function( value ) {
 		return parseFloat( value ) || 0;
 	},
 
 	_isNumber: function( value ) {
 		return !isNaN( parseFloat( value ) );
 	},
 
 	_hasScroll: function( el, a ) {
 
 		if ( $( el ).css( "overflow" ) === "hidden" ) {
 			return false;
 		}
 
 		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
 			has = false;
 
 		if ( el[ scroll ] > 0 ) {
 			return true;
 		}
 
 		// TODO: determine which cases actually cause this to happen
 		// if the element doesn't have the scroll set, see if it's possible to
 		// set the scroll
 		el[ scroll ] = 1;
 		has = ( el[ scroll ] > 0 );
 		el[ scroll ] = 0;
 		return has;
 	},
 
 	_create: function() {
 
 		var margins,
 			o = this.options,
 			that = this;
 		this._addClass( "ui-resizable" );
 
 		$.extend( this, {
 			_aspectRatio: !!( o.aspectRatio ),
 			aspectRatio: o.aspectRatio,
 			originalElement: this.element,
 			_proportionallyResizeElements: [],
 			_helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
 		} );
 
 		// Wrap the element if it cannot hold child nodes
 		if ( this.element[ 0 ].nodeName.match( /^(canvas|textarea|input|select|button|img)$/i ) ) {
 
 			this.element.wrap(
 				$( "<div class='ui-wrapper' style='overflow: hidden;'></div>" ).css( {
 					position: this.element.css( "position" ),
 					width: this.element.outerWidth(),
 					height: this.element.outerHeight(),
 					top: this.element.css( "top" ),
 					left: this.element.css( "left" )
 				} )
 			);
 
 			this.element = this.element.parent().data(
 				"ui-resizable", this.element.resizable( "instance" )
 			);
 
 			this.elementIsWrapper = true;
 
 			margins = {
 				marginTop: this.originalElement.css( "marginTop" ),
 				marginRight: this.originalElement.css( "marginRight" ),
 				marginBottom: this.originalElement.css( "marginBottom" ),
 				marginLeft: this.originalElement.css( "marginLeft" )
 			};
 
 			this.element.css( margins );
 			this.originalElement.css( "margin", 0 );
 
 			// support: Safari
 			// Prevent Safari textarea resize
 			this.originalResizeStyle = this.originalElement.css( "resize" );
 			this.originalElement.css( "resize", "none" );
 
 			this._proportionallyResizeElements.push( this.originalElement.css( {
 				position: "static",
 				zoom: 1,
 				display: "block"
 			} ) );
 
 			// Support: IE9
 			// avoid IE jump (hard set the margin)
 			this.originalElement.css( margins );
 
 			this._proportionallyResize();
 		}
 
 		this._setupHandles();
 
 		if ( o.autoHide ) {
 			$( this.element )
 				.on( "mouseenter", function() {
 					if ( o.disabled ) {
 						return;
 					}
 					that._removeClass( "ui-resizable-autohide" );
 					that._handles.show();
 				} )
 				.on( "mouseleave", function() {
 					if ( o.disabled ) {
 						return;
 					}
 					if ( !that.resizing ) {
 						that._addClass( "ui-resizable-autohide" );
 						that._handles.hide();
 					}
 				} );
 		}
 
 		this._mouseInit();
 	},
 
 	_destroy: function() {
 
 		this._mouseDestroy();
 
 		var wrapper,
 			_destroy = function( exp ) {
 				$( exp )
 					.removeData( "resizable" )
 					.removeData( "ui-resizable" )
 					.off( ".resizable" )
 					.find( ".ui-resizable-handle" )
 						.remove();
 			};
 
 		// TODO: Unwrap at same DOM position
 		if ( this.elementIsWrapper ) {
 			_destroy( this.element );
 			wrapper = this.element;
 			this.originalElement.css( {
 				position: wrapper.css( "position" ),
 				width: wrapper.outerWidth(),
 				height: wrapper.outerHeight(),
 				top: wrapper.css( "top" ),
 				left: wrapper.css( "left" )
 			} ).insertAfter( wrapper );
 			wrapper.remove();
 		}
 
 		this.originalElement.css( "resize", this.originalResizeStyle );
 		_destroy( this.originalElement );
 
 		return this;
 	},
 
 	_setOption: function( key, value ) {
 		this._super( key, value );
 
 		switch ( key ) {
 		case "handles":
 			this._removeHandles();
 			this._setupHandles();
 			break;
 		default:
 			break;
 		}
 	},
 
 	_setupHandles: function() {
 		var o = this.options, handle, i, n, hname, axis, that = this;
 		this.handles = o.handles ||
 			( !$( ".ui-resizable-handle", this.element ).length ?
 				"e,s,se" : {
 					n: ".ui-resizable-n",
 					e: ".ui-resizable-e",
 					s: ".ui-resizable-s",
 					w: ".ui-resizable-w",
 					se: ".ui-resizable-se",
 					sw: ".ui-resizable-sw",
 					ne: ".ui-resizable-ne",
 					nw: ".ui-resizable-nw"
 				} );
 
 		this._handles = $();
 		if ( this.handles.constructor === String ) {
 
 			if ( this.handles === "all" ) {
 				this.handles = "n,e,s,w,se,sw,ne,nw";
 			}
 
 			n = this.handles.split( "," );
 			this.handles = {};
 
 			for ( i = 0; i < n.length; i++ ) {
 
 				handle = $.trim( n[ i ] );
 				hname = "ui-resizable-" + handle;
 				axis = $( "<div>" );
 				this._addClass( axis, "ui-resizable-handle " + hname );
 
 				axis.css( { zIndex: o.zIndex } );
 
 				this.handles[ handle ] = ".ui-resizable-" + handle;
 				this.element.append( axis );
 			}
 
 		}
 
 		this._renderAxis = function( target ) {
 
 			var i, axis, padPos, padWrapper;
 
 			target = target || this.element;
 
 			for ( i in this.handles ) {
 
 				if ( this.handles[ i ].constructor === String ) {
 					this.handles[ i ] = this.element.children( this.handles[ i ] ).first().show();
 				} else if ( this.handles[ i ].jquery || this.handles[ i ].nodeType ) {
 					this.handles[ i ] = $( this.handles[ i ] );
 					this._on( this.handles[ i ], { "mousedown": that._mouseDown } );
 				}
 
 				if ( this.elementIsWrapper &&
 						this.originalElement[ 0 ]
 							.nodeName
 							.match( /^(textarea|input|select|button)$/i ) ) {
 					axis = $( this.handles[ i ], this.element );
 
 					padWrapper = /sw|ne|nw|se|n|s/.test( i ) ?
 						axis.outerHeight() :
 						axis.outerWidth();
 
 					padPos = [ "padding",
 						/ne|nw|n/.test( i ) ? "Top" :
 						/se|sw|s/.test( i ) ? "Bottom" :
 						/^e$/.test( i ) ? "Right" : "Left" ].join( "" );
 
 					target.css( padPos, padWrapper );
 
 					this._proportionallyResize();
 				}
 
 				this._handles = this._handles.add( this.handles[ i ] );
 			}
 		};
 
 		// TODO: make renderAxis a prototype function
 		this._renderAxis( this.element );
 
 		this._handles = this._handles.add( this.element.find( ".ui-resizable-handle" ) );
 		this._handles.disableSelection();
 
 		this._handles.on( "mouseover", function() {
 			if ( !that.resizing ) {
 				if ( this.className ) {
 					axis = this.className.match( /ui-resizable-(se|sw|ne|nw|n|e|s|w)/i );
 				}
 				that.axis = axis && axis[ 1 ] ? axis[ 1 ] : "se";
 			}
 		} );
 
 		if ( o.autoHide ) {
 			this._handles.hide();
 			this._addClass( "ui-resizable-autohide" );
 		}
 	},
 
 	_removeHandles: function() {
 		this._handles.remove();
 	},
 
 	_mouseCapture: function( event ) {
 		var i, handle,
 			capture = false;
 
 		for ( i in this.handles ) {
 			handle = $( this.handles[ i ] )[ 0 ];
 			if ( handle === event.target || $.contains( handle, event.target ) ) {
 				capture = true;
 			}
 		}
 
 		return !this.options.disabled && capture;
 	},
 
 	_mouseStart: function( event ) {
 
 		var curleft, curtop, cursor,
 			o = this.options,
 			el = this.element;
 
 		this.resizing = true;
 
 		this._renderProxy();
 
 		curleft = this._num( this.helper.css( "left" ) );
 		curtop = this._num( this.helper.css( "top" ) );
 
 		if ( o.containment ) {
 			curleft += $( o.containment ).scrollLeft() || 0;
 			curtop += $( o.containment ).scrollTop() || 0;
 		}
 
 		this.offset = this.helper.offset();
 		this.position = { left: curleft, top: curtop };
 
 		this.size = this._helper ? {
 				width: this.helper.width(),
 				height: this.helper.height()
 			} : {
 				width: el.width(),
 				height: el.height()
 			};
 
 		this.originalSize = this._helper ? {
 				width: el.outerWidth(),
 				height: el.outerHeight()
 			} : {
 				width: el.width(),
 				height: el.height()
 			};
 
 		this.sizeDiff = {
 			width: el.outerWidth() - el.width(),
 			height: el.outerHeight() - el.height()
 		};
 
 		this.originalPosition = { left: curleft, top: curtop };
 		this.originalMousePosition = { left: event.pageX, top: event.pageY };
 
 		this.aspectRatio = ( typeof o.aspectRatio === "number" ) ?
 			o.aspectRatio :
 			( ( this.originalSize.width / this.originalSize.height ) || 1 );
 
 		cursor = $( ".ui-resizable-" + this.axis ).css( "cursor" );
 		$( "body" ).css( "cursor", cursor === "auto" ? this.axis + "-resize" : cursor );
 
 		this._addClass( "ui-resizable-resizing" );
 		this._propagate( "start", event );
 		return true;
 	},
 
 	_mouseDrag: function( event ) {
 
 		var data, props,
 			smp = this.originalMousePosition,
 			a = this.axis,
 			dx = ( event.pageX - smp.left ) || 0,
 			dy = ( event.pageY - smp.top ) || 0,
 			trigger = this._change[ a ];
 
 		this._updatePrevProperties();
 
 		if ( !trigger ) {
 			return false;
 		}
 
 		data = trigger.apply( this, [ event, dx, dy ] );
 
 		this._updateVirtualBoundaries( event.shiftKey );
 		if ( this._aspectRatio || event.shiftKey ) {
 			data = this._updateRatio( data, event );
 		}
 
 		data = this._respectSize( data, event );
 
 		this._updateCache( data );
 
 		this._propagate( "resize", event );
 
 		props = this._applyChanges();
 
 		if ( !this._helper && this._proportionallyResizeElements.length ) {
 			this._proportionallyResize();
 		}
 
 		if ( !$.isEmptyObject( props ) ) {
 			this._updatePrevProperties();
 			this._trigger( "resize", event, this.ui() );
 			this._applyChanges();
 		}
 
 		return false;
 	},
 
 	_mouseStop: function( event ) {
 
 		this.resizing = false;
 		var pr, ista, soffseth, soffsetw, s, left, top,
 			o = this.options, that = this;
 
 		if ( this._helper ) {
 
 			pr = this._proportionallyResizeElements;
 			ista = pr.length && ( /textarea/i ).test( pr[ 0 ].nodeName );
 			soffseth = ista && this._hasScroll( pr[ 0 ], "left" ) ? 0 : that.sizeDiff.height;
 			soffsetw = ista ? 0 : that.sizeDiff.width;
 
 			s = {
 				width: ( that.helper.width()  - soffsetw ),
 				height: ( that.helper.height() - soffseth )
 			};
 			left = ( parseFloat( that.element.css( "left" ) ) +
 				( that.position.left - that.originalPosition.left ) ) || null;
 			top = ( parseFloat( that.element.css( "top" ) ) +
 				( that.position.top - that.originalPosition.top ) ) || null;
 
 			if ( !o.animate ) {
 				this.element.css( $.extend( s, { top: top, left: left } ) );
 			}
 
 			that.helper.height( that.size.height );
 			that.helper.width( that.size.width );
 
 			if ( this._helper && !o.animate ) {
 				this._proportionallyResize();
 			}
 		}
 
 		$( "body" ).css( "cursor", "auto" );
 
 		this._removeClass( "ui-resizable-resizing" );
 
 		this._propagate( "stop", event );
 
 		if ( this._helper ) {
 			this.helper.remove();
 		}
 
 		return false;
 
 	},
 
 	_updatePrevProperties: function() {
 		this.prevPosition = {
 			top: this.position.top,
 			left: this.position.left
 		};
 		this.prevSize = {
 			width: this.size.width,
 			height: this.size.height
 		};
 	},
 
 	_applyChanges: function() {
 		var props = {};
 
 		if ( this.position.top !== this.prevPosition.top ) {
 			props.top = this.position.top + "px";
 		}
 		if ( this.position.left !== this.prevPosition.left ) {
 			props.left = this.position.left + "px";
 		}
 		if ( this.size.width !== this.prevSize.width ) {
 			props.width = this.size.width + "px";
 		}
 		if ( this.size.height !== this.prevSize.height ) {
 			props.height = this.size.height + "px";
 		}
 
 		this.helper.css( props );
 
 		return props;
 	},
 
 	_updateVirtualBoundaries: function( forceAspectRatio ) {
 		var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
 			o = this.options;
 
 		b = {
 			minWidth: this._isNumber( o.minWidth ) ? o.minWidth : 0,
 			maxWidth: this._isNumber( o.maxWidth ) ? o.maxWidth : Infinity,
 			minHeight: this._isNumber( o.minHeight ) ? o.minHeight : 0,
 			maxHeight: this._isNumber( o.maxHeight ) ? o.maxHeight : Infinity
 		};
 
 		if ( this._aspectRatio || forceAspectRatio ) {
 			pMinWidth = b.minHeight * this.aspectRatio;
 			pMinHeight = b.minWidth / this.aspectRatio;
 			pMaxWidth = b.maxHeight * this.aspectRatio;
 			pMaxHeight = b.maxWidth / this.aspectRatio;
 
 			if ( pMinWidth > b.minWidth ) {
 				b.minWidth = pMinWidth;
 			}
 			if ( pMinHeight > b.minHeight ) {
 				b.minHeight = pMinHeight;
 			}
 			if ( pMaxWidth < b.maxWidth ) {
 				b.maxWidth = pMaxWidth;
 			}
 			if ( pMaxHeight < b.maxHeight ) {
 				b.maxHeight = pMaxHeight;
 			}
 		}
 		this._vBoundaries = b;
 	},
 
 	_updateCache: function( data ) {
 		this.offset = this.helper.offset();
 		if ( this._isNumber( data.left ) ) {
 			this.position.left = data.left;
 		}
 		if ( this._isNumber( data.top ) ) {
 			this.position.top = data.top;
 		}
 		if ( this._isNumber( data.height ) ) {
 			this.size.height = data.height;
 		}
 		if ( this._isNumber( data.width ) ) {
 			this.size.width = data.width;
 		}
 	},
 
 	_updateRatio: function( data ) {
 
 		var cpos = this.position,
 			csize = this.size,
 			a = this.axis;
 
 		if ( this._isNumber( data.height ) ) {
 			data.width = ( data.height * this.aspectRatio );
 		} else if ( this._isNumber( data.width ) ) {
 			data.height = ( data.width / this.aspectRatio );
 		}
 
 		if ( a === "sw" ) {
 			data.left = cpos.left + ( csize.width - data.width );
 			data.top = null;
 		}
 		if ( a === "nw" ) {
 			data.top = cpos.top + ( csize.height - data.height );
 			data.left = cpos.left + ( csize.width - data.width );
 		}
 
 		return data;
 	},
 
 	_respectSize: function( data ) {
 
 		var o = this._vBoundaries,
 			a = this.axis,
 			ismaxw = this._isNumber( data.width ) && o.maxWidth && ( o.maxWidth < data.width ),
 			ismaxh = this._isNumber( data.height ) && o.maxHeight && ( o.maxHeight < data.height ),
 			isminw = this._isNumber( data.width ) && o.minWidth && ( o.minWidth > data.width ),
 			isminh = this._isNumber( data.height ) && o.minHeight && ( o.minHeight > data.height ),
 			dw = this.originalPosition.left + this.originalSize.width,
 			dh = this.originalPosition.top + this.originalSize.height,
 			cw = /sw|nw|w/.test( a ), ch = /nw|ne|n/.test( a );
 		if ( isminw ) {
 			data.width = o.minWidth;
 		}
 		if ( isminh ) {
 			data.height = o.minHeight;
 		}
 		if ( ismaxw ) {
 			data.width = o.maxWidth;
 		}
 		if ( ismaxh ) {
 			data.height = o.maxHeight;
 		}
 
 		if ( isminw && cw ) {
 			data.left = dw - o.minWidth;
 		}
 		if ( ismaxw && cw ) {
 			data.left = dw - o.maxWidth;
 		}
 		if ( isminh && ch ) {
 			data.top = dh - o.minHeight;
 		}
 		if ( ismaxh && ch ) {
 			data.top = dh - o.maxHeight;
 		}
 
 		// Fixing jump error on top/left - bug #2330
 		if ( !data.width && !data.height && !data.left && data.top ) {
 			data.top = null;
 		} else if ( !data.width && !data.height && !data.top && data.left ) {
 			data.left = null;
 		}
 
 		return data;
 	},
 
 	_getPaddingPlusBorderDimensions: function( element ) {
 		var i = 0,
 			widths = [],
 			borders = [
 				element.css( "borderTopWidth" ),
 				element.css( "borderRightWidth" ),
 				element.css( "borderBottomWidth" ),
 				element.css( "borderLeftWidth" )
 			],
 			paddings = [
 				element.css( "paddingTop" ),
 				element.css( "paddingRight" ),
 				element.css( "paddingBottom" ),
 				element.css( "paddingLeft" )
 			];
 
 		for ( ; i < 4; i++ ) {
 			widths[ i ] = ( parseFloat( borders[ i ] ) || 0 );
 			widths[ i ] += ( parseFloat( paddings[ i ] ) || 0 );
 		}
 
 		return {
 			height: widths[ 0 ] + widths[ 2 ],
 			width: widths[ 1 ] + widths[ 3 ]
 		};
 	},
 
 	_proportionallyResize: function() {
 
 		if ( !this._proportionallyResizeElements.length ) {
 			return;
 		}
 
 		var prel,
 			i = 0,
 			element = this.helper || this.element;
 
 		for ( ; i < this._proportionallyResizeElements.length; i++ ) {
 
 			prel = this._proportionallyResizeElements[ i ];
 
 			// TODO: Seems like a bug to cache this.outerDimensions
 			// considering that we are in a loop.
 			if ( !this.outerDimensions ) {
 				this.outerDimensions = this._getPaddingPlusBorderDimensions( prel );
 			}
 
 			prel.css( {
 				height: ( element.height() - this.outerDimensions.height ) || 0,
 				width: ( element.width() - this.outerDimensions.width ) || 0
 			} );
 
 		}
 
 	},
 
 	_renderProxy: function() {
 
 		var el = this.element, o = this.options;
 		this.elementOffset = el.offset();
 
 		if ( this._helper ) {
 
 			this.helper = this.helper || $( "<div style='overflow:hidden;'></div>" );
 
 			this._addClass( this.helper, this._helper );
 			this.helper.css( {
 				width: this.element.outerWidth(),
 				height: this.element.outerHeight(),
 				position: "absolute",
 				left: this.elementOffset.left + "px",
 				top: this.elementOffset.top + "px",
 				zIndex: ++o.zIndex //TODO: Don't modify option
 			} );
 
 			this.helper
 				.appendTo( "body" )
 				.disableSelection();
 
 		} else {
 			this.helper = this.element;
 		}
 
 	},
 
 	_change: {
 		e: function( event, dx ) {
 			return { width: this.originalSize.width + dx };
 		},
 		w: function( event, dx ) {
 			var cs = this.originalSize, sp = this.originalPosition;
 			return { left: sp.left + dx, width: cs.width - dx };
 		},
 		n: function( event, dx, dy ) {
 			var cs = this.originalSize, sp = this.originalPosition;
 			return { top: sp.top + dy, height: cs.height - dy };
 		},
 		s: function( event, dx, dy ) {
 			return { height: this.originalSize.height + dy };
 		},
 		se: function( event, dx, dy ) {
 			return $.extend( this._change.s.apply( this, arguments ),
 				this._change.e.apply( this, [ event, dx, dy ] ) );
 		},
 		sw: function( event, dx, dy ) {
 			return $.extend( this._change.s.apply( this, arguments ),
 				this._change.w.apply( this, [ event, dx, dy ] ) );
 		},
 		ne: function( event, dx, dy ) {
 			return $.extend( this._change.n.apply( this, arguments ),
 				this._change.e.apply( this, [ event, dx, dy ] ) );
 		},
 		nw: function( event, dx, dy ) {
 			return $.extend( this._change.n.apply( this, arguments ),
 				this._change.w.apply( this, [ event, dx, dy ] ) );
 		}
 	},
 
 	_propagate: function( n, event ) {
 		$.ui.plugin.call( this, n, [ event, this.ui() ] );
 		( n !== "resize" && this._trigger( n, event, this.ui() ) );
 	},
 
 	plugins: {},
 
 	ui: function() {
 		return {
 			originalElement: this.originalElement,
 			element: this.element,
 			helper: this.helper,
 			position: this.position,
 			size: this.size,
 			originalSize: this.originalSize,
 			originalPosition: this.originalPosition
 		};
 	}
 
 } );
 
 /*
  * Resizable Extensions
  */
 
 $.ui.plugin.add( "resizable", "animate", {
 
 	stop: function( event ) {
 		var that = $( this ).resizable( "instance" ),
 			o = that.options,
 			pr = that._proportionallyResizeElements,
 			ista = pr.length && ( /textarea/i ).test( pr[ 0 ].nodeName ),
 			soffseth = ista && that._hasScroll( pr[ 0 ], "left" ) ? 0 : that.sizeDiff.height,
 			soffsetw = ista ? 0 : that.sizeDiff.width,
 			style = {
 				width: ( that.size.width - soffsetw ),
 				height: ( that.size.height - soffseth )
 			},
 			left = ( parseFloat( that.element.css( "left" ) ) +
 				( that.position.left - that.originalPosition.left ) ) || null,
 			top = ( parseFloat( that.element.css( "top" ) ) +
 				( that.position.top - that.originalPosition.top ) ) || null;
 
 		that.element.animate(
 			$.extend( style, top && left ? { top: top, left: left } : {} ), {
 				duration: o.animateDuration,
 				easing: o.animateEasing,
 				step: function() {
 
 					var data = {
 						width: parseFloat( that.element.css( "width" ) ),
 						height: parseFloat( that.element.css( "height" ) ),
 						top: parseFloat( that.element.css( "top" ) ),
 						left: parseFloat( that.element.css( "left" ) )
 					};
 
 					if ( pr && pr.length ) {
 						$( pr[ 0 ] ).css( { width: data.width, height: data.height } );
 					}
 
 					// Propagating resize, and updating values for each animation step
 					that._updateCache( data );
 					that._propagate( "resize", event );
 
 				}
 			}
 		);
 	}
 
 } );
 
 $.ui.plugin.add( "resizable", "containment", {
 
 	start: function() {
 		var element, p, co, ch, cw, width, height,
 			that = $( this ).resizable( "instance" ),
 			o = that.options,
 			el = that.element,
 			oc = o.containment,
 			ce = ( oc instanceof $ ) ?
 				oc.get( 0 ) :
 				( /parent/.test( oc ) ) ? el.parent().get( 0 ) : oc;
 
 		if ( !ce ) {
 			return;
 		}
 
 		that.containerElement = $( ce );
 
 		if ( /document/.test( oc ) || oc === document ) {
 			that.containerOffset = {
 				left: 0,
 				top: 0
 			};
 			that.containerPosition = {
 				left: 0,
 				top: 0
 			};
 
 			that.parentData = {
 				element: $( document ),
 				left: 0,
 				top: 0,
 				width: $( document ).width(),
 				height: $( document ).height() || document.body.parentNode.scrollHeight
 			};
 		} else {
 			element = $( ce );
 			p = [];
 			$( [ "Top", "Right", "Left", "Bottom" ] ).each( function( i, name ) {
 				p[ i ] = that._num( element.css( "padding" + name ) );
 			} );
 
 			that.containerOffset = element.offset();
 			that.containerPosition = element.position();
 			that.containerSize = {
 				height: ( element.innerHeight() - p[ 3 ] ),
 				width: ( element.innerWidth() - p[ 1 ] )
 			};
 
 			co = that.containerOffset;
 			ch = that.containerSize.height;
 			cw = that.containerSize.width;
 			width = ( that._hasScroll ( ce, "left" ) ? ce.scrollWidth : cw );
 			height = ( that._hasScroll ( ce ) ? ce.scrollHeight : ch ) ;
 
 			that.parentData = {
 				element: ce,
 				left: co.left,
 				top: co.top,
 				width: width,
 				height: height
 			};
 		}
 	},
 
 	resize: function( event ) {
 		var woset, hoset, isParent, isOffsetRelative,
 			that = $( this ).resizable( "instance" ),
 			o = that.options,
 			co = that.containerOffset,
 			cp = that.position,
 			pRatio = that._aspectRatio || event.shiftKey,
 			cop = {
 				top: 0,
 				left: 0
 			},
 			ce = that.containerElement,
 			continueResize = true;
 
 		if ( ce[ 0 ] !== document && ( /static/ ).test( ce.css( "position" ) ) ) {
 			cop = co;
 		}
 
 		if ( cp.left < ( that._helper ? co.left : 0 ) ) {
 			that.size.width = that.size.width +
 				( that._helper ?
 					( that.position.left - co.left ) :
 					( that.position.left - cop.left ) );
 
 			if ( pRatio ) {
 				that.size.height = that.size.width / that.aspectRatio;
 				continueResize = false;
 			}
 			that.position.left = o.helper ? co.left : 0;
 		}
 
 		if ( cp.top < ( that._helper ? co.top : 0 ) ) {
 			that.size.height = that.size.height +
 				( that._helper ?
 					( that.position.top - co.top ) :
 					that.position.top );
 
 			if ( pRatio ) {
 				that.size.width = that.size.height * that.aspectRatio;
 				continueResize = false;
 			}
 			that.position.top = that._helper ? co.top : 0;
 		}
 
 		isParent = that.containerElement.get( 0 ) === that.element.parent().get( 0 );
 		isOffsetRelative = /relative|absolute/.test( that.containerElement.css( "position" ) );
 
 		if ( isParent && isOffsetRelative ) {
 			that.offset.left = that.parentData.left + that.position.left;
 			that.offset.top = that.parentData.top + that.position.top;
 		} else {
 			that.offset.left = that.element.offset().left;
 			that.offset.top = that.element.offset().top;
 		}
 
 		woset = Math.abs( that.sizeDiff.width +
 			( that._helper ?
 				that.offset.left - cop.left :
 				( that.offset.left - co.left ) ) );
 
 		hoset = Math.abs( that.sizeDiff.height +
 			( that._helper ?
 				that.offset.top - cop.top :
 				( that.offset.top - co.top ) ) );
 
 		if ( woset + that.size.width >= that.parentData.width ) {
 			that.size.width = that.parentData.width - woset;
 			if ( pRatio ) {
 				that.size.height = that.size.width / that.aspectRatio;
 				continueResize = false;
 			}
 		}
 
 		if ( hoset + that.size.height >= that.parentData.height ) {
 			that.size.height = that.parentData.height - hoset;
 			if ( pRatio ) {
 				that.size.width = that.size.height * that.aspectRatio;
 				continueResize = false;
 			}
 		}
 
 		if ( !continueResize ) {
 			that.position.left = that.prevPosition.left;
 			that.position.top = that.prevPosition.top;
 			that.size.width = that.prevSize.width;
 			that.size.height = that.prevSize.height;
 		}
 	},
 
 	stop: function() {
 		var that = $( this ).resizable( "instance" ),
 			o = that.options,
 			co = that.containerOffset,
 			cop = that.containerPosition,
 			ce = that.containerElement,
 			helper = $( that.helper ),
 			ho = helper.offset(),
 			w = helper.outerWidth() - that.sizeDiff.width,
 			h = helper.outerHeight() - that.sizeDiff.height;
 
 		if ( that._helper && !o.animate && ( /relative/ ).test( ce.css( "position" ) ) ) {
 			$( this ).css( {
 				left: ho.left - cop.left - co.left,
 				width: w,
 				height: h
 			} );
 		}
 
 		if ( that._helper && !o.animate && ( /static/ ).test( ce.css( "position" ) ) ) {
 			$( this ).css( {
 				left: ho.left - cop.left - co.left,
 				width: w,
 				height: h
 			} );
 		}
 	}
 } );
 
 $.ui.plugin.add( "resizable", "alsoResize", {
 
 	start: function() {
 		var that = $( this ).resizable( "instance" ),
 			o = that.options;
 
 		$( o.alsoResize ).each( function() {
 			var el = $( this );
 			el.data( "ui-resizable-alsoresize", {
 				width: parseFloat( el.width() ), height: parseFloat( el.height() ),
 				left: parseFloat( el.css( "left" ) ), top: parseFloat( el.css( "top" ) )
 			} );
 		} );
 	},
 
 	resize: function( event, ui ) {
 		var that = $( this ).resizable( "instance" ),
 			o = that.options,
 			os = that.originalSize,
 			op = that.originalPosition,
 			delta = {
 				height: ( that.size.height - os.height ) || 0,
 				width: ( that.size.width - os.width ) || 0,
 				top: ( that.position.top - op.top ) || 0,
 				left: ( that.position.left - op.left ) || 0
 			};
 
 			$( o.alsoResize ).each( function() {
 				var el = $( this ), start = $( this ).data( "ui-resizable-alsoresize" ), style = {},
 					css = el.parents( ui.originalElement[ 0 ] ).length ?
 							[ "width", "height" ] :
 							[ "width", "height", "top", "left" ];
 
 				$.each( css, function( i, prop ) {
 					var sum = ( start[ prop ] || 0 ) + ( delta[ prop ] || 0 );
 					if ( sum && sum >= 0 ) {
 						style[ prop ] = sum || null;
 					}
 				} );
 
 				el.css( style );
 			} );
 	},
 
 	stop: function() {
 		$( this ).removeData( "ui-resizable-alsoresize" );
 	}
 } );
 
 $.ui.plugin.add( "resizable", "ghost", {
 
 	start: function() {
 
 		var that = $( this ).resizable( "instance" ), cs = that.size;
 
 		that.ghost = that.originalElement.clone();
 		that.ghost.css( {
 			opacity: 0.25,
 			display: "block",
 			position: "relative",
 			height: cs.height,
 			width: cs.width,
 			margin: 0,
 			left: 0,
 			top: 0
 		} );
 
 		that._addClass( that.ghost, "ui-resizable-ghost" );
 
 		// DEPRECATED
 		// TODO: remove after 1.12
 		if ( $.uiBackCompat !== false && typeof that.options.ghost === "string" ) {
 
 			// Ghost option
 			that.ghost.addClass( this.options.ghost );
 		}
 
 		that.ghost.appendTo( that.helper );
 
 	},
 
 	resize: function() {
 		var that = $( this ).resizable( "instance" );
 		if ( that.ghost ) {
 			that.ghost.css( {
 				position: "relative",
 				height: that.size.height,
 				width: that.size.width
 			} );
 		}
 	},
 
 	stop: function() {
 		var that = $( this ).resizable( "instance" );
 		if ( that.ghost && that.helper ) {
 			that.helper.get( 0 ).removeChild( that.ghost.get( 0 ) );
 		}
 	}
 
 } );
 
 $.ui.plugin.add( "resizable", "grid", {
 
 	resize: function() {
 		var outerDimensions,
 			that = $( this ).resizable( "instance" ),
 			o = that.options,
 			cs = that.size,
 			os = that.originalSize,
 			op = that.originalPosition,
 			a = that.axis,
 			grid = typeof o.grid === "number" ? [ o.grid, o.grid ] : o.grid,
 			gridX = ( grid[ 0 ] || 1 ),
 			gridY = ( grid[ 1 ] || 1 ),
 			ox = Math.round( ( cs.width - os.width ) / gridX ) * gridX,
 			oy = Math.round( ( cs.height - os.height ) / gridY ) * gridY,
 			newWidth = os.width + ox,
 			newHeight = os.height + oy,
 			isMaxWidth = o.maxWidth && ( o.maxWidth < newWidth ),
 			isMaxHeight = o.maxHeight && ( o.maxHeight < newHeight ),
 			isMinWidth = o.minWidth && ( o.minWidth > newWidth ),
 			isMinHeight = o.minHeight && ( o.minHeight > newHeight );
 
 		o.grid = grid;
 
 		if ( isMinWidth ) {
 			newWidth += gridX;
 		}
 		if ( isMinHeight ) {
 			newHeight += gridY;
 		}
 		if ( isMaxWidth ) {
 			newWidth -= gridX;
 		}
 		if ( isMaxHeight ) {
 			newHeight -= gridY;
 		}
 
 		if ( /^(se|s|e)$/.test( a ) ) {
 			that.size.width = newWidth;
 			that.size.height = newHeight;
 		} else if ( /^(ne)$/.test( a ) ) {
 			that.size.width = newWidth;
 			that.size.height = newHeight;
 			that.position.top = op.top - oy;
 		} else if ( /^(sw)$/.test( a ) ) {
 			that.size.width = newWidth;
 			that.size.height = newHeight;
 			that.position.left = op.left - ox;
 		} else {
 			if ( newHeight - gridY <= 0 || newWidth - gridX <= 0 ) {
 				outerDimensions = that._getPaddingPlusBorderDimensions( this );
 			}
 
 			if ( newHeight - gridY > 0 ) {
 				that.size.height = newHeight;
 				that.position.top = op.top - oy;
 			} else {
 				newHeight = gridY - outerDimensions.height;
 				that.size.height = newHeight;
 				that.position.top = op.top + os.height - newHeight;
 			}
 			if ( newWidth - gridX > 0 ) {
 				that.size.width = newWidth;
 				that.position.left = op.left - ox;
 			} else {
 				newWidth = gridX - outerDimensions.width;
 				that.size.width = newWidth;
 				that.position.left = op.left + os.width - newWidth;
 			}
 		}
 	}
 
 } );
 
 return $.ui.resizable;
 
 } ) );