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

1384			this.containment = o.containment;
1385			return;
1386		}
1387
1388		if ( o.containment === "parent" ) {
1389			o.containment = this.helper[ 0 ].parentNode;
1390		}
1391
1392		c = $( o.containment );
1393		ce = c[ 0 ];
1394
1395		if( !ce ) {
1396			return;
1397		}
1398
1399		over = c.css( "overflow" ) !== "hidden";
1400
1401		this.containment = [
1402			( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
1403			( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ) ,
1404			( 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,
1405			( 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
1406		];
1407		this.relative_container = c;
1408	},
1409
1410	_convertPositionTo: function(d, pos) {
1411
1412		if(!pos) {
1413			pos = this.position;
1414		}
1415
1416		var mod = d === "absolute" ? 1 : -1,
1417			scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent;
1418
1419		//Cache the scroll
1420		if (!this.offset.scroll) {
1421			this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
1422		}
1423
1424		return {
1425			top: (
1426				pos.top	+																// The absolute mouse position
1427				this.offset.relative.top * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
1428				this.offset.parent.top * mod -										// The offsetParent's offset without borders (offset + border)
1429				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top ) * mod )
1430			),
1431			left: (
1432				pos.left +																// The absolute mouse position
1433				this.offset.relative.left * mod +										// Only for relative positioned nodes: Relative offset from element to offset parent
1434				this.offset.parent.left * mod	-										// The offsetParent's offset without borders (offset + border)
1435				( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left ) * mod )
1436			)
1437		};
1438
1439	},
1440
1441	_generatePosition: function(event) {
1442
1443		var containment, co, top, left,
1444			o = this.options,
1445			scroll = this.cssPosition === "absolute" && !( this.scrollParent[ 0 ] !== document && $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ? this.offsetParent : this.scrollParent,
1446			pageX = event.pageX,
1447			pageY = event.pageY;
1448
1449		//Cache the scroll
1450		if (!this.offset.scroll) {
1451			this.offset.scroll = {top : scroll.scrollTop(), left : scroll.scrollLeft()};
1452		}
1453
1454		/*
1455		 * - Position constraining -
1456		 * Constrain the position to a mix of grid, containment.
1457		 */
1458
1459		// If we are not dragging yet, we won't check for options
1460		if ( this.originalPosition ) {
1461			if ( this.containment ) {
1462				if ( this.relative_container ){
1463					co = this.relative_container.offset();
1464					containment = [
1465						this.containment[ 0 ] + co.left,
1466						this.containment[ 1 ] + co.top,
1467						this.containment[ 2 ] + co.left,
1468						this.containment[ 3 ] + co.top
1469					];
1470				}
1471				else {
1472					containment = this.containment;
1473				}
1474
1475				if(event.pageX - this.offset.click.left < containment[0]) {
1476					pageX = containment[0] + this.offset.click.left;
1477				}
1478				if(event.pageY - this.offset.click.top < containment[1]) {
1479					pageY = containment[1] + this.offset.click.top;
1480				}
1481				if(event.pageX - this.offset.click.left > containment[2]) {
1482					pageX = containment[2] + this.offset.click.left;
1483				}
1484				if(event.pageY - this.offset.click.top > containment[3]) {
1485					pageY = containment[3] + this.offset.click.top;
1486				}
1487			}
1488
1489			if(o.grid) {
1490				//Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
1491				top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
1492				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;
1493
1494				left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
1495				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;
1496			}
1497
1498		}
1499
1500		return {
1501			top: (
1502				pageY -																	// The absolute mouse position
1503				this.offset.click.top	-												// Click offset (relative to the element)
1504				this.offset.relative.top -												// Only for relative positioned nodes: Relative offset from element to offset parent
1505				this.offset.parent.top +												// The offsetParent's offset without borders (offset + border)
1506				( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : this.offset.scroll.top )
1507			),
1508			left: (
1509				pageX -																	// The absolute mouse position
1510				this.offset.click.left -												// Click offset (relative to the element)
1511				this.offset.relative.left -												// Only for relative positioned nodes: Relative offset from element to offset parent
1512				this.offset.parent.left +												// The offsetParent's offset without borders (offset + border)
1513				( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : this.offset.scroll.left )
1514			)
1515		};
1516
1517	},
1518
1519	_clear: function() {
1520		this.helper.removeClass("ui-draggable-dragging");
1521		if(this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
1522			this.helper.remove();
1523		}
1524		this.helper = null;
1525		this.cancelHelperRemoval = false;
1526	},
1527
1528	// From now on bulk stuff - mainly helpers
1529
1530	_trigger: function(type, event, ui) {
1531		ui = ui || this._uiHash();
1532		$.ui.plugin.call(this, type, [event, ui]);
1533		//The absolute position has to be recalculated after plugins
1534		if(type === "drag") {
1535			this.positionAbs = this._convertPositionTo("absolute");
1536		}
1537		return $.Widget.prototype._trigger.call(this, type, event, ui);
1538	},
1539
1540	plugins: {},
1541
1542	_uiHash: function() {
1543		return {
1544			helper: this.helper,
1545			position: this.position,
1546			originalPosition: this.originalPosition,
1547			offset: this.positionAbs
1548		};
1549	}
1550
1551});
1552
1553$.ui.plugin.add("draggable", "connectToSortable", {
1554	start: function(event, ui) {
1555
1556		var inst = $(this).data("ui-draggable"), o = inst.options,
1557			uiSortable = $.extend({}, ui, { item: inst.element });
1558		inst.sortables = [];
1559		$(o.connectToSortable).each(function() {
1560			var sortable = $.data(this, "ui-sortable");

1561			if (sortable && !sortable.options.disabled) {
1562				inst.sortables.push({
1563					instance: sortable,
1564					shouldRevert: sortable.options.revert
1565				});
1566				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).
1567				sortable._trigger("activate", event, uiSortable);
1568			}
1569		});
1570
1571	},
1572	stop: function(event, ui) {
1573
1574		//If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
1575		var inst = $(this).data("ui-draggable"),
1576			uiSortable = $.extend({}, ui, { item: inst.element });
1577
1578		$.each(inst.sortables, function() {
1579			if(this.instance.isOver) {
1580
1581				this.instance.isOver = 0;
1582
1583				inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
1584				this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
1585
1586				//The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: "valid/invalid"
1587				if(this.shouldRevert) {
1588					this.instance.options.revert = this.shouldRevert;
1589				}
1590
1591				//Trigger the stop of the sortable
1592				this.instance._mouseStop(event);
1593
1594				this.instance.options.helper = this.instance.options._helper;
1595
1596				//If the helper has been the original item, restore properties in the sortable
1597				if(inst.options.helper === "original") {
1598					this.instance.currentItem.css({ top: "auto", left: "auto" });
1599				}
1600
1601			} else {
1602				this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
1603				this.instance._trigger("deactivate", event, uiSortable);
1604			}
1605
1606		});
1607
1608	},
1609	drag: function(event, ui) {
1610
1611		var inst = $(this).data("ui-draggable"), that = this;
1612
1613		$.each(inst.sortables, function() {
1614
1615			var innermostIntersecting = false,
1616				thisSortable = this;
1617
1618			//Copy over some variables to allow calling the sortable's native _intersectsWith
1619			this.instance.positionAbs = inst.positionAbs;
1620			this.instance.helperProportions = inst.helperProportions;
1621			this.instance.offset.click = inst.offset.click;
1622
1623			if(this.instance._intersectsWith(this.instance.containerCache)) {
1624				innermostIntersecting = true;
1625				$.each(inst.sortables, function () {
1626					this.instance.positionAbs = inst.positionAbs;
1627					this.instance.helperProportions = inst.helperProportions;
1628					this.instance.offset.click = inst.offset.click;
1629					if (this !== thisSortable &&
1630						this.instance._intersectsWith(this.instance.containerCache) &&
1631						$.contains(thisSortable.instance.element[0], this.instance.element[0])
1632					) {
1633						innermostIntersecting = false;
1634					}
1635					return innermostIntersecting;
1636				});
1637			}
1638
1639
1640			if(innermostIntersecting) {
1641				//If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
1642				if(!this.instance.isOver) {
1643
1644					this.instance.isOver = 1;
1645					//Now we fake the start of dragging for the sortable instance,
1646					//by cloning the list group item, appending it to the sortable and using it as inst.currentItem
1647					//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)
1648					this.instance.currentItem = $(that).clone().removeAttr("id").appendTo(this.instance.element).data("ui-sortable-item", true);
1649					this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
1650					this.instance.options.helper = function() { return ui.helper[0]; };
1651
1652					event.target = this.instance.currentItem[0];
1653					this.instance._mouseCapture(event, true);
1654					this.instance._mouseStart(event, true, true);
1655
1656					//Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
1657					this.instance.offset.click.top = inst.offset.click.top;
1658					this.instance.offset.click.left = inst.offset.click.left;
1659					this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
1660					this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
1661
1662					inst._trigger("toSortable", event);
1663					inst.dropped = this.instance.element; //draggable revert needs that
1664					//hack so receive/update callbacks work (mostly)
1665					inst.currentItem = inst.element;
1666					this.instance.fromOutside = inst;
1667
1668				}
1669
1670				//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
1671				if(this.instance.currentItem) {
1672					this.instance._mouseDrag(event);
1673				}
1674
1675			} else {
1676
1677				//If it doesn't intersect with the sortable, and it intersected before,
1678				//we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
1679				if(this.instance.isOver) {
1680
1681					this.instance.isOver = 0;
1682					this.instance.cancelHelperRemoval = true;
1683
1684					//Prevent reverting on this forced stop
1685					this.instance.options.revert = false;
1686
1687					// The out event needs to be triggered independently
1688					this.instance._trigger("out", event, this.instance._uiHash(this.instance));
1689
1690					this.instance._mouseStop(event, true);
1691					this.instance.options.helper = this.instance.options._helper;
1692
1693					//Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
1694					this.instance.currentItem.remove();
1695					if(this.instance.placeholder) {
1696						this.instance.placeholder.remove();
1697					}
1698
1699					inst._trigger("fromSortable", event);
1700					inst.dropped = false; //draggable revert needs that
1701				}
1702
1703			}
1704
1705		});
1706
1707	}
1708});
1709
1710$.ui.plugin.add("draggable", "cursor", {
1711	start: function() {
1712		var t = $("body"), o = $(this).data("ui-draggable").options;
1713		if (t.css("cursor")) {
1714			o._cursor = t.css("cursor");
1715		}
1716		t.css("cursor", o.cursor);
1717	},
1718	stop: function() {
1719		var o = $(this).data("ui-draggable").options;
1720		if (o._cursor) {
1721			$("body").css("cursor", o._cursor);
1722		}
1723	}
1724});
1725
1726$.ui.plugin.add("draggable", "opacity", {
1727	start: function(event, ui) {
1728		var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1729		if(t.css("opacity")) {
1730			o._opacity = t.css("opacity");
1731		}
1732		t.css("opacity", o.opacity);
1733	},
1734	stop: function(event, ui) {
1735		var o = $(this).data("ui-draggable").options;
1736		if(o._opacity) {
1737			$(ui.helper).css("opacity", o._opacity);
1738		}
1739	}
1740});
1741
1742$.ui.plugin.add("draggable", "scroll", {
1743	start: function() {
1744		var i = $(this).data("ui-draggable");
1745		if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
1746			i.overflowOffset = i.scrollParent.offset();
1747		}
1748	},
1749	drag: function( event ) {
1750
1751		var i = $(this).data("ui-draggable"), o = i.options, scrolled = false;
1752
1753		if(i.scrollParent[0] !== document && i.scrollParent[0].tagName !== "HTML") {
1754
1755			if(!o.axis || o.axis !== "x") {
1756				if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
1757					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
1758				} else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity) {
1759					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
1760				}
1761			}
1762
1763			if(!o.axis || o.axis !== "y") {
1764				if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
1765					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
1766				} else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity) {
1767					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
1768				}
1769			}
1770
1771		} else {
1772
1773			if(!o.axis || o.axis !== "x") {
1774				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
1775					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
1776				} else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
1777					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
1778				}
1779			}
1780
1781			if(!o.axis || o.axis !== "y") {
1782				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
1783					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
1784				} else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
1785					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
1786				}
1787			}
1788
1789		}
1790
1791		if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
1792			$.ui.ddmanager.prepareOffsets(i, event);
1793		}
1794
1795	}
1796});
1797
1798$.ui.plugin.add("draggable", "snap", {
1799	start: function() {
1800
1801		var i = $(this).data("ui-draggable"),
1802			o = i.options;
1803
1804		i.snapElements = [];
1805
1806		$(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
1807			var $t = $(this),
1808				$o = $t.offset();
1809			if(this !== i.element[0]) {
1810				i.snapElements.push({
1811					item: this,
1812					width: $t.outerWidth(), height: $t.outerHeight(),
1813					top: $o.top, left: $o.left
1814				});
1815			}
1816		});
1817
1818	},
1819	drag: function(event, ui) {
1820
1821		var ts, bs, ls, rs, l, r, t, b, i, first,
1822			inst = $(this).data("ui-draggable"),
1823			o = inst.options,
1824			d = o.snapTolerance,
1825			x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
1826			y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
1827
1828		for (i = inst.snapElements.length - 1; i >= 0; i--){
1829
1830			l = inst.snapElements[i].left;
1831			r = l + inst.snapElements[i].width;
1832			t = inst.snapElements[i].top;
1833			b = t + inst.snapElements[i].height;
1834
1835			if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
1836				if(inst.snapElements[i].snapping) {
1837					(inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1838				}
1839				inst.snapElements[i].snapping = false;
1840				continue;
1841			}
1842
1843			if(o.snapMode !== "inner") {
1844				ts = Math.abs(t - y2) <= d;
1845				bs = Math.abs(b - y1) <= d;
1846				ls = Math.abs(l - x2) <= d;
1847				rs = Math.abs(r - x1) <= d;
1848				if(ts) {
1849					ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1850				}
1851				if(bs) {
1852					ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
1853				}
1854				if(ls) {
1855					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
1856				}
1857				if(rs) {
1858					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
1859				}
1860			}
1861
1862			first = (ts || bs || ls || rs);
1863
1864			if(o.snapMode !== "outer") {
1865				ts = Math.abs(t - y1) <= d;
1866				bs = Math.abs(b - y2) <= d;
1867				ls = Math.abs(l - x1) <= d;
1868				rs = Math.abs(r - x2) <= d;
1869				if(ts) {
1870					ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
1871				}
1872				if(bs) {
1873					ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
1874				}
1875				if(ls) {
1876					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
1877				}
1878				if(rs) {
1879					ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
1880				}
1881			}
1882
1883			if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
1884				(inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
1885			}
1886			inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
1887
1888		}
1889
1890	}
1891});
1892
1893$.ui.plugin.add("draggable", "stack", {
1894	start: function() {
1895		var min,
1896			o = this.data("ui-draggable").options,
1897			group = $.makeArray($(o.stack)).sort(function(a,b) {
1898				return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
1899			});
1900
1901		if (!group.length) { return; }
1902
1903		min = parseInt($(group[0]).css("zIndex"), 10) || 0;
1904		$(group).each(function(i) {
1905			$(this).css("zIndex", min + i);
1906		});
1907		this.css("zIndex", (min + group.length));
1908	}
1909});
1910
1911$.ui.plugin.add("draggable", "zIndex", {
1912	start: function(event, ui) {
1913		var t = $(ui.helper), o = $(this).data("ui-draggable").options;
1914		if(t.css("zIndex")) {
1915			o._zIndex = t.css("zIndex");
1916		}
1917		t.css("zIndex", o.zIndex);
1918	},
1919	stop: function(event, ui) {
1920		var o = $(this).data("ui-draggable").options;
1921		if(o._zIndex) {
1922			$(ui.helper).css("zIndex", o._zIndex);
1923		}
1924	}
1925});
1926
1927})(jQuery);
1928
1929(function( $, undefined ) {
1930
1931function isOverAxis( x, reference, size ) {
1932	return ( x > reference ) && ( x < ( reference + size ) );
1933}
1934
1935$.widget("ui.droppable", {
1936	version: "1.10.3",
1937	widgetEventPrefix: "drop",
1938	options: {
1939		accept: "*",

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