https://www.clickteam.com/wp-content/cache/wpfc-minified/1mvho338/3xclg.js

131		}
132		img = $( "img[usemap=#" + mapName + "]" )[0];
133		return !!img && visible( img );
134	}
135	return ( /input|select|textarea|button|object/.test( nodeName ) ?
136		!element.disabled :
137		"a" === nodeName ?
138			element.href || isTabIndexNotNaN :
139			isTabIndexNotNaN) &&
140		// the element and all of its ancestors must be visible
141		visible( element );
142}
143
144function visible( element ) {
145	return $.expr.filters.visible( element ) &&
146		!$( element ).parents().addBack().filter(function() {
147			return $.css( this, "visibility" ) === "hidden";
148		}).length;
149}
150
151$.extend( $.expr[ ":" ], {
152	data: $.expr.createPseudo ?
153		$.expr.createPseudo(function( dataName ) {
154			return function( elem ) {
155				return !!$.data( elem, dataName );
156			};
157		}) :
158		// support: jQuery <1.8
159		function( elem, i, match ) {
160			return !!$.data( elem, match[ 3 ] );
161		},
162
163	focusable: function( element ) {
164		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
165	},
166
167	tabbable: function( element ) {
168		var tabIndex = $.attr( element, "tabindex" ),
169			isTabIndexNaN = isNaN( tabIndex );
170		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
171	}
172});
173
174// support: jQuery <1.8
175if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
176	$.each( [ "Width", "Height" ], function( i, name ) {
177		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
178			type = name.toLowerCase(),
179			orig = {
180				innerWidth: $.fn.innerWidth,
181				innerHeight: $.fn.innerHeight,
182				outerWidth: $.fn.outerWidth,
183				outerHeight: $.fn.outerHeight
184			};
185
186		function reduce( elem, size, border, margin ) {
187			$.each( side, function() {
188				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
189				if ( border ) {
190					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
191				}
192				if ( margin ) {
193					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
194				}
195			});
196			return size;
197		}
198
199		$.fn[ "inner" + name ] = function( size ) {
200			if ( size === undefined ) {
201				return orig[ "inner" + name ].call( this );
202			}
203
204			return this.each(function() {
205				$( this ).css( type, reduce( this, size ) + "px" );
206			});
207		};
208
209		$.fn[ "outer" + name] = function( size, margin ) {
210			if ( typeof size !== "number" ) {
211				return orig[ "outer" + name ].call( this, size );
212			}
213
214			return this.each(function() {
215				$( this).css( type, reduce( this, size, true, margin ) + "px" );
216			});
217		};
218	});
219}
220
221// support: jQuery <1.8
222if ( !$.fn.addBack ) {
223	$.fn.addBack = function( selector ) {
224		return this.add( selector == null ?
225			this.prevObject : this.prevObject.filter( selector )
226		);
227	};
228}
229
230// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
231if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
232	$.fn.removeData = (function( removeData ) {
233		return function( key ) {
234			if ( arguments.length ) {
235				return removeData.call( this, $.camelCase( key ) );
236			} else {
237				return removeData.call( this );
238			}
239		};
240	})( $.fn.removeData );
241}
242
243
244
245
246
247// deprecated
248$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
249
250$.support.selectstart = "onselectstart" in document.createElement( "div" );
251$.fn.extend({
252	disableSelection: function() {
253		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
254			".ui-disableSelection", function( event ) {
255				event.preventDefault();
256			});
257	},
258
259	enableSelection: function() {
260		return this.unbind( ".ui-disableSelection" );
261	}
262});
263
264$.extend( $.ui, {
265	// $.ui.plugin is deprecated.  Use the proxy pattern instead.
266	plugin: {
267		add: function( module, option, set ) {
268			var i,
269				proto = $.ui[ module ].prototype;
270			for ( i in set ) {
271				proto.plugins[ i ] = proto.plugins[ i ] || [];
272				proto.plugins[ i ].push( [ option, set[ i ] ] );
273			}
274		},
275		call: function( instance, name, args ) {
276			var i,
277				set = instance.plugins[ name ];
278			if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
279				return;
280			}
281
282			for ( i = 0; i < set.length; i++ ) {
283				if ( instance.options[ set[ i ][ 0 ] ] ) {
284					set[ i ][ 1 ].apply( instance.element, args );
285				}
286			}
287		}
288	},
289
290	// only used by resizable
291	hasScroll: function( el, a ) {
292
293		//If overflow is hidden, the element might have extra content, but the user wants to hide it
294		if ( $( el ).css( "overflow" ) === "hidden") {
295			return false;
296		}
297
298		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
299			has = false;
300
301		if ( el[ scroll ] > 0 ) {
302			return true;
303		}
304
305		// TODO: determine which cases actually cause this to happen
306		// if the element doesn't have the scroll set, see if it's possible to
307		// set the scroll
308		el[ scroll ] = 1;
309		has = ( el[ scroll ] > 0 );
310		el[ scroll ] = 0;
311		return has;
312	}
313});
314
315})( jQuery );
316
317(function( $, undefined ) {
318
319var uuid = 0,
320	slice = Array.prototype.slice,
321	_cleanData = $.cleanData;
322$.cleanData = function( elems ) {
323	for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
324		try {
325			$( elem ).triggerHandler( "remove" );
326		// http://bugs.jquery.com/ticket/8235
327		} catch( e ) {}
328	}
329	_cleanData( elems );
330};
331
332$.widget = function( name, base, prototype ) {
333	var fullName, existingConstructor, constructor, basePrototype,
334		// proxiedPrototype allows the provided prototype to remain unmodified
335		// so that it can be used as a mixin for multiple widgets (#8876)
336		proxiedPrototype = {},
337		namespace = name.split( "." )[ 0 ];
338
339	name = name.split( "." )[ 1 ];
340	fullName = namespace + "-" + name;
341
342	if ( !prototype ) {
343		prototype = base;
344		base = $.Widget;
345	}
346
347	// create selector for plugin
348	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
349		return !!$.data( elem, fullName );
350	};
351
352	$[ namespace ] = $[ namespace ] || {};
353	existingConstructor = $[ namespace ][ name ];
354	constructor = $[ namespace ][ name ] = function( options, element ) {
355		// allow instantiation without "new" keyword
356		if ( !this._createWidget ) {
357			return new constructor( options, element );
358		}
359
360		// allow instantiation without initializing for simple inheritance
361		// must use "new" keyword (the code above always passes args)
362		if ( arguments.length ) {
363			this._createWidget( options, element );
364		}
365	};
366	// extend with the existing constructor to carry over any static properties
367	$.extend( constructor, existingConstructor, {
368		version: prototype.version,
369		// copy the object used to create the prototype in case we need to
370		// redefine the widget later
371		_proto: $.extend( {}, prototype ),
372		// track widgets that inherit from this widget in case this widget is
373		// redefined after a widget inherits from it
374		_childConstructors: []
375	});
376
377	basePrototype = new base();
378	// we need to make the options hash a property directly on the new instance
379	// otherwise we'll modify the options hash on the prototype that we're
380	// inheriting from
381	basePrototype.options = $.widget.extend( {}, basePrototype.options );
382	$.each( prototype, function( prop, value ) {
383		if ( !$.isFunction( value ) ) {
384			proxiedPrototype[ prop ] = value;
385			return;
386		}
387		proxiedPrototype[ prop ] = (function() {
388			var _super = function() {
389					return base.prototype[ prop ].apply( this, arguments );
390				},
391				_superApply = function( args ) {
392					return base.prototype[ prop ].apply( this, args );
393				};
394			return function() {
395				var __super = this._super,
396					__superApply = this._superApply,
397					returnValue;
398
399				this._super = _super;
400				this._superApply = _superApply;
401
402				returnValue = value.apply( this, arguments );
403
404				this._super = __super;
405				this._superApply = __superApply;
406
407				return returnValue;
408			};
409		})();
410	});
411	constructor.prototype = $.widget.extend( basePrototype, {
412		// TODO: remove support for widgetEventPrefix
413		// always use the name + a colon as the prefix, e.g., draggable:start
414		// don't prefix for widgets that aren't DOM-based
415		widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
416	}, proxiedPrototype, {
417		constructor: constructor,
418		namespace: namespace,
419		widgetName: name,
420		widgetFullName: fullName
421	});
422
423	// If this widget is being redefined then we need to find all widgets that
424	// are inheriting from it and redefine all of them so that they inherit from
425	// the new version of this widget. We're essentially trying to replace one
426	// level in the prototype chain.
427	if ( existingConstructor ) {
428		$.each( existingConstructor._childConstructors, function( i, child ) {
429			var childPrototype = child.prototype;
430
431			// redefine the child widget using the same prototype that was
432			// originally used, but inherit from the new version of the base
433			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
434		});
435		// remove the list of existing child constructors from the old constructor
436		// so the old child constructors can be garbage collected
437		delete existingConstructor._childConstructors;
438	} else {
439		base._childConstructors.push( constructor );
440	}
441
442	$.widget.bridge( name, constructor );
443};
444
445$.widget.extend = function( target ) {
446	var input = slice.call( arguments, 1 ),
447		inputIndex = 0,
448		inputLength = input.length,
449		key,
450		value;
451	for ( ; inputIndex < inputLength; inputIndex++ ) {
452		for ( key in input[ inputIndex ] ) {
453			value = input[ inputIndex ][ key ];
454			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
455				// Clone objects
456				if ( $.isPlainObject( value ) ) {
457					target[ key ] = $.isPlainObject( target[ key ] ) ?
458						$.widget.extend( {}, target[ key ], value ) :
459						// Don't extend strings, arrays, etc. with objects
460						$.widget.extend( {}, value );
461				// Copy everything else by reference
462				} else {
463					target[ key ] = value;
464				}
465			}
466		}
467	}
468	return target;
469};
470
471$.widget.bridge = function( name, object ) {
472	var fullName = object.prototype.widgetFullName || name;
473	$.fn[ name ] = function( options ) {
474		var isMethodCall = typeof options === "string",
475			args = slice.call( arguments, 1 ),
476			returnValue = this;
477
478		// allow multiple hashes to be passed on init
479		options = !isMethodCall && args.length ?
480			$.widget.extend.apply( null, [ options ].concat(args) ) :
481			options;
482
483		if ( isMethodCall ) {
484			this.each(function() {
485				var methodValue,
486					instance = $.data( this, fullName );
487				if ( !instance ) {
488					return $.error( "cannot call methods on " + name + " prior to initialization; " +
489						"attempted to call method '" + options + "'" );
490				}
491				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
492					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
493				}
494				methodValue = instance[ options ].apply( instance, args );
495				if ( methodValue !== instance && methodValue !== undefined ) {
496					returnValue = methodValue && methodValue.jquery ?
497						returnValue.pushStack( methodValue.get() ) :
498						methodValue;
499					return false;
500				}
501			});
502		} else {
503			this.each(function() {
504				var instance = $.data( this, fullName );
505				if ( instance ) {
506					instance.option( options || {} )._init();
507				} else {
508					$.data( this, fullName, new object( options, this ) );
509				}
510			});
511		}
512
513		return returnValue;
514	};
515};
516
517$.Widget = function( /* options, element */ ) {};
518$.Widget._childConstructors = [];
519
520$.Widget.prototype = {
521	widgetName: "widget",
522	widgetEventPrefix: "",
523	defaultElement: "<div>",
524	options: {
525		disabled: false,
526
527		// callbacks
528		create: null
529	},
530	_createWidget: function( options, element ) {
531		element = $( element || this.defaultElement || this )[ 0 ];
532		this.element = $( element );
533		this.uuid = uuid++;
534		this.eventNamespace = "." + this.widgetName + this.uuid;
535		this.options = $.widget.extend( {},
536			this.options,
537			this._getCreateOptions(),
538			options );
539
540		this.bindings = $();
541		this.hoverable = $();
542		this.focusable = $();
543
544		if ( element !== this ) {
545			$.data( element, this.widgetFullName, this );
546			this._on( true, this.element, {
547				remove: function( event ) {
548					if ( event.target === element ) {
549						this.destroy();
550					}
551				}
552			});
553			this.document = $( element.style ?
554				// element within the document
555				element.ownerDocument :
556				// element is window or document
557				element.document || element );
558			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
559		}
560
561		this._create();
562		this._trigger( "create", null, this._getCreateEventData() );
563		this._init();
564	},
565	_getCreateOptions: $.noop,
566	_getCreateEventData: $.noop,
567	_create: $.noop,
568	_init: $.noop,
569
570	destroy: function() {
571		this._destroy();
572		// we can probably remove the unbind calls in 2.0
573		// all event bindings should go through this._on()
574		this.element
575			.unbind( this.eventNamespace )
576			// 1.9 BC for #7810
577			// TODO remove dual storage
578			.removeData( this.widgetName )
579			.removeData( this.widgetFullName )
580			// support: jquery <1.6.3
581			// http://bugs.jquery.com/ticket/9413
582			.removeData( $.camelCase( this.widgetFullName ) );
583		this.widget()
584			.unbind( this.eventNamespace )
585			.removeAttr( "aria-disabled" )
586			.removeClass(
587				this.widgetFullName + "-disabled " +
588				"ui-state-disabled" );
589
590		// clean up events and states
591		this.bindings.unbind( this.eventNamespace );
592		this.hoverable.removeClass( "ui-state-hover" );
593		this.focusable.removeClass( "ui-state-focus" );
594	},
595	_destroy: $.noop,
596
597	widget: function() {
598		return this.element;
599	},
600
601	option: function( key, value ) {
602		var options = key,
603			parts,
604			curOption,
605			i;
606
607		if ( arguments.length === 0 ) {
608			// don't return a reference to the internal hash
609			return $.widget.extend( {}, this.options );
610		}
611
612		if ( typeof key === "string" ) {
613			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
614			options = {};
615			parts = key.split( "." );
616			key = parts.shift();
617			if ( parts.length ) {
618				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
619				for ( i = 0; i < parts.length - 1; i++ ) {
620					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
621					curOption = curOption[ parts[ i ] ];
622				}
623				key = parts.pop();
624				if ( value === undefined ) {
625					return curOption[ key ] === undefined ? null : curOption[ key ];
626				}
627				curOption[ key ] = value;
628			} else {
629				if ( value === undefined ) {
630					return this.options[ key ] === undefined ? null : this.options[ key ];
631				}
632				options[ key ] = value;
633			}
634		}
635
636		this._setOptions( options );
637
638		return this;
639	},
640	_setOptions: function( options ) {
641		var key;
642
643		for ( key in options ) {
644			this._setOption( key, options[ key ] );
645		}
646
647		return this;
648	},
649	_setOption: function( key, value ) {
650		this.options[ key ] = value;
651
652		if ( key === "disabled" ) {
653			this.widget()
654				.toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
655				.attr( "aria-disabled", value );
656			this.hoverable.removeClass( "ui-state-hover" );
657			this.focusable.removeClass( "ui-state-focus" );
658		}
659
660		return this;
661	},
662
663	enable: function() {
664		return this._setOption( "disabled", false );
665	},
666	disable: function() {
667		return this._setOption( "disabled", true );
668	},
669
670	_on: function( suppressDisabledCheck, element, handlers ) {
671		var delegateElement,
672			instance = this;
673
674		// no suppressDisabledCheck flag, shuffle arguments
675		if ( typeof suppressDisabledCheck !== "boolean" ) {
676			handlers = element;
677			element = suppressDisabledCheck;
678			suppressDisabledCheck = false;
679		}
680
681		// no element argument, shuffle and use this.element
682		if ( !handlers ) {
683			handlers = element;
684			element = this.element;
685			delegateElement = this.widget();
686		} else {
687			// accept selectors, DOM elements
688			element = delegateElement = $( element );
689			this.bindings = this.bindings.add( element );
690		}
691
692		$.each( handlers, function( event, handler ) {
693			function handlerProxy() {
694				// allow widgets to customize the disabled handling
695				// - disabled as an array instead of boolean
696				// - disabled class as method for disabling individual parts
697				if ( !suppressDisabledCheck &&
698						( instance.options.disabled === true ||
699							$( this ).hasClass( "ui-state-disabled" ) ) ) {
700					return;
701				}
702				return ( typeof handler === "string" ? instance[ handler ] : handler )
703					.apply( instance, arguments );
704			}
705
706			// copy the guid so direct unbinding works
707			if ( typeof handler !== "string" ) {
708				handlerProxy.guid = handler.guid =
709					handler.guid || handlerProxy.guid || $.guid++;
710			}
711
712			var match = event.match( /^(\w+)\s*(.*)$/ ),
713				eventName = match[1] + instance.eventNamespace,
714				selector = match[2];
715			if ( selector ) {
716				delegateElement.delegate( selector, eventName, handlerProxy );
717			} else {
718				element.bind( eventName, handlerProxy );
719			}
720		});
721	},
722
723	_off: function( element, eventName ) {
724		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
725		element.unbind( eventName ).undelegate( eventName );
726	},
727
728	_delay: function( handler, delay ) {
729		function handlerProxy() {
730			return ( typeof handler === "string" ? instance[ handler ] : handler )
731				.apply( instance, arguments );
732		}
733		var instance = this;
734		return setTimeout( handlerProxy, delay || 0 );
735	},
736
737	_hoverable: function( element ) {
738		this.hoverable = this.hoverable.add( element );
739		this._on( element, {
740			mouseenter: function( event ) {
741				$( event.currentTarget ).addClass( "ui-state-hover" );
742			},
743			mouseleave: function( event ) {
744				$( event.currentTarget ).removeClass( "ui-state-hover" );
745			}
746		});
747	},
748
749	_focusable: function( element ) {
750		this.focusable = this.focusable.add( element );
751		this._on( element, {
752			focusin: function( event ) {
753				$( event.currentTarget ).addClass( "ui-state-focus" );
754			},
755			focusout: function( event ) {
756				$( event.currentTarget ).removeClass( "ui-state-focus" );
757			}
758		});
759	},
760
761	_trigger: function( type, event, data ) {
762		var prop, orig,
763			callback = this.options[ type ];
764
765		data = data || {};
766		event = $.Event( event );
767		event.type = ( type === this.widgetEventPrefix ?
768			type :
769			this.widgetEventPrefix + type ).toLowerCase();
770		// the original event may come from any element
771		// so we need to reset the target on the new event
772		event.target = this.element[ 0 ];
773
774		// copy original event properties over to the new event
775		orig = event.originalEvent;
776		if ( orig ) {
777			for ( prop in orig ) {
778				if ( !( prop in event ) ) {
779					event[ prop ] = orig[ prop ];
780				}
781			}
782		}
783
784		this.element.trigger( event, data );
785		return !( $.isFunction( callback ) &&
786			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
787			event.isDefaultPrevented() );
788	}
789};
790
791$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
792	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
793		if ( typeof options === "string" ) {
794			options = { effect: options };
795		}
796		var hasOptions,
797			effectName = !options ?
798				method :
799				options === true || typeof options === "number" ?
800					defaultEffect :
801					options.effect || defaultEffect;
802		options = options || {};
803		if ( typeof options === "number" ) {
804			options = { duration: options };
805		}
806		hasOptions = !$.isEmptyObject( options );
807		options.complete = callback;
808		if ( options.delay ) {
809			element.delay( options.delay );
810		}
811		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
812			element[ method ]( options );
813		} else if ( effectName !== method && element[ effectName ] ) {
814			element[ effectName ]( options.duration, options.easing, callback );
815		} else {
816			element.queue(function( next ) {
817				$( this )[ method ]();
818				if ( callback ) {
819					callback.call( element[ 0 ] );
820				}
821				next();
822			});
823		}
824	};
825});
826
827})( jQuery );
828
829(function( $, undefined ) {
830
831var mouseHandled = false;
832$( document ).mouseup( function() {
833	mouseHandled = false;
834});
835
836$.widget("ui.mouse", {
837	version: "1.10.2",
838	options: {
839		cancel: "input,textarea,button,select,option",
840		distance: 1,
841		delay: 0
842	},
843	_mouseInit: function() {
844		var that = this;
845
846		this.element
847			.bind("mousedown."+this.widgetName, function(event) {
848				return that._mouseDown(event);
849			})
850			.bind("click."+this.widgetName, function(event) {
851				if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
852					$.removeData(event.target, that.widgetName + ".preventClickEvent");
853					event.stopImmediatePropagation();
854					return false;
855				}
856			});
857
858		this.started = false;
859	},
860
861	// TODO: make sure destroying one instance of mouse doesn't mess with
862	// other instances of mouse
863	_mouseDestroy: function() {
864		this.element.unbind("."+this.widgetName);
865		if ( this._mouseMoveDelegate ) {
866			$(document)
867				.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
868				.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
869		}
870	},
871
872	_mouseDown: function(event) {
873		// don't let more than one widget handle mouseStart
874		if( mouseHandled ) { return; }
875
876		// we may have missed mouseup (out of window)
877		(this._mouseStarted && this._mouseUp(event));
878
879		this._mouseDownEvent = event;
880
881		var that = this,
882			btnIsLeft = (event.which === 1),
883			// event.target.nodeName works around a bug in IE 8 with
884			// disabled inputs (#7620)
885			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
886		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
887			return true;
888		}
889
890		this.mouseDelayMet = !this.options.delay;
891		if (!this.mouseDelayMet) {
892			this._mouseDelayTimer = setTimeout(function() {
893				that.mouseDelayMet = true;
894			}, this.options.delay);
895		}
896
897		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
898			this._mouseStarted = (this._mouseStart(event) !== false);
899			if (!this._mouseStarted) {
900				event.preventDefault();
901				return true;
902			}
903		}
904
905		// Click event may never have fired (Gecko & Opera)
906		if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
907			$.removeData(event.target, this.widgetName + ".preventClickEvent");
908		}
909
910		// these delegates are required to keep context
911		this._mouseMoveDelegate = function(event) {
912			return that._mouseMove(event);
913		};
914		this._mouseUpDelegate = function(event) {
915			return that._mouseUp(event);
916		};
917		$(document)
918			.bind("mousemove."+this.widgetName, this._mouseMoveDelegate)
919			.bind("mouseup."+this.widgetName, this._mouseUpDelegate);
920
921		event.preventDefault();
922
923		mouseHandled = true;
924		return true;
925	},
926
927	_mouseMove: function(event) {
928		// IE mouseup check - mouseup happened when mouse was out of window
929		if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
930			return this._mouseUp(event);
931		}
932
933		if (this._mouseStarted) {
934			this._mouseDrag(event);
935			return event.preventDefault();
936		}
937
938		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
939			this._mouseStarted =
940				(this._mouseStart(this._mouseDownEvent, event) !== false);
941			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
942		}
943
944		return !this._mouseStarted;
945	},
946
947	_mouseUp: function(event) {
948		$(document)
949			.unbind("mousemove."+this.widgetName, this._mouseMoveDelegate)
950			.unbind("mouseup."+this.widgetName, this._mouseUpDelegate);
951
952		if (this._mouseStarted) {
953			this._mouseStarted = false;
954
955			if (event.target === this._mouseDownEvent.target) {
956				$.data(event.target, this.widgetName + ".preventClickEvent", true);
957			}
958
959			this._mouseStop(event);
960		}
961
962		return false;
963	},
964
965	_mouseDistanceMet: function(event) {
966		return (Math.max(
967				Math.abs(this._mouseDownEvent.pageX - event.pageX),
968				Math.abs(this._mouseDownEvent.pageY - event.pageY)
969			) >= this.options.distance
970		);
971	},
972
973	_mouseDelayMet: function(/* event */) {
974		return this.mouseDelayMet;
975	},
976
977	// These are placeholder methods, to be overriden by extending plugin
978	_mouseStart: function(/* event */) {},
979	_mouseDrag: function(/* event */) {},
980	_mouseStop: function(/* event */) {},
981	_mouseCapture: function(/* event */) { return true; }
982});
983
984})(jQuery);
985
986(function( $, undefined ) {
987
988$.widget("ui.draggable", $.ui.mouse, {
989	version: "1.10.2",
990	widgetEventPrefix: "drag",
991	options: {
992		addClasses: true,
993		appendTo: "parent",
994		axis: false,
995		connectToSortable: false,
996		containment: false,
997		cursor: "auto",

132010) || 0),
1321			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
1322		};
1323
1324	},
1325
1326	_getRelativeOffset: function() {
1327
1328		if(this.cssPosition === "relative") {
1329			var p = this.element.position();
1330			return {
1331				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
1332				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
1333			};
1334		} else {
1335			return { top: 0, left: 0 };
1336		}
1337
1338	},
1339
1340	_cacheMargins: function() {
1341		this.margins = {
1342			left: (parseInt(this.element.css("marginLeft"),10) || 0),
1343			top: (parseInt(this.element.css("marginTop"),10) || 0),
1344			right: (parseInt(this.element.css("marginRight"),10) || 0),
1345			bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
1346		};
1347	},
1348
1349	_cacheHelperProportions: function() {
1350		this.helperProportions = {
1351			width: this.helper.outerWidth(),
1352			height: this.helper.outerHeight()
1353		};
1354	},
1355
1356	_setContainment: function() {
1357
1358		var over, c, ce,
1359			o = this.options;
1360
1361		if(o.containment === "parent") {
1362			o.containment = this.helper[0].parentNode;
1363		}
1364		if(o.containment === "document" || o.containment === "window") {
1365			this.containment = [
1366				o.containment === "document" ? 0 : $(window).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
1367				o.containment === "document" ? 0 : $(window).scrollTop() - this.offset.relative.top - this.offset.parent.top,

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

1816				continue;
1817			}
1818
1819			if(o.snapMode !== "inner") {
1820				ts = Math.abs(t - y2) <= d;
1821				bs = Math.abs(b - y1) <= d;
1822				ls = Math.abs(l - x2) <= d;
1823				rs = Math.abs(r - x1) <= d;
1824				if(ts) {
1825					ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1826				}
1827				if(bs) {
1828					ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
1829				}
1830				if(ls) {
1831					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
1832				}
1833				if(rs) {
1834					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
1835				}
1836			}
1837
1838			first = (ts || bs || ls || rs);
1839
1840			if(o.snapMode !== "outer") {
1841				ts = Math.abs(t - y1) <= d;
1842				bs = Math.abs(b - y2) <= d;
1843				ls = Math.abs(l - x1) <= d;
1844				rs = Math.abs(r - x2) <= d;
1845				if(ts) {
1846					ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
1847				}
1848				if(bs) {
1849					ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1850				}
1851				if(ls) {
1852					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
1853				}
1854				if(rs) {
1855					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
1856				}
1857			}
1858
1859			if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
1860				(inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1861			}
1862			inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
1863
1864		}
1865
1866	}
1867});
1868
1869$.ui.plugin.add("draggable", "stack", {
1870	start: function() {
1871		var min,
1872			o = this.data("ui-draggable").options,
1873			group = $.makeArray($(o.stack)).sort(function(a,b) {
1874				return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
1875			});
1876
1877		if (!group.length) { return; }
1878
1879		min = parseInt($(group[0]).css("zIndex"), 10) || 0;
1880		$(group).each(function(i) {
1881			$(this).css("zIndex", min + i);
1882		});
1883		this.css("zIndex", (min + group.length));
1884	}
1885});
1886
1887$.ui.plugin.add("draggable", "zIndex", {
1888	start: function(event, ui) {
1889		var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1890		if(t.css("zIndex")) {
1891			o._zIndex = t.css("zIndex");
1892		}
1893		t.css("zIndex", o.zIndex);
1894	},
1895	stop: function(event, ui) {
1896		var o = $(this).data("ui-draggable").options;
1897		if(o._zIndex) {
1898			$(ui.helper).css("zIndex", o._zIndex);
1899		}
1900	}
1901});
1902
1903})(jQuery);
1904
1905(function( $, undefined ) {
1906
1907function isOverAxis( x, reference, size ) {
1908	return ( x > reference ) && ( x < ( reference + size ) );
1909}
1910
1911$.widget("ui.droppable", {
1912	version: "1.10.2",
1913	widgetEventPrefix: "drop",
1914	options: {
1915		accept: "*",
1916		activeClass: false,
1917		addClasses: true,
1918		greedy: false,
1919		hoverClass: false,
1920		scope: "default",
1921		tolerance: "intersect",
1922
1923		// callbacks
1924		activate: null,
1925		deactivate: null,
1926		drop: null,
1927		out: null,
1928		over: null
1929	},
1930	_create: function() {
1931
1932		var o = this.options,
1933			accept = o.accept;
1934
1935		this.isover = false;
1936		this.isout = true;
1937
1938		this.accept = $.isFunction(accept) ? accept : function(d) {
1939			return d.is(accept);
1940		};
1941
1942		//Store the droppable's proportions
1943		this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
1944
1945		// Add the reference and positions to the manager
1946		$.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
1947		$.ui.ddmanager.droppables[o.scope].push(this);
1948
1949		(o.addClasses && this.element.addClass("ui-droppable"));
1950
1951	},
1952
1953	_destroy: function() {
1954		var i = 0,
1955			drop = $.ui.ddmanager.droppables[this.options.scope];
1956
1957		for ( ; i < drop.length; i++ ) {
1958			if ( drop[i] === this ) {
1959				drop.splice(i, 1);
1960			}
1961		}
1962
1963		this.element.removeClass("ui-droppable ui-droppable-disabled");
1964	},
1965
1966	_setOption: function(key, value) {
1967
1968		if(key === "accept") {
1969			this.accept = $.isFunction(value) ? value : function(d) {
1970				return d.is(value);
1971			};
1972		}
1973		$.Widget.prototype._setOption.apply(this, arguments);
1974	},
1975
1976	_activate: function(event) {
1977		var draggable = $.ui.ddmanager.current;
1978		if(this.options.activeClass) {
1979			this.element.addClass(this.options.activeClass);
1980		}
1981		if(draggable){
1982			this._trigger("activate", event, this.ui(draggable));
1983		}
1984	},
1985
1986	_deactivate: function(event) {
1987		var draggable = $.ui.ddmanager.current;
1988		if(this.options.activeClass) {
1989			this.element.removeClass(this.options.activeClass);
1990		}
1991		if(draggable){
1992			this._trigger("deactivate", event, this.ui(draggable));
1993		}
1994	},
1995
1996	_over: function(event) {
1997
1998		var draggable = $.ui.ddmanager.current;
1999
2000		// Bail if draggable and droppable are same element
2001		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2002			return;
2003		}
2004
2005		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2006			if(this.options.hoverClass) {
2007				this.element.addClass(this.options.hoverClass);
2008			}
2009			this._trigger("over", event, this.ui(draggable));
2010		}
2011
2012	},
2013
2014	_out: function(event) {
2015
2016		var draggable = $.ui.ddmanager.current;
2017
2018		// Bail if draggable and droppable are same element
2019		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2020			return;
2021		}
2022
2023		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2024			if(this.options.hoverClass) {
2025				this.element.removeClass(this.options.hoverClass);
2026			}
2027			this._trigger("out", event, this.ui(draggable));
2028		}
2029
2030	},
2031
2032	_drop: function(event,custom) {
2033
2034		var draggable = custom || $.ui.ddmanager.current,
2035			childrenIntersection = false;

2169		// Create a copy of the droppables in case the list changes during the drop (#9116)
2170		$.each(($.ui.ddmanager.droppables[draggable.options.scope] || []).slice(), function() {
2171
2172			if(!this.options) {
2173				return;
2174			}
2175			if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
2176				dropped = this._drop.call(this, event) || dropped;
2177			}
2178
2179			if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2180				this.isout = true;
2181				this.isover = false;
2182				this._deactivate.call(this, event);
2183			}
2184
2185		});
2186		return dropped;
2187
2188	},
2189	dragStart: function( draggable, event ) {
2190		//Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
2191		draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
2192			if( !draggable.options.refreshPositions ) {
2193				$.ui.ddmanager.prepareOffsets( draggable, event );
2194			}
2195		});
2196	},
2197	drag: function(draggable, event) {
2198
2199		//If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
2200		if(draggable.options.refreshPositions) {
2201			$.ui.ddmanager.prepareOffsets(draggable, event);
2202		}
2203
2204		//Run through all droppables and check their positions based on specific tolerance options
2205		$.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
2206
2207			if(this.options.disabled || this.greedyChild || !this.visible) {
2208				return;
2209			}
2210
2211			var parentInstance, scope, parent,
2212				intersects = $.ui.intersect(draggable, this, this.options.tolerance),
2213				c = !intersects && this.isover ? "isout" : (intersects && !this.isover ? "isover" : null);
2214			if(!c) {
2215				return;
2216			}
2217
2218			if (this.options.greedy) {
2219				// find droppable parents with same scope
2220				scope = this.options.scope;
2221				parent = this.element.parents(":data(ui-droppable)").filter(function () {
2222					return $.data(this, "ui-droppable").options.scope === scope;
2223				});
2224
2225				if (parent.length) {
2226					parentInstance = $.data(parent[0], "ui-droppable");
2227					parentInstance.greedyChild = (c === "isover");
2228				}
2229			}
2230
2231			// we just moved into a greedy child
2232			if (parentInstance && c === "isover") {
2233				parentInstance.isover = false;
2234				parentInstance.isout = true;
2235				parentInstance._out.call(parentInstance, event);
2236			}
2237
2238			this[c] = true;
2239			this[c === "isout" ? "isover" : "isout"] = false;
2240			this[c === "isover" ? "_over" : "_out"].call(this, event);
2241
2242			// we just moved out of a greedy child
2243			if (parentInstance && c === "isout") {
2244				parentInstance.isout = false;
2245				parentInstance.isover = true;
2246				parentInstance._over.call(parentInstance, event);
2247			}
2248		});
2249
2250	},
2251	dragStop: function( draggable, event ) {
2252		draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
2253		//Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
2254		if( !draggable.options.refreshPositions ) {
2255			$.ui.ddmanager.prepareOffsets( draggable, event );
2256		}
2257	}
2258};
2259
2260})(jQuery);
2261
2262(function( $, undefined ) {
2263
2264function num(v) {
2265	return parseInt(v, 10) || 0;
2266}
2267
2268function isNumber(value) {
2269	return !isNaN(parseInt(value, 10));
2270}
2271
2272$.widget("ui.resizable", $.ui.mouse, {
2273	version: "1.10.2",
2274	widgetEventPrefix: "resize",
2275	options: {
2276		alsoResize: false,
2277		animate: false,
2278		animateDuration: "slow",
2279		animateEasing: "swing",
2280		aspectRatio: false,
2281		autoHide: false,
2282		containment: false,
2283		ghost: false,
2284		grid: false,
2285		handles: "e,s,se",
2286		helper: false,
2287		maxHeight: null,
2288		maxWidth: null,
2289		minHeight: 10,
2290		minWidth: 10,
2291		// See #7960
2292		zIndex: 90,
2293
2294		// callbacks
2295		resize: null,
2296		start: null,
2297		stop: null
2298	},
2299	_create: function() {
2300
2301		var n, i, handle, axis, hname,
2302			that = this,
2303			o = this.options;
2304		this.element.addClass("ui-resizable");
2305
2306		$.extend(this, {
2307			_aspectRatio: !!(o.aspectRatio),
2308			aspectRatio: o.aspectRatio,
2309			originalElement: this.element,
2310			_proportionallyResizeElements: [],
2311			_helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
2312		});
2313
2314		//Wrap the element if it cannot hold child nodes
2315		if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
2316
2317			//Create a wrapper element and set the wrapper to the new current internal element
2318			this.element.wrap(
2319				$("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
2320					position: this.element.css("position"),
2321					width: this.element.outerWidth(),
2322					height: this.element.outerHeight(),
2323					top: this.element.css("top"),
2324					left: this.element.css("left")
2325				})
2326			);
2327
2328			//Overwrite the original this.element
2329			this.element = this.element.parent().data(
2330				"ui-resizable", this.element.data("ui-resizable")
2331			);
2332
2333			this.elementIsWrapper = true;
2334
2335			//Move margins to the wrapper
2336			this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
2337			this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
2338
2339			//Prevent Safari textarea resize
2340			this.originalResizeStyle = this.originalElement.css("resize");
2341			this.originalElement.css("resize", "none");
2342
2343			//Push the actual element to our proportionallyResize internal array
2344			this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
2345
2346			// avoid IE jump (hard set the margin)
2347			this.originalElement.css({ margin: this.originalElement.css("margin") });
2348
2349			// fix handlers offset
2350			this._proportionallyResize();
2351
2352		}
2353
2354		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" });
2355		if(this.handles.constructor === String) {
2356
2357			if ( this.handles === "all") {
2358				this.handles = "n,e,s,w,se,sw,ne,nw";
2359			}
2360
2361			n = this.handles.split(",");
2362			this.handles = {};
2363
2364			for(i = 0; i < n.length; i++) {
2365
2366				handle = $.trim(n[i]);
2367				hname = "ui-resizable-"+handle;
2368				axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
2369
2370				// Apply zIndex to all handles - see #7960
2371				axis.css({ zIndex: o.zIndex });
2372
2373				//TODO : What's going on here?
2374				if ("se" === handle) {
2375					axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
2376				}
2377
2378				//Insert into internal handles object and append to element
2379				this.handles[handle] = ".ui-resizable-"+handle;
2380				this.element.append(axis);
2381			}
2382
2383		}
2384
2385		this._renderAxis = function(target) {
2386
2387			var i, axis, padPos, padWrapper;
2388
2389			target = target || this.element;
2390
2391			for(i in this.handles) {
2392
2393				if(this.handles[i].constructor === String) {
2394					this.handles[i] = $(this.handles[i], this.element).show();
2395				}
2396
2397				//Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
2398				if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
2399
2400					axis = $(this.handles[i], this.element);
2401
2402					//Checking the correct pad and border
2403					padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
2404
2405					//The padding type i have to apply...
2406					padPos = [ "padding",
2407						/ne|nw|n/.test(i) ? "Top" :
2408						/se|sw|s/.test(i) ? "Bottom" :
2409						/^e$/.test(i) ? "Right" : "Left" ].join("");
2410
2411					target.css(padPos, padWrapper);
2412
2413					this._proportionallyResize();
2414
2415				}
2416
2417				//TODO: What's that good for? There's not anything to be executed left
2418				if(!$(this.handles[i]).length) {
2419					continue;
2420				}
2421			}
2422		};
2423
2424		//TODO: make renderAxis a prototype function
2425		this._renderAxis(this.element);
2426
2427		this._handles = $(".ui-resizable-handle", this.element)
2428			.disableSelection();
2429
2430		//Matching axis name
2431		this._handles.mouseover(function() {
2432			if (!that.resizing) {
2433				if (this.className) {
2434					axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
2435				}
2436				//Axis, default = se
2437				that.axis = axis && axis[1] ? axis[1] : "se";
2438			}
2439		});
2440
2441		//If we want to auto hide the elements
2442		if (o.autoHide) {
2443			this._handles.hide();
2444			$(this.element)
2445				.addClass("ui-resizable-autohide")
2446				.mouseenter(function() {
2447					if (o.disabled) {
2448						return;
2449					}
2450					$(this).removeClass("ui-resizable-autohide");
2451					that._handles.show();
2452				})
2453				.mouseleave(function(){
2454					if (o.disabled) {
2455						return;
2456					}
2457					if (!that.resizing) {
2458						$(this).addClass("ui-resizable-autohide");
2459						that._handles.hide();
2460					}
2461				});
2462		}
2463
2464		//Initialize the mouse interaction
2465		this._mouseInit();
2466
2467	},
2468
2469	_destroy: function() {
2470
2471		this._mouseDestroy();
2472
2473		var wrapper,
2474			_destroy = function(exp) {
2475				$(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
2476					.removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
2477			};
2478
2479		//TODO: Unwrap at same DOM position
2480		if (this.elementIsWrapper) {
2481			_destroy(this.element);
2482			wrapper = this.element;
2483			this.originalElement.css({
2484				position: wrapper.css("position"),
2485				width: wrapper.outerWidth(),
2486				height: wrapper.outerHeight(),
2487				top: wrapper.css("top"),
2488				left: wrapper.css("left")
2489			}).insertAfter( wrapper );
2490			wrapper.remove();
2491		}
2492
2493		this.originalElement.css("resize", this.originalResizeStyle);
2494		_destroy(this.originalElement);
2495
2496		return this;
2497	},
2498
2499	_mouseCapture: function(event) {
2500		var i, handle,
2501			capture = false;
2502
2503		for (i in this.handles) {
2504			handle = $(this.handles[i])[0];
2505			if (handle === event.target || $.contains(handle, event.target)) {
2506				capture = true;
2507			}
2508		}
2509
2510		return !this.options.disabled && capture;
2511	},
2512
2513	_mouseStart: function(event) {
2514
2515		var curleft, curtop, cursor,
2516			o = this.options,
2517			iniPos = this.element.position(),
2518			el = this.element;
2519
2520		this.resizing = true;
2521
2522		// bugfix for http://dev.jquery.com/ticket/1749
2523		if ( (/absolute/).test( el.css("position") ) ) {
2524			el.css({ position: "absolute", top: el.css("top"), left: el.css("left") });
2525		} else if (el.is(".ui-draggable")) {
2526			el.css({ position: "absolute", top: iniPos.top, left: iniPos.left });
2527		}
2528
2529		this._renderProxy();
2530
2531		curleft = num(this.helper.css("left"));
2532		curtop = num(this.helper.css("top"));
2533
2534		if (o.containment) {
2535			curleft += $(o.containment).scrollLeft() || 0;
2536			curtop += $(o.containment).scrollTop() || 0;
2537		}
2538
2539		//Store needed variables
2540		this.offset = this.helper.offset();
2541		this.position = { left: curleft, top: curtop };
2542		this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2543		this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2544		this.originalPosition = { left: curleft, top: curtop };
2545		this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
2546		this.originalMousePosition = { left: event.pageX, top: event.pageY };
2547
2548		//Aspect Ratio
2549		this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
2550
2551		cursor = $(".ui-resizable-" + this.axis).css("cursor");
2552		$("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
2553
2554		el.addClass("ui-resizable-resizing");
2555		this._propagate("start", event);
2556		return true;
2557	},
2558
2559	_mouseDrag: function(event) {
2560
2561		//Increase performance, avoid regex
2562		var data,
2563			el = this.helper, props = {},
2564			smp = this.originalMousePosition,
2565			a = this.axis,
2566			prevTop = this.position.top,
2567			prevLeft = this.position.left,
2568			prevWidth = this.size.width,
2569			prevHeight = this.size.height,
2570			dx = (event.pageX-smp.left)||0,
2571			dy = (event.pageY-smp.top)||0,
2572			trigger = this._change[a];
2573
2574		if (!trigger) {
2575			return false;
2576		}
2577
2578		// Calculate the attrs that will be change
2579		data = trigger.apply(this, [event, dx, dy]);
2580
2581		// Put this in the mouseDrag handler since the user can start pressing shift while resizing
2582		this._updateVirtualBoundaries(event.shiftKey);
2583		if (this._aspectRatio || event.shiftKey) {
2584			data = this._updateRatio(data, event);
2585		}
2586
2587		data = this._respectSize(data, event);
2588
2589		this._updateCache(data);
2590
2591		// plugins callbacks need to be called first
2592		this._propagate("resize", event);
2593
2594		if (this.position.top !== prevTop) {
2595			props.top = this.position.top + "px";
2596		}
2597		if (this.position.left !== prevLeft) {
2598			props.left = this.position.left + "px";
2599		}
2600		if (this.size.width !== prevWidth) {
2601			props.width = this.size.width + "px";
2602		}
2603		if (this.size.height !== prevHeight) {
2604			props.height = this.size.height + "px";
2605		}
2606		el.css(props);
2607
2608		if (!this._helper && this._proportionallyResizeElements.length) {
2609			this._proportionallyResize();
2610		}
2611
2612		// Call the user callback if the element was resized
2613		if ( ! $.isEmptyObject(props) ) {
2614			this._trigger("resize", event, this.ui());
2615		}
2616
2617		return false;
2618	},
2619
2620	_mouseStop: function(event) {
2621
2622		this.resizing = false;
2623		var pr, ista, soffseth, soffsetw, s, left, top,
2624			o = this.options, that = this;
2625
2626		if(this._helper) {
2627
2628			pr = this._proportionallyResizeElements;
2629			ista = pr.length && (/textarea/i).test(pr[0].nodeName);
2630			soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
2631			soffsetw = ista ? 0 : that.sizeDiff.width;
2632
2633			s = { width: (that.helper.width()  - soffsetw), height: (that.helper.height() - soffseth) };
2634			left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
2635			top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2636
2637			if (!o.animate) {
2638				this.element.css($.extend(s, { top: top, left: left }));
2639			}
2640
2641			that.helper.height(that.size.height);
2642			that.helper.width(that.size.width);
2643
2644			if (this._helper && !o.animate) {
2645				this._proportionallyResize();
2646			}
2647		}
2648
2649		$("body").css("cursor", "auto");
2650
2651		this.element.removeClass("ui-resizable-resizing");
2652
2653		this._propagate("stop", event);
2654
2655		if (this._helper) {
2656			this.helper.remove();
2657		}
2658
2659		return false;
2660
2661	},
2662
2663	_updateVirtualBoundaries: function(forceAspectRatio) {
2664		var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
2665			o = this.options;
2666
2667		b = {
2668			minWidth: isNumber(o.minWidth) ? o.minWidth : 0,
2669			maxWidth: isNumber(o.maxWidth) ? o.maxWidth : Infinity,
2670			minHeight: isNumber(o.minHeight) ? o.minHeight : 0,
2671			maxHeight: isNumber(o.maxHeight) ? o.maxHeight : Infinity
2672		};
2673
2674		if(this._aspectRatio || forceAspectRatio) {
2675			// We want to create an enclosing box whose aspect ration is the requested one
2676			// First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
2677			pMinWidth = b.minHeight * this.aspectRatio;
2678			pMinHeight = b.minWidth / this.aspectRatio;
2679			pMaxWidth = b.maxHeight * this.aspectRatio;
2680			pMaxHeight = b.maxWidth / this.aspectRatio;
2681
2682			if(pMinWidth > b.minWidth) {
2683				b.minWidth = pMinWidth;
2684			}
2685			if(pMinHeight > b.minHeight) {
2686				b.minHeight = pMinHeight;
2687			}
2688			if(pMaxWidth < b.maxWidth) {
2689				b.maxWidth = pMaxWidth;
2690			}
2691			if(pMaxHeight < b.maxHeight) {
2692				b.maxHeight = pMaxHeight;
2693			}
2694		}
2695		this._vBoundaries = b;
2696	},
2697
2698	_updateCache: function(data) {
2699		this.offset = this.helper.offset();
2700		if (isNumber(data.left)) {
2701			this.position.left = data.left;
2702		}
2703		if (isNumber(data.top)) {
2704			this.position.top = data.top;
2705		}
2706		if (isNumber(data.height)) {
2707			this.size.height = data.height;
2708		}
2709		if (isNumber(data.width)) {
2710			this.size.width = data.width;
2711		}
2712	},
2713
2714	_updateRatio: function( data ) {
2715
2716		var cpos = this.position,
2717			csize = this.size,
2718			a = this.axis;
2719
2720		if (isNumber(data.height)) {
2721			data.width = (data.height * this.aspectRatio);
2722		} else if (isNumber(data.width)) {
2723			data.height = (data.width / this.aspectRatio);
2724		}
2725
2726		if (a === "sw") {
2727			data.left = cpos.left + (csize.width - data.width);
2728			data.top = null;
2729		}
2730		if (a === "nw") {
2731			data.top = cpos.top + (csize.height - data.height);
2732			data.left = cpos.left + (csize.width - data.width);
2733		}
2734
2735		return data;
2736	},
2737
2738	_respectSize: function( data ) {
2739
2740		var o = this._vBoundaries,
2741			a = this.axis,
2742			ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
2743			isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
2744			dw = this.originalPosition.left + this.originalSize.width,
2745			dh = this.position.top + this.size.height,
2746			cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
2747		if (isminw) {
2748			data.width = o.minWidth;
2749		}
2750		if (isminh) {
2751			data.height = o.minHeight;
2752		}
2753		if (ismaxw) {
2754			data.width = o.maxWidth;
2755		}
2756		if (ismaxh) {
2757			data.height = o.maxHeight;
2758		}
2759
2760		if (isminw && cw) {
2761			data.left = dw - o.minWidth;
2762		}
2763		if (ismaxw && cw) {
2764			data.left = dw - o.maxWidth;
2765		}
2766		if (isminh && ch) {
2767			data.top = dh - o.minHeight;
2768		}
2769		if (ismaxh && ch) {
2770			data.top = dh - o.maxHeight;
2771		}
2772
2773		// fixing jump error on top/left - bug #2330
2774		if (!data.width && !data.height && !data.left && data.top) {
2775			data.top = null;
2776		} else if (!data.width && !data.height && !data.top && data.left) {
2777			data.left = null;
2778		}
2779
2780		return data;
2781	},
2782
2783	_proportionallyResize: function() {
2784
2785		if (!this._proportionallyResizeElements.length) {
2786			return;
2787		}
2788
2789		var i, j, borders, paddings, prel,
2790			element = this.helper || this.element;
2791
2792		for ( i=0; i < this._proportionallyResizeElements.length; i++) {
2793
2794			prel = this._proportionallyResizeElements[i];
2795
2796			if (!this.borderDif) {
2797				this.borderDif = [];
2798				borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
2799				paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
2800
2801				for ( j = 0; j < borders.length; j++ ) {
2802					this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
2803				}
2804			}
2805
2806			prel.css({
2807				height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
2808				width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
2809			});
2810
2811		}
2812
2813	},
2814
2815	_renderProxy: function() {
2816
2817		var el = this.element, o = this.options;
2818		this.elementOffset = el.offset();
2819
2820		if(this._helper) {
2821
2822			this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
2823
2824			this.helper.addClass(this._helper).css({
2825				width: this.element.outerWidth() - 1,
2826				height: this.element.outerHeight() - 1,
2827				position: "absolute",
2828				left: this.elementOffset.left +"px",
2829				top: this.elementOffset.top +"px",
2830				zIndex: ++o.zIndex //TODO: Don't modify option
2831			});
2832
2833			this.helper
2834				.appendTo("body")
2835				.disableSelection();
2836
2837		} else {
2838			this.helper = this.element;
2839		}
2840
2841	},
2842
2843	_change: {
2844		e: function(event, dx) {
2845			return { width: this.originalSize.width + dx };
2846		},
2847		w: function(event, dx) {
2848			var cs = this.originalSize, sp = this.originalPosition;
2849			return { left: sp.left + dx, width: cs.width - dx };
2850		},
2851		n: function(event, dx, dy) {
2852			var cs = this.originalSize, sp = this.originalPosition;
2853			return { top: sp.top + dy, height: cs.height - dy };
2854		},
2855		s: function(event, dx, dy) {
2856			return { height: this.originalSize.height + dy };
2857		},
2858		se: function(event, dx, dy) {
2859			return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2860		},
2861		sw: function(event, dx, dy) {
2862			return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2863		},
2864		ne: function(event, dx, dy) {
2865			return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2866		},
2867		nw: function(event, dx, dy) {
2868			return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2869		}
2870	},
2871
2872	_propagate: function(n, event) {
2873		$.ui.plugin.call(this, n, [event, this.ui()]);
2874		(n !== "resize" && this._trigger(n, event, this.ui()));
2875	},
2876
2877	plugins: {},
2878
2879	ui: function() {
2880		return {
2881			originalElement: this.originalElement,
2882			element: this.element,
2883			helper: this.helper,
2884			position: this.position,
2885			size: this.size,
2886			originalSize: this.originalSize,
2887			originalPosition: this.originalPosition
2888		};
2889	}
2890
2891});
2892
2893/*
2894 * Resizable Extensions
2895 */
2896
2897$.ui.plugin.add("resizable", "animate", {
2898
2899	stop: function( event ) {
2900		var that = $(this).data("ui-resizable"),
2901			o = that.options,
2902			pr = that._proportionallyResizeElements,
2903			ista = pr.length && (/textarea/i).test(pr[0].nodeName),
2904			soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
2905			soffsetw = ista ? 0 : that.sizeDiff.width,
2906			style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
2907			left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
2908			top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2909
2910		that.element.animate(
2911			$.extend(style, top && left ? { top: top, left: left } : {}), {
2912				duration: o.animateDuration,
2913				easing: o.animateEasing,
2914				step: function() {
2915
2916					var data = {
2917						width: parseInt(that.element.css("width"), 10),
2918						height: parseInt(that.element.css("height"), 10),
2919						top: parseInt(that.element.css("top"), 10),
2920						left: parseInt(that.element.css("left"), 10)
2921					};
2922
2923					if (pr && pr.length) {
2924						$(pr[0]).css({ width: data.width, height: data.height });
2925					}
2926
2927					// propagating resize, and updating values for each animation step
2928					that._updateCache(data);
2929					that._propagate("resize", event);
2930
2931				}
2932			}
2933		);
2934	}
2935
2936});
2937
2938$.ui.plugin.add("resizable", "containment", {
2939
2940	start: function() {
2941		var element, p, co, ch, cw, width, height,
2942			that = $(this).data("ui-resizable"),
2943			o = that.options,
2944			el = that.element,
2945			oc = o.containment,
2946			ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
2947
2948		if (!ce) {
2949			return;
2950		}
2951
2952		that.containerElement = $(ce);
2953
2954		if (/document/.test(oc) || oc === document) {
2955			that.containerOffset = { left: 0, top: 0 };
2956			that.containerPosition = { left: 0, top: 0 };
2957
2958			that.parentData = {