+} );

+module( "resizable: core" );

+test( "n", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-n", target = $( "#resizable1" ).resizable( { handles: "all" } );

+ testHelper.drag( handle, 0, -50 );

+ testHelper.drag( handle, 0, 50 );

+ equal( target[ 0 ].style.left, "", "left should not be modified" );

+ equal( target[ 0 ].style.width, "", "width should not be modified" );

+} );

+test( "s", function() {

+ expect( 5 );

+ var handle = ".ui-resizable-s", target = $( "#resizable1" ).resizable( { handles: "all" } );

+ testHelper.drag( handle, 0, 50 );

+ testHelper.drag( handle, 0, -50 );

+ equal( target[ 0 ].style.top, "", "top should not be modified" );

+ equal( target[ 0 ].style.left, "", "left should not be modified" );

+ equal( target[ 0 ].style.width, "", "width should not be modified" );

+} );

+test( "e", function() {

+ expect( 5 );

+ var handle = ".ui-resizable-e", target = $( "#resizable1" ).resizable( { handles: "all" } );

+ testHelper.drag( handle, 50 );

+ equal( target.width(), 150, "compare width" );

+ testHelper.drag( handle, -50 );

+ equal( target[ 0 ].style.height, "", "height should not be modified" );

+ equal( target[ 0 ].style.top, "", "top should not be modified" );

+ equal( target[ 0 ].style.left, "", "left should not be modified" );

+} );

+test( "w", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-w", target = $( "#resizable1" ).resizable( { handles: "all" } );

+ testHelper.drag( handle, -50 );

+ testHelper.drag( handle, 50 );

+ equal( target[ 0 ].style.height, "", "height should not be modified" );

+ equal( target[ 0 ].style.top, "", "top should not be modified" );

+} );

+test( "ne", function() {

+ expect( 5 );

+ var handle = ".ui-resizable-ne", target = $( "#resizable1" ).css( { overflow: "hidden" } ).resizable( { handles: "all" } );

+ testHelper.drag( handle, -50, -50 );

+ testHelper.drag( handle, 50, 50 );

+ equal( target[ 0 ].style.left, "", "left should not be modified" );

+} );

+test( "se", function() {

+ expect( 6 );

+ var handle = ".ui-resizable-se", target = $( "#resizable1" ).resizable( { handles: "all" } );

+ testHelper.drag( handle, 50, 50 );

+ testHelper.drag( handle, -50, -50 );

+ equal( target[ 0 ].style.top, "", "top should not be modified" );

+ equal( target[ 0 ].style.left, "", "left should not be modified" );

+} );

+test( "sw", function() {

+ expect( 5 );

+ var handle = ".ui-resizable-sw", target = $( "#resizable1" ).resizable( { handles: "all" } );

+ testHelper.drag( handle, -50, -50 );

+ testHelper.drag( handle, 50, 50 );

+ equal( target[ 0 ].style.top, "", "top should not be modified" );

+} );

+test( "nw", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-nw", target = $( "#resizable1" ).resizable( { handles: "all" } );

+ testHelper.drag( handle, -50, -50 );

+ testHelper.drag( handle, 50, 50 );

+} );

+test( "handle with complex markup (#8756)", function() {

+ expect( 2 );

+ $( "#resizable1" )

+ $( "<div>" )

+ .addClass( "ui-resizable-handle" )

+ .addClass( "ui-resizable-w" )

+ .append( $( "<div>" ) )

+ var handle = ".ui-resizable-w div", target = $( "#resizable1" ).resizable( { handles: "all" } );

+ testHelper.drag( handle, -50 );

+ testHelper.drag( handle, 50 );

+} );

+test( "resizable accounts for scroll position correctly (#3815)", function() {

+ container = $( "<div style='overflow:scroll;height:300px;width:300px;position:relative;'></div>" ).appendTo( "#qunit-fixture" ),

+ overflowed = $( "<div style='width: 1000px; height: 1000px;'></div>" ).appendTo( container ),

+ el = $( "<div style='height:100px;width:100px;position:absolute;top:10px;left:10px;'></div>" ).appendTo( overflowed ).resizable( { handles: "all" } ),

+ handlePosition = $( handle ).position().left;

+ left = el.css( "left" );

+ top = el.css( "top" );

+ testHelper.drag( handle, 50, 50 );

+ equal( el.css( "left" ), left, "css('left') stays the same when resized" );

+ equal( el.css( "top" ), top, "css('top') stays the same when resized" );

+ equal( $( handle ).position().left, handlePosition + 50, "handle also moved" );

+} );

+ target = $( "#resizable1" ).resizable( {

+ } );

+} );

+ inner.resizable( { handles: "e" } );

+ outer.resizable( { handles: "e" } );

+ target.resizable( { handles: "e" } );

+} );

+module( "resizable: events" );

+test( "start", function() {

+ expect( 5 );

+ $( "#resizable1" ).resizable( {

+ start: function( event, ui ) {

+ } );

+ testHelper.drag( handle, 50, 50 );

+ equal( count, 1, "start callback should happen exactly once" );

+} );

+ $( "#resizable1" ).resizable( {

+ } );

+} );

+ $( "#resizable1" ).resizable( {

+ } );

+} );

+ container = $( "#resizable1" ).wrap( "<div>" ).parent().css( {

+ } );

+ $( "#resizable1" ).resizable( {

+ } );

+} );

+test( "resize (grid)", function() {

+ expect( 5 );

+ $( "#resizable1" ).resizable( {

+ resize: function( event, ui ) {

+ } );

+ testHelper.drag( handle, 50, 50 );

+ equal( count, 1, "resize callback should happen exactly once per grid-unit size adjustment" );

+} );

+ element = $( "#resizable1" ).resizable( {

+ } );

+} );

+test( "stop", function() {

+ expect( 5 );

+ $( "#resizable1" ).resizable( {

+ stop: function( event, ui ) {

+ } );

+ testHelper.drag( handle, 50, 50 );

+ equal( count, 1, "stop callback should happen exactly once" );

+} );

+ fixedContainer.css( {

+ } );

+ absoluteContainer.css( {

+ } );

+ target.resizable( {

+ } ).css( {

+ } );

+} );

+

+ $( el ).simulate( "mouseover" ).simulate( "drag", {

+ } );

+ var element = $( "#resizable1" ).resizable( { disabled: false } ),

+} );

+module( "resizable: options" );

+ .css( {

+ } )

+ element = $( "#resizable1" ).resizable( {

+ } ),

+} );

+test( "aspectRatio: 'preserve' (e)", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-e", target = $( "#resizable1" ).resizable( { aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 } );

+ testHelper.drag( handle, 80 );

+ equal( target.width(), 130, "compare maxWidth" );

+ equal( target.height(), 130, "compare maxHeight" );

+ testHelper.drag( handle, -130 );

+ equal( target.width(), 70, "compare minWidth" );

+ equal( target.height(), 70, "compare minHeight" );

+} );

+test( "aspectRatio: 'preserve' (w)", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-w", target = $( "#resizable1" ).resizable( { aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 } );

+ testHelper.drag( handle, -80 );

+ equal( target.width(), 130, "compare maxWidth" );

+ equal( target.height(), 130, "compare maxHeight" );

+ testHelper.drag( handle, 130 );

+ equal( target.width(), 70, "compare minWidth" );

+ equal( target.height(), 70, "compare minHeight" );

+} );

+test( "aspectRatio: 'preserve' (n)", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-n", target = $( "#resizable1" ).resizable( { aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 } );

+ testHelper.drag( handle, 0, -80 );

+ equal( target.width(), 130, "compare maxWidth" );

+ equal( target.height(), 130, "compare maxHeight" );

+ testHelper.drag( handle, 0, 80 );

+ equal( target.width(), 70, "compare minWidth" );

+ equal( target.height(), 70, "compare minHeight" );

+} );

+test( "aspectRatio: 'preserve' (s)", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-s", target = $( "#resizable1" ).resizable( { aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 } );

+ testHelper.drag( handle, 0, 80 );

+ equal( target.width(), 130, "compare maxWidth" );

+ equal( target.height(), 130, "compare maxHeight" );

+ testHelper.drag( handle, 0, -80 );

+ equal( target.width(), 70, "compare minWidth" );

+ equal( target.height(), 70, "compare minHeight" );

+} );

+test( "aspectRatio: 'preserve' (se)", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-se", target = $( "#resizable1" ).resizable( { aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 } );

+ testHelper.drag( handle, 80, 80 );

+ equal( target.width(), 130, "compare maxWidth" );

+ equal( target.height(), 130, "compare maxHeight" );

+ testHelper.drag( handle, -80, -80 );

+ equal( target.width(), 70, "compare minWidth" );

+ equal( target.height(), 70, "compare minHeight" );

+} );

+test( "aspectRatio: 'preserve' (sw)", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-sw", target = $( "#resizable1" ).resizable( { aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 } );

+ testHelper.drag( handle, -80, 80 );

+ equal( target.width(), 130, "compare maxWidth" );

+ equal( target.height(), 130, "compare maxHeight" );

+ testHelper.drag( handle, 80, -80 );

+ equal( target.width(), 70, "compare minWidth" );

+ equal( target.height(), 70, "compare minHeight" );

+} );

+test( "aspectRatio: 'preserve' (ne)", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-ne", target = $( "#resizable1" ).resizable( { aspectRatio: "preserve", handles: "all", minWidth: 70, minHeight: 50, maxWidth: 150, maxHeight: 130 } );

+ testHelper.drag( handle, 80, -80 );

+ equal( target.width(), 130, "compare maxWidth" );

+ equal( target.height(), 130, "compare maxHeight" );

+ testHelper.drag( handle, -80, 80 );

+ equal( target.width(), 70, "compare minWidth" );

+ equal( target.height(), 70, "compare minHeight" );

+} );

+ target = $( "#resizable1" ).resizable( {

+ } );

+ $( "#container" ).css( { width: 200, height: 300 } );

+ $( "#resizable1" ).css( { width: 100, height: 100, left: 75, top: 200 } );

+ $( "#container" ).css( { width: 200, height: 300, position: "absolute", left: 100, top: 100 } );

+ $( "#resizable1" ).css( { width: 100, height: 100, left: 0, top: 0 } );

+} );

+ var element = $( "#resizable1" ).resizable( {

+ } );

+} );

+ var element = $( "#child" ).resizable( {

+ } );

+ element = $( "#child" ).resizable( {

+ } );

+} );

+ var element = $( "#child" ).resizable( {

+ } );

+ element = $( "#child" ).resizable( {

+ } );

+} );

+test( "grid", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-se", target = $( "#resizable1" ).resizable( { handles: "all", grid: [ 0, 20 ] } );

+ testHelper.drag( handle, 3, 9 );

+ equal( target.width(), 103, "compare width" );

+ equal( target.height(), 100, "compare height" );

+ testHelper.drag( handle, 15, 11 );

+ equal( target.width(), 118, "compare width" );

+ equal( target.height(), 120, "compare height" );

+} );

+test( "grid (min/max dimensions)", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-se", target = $( "#resizable1" ).resizable( { handles: "all", grid: 20, minWidth: 65, minHeight: 65, maxWidth: 135, maxHeight: 135 } );

+ testHelper.drag( handle, 50, 50 );

+ equal( target.width(), 120, "grid should respect maxWidth" );

+ equal( target.height(), 120, "grid should respect maxHeight" );

+ testHelper.drag( handle, -100, -100 );

+ equal( target.width(), 80, "grid should respect minWidth" );

+ equal( target.height(), 80, "grid should respect minHeight" );

+} );

+test( "grid (wrapped)", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-se", target = $( "#resizable2" ).resizable( { handles: "all", grid: [ 0, 20 ] } );

+ testHelper.drag( handle, 3, 9 );

+ equal( target.width(), 103, "compare width" );

+ equal( target.height(), 100, "compare height" );

+ testHelper.drag( handle, 15, 11 );

+ equal( target.width(), 118, "compare width" );

+ equal( target.height(), 120, "compare height" );

+} );

+ target = $( "#resizable1" ).resizable( {

+ } );

+} );

+ target = $( "#resizable1" ).css( {

+ } ).resizable( {

+ } );

+} );

+test( "ui-resizable-se { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-se", target = $( "#resizable1" ).resizable( { handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 } );

+ testHelper.drag( handle, -50, -50 );

+ testHelper.drag( handle, 70, 70 );

+} );

+test( "ui-resizable-sw { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-sw", target = $( "#resizable1" ).resizable( { handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 } );

+ testHelper.drag( handle, 50, -50 );

+ testHelper.drag( handle, -70, 70 );

+} );

+test( "ui-resizable-ne { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-ne", target = $( "#resizable1" ).resizable( { handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 } );

+ testHelper.drag( handle, -50, 50 );

+ testHelper.drag( handle, 70, -70 );

+} );

+test( "ui-resizable-nw { handles: 'all', minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 }", function() {

+ expect( 4 );

+ var handle = ".ui-resizable-nw", target = $( "#resizable1" ).resizable( { handles: "all", minWidth: 60, minHeight: 60, maxWidth: 100, maxHeight: 100 } );

+ testHelper.drag( handle, 70, 70 );

+ testHelper.drag( handle, -70, -70 );

+} );

+test( "custom handles { handles: { 's': $('#resizer1'), containment: 'parent' }", function() {

+ target = $( "#resizable1" ).resizable( { handles: { "s": $( "#resizer1" ) }, containment: "parent" } );

+} );

+test( "custom handles { handles: { 's': $('#resizer1')[0], containment: 'parent' }", function() {

+ target = $( "#resizable1" ).resizable( { handles: { "s": $( "#resizer1" )[ 0 ] }, containment: "parent" } );

+} );

+test( "zIndex, applied to all handles", function() {

+ expect( 8 );

+ var target = $( "<div></div>" ).resizable( { handles: "all", zIndex: 100 } );

+ } );

+} );

+ .css( {

+ } )

+ element = $( "#resizable1" ).resizable( {

+ } );

+} );

+ .css( {

+ } )

+ .css( {

+ } )

+ .appendTo( "body" ),

+ element = $( "#resizable1" ).resizable( {

+ } );

+} );

+( function( factory ) {

+ define( [

+}( function( $ ) {

+$.widget( "ui.resizable", $.ui.mouse, {

+

+ if ( $( el ).css( "overflow" ) === "hidden" ) {

+ $.extend( this, {

+ _aspectRatio: !!( o.aspectRatio ),

+ } );

+ if ( this.element[ 0 ].nodeName.match( /^(canvas|textarea|input|select|button|img)$/i ) ) {

+ $( "<div class='ui-wrapper' style='overflow: hidden;'></div>" ).css( {

+ position: this.element.css( "position" ),

+ top: this.element.css( "top" ),

+ left: this.element.css( "left" )

+ } )

+ this.element.css( {

+ marginLeft: this.originalElement.css( "marginLeft" ),

+ marginTop: this.originalElement.css( "marginTop" ),

+ marginRight: this.originalElement.css( "marginRight" ),

+ marginBottom: this.originalElement.css( "marginBottom" )

+ } );

+ this.originalElement.css( {

+ } );

+

+ this.originalResizeStyle = this.originalElement.css( "resize" );

+ this.originalElement.css( "resize", "none" );

+ this._proportionallyResizeElements.push( this.originalElement.css( {

+ } ) );

+ this.originalElement.css( { margin: this.originalElement.css( "margin" ) } );

+ ( !$( ".ui-resizable-handle", this.element ).length ?

+ if ( this.handles === "all" ) {

+ n = this.handles.split( "," );

+ for ( i = 0; i < n.length; i++ ) {

+ handle = $.trim( n[ i ] );

+ axis = $( "<div>" );

+ axis.css( { zIndex: o.zIndex } );

+ this.handles[ handle ] = ".ui-resizable-" + handle;

+ this.element.append( axis );

+ this._renderAxis = function( target ) {

+ for ( i in this.handles ) {

+ if ( this.handles[ i ].constructor === String ) {

+ this.handles[ i ] = this.element.children( this.handles[ i ] ).first().show();

+ 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();

+ /ne|nw|n/.test( i ) ? "Top" :

+ /se|sw|s/.test( i ) ? "Bottom" :

+ /^e$/.test( i ) ? "Right" : "Left" ].join( "" );

+ target.css( padPos, padWrapper );

+ this._renderAxis( this.element );

+ 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.element )

+ if ( o.disabled ) {

+ } )

+ if ( o.disabled ) {

+ if ( !that.resizing ) {

+ } );

+ _destroy = function( exp ) {

+ $( exp )

+ .removeData( "resizable" )

+ .removeData( "ui-resizable" )

+ .off( ".resizable" )

+ .find( ".ui-resizable-handle" )

+ if ( this.elementIsWrapper ) {

+ _destroy( this.element );

+ this.originalElement.css( {

+ position: wrapper.css( "position" ),

+ top: wrapper.css( "top" ),

+ left: wrapper.css( "left" )

+ } ).insertAfter( wrapper );

+ this.originalElement.css( "resize", this.originalResizeStyle );

+ _destroy( this.originalElement );

+ _mouseCapture: function( event ) {

+ for ( i in this.handles ) {

+ handle = $( this.handles[ i ] )[ 0 ];

+ if ( handle === event.target || $.contains( handle, event.target ) ) {

+ _mouseStart: function( event ) {

+ 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.aspectRatio = ( typeof o.aspectRatio === "number" ) ?

+ ( ( this.originalSize.width / this.originalSize.height ) || 1 );

+ cursor = $( ".ui-resizable-" + this.axis ).css( "cursor" );

+ $( "body" ).css( "cursor", cursor === "auto" ? this.axis + "-resize" : cursor );

+ this._propagate( "start", event );

+ _mouseDrag: function( event ) {

+ dx = ( event.pageX - smp.left ) || 0,

+ dy = ( event.pageY - smp.top ) || 0,

+ trigger = this._change[ a ];

+ if ( !trigger ) {

+ 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 );

+ _mouseStop: function( event ) {

+ if ( this._helper ) {

+ ista = pr.length && ( /textarea/i ).test( pr[ 0 ].nodeName );

+ soffseth = ista && this._hasScroll( pr[ 0 ], "left" ) ? 0 : that.sizeDiff.height;

+ width: ( that.helper.width() - soffsetw ),

+ height: ( that.helper.height() - soffseth )

+ left = ( parseInt( that.element.css( "left" ), 10 ) +

+ ( that.position.left - that.originalPosition.left ) ) || null;

+ top = ( parseInt( that.element.css( "top" ), 10 ) +

+ ( 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 ) {

+ $( "body" ).css( "cursor", "auto" );

+ this._propagate( "stop", event );

+ if ( this._helper ) {

+ _updateVirtualBoundaries: function( forceAspectRatio ) {

+ 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 ) {

+ if ( pMinWidth > b.minWidth ) {

+ if ( pMinHeight > b.minHeight ) {

+ if ( pMaxWidth < b.maxWidth ) {

+ if ( pMaxHeight < b.maxHeight ) {

+ _updateCache: function( data ) {

+ if ( this._isNumber( data.left ) ) {

+ if ( this._isNumber( data.top ) ) {

+ if ( this._isNumber( data.height ) ) {

+ if ( this._isNumber( data.width ) ) {

+ 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 );

+ if ( a === "nw" ) {

+ data.top = cpos.top + ( csize.height - data.height );

+ data.left = cpos.left + ( csize.width - data.width );

+ 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 ),

+ cw = /sw|nw|w/.test( a ), ch = /nw|ne|n/.test( a );

+ if ( isminw ) {

+ if ( isminh ) {

+ if ( ismaxw ) {

+ if ( ismaxh ) {

+ if ( isminw && cw ) {

+ if ( ismaxw && cw ) {

+ if ( isminh && ch ) {

+ if ( ismaxh && ch ) {

+ if ( !data.width && !data.height && !data.left && data.top ) {

+ } else if ( !data.width && !data.height && !data.top && data.left ) {

+ if ( !this._proportionallyResizeElements.length ) {

+ for ( ; i < this._proportionallyResizeElements.length; i++ ) {

+ prel = this._proportionallyResizeElements[ i ];

+ if ( !this.outerDimensions ) {

+ prel.css( {

+ height: ( element.height() - this.outerDimensions.height ) || 0,

+ width: ( element.width() - this.outerDimensions.width ) || 0

+ } );

+ if ( this._helper ) {

+ this.helper = this.helper || $( "<div style='overflow:hidden;'></div>" );

+ this.helper.css( {

+ } );

+ .appendTo( "body" )

+ e: function( event, dx ) {

+ w: function( event, dx ) {

+ n: function( event, dx, dy ) {

+ s: function( event, dx, 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() ) );

+} );

+$.ui.plugin.add( "resizable", "animate", {

+ var that = $( this ).resizable( "instance" ),

+ ista = pr.length && ( /textarea/i ).test( pr[ 0 ].nodeName ),

+ soffseth = ista && that._hasScroll( pr[ 0 ], "left" ) ? 0 : that.sizeDiff.height,

+ style = { width: ( that.size.width - soffsetw ), height: ( that.size.height - soffseth ) },

+ left = ( parseInt( that.element.css( "left" ), 10 ) +

+ ( that.position.left - that.originalPosition.left ) ) || null,

+ top = ( parseInt( that.element.css( "top" ), 10 ) +

+ ( that.position.top - that.originalPosition.top ) ) || null;

+ $.extend( style, top && left ? { top: top, left: left } : {} ), {

+ width: parseInt( that.element.css( "width" ), 10 ),

+ height: parseInt( that.element.css( "height" ), 10 ),

+ top: parseInt( that.element.css( "top" ), 10 ),

+ left: parseInt( that.element.css( "left" ), 10 )

+ if ( pr && pr.length ) {

+ $( pr[ 0 ] ).css( { width: data.width, height: data.height } );

+ that._updateCache( data );

+ that._propagate( "resize", event );

+} );

+ $( [ "Top", "Right", "Left", "Bottom" ] ).each( function( i, name ) {

+ } );

+ ( that._helper ?

+ ( that.offset.left - co.left ) ) );

+ ( that._helper ?

+ ( that.offset.top - co.top ) ) );

+ $( this ).css( {

+ } );

+ $( this ).css( {

+ } );

+} );

+$.ui.plugin.add( "resizable", "alsoResize", {

+ var that = $( this ).resizable( "instance" ),

+ $( o.alsoResize ).each( function() {

+ var el = $( this );

+ el.data( "ui-resizable-alsoresize", {

+ width: parseInt( el.width(), 10 ), height: parseInt( el.height(), 10 ),

+ left: parseInt( el.css( "left" ), 10 ), top: parseInt( el.css( "top" ), 10 )

+ } );

+ } );

+ resize: function( event, ui ) {

+ var that = $( this ).resizable( "instance" ),

+ 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 ?

+ $.each( css, function( i, prop ) {

+ var sum = ( start[ prop ] || 0 ) + ( delta[ prop ] || 0 );

+ if ( sum && sum >= 0 ) {

+ style[ prop ] = sum || null;

+ } );

+ el.css( style );

+ } );

+ $( this ).removeData( "resizable-alsoresize" );

+} );

+$.ui.plugin.add( "resizable", "ghost", {

+ var that = $( this ).resizable( "instance" ), cs = that.size;

+ that.ghost.css( {

+ } );

+ that.ghost.appendTo( that.helper );

+ var that = $( this ).resizable( "instance" );

+ if ( that.ghost ) {

+ that.ghost.css( {

+ } );

+ var that = $( this ).resizable( "instance" );

+ if ( that.ghost && that.helper ) {

+ that.helper.get( 0 ).removeChild( that.ghost.get( 0 ) );

+} );

+$.ui.plugin.add( "resizable", "grid", {

+ that = $( this ).resizable( "instance" ),

+ 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,

+ isMaxWidth = o.maxWidth && ( o.maxWidth < newWidth ),

+ isMaxHeight = o.maxHeight && ( o.maxHeight < newHeight ),

+ isMinWidth = o.minWidth && ( o.minWidth > newWidth ),

+ isMinHeight = o.minHeight && ( o.minHeight > newHeight );

+ if ( isMinWidth ) {

+ if ( isMinHeight ) {

+ if ( isMaxWidth ) {

+ if ( isMaxHeight ) {

+ if ( /^(se|s|e)$/.test( a ) ) {

+ } else if ( /^(ne)$/.test( a ) ) {

+ } else if ( /^(sw)$/.test( a ) ) {

+ if ( newHeight - gridY <= 0 || newWidth - gridX <= 0 ) {

+} );

+} ) );