https://iea-wind.org/wp-content/plugins/tree-website-map/lib/horizontal-tree/js/jquery-ui.js?ver=7.0.6

135		}
136		img = $( "img[usemap=#" + mapName + "]" )[0];
137		return !!img && visible( img );
138	}
139	return ( /input|select|textarea|button|object/.test( nodeName ) ?
140		!element.disabled :
141		"a" === nodeName ?
142			element.href || isTabIndexNotNaN :
143			isTabIndexNotNaN) &&
144		// the element and all of its ancestors must be visible
145		visible( element );
146}
147
148function visible( element ) {
149	return $.expr.filters.visible( element ) &&
150		!$( element ).parents().addBack().filter(function() {
151			return $.css( this, "visibility" ) === "hidden";
152		}).length;
153}
154
155$.extend( $.expr[ ":" ], {
156	data: $.expr.createPseudo ?
157		$.expr.createPseudo(function( dataName ) {
158			return function( elem ) {
159				return !!$.data( elem, dataName );
160			};
161		}) :
162		// support: jQuery <1.8
163		function( elem, i, match ) {
164			return !!$.data( elem, match[ 3 ] );
165		},
166
167	focusable: function( element ) {
168		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
169	},
170
171	tabbable: function( element ) {
172		var tabIndex = $.attr( element, "tabindex" ),
173			isTabIndexNaN = isNaN( tabIndex );
174		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
175	}
176});
177
178// support: jQuery <1.8
179if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
180	$.each( [ "Width", "Height" ], function( i, name ) {
181		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
182			type = name.toLowerCase(),
183			orig = {
184				innerWidth: $.fn.innerWidth,
185				innerHeight: $.fn.innerHeight,
186				outerWidth: $.fn.outerWidth,
187				outerHeight: $.fn.outerHeight
188			};
189
190		function reduce( elem, size, border, margin ) {
191			$.each( side, function() {
192				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
193				if ( border ) {
194					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
195				}
196				if ( margin ) {
197					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
198				}
199			});
200			return size;
201		}
202
203		$.fn[ "inner" + name ] = function( size ) {
204			if ( size === undefined ) {
205				return orig[ "inner" + name ].call( this );
206			}
207
208			return this.each(function() {
209				$( this ).css( type, reduce( this, size ) + "px" );
210			});
211		};
212
213		$.fn[ "outer" + name] = function( size, margin ) {
214			if ( typeof size !== "number" ) {
215				return orig[ "outer" + name ].call( this, size );
216			}
217
218			return this.each(function() {
219				$( this).css( type, reduce( this, size, true, margin ) + "px" );
220			});
221		};
222	});
223}
224
225// support: jQuery <1.8
226if ( !$.fn.addBack ) {
227	$.fn.addBack = function( selector ) {
228		return this.add( selector == null ?
229			this.prevObject : this.prevObject.filter( selector )
230		);
231	};
232}
233
234// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
235if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
236	$.fn.removeData = (function( removeData ) {
237		return function( key ) {
238			if ( arguments.length ) {
239				return removeData.call( this, $.camelCase( key ) );
240			} else {
241				return removeData.call( this );
242			}
243		};
244	})( $.fn.removeData );
245}
246
247
248
249
250
251// deprecated
252$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
253
254$.support.selectstart = "onselectstart" in document.createElement( "div" );
255$.fn.extend({
256	disableSelection: function() {
257		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
258			".ui-disableSelection", function( event ) {
259				event.preventDefault();
260			});
261	},
262
263	enableSelection: function() {
264		return this.unbind( ".ui-disableSelection" );
265	}
266});
267
268$.extend( $.ui, {
269	// $.ui.plugin is deprecated.  Use the proxy pattern instead.
270	plugin: {
271		add: function( module, option, set ) {
272			var i,
273				proto = $.ui[ module ].prototype;
274			for ( i in set ) {
275				proto.plugins[ i ] = proto.plugins[ i ] || [];
276				proto.plugins[ i ].push( [ option, set[ i ] ] );
277			}
278		},
279		call: function( instance, name, args ) {
280			var i,
281				set = instance.plugins[ name ];
282			if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
283				return;
284			}
285
286			for ( i = 0; i < set.length; i++ ) {
287				if ( instance.options[ set[ i ][ 0 ] ] ) {
288					set[ i ][ 1 ].apply( instance.element, args );
289				}
290			}
291		}
292	},
293
294	// only used by resizable
295	hasScroll: function( el, a ) {
296
297		//If overflow is hidden, the element might have extra content, but the user wants to hide it
298		if ( $( el ).css( "overflow" ) === "hidden") {
299			return false;
300		}
301
302		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
303			has = false;
304
305		if ( el[ scroll ] > 0 ) {
306			return true;
307		}
308
309		// TODO: determine which cases actually cause this to happen
310		// if the element doesn't have the scroll set, see if it's possible to
311		// set the scroll
312		el[ scroll ] = 1;
313		has = ( el[ scroll ] > 0 );
314		el[ scroll ] = 0;
315		return has;
316	}
317});
318
319})( jQuery );
320
321(function( $, undefined ) {
322
323var uuid = 0,
324	slice = Array.prototype.slice,
325	_cleanData = $.cleanData;
326$.cleanData = function( elems ) {
327	for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
328		try {
329			$( elem ).triggerHandler( "remove" );
330		// http://bugs.jquery.com/ticket/8235
331		} catch( e ) {}
332	}
333	_cleanData( elems );
334};
335
336$.widget = function( name, base, prototype ) {
337	var fullName, existingConstructor, constructor, basePrototype,
338		// proxiedPrototype allows the provided prototype to remain unmodified
339		// so that it can be used as a mixin for multiple widgets (#8876)
340		proxiedPrototype = {},
341		namespace = name.split( "." )[ 0 ];
342
343	name = name.split( "." )[ 1 ];
344	fullName = namespace + "-" + name;
345
346	if ( !prototype ) {
347		prototype = base;
348		base = $.Widget;
349	}
350
351	// create selector for plugin
352	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
353		return !!$.data( elem, fullName );
354	};
355
356	$[ namespace ] = $[ namespace ] || {};
357	existingConstructor = $[ namespace ][ name ];
358	constructor = $[ namespace ][ name ] = function( options, element ) {
359		// allow instantiation without "new" keyword
360		if ( !this._createWidget ) {
361			return new constructor( options, element );
362		}
363
364		// allow instantiation without initializing for simple inheritance
365		// must use "new" keyword (the code above always passes args)
366		if ( arguments.length ) {
367			this._createWidget( options, element );
368		}
369	};
370	// extend with the existing constructor to carry over any static properties
371	$.extend( constructor, existingConstructor, {
372		version: prototype.version,
373		// copy the object used to create the prototype in case we need to
374		// redefine the widget later
375		_proto: $.extend( {}, prototype ),
376		// track widgets that inherit from this widget in case this widget is
377		// redefined after a widget inherits from it
378		_childConstructors: []
379	});
380
381	basePrototype = new base();
382	// we need to make the options hash a property directly on the new instance
383	// otherwise we'll modify the options hash on the prototype that we're
384	// inheriting from
385	basePrototype.options = $.widget.extend( {}, basePrototype.options );
386	$.each( prototype, function( prop, value ) {
387		if ( !$.isFunction( value ) ) {
388			proxiedPrototype[ prop ] = value;
389			return;
390		}
391		proxiedPrototype[ prop ] = (function() {
392			var _super = function() {
393					return base.prototype[ prop ].apply( this, arguments );
394				},
395				_superApply = function( args ) {
396					return base.prototype[ prop ].apply( this, args );
397				};
398			return function() {
399				var __super = this._super,
400					__superApply = this._superApply,
401					returnValue;
402
403				this._super = _super;
404				this._superApply = _superApply;
405
406				returnValue = value.apply( this, arguments );
407
408				this._super = __super;
409				this._superApply = __superApply;
410
411				return returnValue;
412			};
413		})();
414	});
415	constructor.prototype = $.widget.extend( basePrototype, {
416		// TODO: remove support for widgetEventPrefix
417		// always use the name + a colon as the prefix, e.g., draggable:start
418		// don't prefix for widgets that aren't DOM-based
419		widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
420	}, proxiedPrototype, {
421		constructor: constructor,
422		namespace: namespace,
423		widgetName: name,
424		widgetFullName: fullName
425	});
426
427	// If this widget is being redefined then we need to find all widgets that
428	// are inheriting from it and redefine all of them so that they inherit from
429	// the new version of this widget. We're essentially trying to replace one
430	// level in the prototype chain.
431	if ( existingConstructor ) {
432		$.each( existingConstructor._childConstructors, function( i, child ) {
433			var childPrototype = child.prototype;
434
435			// redefine the child widget using the same prototype that was
436			// originally used, but inherit from the new version of the base
437			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
438		});
439		// remove the list of existing child constructors from the old constructor
440		// so the old child constructors can be garbage collected
441		delete existingConstructor._childConstructors;
442	} else {
443		base._childConstructors.push( constructor );
444	}
445
446	$.widget.bridge( name, constructor );
447};
448
449$.widget.extend = function( target ) {
450	var input = slice.call( arguments, 1 ),
451		inputIndex = 0,
452		inputLength = input.length,
453		key,
454		value;
455	for ( ; inputIndex < inputLength; inputIndex++ ) {
456		for ( key in input[ inputIndex ] ) {
457			value = input[ inputIndex ][ key ];
458			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
459				// Clone objects
460				if ( $.isPlainObject( value ) ) {
461					target[ key ] = $.isPlainObject( target[ key ] ) ?
462						$.widget.extend( {}, target[ key ], value ) :
463						// Don't extend strings, arrays, etc. with objects
464						$.widget.extend( {}, value );
465				// Copy everything else by reference
466				} else {
467					target[ key ] = value;
468				}
469			}
470		}
471	}
472	return target;
473};
474
475$.widget.bridge = function( name, object ) {
476	var fullName = object.prototype.widgetFullName || name;
477	$.fn[ name ] = function( options ) {
478		var isMethodCall = typeof options === "string",
479			args = slice.call( arguments, 1 ),
480			returnValue = this;
481
482		// allow multiple hashes to be passed on init
483		options = !isMethodCall && args.length ?
484			$.widget.extend.apply( null, [ options ].concat(args) ) :
485			options;
486
487		if ( isMethodCall ) {
488			this.each(function() {
489				var methodValue,
490					instance = $.data( this, fullName );
491				if ( !instance ) {
492					return $.error( "cannot call methods on " + name + " prior to initialization; " +
493						"attempted to call method '" + options + "'" );
494				}
495				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
496					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
497				}
498				methodValue = instance[ options ].apply( instance, args );
499				if ( methodValue !== instance && methodValue !== undefined ) {
500					returnValue = methodValue && methodValue.jquery ?
501						returnValue.pushStack( methodValue.get() ) :
502						methodValue;
503					return false;
504				}
505			});
506		} else {
507			this.each(function() {
508				var instance = $.data( this, fullName );
509				if ( instance ) {
510					instance.option( options || {} )._init();
511				} else {
512					$.data( this, fullName, new object( options, this ) );
513				}
514			});
515		}
516
517		return returnValue;
518	};
519};
520
521$.Widget = function( /* options, element */ ) {};
522$.Widget._childConstructors = [];
523
524$.Widget.prototype = {
525	widgetName: "widget",
526	widgetEventPrefix: "",
527	defaultElement: "<div>",
528	options: {
529		disabled: false,
530
531		// callbacks
532		create: null
533	},
534	_createWidget: function( options, element ) {
535		element = $( element || this.defaultElement || this )[ 0 ];
536		this.element = $( element );
537		this.uuid = uuid++;
538		this.eventNamespace = "." + this.widgetName + this.uuid;
539		this.options = $.widget.extend( {},
540			this.options,
541			this._getCreateOptions(),
542			options );
543
544		this.bindings = $();
545		this.hoverable = $();
546		this.focusable = $();
547
548		if ( element !== this ) {
549			$.data( element, this.widgetFullName, this );
550			this._on( true, this.element, {
551				remove: function( event ) {
552					if ( event.target === element ) {
553						this.destroy();
554					}
555				}
556			});
557			this.document = $( element.style ?
558				// element within the document
559				element.ownerDocument :
560				// element is window or document
561				element.document || element );
562			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
563		}
564
565		this._create();
566		this._trigger( "create", null, this._getCreateEventData() );
567		this._init();
568	},
569	_getCreateOptions: $.noop,
570	_getCreateEventData: $.noop,
571	_create: $.noop,
572	_init: $.noop,
573
574	destroy: function() {
575		this._destroy();
576		// we can probably remove the unbind calls in 2.0
577		// all event bindings should go through this._on()
578		this.element
579			.unbind( this.eventNamespace )
580			// 1.9 BC for #7810
581			// TODO remove dual storage
582			.removeData( this.widgetName )
583			.removeData( this.widgetFullName )
584			// support: jquery <1.6.3
585			// http://bugs.jquery.com/ticket/9413
586			.removeData( $.camelCase( this.widgetFullName ) );
587		this.widget()
588			.unbind( this.eventNamespace )
589			.removeAttr( "aria-disabled" )
590			.removeClass(
591				this.widgetFullName + "-disabled " +
592				"ui-state-disabled" );
593
594		// clean up events and states
595		this.bindings.unbind( this.eventNamespace );
596		this.hoverable.removeClass( "ui-state-hover" );
597		this.focusable.removeClass( "ui-state-focus" );
598	},
599	_destroy: $.noop,
600
601	widget: function() {
602		return this.element;
603	},
604
605	option: function( key, value ) {
606		var options = key,
607			parts,
608			curOption,
609			i;
610
611		if ( arguments.length === 0 ) {
612			// don't return a reference to the internal hash
613			return $.widget.extend( {}, this.options );
614		}
615
616		if ( typeof key === "string" ) {
617			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
618			options = {};
619			parts = key.split( "." );
620			key = parts.shift();
621			if ( parts.length ) {
622				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
623				for ( i = 0; i < parts.length - 1; i++ ) {
624					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
625					curOption = curOption[ parts[ i ] ];
626				}
627				key = parts.pop();
628				if ( value === undefined ) {
629					return curOption[ key ] === undefined ? null : curOption[ key ];
630				}
631				curOption[ key ] = value;
632			} else {
633				if ( value === undefined ) {
634					return this.options[ key ] === undefined ? null : this.options[ key ];
635				}
636				options[ key ] = value;
637			}
638		}
639
640		this._setOptions( options );
641
642		return this;
643	},
644	_setOptions: function( options ) {
645		var key;
646
647		for ( key in options ) {
648			this._setOption( key, options[ key ] );
649		}
650
651		return this;
652	},
653	_setOption: function( key, value ) {
654		this.options[ key ] = value;
655
656		if ( key === "disabled" ) {
657			this.widget()
658				.toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
659				.attr( "aria-disabled", value );
660			this.hoverable.removeClass( "ui-state-hover" );
661			this.focusable.removeClass( "ui-state-focus" );
662		}
663
664		return this;
665	},
666
667	enable: function() {
668		return this._setOption( "disabled", false );
669	},
670	disable: function() {
671		return this._setOption( "disabled", true );
672	},
673
674	_on: function( suppressDisabledCheck, element, handlers ) {
675		var delegateElement,
676			instance = this;
677
678		// no suppressDisabledCheck flag, shuffle arguments
679		if ( typeof suppressDisabledCheck !== "boolean" ) {
680			handlers = element;
681			element = suppressDisabledCheck;
682			suppressDisabledCheck = false;
683		}
684
685		// no element argument, shuffle and use this.element
686		if ( !handlers ) {
687			handlers = element;
688			element = this.element;
689			delegateElement = this.widget();
690		} else {
691			// accept selectors, DOM elements
692			element = delegateElement = $( element );
693			this.bindings = this.bindings.add( element );
694		}
695
696		$.each( handlers, function( event, handler ) {
697			function handlerProxy() {
698				// allow widgets to customize the disabled handling
699				// - disabled as an array instead of boolean
700				// - disabled class as method for disabling individual parts
701				if ( !suppressDisabledCheck &&
702						( instance.options.disabled === true ||
703							$( this ).hasClass( "ui-state-disabled" ) ) ) {
704					return;
705				}
706				return ( typeof handler === "string" ? instance[ handler ] : handler )
707					.apply( instance, arguments );
708			}
709
710			// copy the guid so direct unbinding works
711			if ( typeof handler !== "string" ) {
712				handlerProxy.guid = handler.guid =
713					handler.guid || handlerProxy.guid || $.guid++;
714			}
715
716			var match = event.match( /^(\w+)\s*(.*)$/ ),
717				eventName = match[1] + instance.eventNamespace,
718				selector = match[2];
719			if ( selector ) {
720				delegateElement.delegate( selector, eventName, handlerProxy );
721			} else {
722				element.bind( eventName, handlerProxy );
723			}
724		});
725	},
726
727	_off: function( element, eventName ) {
728		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
729		element.unbind( eventName ).undelegate( eventName );
730	},
731
732	_delay: function( handler, delay ) {
733		function handlerProxy() {
734			return ( typeof handler === "string" ? instance[ handler ] : handler )
735				.apply( instance, arguments );
736		}
737		var instance = this;
738		return setTimeout( handlerProxy, delay || 0 );
739	},
740
741	_hoverable: function( element ) {
742		this.hoverable = this.hoverable.add( element );
743		this._on( element, {
744			mouseenter: function( event ) {
745				$( event.currentTarget ).addClass( "ui-state-hover" );
746			},
747			mouseleave: function( event ) {
748				$( event.currentTarget ).removeClass( "ui-state-hover" );
749			}
750		});
751	},
752
753	_focusable: function( element ) {
754		this.focusable = this.focusable.add( element );
755		this._on( element, {
756			focusin: function( event ) {
757				$( event.currentTarget ).addClass( "ui-state-focus" );
758			},
759			focusout: function( event ) {
760				$( event.currentTarget ).removeClass( "ui-state-focus" );
761			}
762		});
763	},
764
765	_trigger: function( type, event, data ) {
766		var prop, orig,
767			callback = this.options[ type ];
768
769		data = data || {};
770		event = $.Event( event );
771		event.type = ( type === this.widgetEventPrefix ?
772			type :
773			this.widgetEventPrefix + type ).toLowerCase();
774		// the original event may come from any element
775		// so we need to reset the target on the new event
776		event.target = this.element[ 0 ];
777
778		// copy original event properties over to the new event
779		orig = event.originalEvent;
780		if ( orig ) {
781			for ( prop in orig ) {
782				if ( !( prop in event ) ) {
783					event[ prop ] = orig[ prop ];
784				}
785			}
786		}
787
788		this.element.trigger( event, data );
789		return !( $.isFunction( callback ) &&
790			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
791			event.isDefaultPrevented() );
792	}
793};
794
795$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
796	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
797		if ( typeof options === "string" ) {
798			options = { effect: options };
799		}
800		var hasOptions,
801			effectName = !options ?
802				method :
803				options === true || typeof options === "number" ?
804					defaultEffect :
805					options.effect || defaultEffect;
806		options = options || {};
807		if ( typeof options === "number" ) {
808			options = { duration: options };
809		}
810		hasOptions = !$.isEmptyObject( options );
811		options.complete = callback;
812		if ( options.delay ) {
813			element.delay( options.delay );
814		}
815		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
816			element[ method ]( options );
817		} else if ( effectName !== method && element[ effectName ] ) {
818			element[ effectName ]( options.duration, options.easing, callback );
819		} else {
820			element.queue(function( next ) {
821				$( this )[ method ]();
822				if ( callback ) {
823					callback.call( element[ 0 ] );
824				}
825				next();
826			});
827		}
828	};
829});
830
831})( jQuery );
832
833(function( $, undefined ) {
834
835var mouseHandled = false;
836$( document ).mouseup( function() {
837	mouseHandled = false;
838});
839
840$.widget("ui.mouse", {
841	version: "1.10.1",
842	options: {
843		cancel: "input,textarea,button,select,option",
844		distance: 1,
845		delay: 0
846	},
847	_mouseInit: function() {
848		var that = this;
849
850		this.element
851			.bind("mousedown."+this.widgetName, function(event) {
852				return that._mouseDown(event);
853			})
854			.bind("click."+this.widgetName, function(event) {
855				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
856					$.removeData(event.target, that.widgetName + ".preventClickEvent");
857					event.stopImmediatePropagation();
858					return false;
859				}
860			});
861
862		this.started = false;
863	},
864
865	// TODO: make sure destroying one instance of mouse doesn't mess with
866	// other instances of mouse
867	_mouseDestroy: function() {
868		this.element.unbind("."+this.widgetName);
869		if ( this._mouseMoveDelegate ) {
870			$(document)
871				.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
872				.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
873		}
874	},
875
876	_mouseDown: function(event) {
877		// don't let more than one widget handle mouseStart
878		if( mouseHandled ) { return; }
879
880		// we may have missed mouseup (out of window)
881		(this._mouseStarted && this._mouseUp(event));
882
883		this._mouseDownEvent = event;
884
885		var that = this,
886			btnIsLeft = (event.which === 1),
887			// event.target.nodeName works around a bug in IE 8 with
888			// disabled inputs (#7620)
889			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
890		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
891			return true;
892		}
893
894		this.mouseDelayMet = !this.options.delay;
895		if (!this.mouseDelayMet) {
896			this._mouseDelayTimer = setTimeout(function() {
897				that.mouseDelayMet = true;
898			}, this.options.delay);
899		}
900
901		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
902			this._mouseStarted = (this._mouseStart(event) !== false);
903			if (!this._mouseStarted) {
904				event.preventDefault();
905				return true;
906			}
907		}
908
909		// Click event may never have fired (Gecko & Opera)
910		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
911			$.removeData(event.target, this.widgetName + ".preventClickEvent");
912		}
913
914		// these delegates are required to keep context
915		this._mouseMoveDelegate = function(event) {
916			return that._mouseMove(event);
917		};
918		this._mouseUpDelegate = function(event) {
919			return that._mouseUp(event);
920		};
921		$(document)
922			.bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
923			.bind("mouseup."+this.widgetName, this._mouseUpDelegate);
924
925		event.preventDefault();
926
927		mouseHandled = true;
928		return true;
929	},
930
931	_mouseMove: function(event) {
932		// IE mouseup check - mouseup happened when mouse was out of window
933		if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
934			return this._mouseUp(event);
935		}
936
937		if (this._mouseStarted) {
938			this._mouseDrag(event);
939			return event.preventDefault();
940		}
941
942		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
943			this._mouseStarted =
944				(this._mouseStart(this._mouseDownEvent, event) !== false);
945			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
946		}
947
948		return !this._mouseStarted;
949	},
950
951	_mouseUp: function(event) {
952		$(document)
953			.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
954			.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
955
956		if (this._mouseStarted) {
957			this._mouseStarted = false;
958
959			if (event.target === this._mouseDownEvent.target) {
960				$.data(event.target, this.widgetName + ".preventClickEvent", true);
961			}
962
963			this._mouseStop(event);
964		}
965
966		return false;
967	},
968
969	_mouseDistanceMet: function(event) {
970		return (Math.max(
971				Math.abs(this._mouseDownEvent.pageX - event.pageX),
972				Math.abs(this._mouseDownEvent.pageY - event.pageY)
973			) >= this.options.distance
974		);
975	},
976
977	_mouseDelayMet: function(/* event */) {
978		return this.mouseDelayMet;
979	},
980
981	// These are placeholder methods, to be overriden by extending plugin
982	_mouseStart: function(/* event */) {},
983	_mouseDrag: function(/* event */) {},
984	_mouseStop: function(/* event */) {},
985	_mouseCapture: function(/* event */) { return true; }
986});
987
988})(jQuery);
989
990(function( $, undefined ) {
991
992$.widget("ui.draggable", $.ui.mouse, {
993	version: "1.10.1",
994	widgetEventPrefix: "drag",
995	options: {
996		addClasses: true,
997		appendTo: "parent",
998		axis: false,
999		connectToSortable: false,
1000		containment: false,
1001		cursor: "auto",
1002		cursorAt: false,
1003		grid: false,
1004		handle: false,
1005		helper: "original",
1006		iframeFix: false,
1007		opacity: false,
1008		refreshPositions: false,
1009		revert: false,
1010		revertDuration: 500,
1011		scope: "default",
1012		scroll: true,
1013		scrollSensitivity: 20,
1014		scrollSpeed: 20,
1015		snap: false,
1016		snapMode: "both",
1017		snapTolerance: 20,
1018		stack: false,
1019		zIndex: false,
1020
1021		// callbacks
1022		drag: null,
1023		start: null,
1024		stop: null
1025	},
1026	_create: function() {
1027
1028		if (this.options.helper === "original" && !(/^(?:r|a|f)/).test(this.element.css("position"))) {
1029			this.element[0].style.position = "relative";
1030		}
1031		if (this.options.addClasses){
1032			this.element.addClass("ui-draggable");
1033		}
1034		if (this.options.disabled){
1035			this.element.addClass("ui-draggable-disabled");
1036		}
1037
1038		this._mouseInit();
1039
1040	},
1041
1042	_destroy: function() {
1043		this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
1044		this._mouseDestroy();
1045	},
1046
1047	_mouseCapture: function(event) {
1048
1049		var o = this.options;
1050
1051		// among others, prevent a drag on a resizable-handle
1052		if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
1053			return false;
1054		}
1055
1056		//Quit if we're not on a valid handle
1057		this.handle = this._getHandle(event);
1058		if (!this.handle) {
1059			return false;
1060		}
1061
1062		$(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
1063			$("<div class='ui-draggable-iframeFix' style='background: #fff;'></div>")
1064			.css({
1065				width: this.offsetWidth+"px", height: this.offsetHeight+"px",
1066				position: "absolute", opacity: "0.001", zIndex: 1000
1067			})
1068			.css($(this).offset())
1069			.appendTo("body");
1070		});
1071
1072		return true;
1073
1074	},
1075
1076	_mouseStart: function(event) {
1077
1078		var o = this.options;
1079
1080		//Create and append the visible helper
1081		this.helper = this._createHelper(event);
1082
1083		this.helper.addClass("ui-draggable-dragging");
1084
1085		//Cache the helper size
1086		this._cacheHelperProportions();
1087
1088		//If ddmanager is used for droppables, set the global draggable
1089		if($.ui.ddmanager) {
1090			$.ui.ddmanager.current = this;
1091		}
1092
1093		/*
1094		 * - Position generation -
1095		 * This block generates everything position related - it's the core of draggables.
1096		 */
1097
1098		//Cache the margins of the original element
1099		this._cacheMargins();
1100
1101		//Store the helper's css position
1102		this.cssPosition = this.helper.css("position");
1103		this.scrollParent = this.helper.scrollParent();
1104
1105		//The element's absolute position on the page minus margins
1106		this.offset = this.positionAbs = this.element.offset();
1107		this.offset = {
1108			top: this.offset.top - this.margins.top,
1109			left: this.offset.left - this.margins.left
1110		};
1111
1112		$.extend(this.offset, {
1113			click: { //Where the click happened, relative to the element
1114				left: event.pageX - this.offset.left,
1115				top: event.pageY - this.offset.top
1116			},
1117			parent: this._getParentOffset(),
1118			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
1119		});
1120
1121		//Generate the original position
1122		this.originalPosition = this.position = this._generatePosition(event);
1123		this.originalPageX = event.pageX;
1124		this.originalPageY = event.pageY;
1125
1126		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
1127		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
1128
1129		//Set a containment if given in the options
1130		if(o.containment) {
1131			this._setContainment();
1132		}
1133
1134		//Trigger event + callbacks
1135		if(this._trigger("start", event) === false) {
1136			this._clear();
1137			return false;
1138		}
1139
1140		//Recache the helper size
1141		this._cacheHelperProportions();
1142
1143		//Prepare the droppable offsets
1144		if ($.ui.ddmanager && !o.dropBehaviour) {
1145			$.ui.ddmanager.prepareOffsets(this, event);
1146		}
1147
1148
1149		this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
1150
1151		//If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
1152		if ( $.ui.ddmanager ) {
1153			$.ui.ddmanager.dragStart(this, event);
1154		}
1155
1156		return true;
1157	},
1158
1159	_mouseDrag: function(event, noPropagation) {
1160
1161		//Compute the helpers position
1162		this.position = this._generatePosition(event);
1163		this.positionAbs = this._convertPositionTo("absolute");
1164
1165		//Call plugins and callbacks and use the resulting position if something is returned
1166		if (!noPropagation) {
1167			var ui = this._uiHash();
1168			if(this._trigger("drag", event, ui) === false) {
1169				this._mouseUp({});
1170				return false;
1171			}
1172			this.position = ui.position;
1173		}
1174
1175		if(!this.options.axis || this.options.axis !== "y") {
1176			this.helper[0].style.left = this.position.left+"px";
1177		}
1178		if(!this.options.axis || this.options.axis !== "x") {
1179			this.helper[0].style.top = this.position.top+"px";
1180		}
1181		if($.ui.ddmanager) {
1182			$.ui.ddmanager.drag(this, event);
1183		}
1184
1185		return false;
1186	},
1187
1188	_mouseStop: function(event) {
1189
1190		//If we are using droppables, inform the manager about the drop
1191		var element,
1192			that = this,
1193			elementInDom = false,
1194			dropped = false;
1195		if ($.ui.ddmanager && !this.options.dropBehaviour) {
1196			dropped = $.ui.ddmanager.drop(this, event);
1197		}
1198
1199		//if a drop comes from outside (a sortable)
1200		if(this.dropped) {
1201			dropped = this.dropped;
1202			this.dropped = false;
1203		}
1204
1205		//if the original element is no longer in the DOM don't bother to continue (see #8269)
1206		element = this.element[0];
1207		while ( element && (element = element.parentNode) ) {
1208			if (element === document ) {
1209				elementInDom = true;
1210			}
1211		}
1212		if ( !elementInDom && this.options.helper === "original" ) {
1213			return false;
1214		}
1215
1216		if((this.options.revert === "invalid" && !dropped) || (this.options.revert === "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
1217			$(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
1218				if(that._trigger("stop", event) !== false) {
1219					that._clear();
1220				}
1221			});
1222		} else {
1223			if(this._trigger("stop", event) !== false) {
1224				this._clear();
1225			}
1226		}
1227
1228		return false;
1229	},
1230
1231	_mouseUp: function(event) {
1232		//Remove frame helpers
1233		$("div.ui-draggable-iframeFix").each(function() {
1234			this.parentNode.removeChild(this);
1235		});
1236
1237		//If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
1238		if( $.ui.ddmanager ) {
1239			$.ui.ddmanager.dragStop(this, event);
1240		}
1241
1242		return $.ui.mouse.prototype._mouseUp.call(this, event);
1243	},
1244
1245	cancel: function() {
1246
1247		if(this.helper.is(".ui-draggable-dragging")) {
1248			this._mouseUp({});
1249		} else {
1250			this._clear();
1251		}
1252
1253		return this;
1254
1255	},
1256
1257	_getHandle: function(event) {
1258
1259		var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
1260		$(this.options.handle, this.element)
1261			.find("*")
1262			.addBack()
1263			.each(function() {
1264				if(this === event.target) {
1265					handle = true;
1266				}
1267			});
1268
1269		return handle;
1270
1271	},
1272
1273	_createHelper: function(event) {
1274
1275		var o = this.options,
1276			helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper === "clone" ? this.element.clone().removeAttr("id") : this.element);
1277
1278		if(!helper.parents("body").length) {
1279			helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
1280		}
1281
1282		if(helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
1283			helper.css("position", "absolute");
1284		}
1285
1286		return helper;
1287
1288	},
1289
1290	_adjustOffsetFromHelper: function(obj) {
1291		if (typeof obj === "string") {
1292			obj = obj.split(" ");
1293		}
1294		if ($.isArray(obj)) {
1295			obj = {left: +obj[0], top: +obj[1] || 0};
1296		}
1297		if ("left" in obj) {
1298			this.offset.click.left = obj.left + this.margins.left;
1299		}
1300		if ("right" in obj) {
1301			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
1302		}
1303		if ("top" in obj) {
1304			this.offset.click.top = obj.top + this.margins.top;
1305		}
1306		if ("bottom" in obj) {
1307			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
1308		}
1309	},
1310
1311	_getParentOffset: function() {
1312
1313		//Get the offsetParent and cache its position
1314		this.offsetParent = this.helper.offsetParent();
1315		var po = this.offsetParent.offset();
1316
1317		// This is a special case where we need to modify a offset calculated on start, since the following happened:
1318		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
1319		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
1320		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
1321		if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
1322			po.left += this.scrollParent.scrollLeft();
1323			po.top += this.scrollParent.scrollTop();
1324		}
1325
1326		//This needs to be actually done for all browsers, since pageX/pageY includes this information
1327		//Ugly IE fix
1328		if((this.offsetParent[0] === document.body) ||
1329			(this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
1330			po = { top: 0, left: 0 };
1331		}
1332
1333		return {
1334			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),

133410) || 0),
1335			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
1336		};
1337
1338	},
1339
1340	_getRelativeOffset: function() {
1341
1342		if(this.cssPosition === "relative") {
1343			var p = this.element.position();
1344			return {
1345				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
1346				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
1347			};
1348		} else {
1349			return { top: 0, left: 0 };
1350		}
1351
1352	},
1353
1354	_cacheMargins: function() {
1355		this.margins = {
1356			left: (parseInt(this.element.css("marginLeft"),10) || 0),
1357			top: (parseInt(this.element.css("marginTop"),10) || 0),
1358			right: (parseInt(this.element.css("marginRight"),10) || 0),
1359			bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
1360		};
1361	},
1362
1363	_cacheHelperProportions: function() {
1364		this.helperProportions = {
1365			width: this.helper.outerWidth(),
1366			height: this.helper.outerHeight()
1367		};
1368	},
1369
1370	_setContainment: function() {
1371
1372		var over, c, ce,
1373			o = this.options;
1374
1375		if(o.containment === "parent") {
1376			o.containment = this.helper[0].parentNode;
1377		}
1378		if(o.containment === "document" || o.containment === "window") {
1379			this.containment = [
1380				o.containment === "document" ? 0 : $(window).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
1381				o.containment === "document" ? 0 : $(window).scrollTop() - this.offset.relative.top - this.offset.parent.top,

1382				(o.containment === "document" ? 0 : $(window).scrollLeft()) + $(o.containment === "document" ? document : window).width() - this.helperProportions.width - this.margins.left,
1383				(o.containment === "document" ? 0 : $(window).scrollTop()) + ($(o.containment === "document" ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
1384			];
1385		}
1386
1387		if(!(/^(document|window|parent)$/).test(o.containment) && o.containment.constructor !== Array) {
1388			c = $(o.containment);
1389			ce = c[0];
1390
1391			if(!ce) {
1392				return;
1393			}
1394
1395			over = ($(ce).css("overflow") !== "hidden");
1396
1397			this.containment = [
1398				(parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0),
1399				(parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0),
1400				(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left - this.margins.right,
1401				(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top  - this.margins.bottom
1402			];
1403			this.relative_container = c;
1404
1405		} else if(o.containment.constructor === Array) {
1406			this.containment = o.containment;
1407		}
1408
1409	},
1410
1411	_convertPositionTo: function(d, pos) {
1412
1413		if(!pos) {
1414			pos = this.position;
1415		}
1416
1417		var mod = d === "absolute" ? 1 : -1,
1418			scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
1419
1420		return {
1421			top: (
1422				pos.top	+																// The absolute mouse position
1423				this.offset.relative.top * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
1424				this.offset.parent.top * mod -										// The offsetParent's offset without borders (offset + border)
1425				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
1426			),
1427			left: (
1428				pos.left +																// The absolute mouse position
1429				this.offset.relative.left * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
1430				this.offset.parent.left * mod	-										// The offsetParent's offset without borders (offset + border)
1431				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
1432			)
1433		};
1434
1435	},
1436
1437	_generatePosition: function(event) {
1438
1439		var containment, co, top, left,
1440			o = this.options,
1441			scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
1442			scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName),
1443			pageX = event.pageX,
1444			pageY = event.pageY;
1445
1446		/*
1447		 * - Position constraining -
1448		 * Constrain the position to a mix of grid, containment.
1449		 */
1450
1451		if(this.originalPosition) { //If we are not dragging yet, we won't check for options
1452			if(this.containment) {
1453			if (this.relative_container){
1454				co = this.relative_container.offset();
1455				containment = [ this.containment[0] + co.left,
1456					this.containment[1] + co.top,
1457					this.containment[2] + co.left,
1458					this.containment[3] + co.top ];
1459			}
1460			else {
1461				containment = this.containment;
1462			}
1463
1464				if(event.pageX - this.offset.click.left < containment[0]) {
1465					pageX = containment[0] + this.offset.click.left;
1466				}
1467				if(event.pageY - this.offset.click.top < containment[1]) {
1468					pageY = containment[1] + this.offset.click.top;
1469				}
1470				if(event.pageX - this.offset.click.left > containment[2]) {
1471					pageX = containment[2] + this.offset.click.left;
1472				}
1473				if(event.pageY - this.offset.click.top > containment[3]) {
1474					pageY = containment[3] + this.offset.click.top;
1475				}
1476			}
1477
1478			if(o.grid) {
1479				//Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
1480				top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
1481				pageY = containment ? ((top - this.offset.click.top >= containment[1] || top - this.offset.click.top > containment[3]) ? top : ((top - this.offset.click.top >= containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
1482
1483				left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
1484				pageX = containment ? ((left - this.offset.click.left >= containment[0] || left - this.offset.click.left > containment[2]) ? left : ((left - this.offset.click.left >= containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
1485			}
1486
1487		}
1488
1489		return {
1490			top: (
1491				pageY -																	// The absolute mouse position
1492				this.offset.click.top	-												// Click offset (relative to the element)
1493				this.offset.relative.top -												// Only for relative positioned nodes: Relative offset from element to offset parent
1494				this.offset.parent.top +												// The offsetParent's offset without borders (offset + border)
1495				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
1496			),
1497			left: (
1498				pageX -																	// The absolute mouse position
1499				this.offset.click.left -												// Click offset (relative to the element)
1500				this.offset.relative.left -												// Only for relative positioned nodes: Relative offset from element to offset parent
1501				this.offset.parent.left +												// The offsetParent's offset without borders (offset + border)
1502				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
1503			)
1504		};
1505
1506	},
1507
1508	_clear: function() {
1509		this.helper.removeClass("ui-draggable-dragging");
1510		if(this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
1511			this.helper.remove();
1512		}
1513		this.helper = null;
1514		this.cancelHelperRemoval = false;

1830				continue;
1831			}
1832
1833			if(o.snapMode !== "inner") {
1834				ts = Math.abs(t - y2) <= d;
1835				bs = Math.abs(b - y1) <= d;
1836				ls = Math.abs(l - x2) <= d;
1837				rs = Math.abs(r - x1) <= d;
1838				if(ts) {
1839					ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1840				}
1841				if(bs) {
1842					ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
1843				}
1844				if(ls) {
1845					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
1846				}
1847				if(rs) {
1848					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
1849				}
1850			}
1851
1852			first = (ts || bs || ls || rs);
1853
1854			if(o.snapMode !== "outer") {
1855				ts = Math.abs(t - y1) <= d;
1856				bs = Math.abs(b - y2) <= d;
1857				ls = Math.abs(l - x1) <= d;
1858				rs = Math.abs(r - x2) <= d;
1859				if(ts) {
1860					ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
1861				}
1862				if(bs) {
1863					ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1864				}
1865				if(ls) {
1866					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
1867				}
1868				if(rs) {
1869					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
1870				}
1871			}
1872
1873			if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
1874				(inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1875			}
1876			inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
1877
1878		}
1879
1880	}
1881});
1882
1883$.ui.plugin.add("draggable", "stack", {
1884	start: function() {
1885		var min,
1886			o = this.data("ui-draggable").options,
1887			group = $.makeArray($(o.stack)).sort(function(a,b) {
1888				return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
1889			});
1890
1891		if (!group.length) { return; }
1892
1893		min = parseInt($(group[0]).css("zIndex"), 10) || 0;
1894		$(group).each(function(i) {
1895			$(this).css("zIndex", min + i);
1896		});
1897		this.css("zIndex", (min + group.length));
1898	}
1899});
1900
1901$.ui.plugin.add("draggable", "zIndex", {
1902	start: function(event, ui) {
1903		var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1904		if(t.css("zIndex")) {
1905			o._zIndex = t.css("zIndex");
1906		}
1907		t.css("zIndex", o.zIndex);
1908	},
1909	stop: function(event, ui) {
1910		var o = $(this).data("ui-draggable").options;
1911		if(o._zIndex) {
1912			$(ui.helper).css("zIndex", o._zIndex);
1913		}
1914	}
1915});
1916
1917})(jQuery);
1918
1919(function( $, undefined ) {
1920
1921function isOverAxis( x, reference, size ) {
1922	return ( x > reference ) && ( x < ( reference + size ) );
1923}
1924
1925$.widget("ui.droppable", {
1926	version: "1.10.1",
1927	widgetEventPrefix: "drop",
1928	options: {
1929		accept: "*",
1930		activeClass: false,
1931		addClasses: true,
1932		greedy: false,
1933		hoverClass: false,
1934		scope: "default",
1935		tolerance: "intersect",
1936
1937		// callbacks
1938		activate: null,
1939		deactivate: null,
1940		drop: null,
1941		out: null,
1942		over: null
1943	},
1944	_create: function() {
1945
1946		var o = this.options,
1947			accept = o.accept;
1948
1949		this.isover = false;
1950		this.isout = true;
1951
1952		this.accept = $.isFunction(accept) ? accept : function(d) {
1953			return d.is(accept);
1954		};
1955
1956		//Store the droppable's proportions
1957		this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
1958
1959		// Add the reference and positions to the manager
1960		$.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
1961		$.ui.ddmanager.droppables[o.scope].push(this);
1962
1963		(o.addClasses && this.element.addClass("ui-droppable"));
1964
1965	},
1966
1967	_destroy: function() {
1968		var i = 0,
1969			drop = $.ui.ddmanager.droppables[this.options.scope];
1970
1971		for ( ; i < drop.length; i++ ) {
1972			if ( drop[i] === this ) {
1973				drop.splice(i, 1);
1974			}
1975		}
1976
1977		this.element.removeClass("ui-droppable ui-droppable-disabled");
1978	},
1979
1980	_setOption: function(key, value) {
1981
1982		if(key === "accept") {
1983			this.accept = $.isFunction(value) ? value : function(d) {
1984				return d.is(value);
1985			};
1986		}
1987		$.Widget.prototype._setOption.apply(this, arguments);
1988	},
1989
1990	_activate: function(event) {
1991		var draggable = $.ui.ddmanager.current;
1992		if(this.options.activeClass) {
1993			this.element.addClass(this.options.activeClass);
1994		}
1995		if(draggable){
1996			this._trigger("activate", event, this.ui(draggable));
1997		}
1998	},
1999
2000	_deactivate: function(event) {
2001		var draggable = $.ui.ddmanager.current;
2002		if(this.options.activeClass) {
2003			this.element.removeClass(this.options.activeClass);
2004		}
2005		if(draggable){
2006			this._trigger("deactivate", event, this.ui(draggable));
2007		}
2008	},
2009
2010	_over: function(event) {
2011
2012		var draggable = $.ui.ddmanager.current;
2013
2014		// Bail if draggable and droppable are same element
2015		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2016			return;
2017		}
2018
2019		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2020			if(this.options.hoverClass) {
2021				this.element.addClass(this.options.hoverClass);
2022			}
2023			this._trigger("over", event, this.ui(draggable));
2024		}
2025
2026	},
2027
2028	_out: function(event) {
2029
2030		var draggable = $.ui.ddmanager.current;
2031
2032		// Bail if draggable and droppable are same element
2033		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2034			return;
2035		}
2036
2037		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2038			if(this.options.hoverClass) {
2039				this.element.removeClass(this.options.hoverClass);
2040			}
2041			this._trigger("out", event, this.ui(draggable));
2042		}
2043
2044	},
2045
2046	_drop: function(event,custom) {
2047
2048		var draggable = custom || $.ui.ddmanager.current,
2049			childrenIntersection = false;
2050
2051		// Bail if draggable and droppable are same element
2052		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2053			return false;
2054		}
2055
2056		this.element.find(":data(ui-droppable)").not(".ui-draggable-dragging").each(function() {
2057			var inst = $.data(this, "ui-droppable");
2058			if(
2059				inst.options.greedy &&
2060				!inst.options.disabled &&
2061				inst.options.scope === draggable.options.scope &&
2062				inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element)) &&
2063				$.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
2064			) { childrenIntersection = true; return false; }
2065		});
2066		if(childrenIntersection) {
2067			return false;
2068		}
2069
2070		if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2071			if(this.options.activeClass) {
2072				this.element.removeClass(this.options.activeClass);
2073			}
2074			if(this.options.hoverClass) {
2075				this.element.removeClass(this.options.hoverClass);
2076			}
2077			this._trigger("drop", event, this.ui(draggable));
2078			return this.element;
2079		}
2080
2081		return false;
2082
2083	},
2084
2085	ui: function(c) {
2086		return {
2087			draggable: (c.currentItem || c.element),
2088			helper: c.helper,
2089			position: c.position,
2090			offset: c.positionAbs
2091		};
2092	}
2093
2094});
2095
2096$.ui.intersect = function(draggable, droppable, toleranceMode) {
2097
2098	if (!droppable.offset) {
2099		return false;
2100	}
2101
2102	var draggableLeft, draggableTop,
2103		x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
2104		y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height,
2105		l = droppable.offset.left, r = l + droppable.proportions.width,
2106		t = droppable.offset.top, b = t + droppable.proportions.height;
2107
2108	switch (toleranceMode) {
2109		case "fit":
2110			return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
2111		case "intersect":
2112			return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
2113				x2 - (draggable.helperProportions.width / 2) < r && // Left Half
2114				t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
2115				y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
2116		case "pointer":
2117			draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left);
2118			draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top);
2119			return isOverAxis( draggableTop, t, droppable.proportions.height ) && isOverAxis( draggableLeft, l, droppable.proportions.width );
2120		case "touch":
2121			return (
2122				(y1 >= t && y1 <= b) ||	// Top edge touching
2123				(y2 >= t && y2 <= b) ||	// Bottom edge touching
2124				(y1 < t && y2 > b)		// Surrounded vertically
2125			) && (
2126				(x1 >= l && x1 <= r) ||	// Left edge touching
2127				(x2 >= l && x2 <= r) ||	// Right edge touching
2128				(x1 < l && x2 > r)		// Surrounded horizontally
2129			);
2130		default:
2131			return false;
2132		}
2133
2134};
2135
2136/*
2137	This manager tracks offsets of draggables and droppables
2138*/
2139$.ui.ddmanager = {
2140	current: null,
2141	droppables: { "default": [] },
2142	prepareOffsets: function(t, event) {
2143
2144		var i, j,
2145			m = $.ui.ddmanager.droppables[t.options.scope] || [],
2146			type = event ? event.type : null, // workaround for #2317
2147			list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
2148
2149		droppablesLoop: for (i = 0; i < m.length; i++) {
2150
2151			//No disabled and non-accepted
2152			if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) {
2153				continue;
2154			}
2155
2156			// Filter out elements in the current dragged item
2157			for (j=0; j < list.length; j++) {
2158				if(list[j] === m[i].element[0]) {
2159					m[i].proportions.height = 0;
2160					continue droppablesLoop;
2161				}
2162			}
2163
2164			m[i].visible = m[i].element.css("display") !== "none";
2165			if(!m[i].visible) {
2166				continue;
2167			}
2168
2169			//Activate the droppable if used directly from draggables
2170			if(type === "mousedown") {
2171				m[i]._activate.call(m[i], event);
2172			}
2173
2174			m[i].offset = m[i].element.offset();
2175			m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
2176
2177		}
2178
2179	},
2180	drop: function(draggable, event) {
2181
2182		var dropped = false;
2183		$.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
2184
2185			if(!this.options) {
2186				return;
2187			}
2188			if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
2189				dropped = this._drop.call(this, event) || dropped;
2190			}
2191
2192			if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2193				this.isout = true;
2194				this.isover = false;
2195				this._deactivate.call(this, event);
2196			}
2197
2198		});
2199		return dropped;
2200
2201	},
2202	dragStart: function( draggable, event ) {
2203		//Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
2204		draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
2205			if( !draggable.options.refreshPositions ) {
2206				$.ui.ddmanager.prepareOffsets( draggable, event );
2207			}
2208		});
2209	},
2210	drag: function(draggable, event) {
2211
2212		//If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
2213		if(draggable.options.refreshPositions) {
2214			$.ui.ddmanager.prepareOffsets(draggable, event);
2215		}
2216
2217		//Run through all droppables and check their positions based on specific tolerance options
2218		$.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
2219
2220			if(this.options.disabled || this.greedyChild || !this.visible) {
2221				return;
2222			}
2223
2224			var parentInstance, scope, parent,
2225				intersects = $.ui.intersect(draggable, this, this.options.tolerance),
2226				c = !intersects && this.isover ? "isout" : (intersects && !this.isover ? "isover" : null);
2227			if(!c) {
2228				return;
2229			}
2230
2231			if (this.options.greedy) {
2232				// find droppable parents with same scope
2233				scope = this.options.scope;
2234				parent = this.element.parents(":data(ui-droppable)").filter(function () {
2235					return $.data(this, "ui-droppable").options.scope === scope;
2236				});
2237
2238				if (parent.length) {
2239					parentInstance = $.data(parent[0], "ui-droppable");
2240					parentInstance.greedyChild = (c === "isover");
2241				}
2242			}
2243
2244			// we just moved into a greedy child
2245			if (parentInstance && c === "isover") {
2246				parentInstance.isover = false;
2247				parentInstance.isout = true;
2248				parentInstance._out.call(parentInstance, event);
2249			}
2250
2251			this[c] = true;
2252			this[c === "isout" ? "isover" : "isout"] = false;
2253			this[c === "isover" ? "_over" : "_out"].call(this, event);
2254
2255			// we just moved out of a greedy child
2256			if (parentInstance && c === "isout") {
2257				parentInstance.isout = false;
2258				parentInstance.isover = true;
2259				parentInstance._over.call(parentInstance, event);
2260			}
2261		});
2262
2263	},
2264	dragStop: function( draggable, event ) {
2265		draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
2266		//Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
2267		if( !draggable.options.refreshPositions ) {
2268			$.ui.ddmanager.prepareOffsets( draggable, event );
2269		}
2270	}
2271};
2272
2273})(jQuery);
2274
2275(function( $, undefined ) {
2276
2277function num(v) {
2278	return parseInt(v, 10) || 0;
2279}
2280
2281function isNumber(value) {
2282	return !isNaN(parseInt(value, 10));
2283}
2284
2285$.widget("ui.resizable", $.ui.mouse, {
2286	version: "1.10.1",
2287	widgetEventPrefix: "resize",
2288	options: {
2289		alsoResize: false,
2290		animate: false,
2291		animateDuration: "slow",
2292		animateEasing: "swing",
2293		aspectRatio: false,
2294		autoHide: false,
2295		containment: false,
2296		ghost: false,
2297		grid: false,
2298		handles: "e,s,se",
2299		helper: false,
2300		maxHeight: null,
2301		maxWidth: null,
2302		minHeight: 10,
2303		minWidth: 10,
2304		// See #7960
2305		zIndex: 90,
2306
2307		// callbacks
2308		resize: null,
2309		start: null,
2310		stop: null
2311	},
2312	_create: function() {
2313
2314		var n, i, handle, axis, hname,
2315			that = this,
2316			o = this.options;
2317		this.element.addClass("ui-resizable");
2318
2319		$.extend(this, {
2320			_aspectRatio: !!(o.aspectRatio),
2321			aspectRatio: o.aspectRatio,
2322			originalElement: this.element,
2323			_proportionallyResizeElements: [],
2324			_helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
2325		});
2326
2327		//Wrap the element if it cannot hold child nodes
2328		if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
2329
2330			//Create a wrapper element and set the wrapper to the new current internal element
2331			this.element.wrap(
2332				$("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
2333					position: this.element.css("position"),
2334					width: this.element.outerWidth(),
2335					height: this.element.outerHeight(),
2336					top: this.element.css("top"),
2337					left: this.element.css("left")
2338				})
2339			);
2340
2341			//Overwrite the original this.element
2342			this.element = this.element.parent().data(
2343				"ui-resizable", this.element.data("ui-resizable")
2344			);
2345
2346			this.elementIsWrapper = true;
2347
2348			//Move margins to the wrapper
2349			this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
2350			this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
2351
2352			//Prevent Safari textarea resize
2353			this.originalResizeStyle = this.originalElement.css("resize");
2354			this.originalElement.css("resize", "none");
2355
2356			//Push the actual element to our proportionallyResize internal array
2357			this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
2358
2359			// avoid IE jump (hard set the margin)
2360			this.originalElement.css({ margin: this.originalElement.css("margin") });
2361
2362			// fix handlers offset
2363			this._proportionallyResize();
2364
2365		}
2366
2367		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" });
2368		if(this.handles.constructor === String) {
2369
2370			if ( this.handles === "all") {
2371				this.handles = "n,e,s,w,se,sw,ne,nw";
2372			}
2373
2374			n = this.handles.split(",");
2375			this.handles = {};
2376
2377			for(i = 0; i < n.length; i++) {
2378
2379				handle = $.trim(n[i]);
2380				hname = "ui-resizable-"+handle;
2381				axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
2382
2383				// Apply zIndex to all handles - see #7960
2384				axis.css({ zIndex: o.zIndex });
2385
2386				//TODO : What's going on here?
2387				if ("se" === handle) {
2388					axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
2389				}
2390
2391				//Insert into internal handles object and append to element
2392				this.handles[handle] = ".ui-resizable-"+handle;
2393				this.element.append(axis);
2394			}
2395
2396		}
2397
2398		this._renderAxis = function(target) {
2399
2400			var i, axis, padPos, padWrapper;
2401
2402			target = target || this.element;
2403
2404			for(i in this.handles) {
2405
2406				if(this.handles[i].constructor === String) {
2407					this.handles[i] = $(this.handles[i], this.element).show();
2408				}
2409
2410				//Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
2411				if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
2412
2413					axis = $(this.handles[i], this.element);
2414
2415					//Checking the correct pad and border
2416					padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
2417
2418					//The padding type i have to apply...
2419					padPos = [ "padding",
2420						/ne|nw|n/.test(i) ? "Top" :
2421						/se|sw|s/.test(i) ? "Bottom" :
2422						/^e$/.test(i) ? "Right" : "Left" ].join("");
2423
2424					target.css(padPos, padWrapper);
2425
2426					this._proportionallyResize();
2427
2428				}
2429
2430				//TODO: What's that good for? There's not anything to be executed left
2431				if(!$(this.handles[i]).length) {
2432					continue;
2433				}
2434			}
2435		};
2436
2437		//TODO: make renderAxis a prototype function
2438		this._renderAxis(this.element);
2439
2440		this._handles = $(".ui-resizable-handle", this.element)
2441			.disableSelection();
2442
2443		//Matching axis name
2444		this._handles.mouseover(function() {
2445			if (!that.resizing) {
2446				if (this.className) {
2447					axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
2448				}
2449				//Axis, default = se
2450				that.axis = axis && axis[1] ? axis[1] : "se";
2451			}
2452		});
2453
2454		//If we want to auto hide the elements
2455		if (o.autoHide) {
2456			this._handles.hide();
2457			$(this.element)
2458				.addClass("ui-resizable-autohide")
2459				.mouseenter(function() {
2460					if (o.disabled) {
2461						return;
2462					}
2463					$(this).removeClass("ui-resizable-autohide");
2464					that._handles.show();
2465				})
2466				.mouseleave(function(){
2467					if (o.disabled) {
2468						return;
2469					}
2470					if (!that.resizing) {
2471						$(this).addClass("ui-resizable-autohide");
2472						that._handles.hide();
2473					}
2474				});
2475		}
2476
2477		//Initialize the mouse interaction
2478		this._mouseInit();
2479
2480	},
2481
2482	_destroy: function() {
2483
2484		this._mouseDestroy();
2485
2486		var wrapper,
2487			_destroy = function(exp) {
2488				$(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
2489					.removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
2490			};
2491
2492		//TODO: Unwrap at same DOM position
2493		if (this.elementIsWrapper) {
2494			_destroy(this.element);
2495			wrapper = this.element;
2496			this.originalElement.css({
2497				position: wrapper.css("position"),
2498				width: wrapper.outerWidth(),
2499				height: wrapper.outerHeight(),
2500				top: wrapper.css("top"),
2501				left: wrapper.css("left")
2502			}).insertAfter( wrapper );
2503			wrapper.remove();
2504		}
2505
2506		this.originalElement.css("resize", this.originalResizeStyle);
2507		_destroy(this.originalElement);
2508
2509		return this;
2510	},
2511
2512	_mouseCapture: function(event) {
2513		var i, handle,
2514			capture = false;
2515
2516		for (i in this.handles) {
2517			handle = $(this.handles[i])[0];
2518			if (handle === event.target || $.contains(handle, event.target)) {
2519				capture = true;
2520			}
2521		}
2522
2523		return !this.options.disabled && capture;
2524	},
2525
2526	_mouseStart: function(event) {
2527
2528		var curleft, curtop, cursor,
2529			o = this.options,
2530			iniPos = this.element.position(),
2531			el = this.element;
2532
2533		this.resizing = true;
2534
2535		// bugfix for http://dev.jquery.com/ticket/1749
2536		if ( (/absolute/).test( el.css("position") ) ) {
2537			el.css({ position: "absolute", top: el.css("top"), left: el.css("left") });
2538		} else if (el.is(".ui-draggable")) {
2539			el.css({ position: "absolute", top: iniPos.top, left: iniPos.left });
2540		}
2541
2542		this._renderProxy();
2543
2544		curleft = num(this.helper.css("left"));
2545		curtop = num(this.helper.css("top"));
2546
2547		if (o.containment) {
2548			curleft += $(o.containment).scrollLeft() || 0;
2549			curtop += $(o.containment).scrollTop() || 0;
2550		}
2551
2552		//Store needed variables
2553		this.offset = this.helper.offset();
2554		this.position = { left: curleft, top: curtop };
2555		this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2556		this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2557		this.originalPosition = { left: curleft, top: curtop };
2558		this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
2559		this.originalMousePosition = { left: event.pageX, top: event.pageY };
2560
2561		//Aspect Ratio
2562		this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
2563
2564		cursor = $(".ui-resizable-" + this.axis).css("cursor");
2565		$("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
2566
2567		el.addClass("ui-resizable-resizing");
2568		this._propagate("start", event);
2569		return true;
2570	},
2571
2572	_mouseDrag: function(event) {
2573
2574		//Increase performance, avoid regex
2575		var data,
2576			el = this.helper, props = {},
2577			smp = this.originalMousePosition,
2578			a = this.axis,
2579			prevTop = this.position.top,
2580			prevLeft = this.position.left,
2581			prevWidth = this.size.width,
2582			prevHeight = this.size.height,
2583			dx = (event.pageX-smp.left)||0,
2584			dy = (event.pageY-smp.top)||0,
2585			trigger = this._change[a];
2586
2587		if (!trigger) {
2588			return false;
2589		}
2590
2591		// Calculate the attrs that will be change
2592		data = trigger.apply(this, [event, dx, dy]);
2593
2594		// Put this in the mouseDrag handler since the user can start pressing shift while resizing
2595		this._updateVirtualBoundaries(event.shiftKey);
2596		if (this._aspectRatio || event.shiftKey) {
2597			data = this._updateRatio(data, event);
2598		}
2599
2600		data = this._respectSize(data, event);
2601
2602		this._updateCache(data);
2603
2604		// plugins callbacks need to be called first
2605		this._propagate("resize", event);
2606
2607		if (this.position.top !== prevTop) {
2608			props.top = this.position.top + "px";
2609		}
2610		if (this.position.left !== prevLeft) {
2611			props.left = this.position.left + "px";
2612		}
2613		if (this.size.width !== prevWidth) {
2614			props.width = this.size.width + "px";
2615		}
2616		if (this.size.height !== prevHeight) {
2617			props.height = this.size.height + "px";
2618		}
2619		el.css(props);
2620
2621		if (!this._helper && this._proportionallyResizeElements.length) {
2622			this._proportionallyResize();
2623		}
2624
2625		// Call the user callback if the element was resized
2626		if ( ! $.isEmptyObject(props) ) {
2627			this._trigger("resize", event, this.ui());
2628		}
2629
2630		return false;
2631	},
2632
2633	_mouseStop: function(event) {
2634
2635		this.resizing = false;
2636		var pr, ista, soffseth, soffsetw, s, left, top,
2637			o = this.options, that = this;
2638
2639		if(this._helper) {
2640
2641			pr = this._proportionallyResizeElements;
2642			ista = pr.length && (/textarea/i).test(pr[0].nodeName);
2643			soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
2644			soffsetw = ista ? 0 : that.sizeDiff.width;
2645
2646			s = { width: (that.helper.width()  - soffsetw), height: (that.helper.height() - soffseth) };
2647			left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
2648			top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2649
2650			if (!o.animate) {
2651				this.element.css($.extend(s, { top: top, left: left }));
2652			}
2653
2654			that.helper.height(that.size.height);
2655			that.helper.width(that.size.width);
2656
2657			if (this._helper && !o.animate) {
2658				this._proportionallyResize();
2659			}
2660		}
2661
2662		$("body").css("cursor", "auto");
2663
2664		this.element.removeClass("ui-resizable-resizing");
2665
2666		this._propagate("stop", event);
2667
2668		if (this._helper) {
2669			this.helper.remove();
2670		}
2671
2672		return false;
2673
2674	},
2675
2676	_updateVirtualBoundaries: function(forceAspectRatio) {
2677		var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
2678			o = this.options;
2679
2680		b = {
2681			minWidth: isNumber(o.minWidth) ? o.minWidth : 0,
2682			maxWidth: isNumber(o.maxWidth) ? o.maxWidth : Infinity,
2683			minHeight: isNumber(o.minHeight) ? o.minHeight : 0,
2684			maxHeight: isNumber(o.maxHeight) ? o.maxHeight : Infinity
2685		};
2686
2687		if(this._aspectRatio || forceAspectRatio) {
2688			// We want to create an enclosing box whose aspect ration is the requested one
2689			// First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
2690			pMinWidth = b.minHeight * this.aspectRatio;
2691			pMinHeight = b.minWidth / this.aspectRatio;
2692			pMaxWidth = b.maxHeight * this.aspectRatio;
2693			pMaxHeight = b.maxWidth / this.aspectRatio;
2694
2695			if(pMinWidth > b.minWidth) {
2696				b.minWidth = pMinWidth;
2697			}
2698			if(pMinHeight > b.minHeight) {
2699				b.minHeight = pMinHeight;
2700			}
2701			if(pMaxWidth < b.maxWidth) {
2702				b.maxWidth = pMaxWidth;
2703			}
2704			if(pMaxHeight < b.maxHeight) {
2705				b.maxHeight = pMaxHeight;
2706			}
2707		}
2708		this._vBoundaries = b;
2709	},
2710
2711	_updateCache: function(data) {
2712		this.offset = this.helper.offset();
2713		if (isNumber(data.left)) {
2714			this.position.left = data.left;
2715		}
2716		if (isNumber(data.top)) {
2717			this.position.top = data.top;
2718		}
2719		if (isNumber(data.height)) {
2720			this.size.height = data.height;
2721		}
2722		if (isNumber(data.width)) {
2723			this.size.width = data.width;
2724		}
2725	},
2726
2727	_updateRatio: function( data ) {
2728
2729		var cpos = this.position,
2730			csize = this.size,
2731			a = this.axis;
2732
2733		if (isNumber(data.height)) {
2734			data.width = (data.height * this.aspectRatio);
2735		} else if (isNumber(data.width)) {
2736			data.height = (data.width / this.aspectRatio);
2737		}
2738
2739		if (a === "sw") {
2740			data.left = cpos.left + (csize.width - data.width);
2741			data.top = null;
2742		}
2743		if (a === "nw") {
2744			data.top = cpos.top + (csize.height - data.height);
2745			data.left = cpos.left + (csize.width - data.width);
2746		}
2747
2748		return data;
2749	},
2750
2751	_respectSize: function( data ) {
2752
2753		var o = this._vBoundaries,
2754			a = this.axis,
2755			ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
2756			isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
2757			dw = this.originalPosition.left + this.originalSize.width,
2758			dh = this.position.top + this.size.height,
2759			cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
2760		if (isminw) {
2761			data.width = o.minWidth;
2762		}
2763		if (isminh) {
2764			data.height = o.minHeight;
2765		}
2766		if (ismaxw) {
2767			data.width = o.maxWidth;
2768		}
2769		if (ismaxh) {
2770			data.height = o.maxHeight;
2771		}
2772
2773		if (isminw && cw) {
2774			data.left = dw - o.minWidth;
2775		}
2776		if (ismaxw && cw) {
2777			data.left = dw - o.maxWidth;
2778		}
2779		if (isminh && ch) {
2780			data.top = dh - o.minHeight;
2781		}
2782		if (ismaxh && ch) {
2783			data.top = dh - o.maxHeight;
2784		}
2785
2786		// fixing jump error on top/left - bug #2330
2787		if (!data.width && !data.height && !data.left && data.top) {
2788			data.top = null;
2789		} else if (!data.width && !data.height && !data.top && data.left) {
2790			data.left = null;
2791		}
2792
2793		return data;
2794	},
2795
2796	_proportionallyResize: function() {
2797
2798		if (!this._proportionallyResizeElements.length) {
2799			return;
2800		}
2801
2802		var i, j, borders, paddings, prel,
2803			element = this.helper || this.element;
2804
2805		for ( i=0; i < this._proportionallyResizeElements.length; i++) {
2806
2807			prel = this._proportionallyResizeElements[i];
2808
2809			if (!this.borderDif) {
2810				this.borderDif = [];
2811				borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
2812				paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
2813
2814				for ( j = 0; j < borders.length; j++ ) {
2815					this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
2816				}
2817			}
2818
2819			prel.css({
2820				height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
2821				width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
2822			});
2823
2824		}
2825
2826	},
2827
2828	_renderProxy: function() {
2829
2830		var el = this.element, o = this.options;
2831		this.elementOffset = el.offset();
2832
2833		if(this._helper) {
2834
2835			this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
2836
2837			this.helper.addClass(this._helper).css({
2838				width: this.element.outerWidth() - 1,
2839				height: this.element.outerHeight() - 1,
2840				position: "absolute",
2841				left: this.elementOffset.left +"px",
2842				top: this.elementOffset.top +"px",
2843				zIndex: ++o.zIndex //TODO: Don't modify option
2844			});
2845
2846			this.helper
2847				.appendTo("body")
2848				.disableSelection();
2849
2850		} else {
2851			this.helper = this.element;
2852		}
2853
2854	},
2855
2856	_change: {
2857		e: function(event, dx) {
2858			return { width: this.originalSize.width + dx };
2859		},
2860		w: function(event, dx) {
2861			var cs = this.originalSize, sp = this.originalPosition;
2862			return { left: sp.left + dx, width: cs.width - dx };
2863		},
2864		n: function(event, dx, dy) {
2865			var cs = this.originalSize, sp = this.originalPosition;
2866			return { top: sp.top + dy, height: cs.height - dy };
2867		},
2868		s: function(event, dx, dy) {
2869			return { height: this.originalSize.height + dy };
2870		},
2871		se: function(event, dx, dy) {
2872			return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2873		},
2874		sw: function(event, dx, dy) {
2875			return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2876		},
2877		ne: function(event, dx, dy) {
2878			return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2879		},
2880		nw: function(event, dx, dy) {
2881			return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2882		}
2883	},
2884
2885	_propagate: function(n, event) {
2886		$.ui.plugin.call(this, n, [event, this.ui()]);
2887		(n !== "resize" && this._trigger(n, event, this.ui()));
2888	},
2889
2890	plugins: {},
2891
2892	ui: function() {
2893		return {
2894			originalElement: this.originalElement,
2895			element: this.element,
2896			helper: this.helper,
2897			position: this.position,
2898			size: this.size,
2899			originalSize: this.originalSize,
2900			originalPosition: this.originalPosition
2901		};
2902	}
2903
2904});
2905
2906/*
2907 * Resizable Extensions
2908 */
2909
2910$.ui.plugin.add("resizable", "animate", {
2911
2912	stop: function( event ) {
2913		var that = $(this).data("ui-resizable"),
2914			o = that.options,
2915			pr = that._proportionallyResizeElements,
2916			ista = pr.length && (/textarea/i).test(pr[0].nodeName),
2917			soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
2918			soffsetw = ista ? 0 : that.sizeDiff.width,
2919			style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
2920			left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
2921			top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2922
2923		that.element.animate(
2924			$.extend(style, top && left ? { top: top, left: left } : {}), {
2925				duration: o.animateDuration,
2926				easing: o.animateEasing,
2927				step: function() {
2928
2929					var data = {
2930						width: parseInt(that.element.css("width"), 10),
2931						height: parseInt(that.element.css("height"), 10),
2932						top: parseInt(that.element.css("top"), 10),
2933						left: parseInt(that.element.css("left"), 10)
2934					};
2935
2936					if (pr && pr.length) {
2937						$(pr[0]).css({ width: data.width, height: data.height });
2938					}
2939
2940					// propagating resize, and updating values for each animation step
2941					that._updateCache(data);
2942					that._propagate("resize", event);
2943
2944				}
2945			}
2946		);
2947	}
2948
2949});
2950
2951$.ui.plugin.add("resizable", "containment", {
2952
2953	start: function() {
2954		var element, p, co, ch, cw, width, height,
2955			that = $(this).data("ui-resizable"),
2956			o = that.options,
2957			el = that.element,
2958			oc = o.containment,
2959			ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
2960
2961		if (!ce) {
2962			return;
2963		}
2964
2965		that.containerElement = $(ce);
2966
2967		if (/document/.test(oc) || oc === document) {
2968			that.containerOffset = { left: 0, top: 0 };
2969			that.containerPosition = { left: 0, top: 0 };
2970
2971			that.parentData = {