http://www.activa.com.au/js/jquery-ui-10.js

1/*! jQuery UI - v1.10.3 - 2013-05-03
2* http://jqueryui.com
3* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.ui.effect.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.js, jquery.ui.effect-blind.js, jquery.ui.effect-bounce.js, jquery.ui.effect-clip.js, jquery.ui.effect-drop.js, jquery.ui.effect-explode.js, jquery.ui.effect-fade.js, jquery.ui.effect-fold.js, jquery.ui.effect-highlight.js, jquery.ui.effect-pulsate.js, jquery.ui.effect-scale.js, jquery.ui.effect-shake.js, jquery.ui.effect-slide.js, jquery.ui.effect-transfer.js, jquery.ui.menu.js, jquery.ui.position.js, jquery.ui.progressbar.js, jquery.ui.slider.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js
4* Copyright 2013 jQuery Foundation and other contributors; Licensed MIT */
5(function( $, undefined ) {
6
7var uuid = 0,
8	runiqueId = /^ui-id-\d+$/;
9
10// $.ui might exist from components with no dependencies, e.g., $.ui.position
11$.ui = $.ui || {};
12
13$.extend( $.ui, {
14	version: "1.10.3",
15
16	keyCode: {
17		BACKSPACE: 8,
18		COMMA: 188,
19		DELETE: 46,
20		DOWN: 40,
21		END: 35,
22		ENTER: 13,
23		ESCAPE: 27,
24		HOME: 36,
25		LEFT: 37,
26		NUMPAD_ADD: 107,
27		NUMPAD_DECIMAL: 110,
28		NUMPAD_DIVIDE: 111,
29		NUMPAD_ENTER: 108,
30		NUMPAD_MULTIPLY: 106,
31		NUMPAD_SUBTRACT: 109,
32		PAGE_DOWN: 34,
33		PAGE_UP: 33,
34		PERIOD: 190,
35		RIGHT: 39,
36		SPACE: 32,
37		TAB: 9,
38		UP: 38
39	}
40});
41
42// plugins
43$.fn.extend({
44	focus: (function( orig ) {
45		return function( delay, fn ) {
46			return typeof delay === "number" ?
47				this.each(function() {
48					var elem = this;
49					setTimeout(function() {
50						$( elem ).focus();
51						if ( fn ) {
52							fn.call( elem );
53						}
54					}, delay );
55				}) :
56				orig.apply( this, arguments );
57		};
58	})( $.fn.focus ),
59
60	scrollParent: function() {
61		var scrollParent;
62		if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
63			scrollParent = this.parents().filter(function() {
64				return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
65			}).eq(0);
66		} else {
67			scrollParent = this.parents().filter(function() {
68				return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));
69			}).eq(0);
70		}
71
72		return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
73	},
74
75	zIndex: function( zIndex ) {
76		if ( zIndex !== undefined ) {
77			return this.css( "zIndex", zIndex );
78		}
79
80		if ( this.length ) {
81			var elem = $( this[ 0 ] ), position, value;
82			while ( elem.length && elem[ 0 ] !== document ) {
83				// Ignore z-index if position is set to a value where z-index is ignored by the browser
84				// This makes behavior of this function consistent across browsers
85				// WebKit always returns auto if the element is positioned
86				position = elem.css( "position" );
87				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
88					// IE returns 0 when zIndex is not specified
89					// other browsers return a string
90					// we ignore the case of nested elements with an explicit value of 0
91					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
92					value = parseInt( elem.css( "zIndex" ), 10 );
93					if ( !isNaN( value ) && value !== 0 ) {
94						return value;
95					}
96				}
97				elem = elem.parent();
98			}
99		}
100
101		return 0;
102	},
103
104	uniqueId: function() {
105		return this.each(function() {
106			if ( !this.id ) {
107				this.id = "ui-id-" + (++uuid);
108			}
109		});
110	},
111
112	removeUniqueId: function() {
113		return this.each(function() {
114			if ( runiqueId.test( this.id ) ) {
115				$( this ).removeAttr( "id" );
116			}
117		});
118	}
119});
120
121// selectors
122function focusable( element, isTabIndexNotNaN ) {
123	var map, mapName, img,
124
125		nodeName = element.nodeName.toLowerCase();
126	if ( "area" === nodeName ) {
127		map = element.parentNode;
128		mapName = map.name;
129		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
130			return false;
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 $.widget() extensions 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.3",
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.3",
990	widgetEventPrefix: "drag",
991	options: {
992		addClasses: true,
993		appendTo: "parent",
994		axis: false,
995		connectToSortable: false,
996		containment: false,
997		cursor: "auto",
998		cursorAt: false,
999		grid: false,
1000		handle: false,
1001		helper: "original",
1002		iframeFix: false,
1003		opacity: false,
1004		refreshPositions: false,
1005		revert: false,
1006		revertDuration: 500,
1007		scope: "default",
1008		scroll: true,
1009		scrollSensitivity: 20,
1010		scrollSpeed: 20,
1011		snap: false,
1012		snapMode: "both",
1013		snapTolerance: 20,
1014		stack: false,
1015		zIndex: false,
1016
1017		// callbacks
1018		drag: null,
1019		start: null,
1020		stop: null
1021	},
1022	_create: function() {
1023
1024		if (this.options.helper === "original" && !(/^(?:r|a|f)/).test(this.element.css("position"))) {
1025			this.element[0].style.position = "relative";
1026		}
1027		if (this.options.addClasses){
1028			this.element.addClass("ui-draggable");
1029		}
1030		if (this.options.disabled){
1031			this.element.addClass("ui-draggable-disabled");
1032		}
1033
1034		this._mouseInit();
1035
1036	},
1037
1038	_destroy: function() {
1039		this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
1040		this._mouseDestroy();
1041	},
1042
1043	_mouseCapture: function(event) {
1044
1045		var o = this.options;
1046
1047		// among others, prevent a drag on a resizable-handle
1048		if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
1049			return false;
1050		}
1051
1052		//Quit if we're not on a valid handle
1053		this.handle = this._getHandle(event);
1054		if (!this.handle) {
1055			return false;
1056		}
1057
1058		$(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
1059			$("<div class='ui-draggable-iframeFix' style='background: #fff;'></div>")
1060			.css({
1061				width: this.offsetWidth+"px", height: this.offsetHeight+"px",
1062				position: "absolute", opacity: "0.001", zIndex: 1000
1063			})
1064			.css($(this).offset())
1065			.appendTo("body");
1066		});
1067
1068		return true;
1069
1070	},
1071
1072	_mouseStart: function(event) {
1073
1074		var o = this.options;
1075
1076		//Create and append the visible helper
1077		this.helper = this._createHelper(event);
1078
1079		this.helper.addClass("ui-draggable-dragging");
1080
1081		//Cache the helper size
1082		this._cacheHelperProportions();
1083
1084		//If ddmanager is used for droppables, set the global draggable
1085		if($.ui.ddmanager) {
1086			$.ui.ddmanager.current = this;
1087		}
1088
1089		/*
1090		 * - Position generation -
1091		 * This block generates everything position related - it's the core of draggables.
1092		 */
1093
1094		//Cache the margins of the original element
1095		this._cacheMargins();
1096
1097		//Store the helper's css position
1098		this.cssPosition = this.helper.css( "position" );
1099		this.scrollParent = this.helper.scrollParent();
1100		this.offsetParent = this.helper.offsetParent();
1101		this.offsetParentCssPosition = this.offsetParent.css( "position" );
1102
1103		//The element's absolute position on the page minus margins
1104		this.offset = this.positionAbs = this.element.offset();
1105		this.offset = {
1106			top: this.offset.top - this.margins.top,
1107			left: this.offset.left - this.margins.left
1108		};
1109
1110		//Reset scroll cache
1111		this.offset.scroll = false;
1112
1113		$.extend(this.offset, {
1114			click: { //Where the click happened, relative to the element
1115				left: event.pageX - this.offset.left,
1116				top: event.pageY - this.offset.top
1117			},
1118			parent: this._getParentOffset(),
1119			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
1120		});
1121
1122		//Generate the original position
1123		this.originalPosition = this.position = this._generatePosition(event);
1124		this.originalPageX = event.pageX;
1125		this.originalPageY = event.pageY;
1126
1127		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
1128		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
1129
1130		//Set a containment if given in the options
1131		this._setContainment();
1132
1133		//Trigger event + callbacks
1134		if(this._trigger("start", event) === false) {
1135			this._clear();
1136			return false;
1137		}
1138
1139		//Recache the helper size
1140		this._cacheHelperProportions();
1141
1142		//Prepare the droppable offsets
1143		if ($.ui.ddmanager && !o.dropBehaviour) {
1144			$.ui.ddmanager.prepareOffsets(this, event);
1145		}
1146
1147
1148		this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
1149
1150		//If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
1151		if ( $.ui.ddmanager ) {
1152			$.ui.ddmanager.dragStart(this, event);
1153		}
1154
1155		return true;
1156	},
1157
1158	_mouseDrag: function(event, noPropagation) {
1159		// reset any necessary cached properties (see #5009)
1160		if ( this.offsetParentCssPosition === "fixed" ) {
1161			this.offset.parent = this._getParentOffset();
1162		}
1163
1164		//Compute the helpers position
1165		this.position = this._generatePosition(event);
1166		this.positionAbs = this._convertPositionTo("absolute");
1167
1168		//Call plugins and callbacks and use the resulting position if something is returned
1169		if (!noPropagation) {
1170			var ui = this._uiHash();
1171			if(this._trigger("drag", event, ui) === false) {
1172				this._mouseUp({});
1173				return false;
1174			}
1175			this.position = ui.position;
1176		}
1177
1178		if(!this.options.axis || this.options.axis !== "y") {
1179			this.helper[0].style.left = this.position.left+"px";
1180		}
1181		if(!this.options.axis || this.options.axis !== "x") {
1182			this.helper[0].style.top = this.position.top+"px";
1183		}
1184		if($.ui.ddmanager) {
1185			$.ui.ddmanager.drag(this, event);
1186		}
1187
1188		return false;
1189	},
1190
1191	_mouseStop: function(event) {
1192
1193		//If we are using droppables, inform the manager about the drop
1194		var that = this,
1195			dropped = false;
1196		if ($.ui.ddmanager && !this.options.dropBehaviour) {
1197			dropped = $.ui.ddmanager.drop(this, event);
1198		}
1199
1200		//if a drop comes from outside (a sortable)
1201		if(this.dropped) {
1202			dropped = this.dropped;
1203			this.dropped = false;
1204		}
1205
1206		//if the original element is no longer in the DOM don't bother to continue (see #8269)
1207		if ( this.options.helper === "original" && !$.contains( this.element[ 0 ].ownerDocument, this.element[ 0 ] ) ) {
1208			return false;
1209		}
1210
1211		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))) {
1212			$(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
1213				if(that._trigger("stop", event) !== false) {
1214					that._clear();
1215				}
1216			});
1217		} else {
1218			if(this._trigger("stop", event) !== false) {
1219				this._clear();
1220			}
1221		}
1222
1223		return false;
1224	},
1225
1226	_mouseUp: function(event) {
1227		//Remove frame helpers
1228		$("div.ui-draggable-iframeFix").each(function() {
1229			this.parentNode.removeChild(this);
1230		});
1231
1232		//If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
1233		if( $.ui.ddmanager ) {
1234			$.ui.ddmanager.dragStop(this, event);
1235		}
1236
1237		return $.ui.mouse.prototype._mouseUp.call(this, event);
1238	},
1239
1240	cancel: function() {
1241
1242		if(this.helper.is(".ui-draggable-dragging")) {
1243			this._mouseUp({});
1244		} else {
1245			this._clear();
1246		}
1247
1248		return this;
1249
1250	},
1251
1252	_getHandle: function(event) {
1253		return this.options.handle ?
1254			!!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
1255			true;
1256	},
1257
1258	_createHelper: function(event) {
1259
1260		var o = this.options,
1261			helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper === "clone" ? this.element.clone().removeAttr("id") : this.element);
1262
1263		if(!helper.parents("body").length) {
1264			helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
1265		}
1266
1267		if(helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
1268			helper.css("position", "absolute");
1269		}
1270
1271		return helper;
1272
1273	},
1274
1275	_adjustOffsetFromHelper: function(obj) {
1276		if (typeof obj === "string") {
1277			obj = obj.split(" ");
1278		}
1279		if ($.isArray(obj)) {
1280			obj = {left: +obj[0], top: +obj[1] || 0};
1281		}
1282		if ("left" in obj) {
1283			this.offset.click.left = obj.left + this.margins.left;
1284		}
1285		if ("right" in obj) {
1286			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
1287		}
1288		if ("top" in obj) {
1289			this.offset.click.top = obj.top + this.margins.top;
1290		}
1291		if ("bottom" in obj) {
1292			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
1293		}
1294	},
1295
1296	_getParentOffset: function() {
1297
1298		//Get the offsetParent and cache its position
1299		var po = this.offsetParent.offset();
1300
1301		// This is a special case where we need to modify a offset calculated on start, since the following happened:
1302		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
1303		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
1304		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
1305		if(this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
1306			po.left += this.scrollParent.scrollLeft();
1307			po.top += this.scrollParent.scrollTop();
1308		}
1309
1310		//This needs to be actually done for all browsers, since pageX/pageY includes this information
1311		//Ugly IE fix
1312		if((this.offsetParent[0] === document.body) ||
1313			(this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
1314			po = { top: 0, left: 0 };
1315		}
1316
1317		return {
1318			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
1319			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
1320		};
1321
1322	},
1323
1324	_getRelativeOffset: function() {
1325
1326		if(this.cssPosition === "relative") {
1327			var p = this.element.position();
1328			return {
1329				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
1330				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
1331			};
1332		} else {
1333			return { top: 0, left: 0 };
1334		}
1335
1336	},
1337
1338	_cacheMargins: function() {
1339		this.margins = {
1340			left: (parseInt(this.element.css("marginLeft"),10) || 0),
1341			top: (parseInt(this.element.css("marginTop"),10) || 0),
1342			right: (parseInt(this.element.css("marginRight"),10) || 0),
1343			bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
1344		};
1345	},
1346
1347	_cacheHelperProportions: function() {
1348		this.helperProportions = {
1349			width: this.helper.outerWidth(),
1350			height: this.helper.outerHeight()
1351		};
1352	},
1353
1354	_setContainment: function() {
1355
1356		var over, c, ce,
1357			o = this.options;
1358
1359		if ( !o.containment ) {
1360			this.containment = null;
1361			return;
1362		}
1363
1364		if ( o.containment === "window" ) {
1365			this.containment = [
1366				$( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
1367				$( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
1368				$( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
1369				$( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
1370			];
1371			return;
1372		}
1373
1374		if ( o.containment === "document") {
1375			this.containment = [
1376				0,
1377				0,
1378				$( document ).width() - this.helperProportions.width - this.margins.left,
1379				( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
1380			];
1381			return;
1382		}
1383
1384		if ( o.containment.constructor === Array ) {
1385			this.containment = o.containment;
1386			return;
1387		}
1388
1389		if ( o.containment === "parent" ) {
1390			o.containment = this.helper[ 0 ].parentNode;
1391		}
1392
1393		c = $( o.containment );
1394		ce = c[ 0 ];
1395
1396		if( !ce ) {
1397			return;
1398		}
1399
1400		over = c.css( "overflow" ) !== "hidden";
1401
1402		this.containment = [
1403			( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
1404			( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ) ,
1405			( over ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) - ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) - ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) - this.helperProportions.width - this.margins.left - this.margins.right,
1406			( over ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) - ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) - ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) - this.helperProportions.height - this.margins.top  - this.margins.bottom
1407		];
1408		this.relative_container = c;
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;
1419
1420		//Cache the scroll
1421		if (!this.offset.scroll) {
1422			this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
1423		}
1424
1425		return {
1426			top: (
1427				pos.top	+																// The absolute mouse position
1428				this.offset.relative.top * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
1429				this.offset.parent.top * mod -										// The offsetParent's offset without borders (offset + border)
1430				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top ) * mod )
1431			),
1432			left: (
1433				pos.left +																// The absolute mouse position
1434				this.offset.relative.left * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
1435				this.offset.parent.left * mod	-										// The offsetParent's offset without borders (offset + border)
1436				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left ) * mod )
1437			)
1438		};
1439
1440	},
1441
1442	_generatePosition: function(event) {
1443
1444		var containment, co, top, left,
1445			o = this.options,
1446			scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent,
1447			pageX = event.pageX,
1448			pageY = event.pageY;
1449
1450		//Cache the scroll
1451		if (!this.offset.scroll) {
1452			this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
1453		}
1454
1455		/*
1456		 * - Position constraining -
1457		 * Constrain the position to a mix of grid, containment.
1458		 */
1459
1460		// If we are not dragging yet, we won't check for options
1461		if ( this.originalPosition ) {
1462			if ( this.containment ) {
1463				if ( this.relative_container ){
1464					co = this.relative_container.offset();
1465					containment = [
1466						this.containment[ 0 ] + co.left,
1467						this.containment[ 1 ] + co.top,
1468						this.containment[ 2 ] + co.left,
1469						this.containment[ 3 ] + co.top
1470					];
1471				}
1472				else {
1473					containment = this.containment;
1474				}
1475
1476				if(event.pageX - this.offset.click.left < containment[0]) {
1477					pageX = containment[0] + this.offset.click.left;
1478				}
1479				if(event.pageY - this.offset.click.top < containment[1]) {
1480					pageY = containment[1] + this.offset.click.top;
1481				}
1482				if(event.pageX - this.offset.click.left > containment[2]) {
1483					pageX = containment[2] + this.offset.click.left;
1484				}
1485				if(event.pageY - this.offset.click.top > containment[3]) {
1486					pageY = containment[3] + this.offset.click.top;
1487				}
1488			}
1489
1490			if(o.grid) {
1491				//Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
1492				top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
1493				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;
1494
1495				left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
1496				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;
1497			}
1498
1499		}
1500
1501		return {
1502			top: (
1503				pageY -																	// The absolute mouse position
1504				this.offset.click.top	-												// Click offset (relative to the element)
1505				this.offset.relative.top -												// Only for relative positioned nodes: Relative offset from element to offset parent
1506				this.offset.parent.top +												// The offsetParent's offset without borders (offset + border)
1507				( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top )
1508			),
1509			left: (
1510				pageX -																	// The absolute mouse position
1511				this.offset.click.left -												// Click offset (relative to the element)
1512				this.offset.relative.left -												// Only for relative positioned nodes: Relative offset from element to offset parent
1513				this.offset.parent.left +												// The offsetParent's offset without borders (offset + border)
1514				( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left )
1515			)
1516		};
1517
1518	},
1519
1520	_clear: function() {
1521		this.helper.removeClass("ui-draggable-dragging");
1522		if(this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
1523			this.helper.remove();
1524		}
1525		this.helper = null;
1526		this.cancelHelperRemoval = false;
1527	},
1528
1529	// From now on bulk stuff - mainly helpers
1530
1531	_trigger: function(type, event, ui) {
1532		ui = ui || this._uiHash();
1533		$.ui.plugin.call(this, type, [event, ui]);
1534		//The absolute position has to be recalculated after plugins
1535		if(type === "drag") {
1536			this.positionAbs = this._convertPositionTo("absolute");
1537		}
1538		return $.Widget.prototype._trigger.call(this, type, event, ui);
1539	},
1540
1541	plugins: {},
1542
1543	_uiHash: function() {
1544		return {
1545			helper: this.helper,
1546			position: this.position,
1547			originalPosition: this.originalPosition,
1548			offset: this.positionAbs
1549		};
1550	}
1551
1552});
1553
1554$.ui.plugin.add("draggable", "connectToSortable", {
1555	start: function(event, ui) {
1556
1557		var inst = $(this).data("ui-draggable"), o = inst.options,
1558			uiSortable = $.extend({}, ui, { item: inst.element });
1559		inst.sortables = [];
1560		$(o.connectToSortable).each(function() {
1561			var sortable = $.data(this, "ui-sortable");
1562			if (sortable && !sortable.options.disabled) {
1563				inst.sortables.push({
1564					instance: sortable,
1565					shouldRevert: sortable.options.revert
1566				});
1567				sortable.refreshPositions();	// Call the sortable's refreshPositions at drag start to refresh the containerCache since the sortable container cache is used in drag and needs to be up to date (this will ensure it's initialised as well as being kept in step with any changes that might have happened on the page).
1568				sortable._trigger("activate", event, uiSortable);
1569			}
1570		});
1571
1572	},
1573	stop: function(event, ui) {
1574
1575		//If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
1576		var inst = $(this).data("ui-draggable"),
1577			uiSortable = $.extend({}, ui, { item: inst.element });
1578
1579		$.each(inst.sortables, function() {
1580			if(this.instance.isOver) {
1581
1582				this.instance.isOver = 0;
1583
1584				inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
1585				this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
1586
1587				//The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: "valid/invalid"
1588				if(this.shouldRevert) {
1589					this.instance.options.revert = this.shouldRevert;
1590				}
1591
1592				//Trigger the stop of the sortable
1593				this.instance._mouseStop(event);
1594
1595				this.instance.options.helper = this.instance.options._helper;
1596
1597				//If the helper has been the original item, restore properties in the sortable
1598				if(inst.options.helper === "original") {
1599					this.instance.currentItem.css({ top: "auto", left: "auto" });
1600				}
1601
1602			} else {
1603				this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
1604				this.instance._trigger("deactivate", event, uiSortable);
1605			}
1606
1607		});
1608
1609	},
1610	drag: function(event, ui) {
1611
1612		var inst = $(this).data("ui-draggable"), that = this;
1613
1614		$.each(inst.sortables, function() {
1615
1616			var innermostIntersecting = false,
1617				thisSortable = this;
1618
1619			//Copy over some variables to allow calling the sortable's native _intersectsWith
1620			this.instance.positionAbs = inst.positionAbs;
1621			this.instance.helperProportions = inst.helperProportions;
1622			this.instance.offset.click = inst.offset.click;
1623
1624			if(this.instance._intersectsWith(this.instance.containerCache)) {
1625				innermostIntersecting = true;
1626				$.each(inst.sortables, function () {
1627					this.instance.positionAbs = inst.positionAbs;
1628					this.instance.helperProportions = inst.helperProportions;
1629					this.instance.offset.click = inst.offset.click;
1630					if (this !== thisSortable &&
1631						this.instance._intersectsWith(this.instance.containerCache) &&
1632						$.contains(thisSortable.instance.element[0], this.instance.element[0])
1633					) {
1634						innermostIntersecting = false;
1635					}
1636					return innermostIntersecting;
1637				});
1638			}
1639
1640
1641			if(innermostIntersecting) {
1642				//If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
1643				if(!this.instance.isOver) {
1644
1645					this.instance.isOver = 1;
1646					//Now we fake the start of dragging for the sortable instance,
1647					//by cloning the list group item, appending it to the sortable and using it as inst.currentItem
1648					//We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
1649					this.instance.currentItem = $(that).clone().removeAttr("id").appendTo(this.instance.element).data("ui-sortable-item", true);
1650					this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
1651					this.instance.options.helper = function() { return ui.helper[0]; };
1652
1653					event.target = this.instance.currentItem[0];
1654					this.instance._mouseCapture(event, true);
1655					this.instance._mouseStart(event, true, true);
1656
1657					//Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
1658					this.instance.offset.click.top = inst.offset.click.top;
1659					this.instance.offset.click.left = inst.offset.click.left;
1660					this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
1661					this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
1662
1663					inst._trigger("toSortable", event);
1664					inst.dropped = this.instance.element; //draggable revert needs that
1665					//hack so receive/update callbacks work (mostly)
1666					inst.currentItem = inst.element;
1667					this.instance.fromOutside = inst;
1668
1669				}
1670
1671				//Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
1672				if(this.instance.currentItem) {
1673					this.instance._mouseDrag(event);
1674				}
1675
1676			} else {
1677
1678				//If it doesn't intersect with the sortable, and it intersected before,
1679				//we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
1680				if(this.instance.isOver) {
1681
1682					this.instance.isOver = 0;
1683					this.instance.cancelHelperRemoval = true;
1684
1685					//Prevent reverting on this forced stop
1686					this.instance.options.revert = false;
1687
1688					// The out event needs to be triggered independently
1689					this.instance._trigger("out", event, this.instance._uiHash(this.instance));
1690
1691					this.instance._mouseStop(event, true);
1692					this.instance.options.helper = this.instance.options._helper;
1693
1694					//Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
1695					this.instance.currentItem.remove();
1696					if(this.instance.placeholder) {
1697						this.instance.placeholder.remove();
1698					}
1699
1700					inst._trigger("fromSortable", event);
1701					inst.dropped = false; //draggable revert needs that
1702				}
1703
1704			}
1705
1706		});
1707
1708	}
1709});
1710
1711$.ui.plugin.add("draggable", "cursor", {
1712	start: function() {
1713		var t = $("body"), o = $(this).data("ui-draggable").options;
1714		if (t.css("cursor")) {
1715			o._cursor = t.css("cursor");
1716		}
1717		t.css("cursor", o.cursor);
1718	},
1719	stop: function() {
1720		var o = $(this).data("ui-draggable").options;
1721		if (o._cursor) {
1722			$("body").css("cursor", o._cursor);
1723		}
1724	}
1725});
1726
1727$.ui.plugin.add("draggable", "opacity", {
1728	start: function(event, ui) {
1729		var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1730		if(t.css("opacity")) {
1731			o._opacity = t.css("opacity");
1732		}
1733		t.css("opacity", o.opacity);
1734	},
1735	stop: function(event, ui) {
1736		var o = $(this).data("ui-draggable").options;
1737		if(o._opacity) {
1738			$(ui.helper).css("opacity", o._opacity);
1739		}
1740	}
1741});
1742
1743$.ui.plugin.add("draggable", "scroll", {
1744	start: function() {
1745		var i = $(this).data("ui-draggable");
1746		if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
1747			i.overflowOffset = i.scrollParent.offset();
1748		}
1749	},
1750	drag: function( event ) {
1751
1752		var i = $(this).data("ui-draggable"), o = i.options, scrolled = false;
1753
1754		if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
1755
1756			if(!o.axis || o.axis !== "x") {
1757				if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
1758					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
1759				} else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity) {
1760					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
1761				}
1762			}
1763
1764			if(!o.axis || o.axis !== "y") {
1765				if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
1766					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
1767				} else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity) {
1768					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
1769				}
1770			}
1771
1772		} else {
1773
1774			if(!o.axis || o.axis !== "x") {
1775				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
1776					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
1777				} else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
1778					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
1779				}
1780			}
1781
1782			if(!o.axis || o.axis !== "y") {
1783				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
1784					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
1785				} else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
1786					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
1787				}
1788			}
1789
1790		}
1791
1792		if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
1793			$.ui.ddmanager.prepareOffsets(i, event);
1794		}
1795
1796	}
1797});
1798
1799$.ui.plugin.add("draggable", "snap", {
1800	start: function() {
1801
1802		var i = $(this).data("ui-draggable"),
1803			o = i.options;
1804
1805		i.snapElements = [];
1806
1807		$(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
1808			var $t = $(this),
1809				$o = $t.offset();
1810			if(this !== i.element[0]) {
1811				i.snapElements.push({
1812					item: this,
1813					width: $t.outerWidth(), height: $t.outerHeight(),
1814					top: $o.top, left: $o.left
1815				});
1816			}
1817		});
1818
1819	},
1820	drag: function(event, ui) {
1821
1822		var ts, bs, ls, rs, l, r, t, b, i, first,
1823			inst = $(this).data("ui-draggable"),
1824			o = inst.options,
1825			d = o.snapTolerance,
1826			x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
1827			y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
1828
1829		for (i = inst.snapElements.length - 1; i >= 0; i--){
1830
1831			l = inst.snapElements[i].left;
1832			r = l + inst.snapElements[i].width;
1833			t = inst.snapElements[i].top;
1834			b = t + inst.snapElements[i].height;
1835
1836			if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
1837				if(inst.snapElements[i].snapping) {
1838					(inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1839				}
1840				inst.snapElements[i].snapping = false;
1841				continue;
1842			}
1843
1844			if(o.snapMode !== "inner") {
1845				ts = Math.abs(t - y2) <= d;
1846				bs = Math.abs(b - y1) <= d;
1847				ls = Math.abs(l - x2) <= d;
1848				rs = Math.abs(r - x1) <= d;
1849				if(ts) {
1850					ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1851				}
1852				if(bs) {
1853					ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
1854				}
1855				if(ls) {
1856					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
1857				}
1858				if(rs) {
1859					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
1860				}
1861			}
1862
1863			first = (ts || bs || ls || rs);
1864
1865			if(o.snapMode !== "outer") {
1866				ts = Math.abs(t - y1) <= d;
1867				bs = Math.abs(b - y2) <= d;
1868				ls = Math.abs(l - x1) <= d;
1869				rs = Math.abs(r - x2) <= d;
1870				if(ts) {
1871					ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
1872				}
1873				if(bs) {
1874					ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1875				}
1876				if(ls) {
1877					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
1878				}
1879				if(rs) {
1880					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
1881				}
1882			}
1883
1884			if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
1885				(inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1886			}
1887			inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
1888
1889		}
1890
1891	}
1892});
1893
1894$.ui.plugin.add("draggable", "stack", {
1895	start: function() {
1896		var min,
1897			o = this.data("ui-draggable").options,
1898			group = $.makeArray($(o.stack)).sort(function(a,b) {
1899				return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
1900			});
1901
1902		if (!group.length) { return; }
1903
1904		min = parseInt($(group[0]).css("zIndex"), 10) || 0;
1905		$(group).each(function(i) {
1906			$(this).css("zIndex", min + i);
1907		});
1908		this.css("zIndex", (min + group.length));
1909	}
1910});
1911
1912$.ui.plugin.add("draggable", "zIndex", {
1913	start: function(event, ui) {
1914		var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1915		if(t.css("zIndex")) {
1916			o._zIndex = t.css("zIndex");
1917		}
1918		t.css("zIndex", o.zIndex);
1919	},
1920	stop: function(event, ui) {
1921		var o = $(this).data("ui-draggable").options;
1922		if(o._zIndex) {
1923			$(ui.helper).css("zIndex", o._zIndex);
1924		}
1925	}
1926});
1927
1928})(jQuery);
1929
1930(function( $, undefined ) {
1931
1932function isOverAxis( x, reference, size ) {
1933	return ( x > reference ) && ( x < ( reference + size ) );
1934}
1935
1936$.widget("ui.droppable", {
1937	version: "1.10.3",
1938	widgetEventPrefix: "drop",
1939	options: {
1940		accept: "*",

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