https://datashine.org.uk/js/jquery-ui-1.10.4/ui/jquery-ui.js

1/*! jQuery UI - v1.10.4 - 2014-01-17
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 2014 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.4",
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) : 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 ( arguments.length === 1 ) {
624					return curOption[ key ] === undefined ? null : curOption[ key ];
625				}
626				curOption[ key ] = value;
627			} else {
628				if ( arguments.length === 1 ) {
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.4",
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.4",
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.4",
1937	widgetEventPrefix: "drop",
1938	options: {
1939		accept: "*",
1940		activeClass: false,
1941		addClasses: true,
1942		greedy: false,
1943		hoverClass: false,
1944		scope: "default",
1945		tolerance: "intersect",
1946
1947		// callbacks
1948		activate: null,
1949		deactivate: null,
1950		drop: null,
1951		out: null,
1952		over: null
1953	},
1954	_create: function() {
1955
1956		var proportions,
1957			o = this.options,
1958			accept = o.accept;
1959
1960		this.isover = false;
1961		this.isout = true;
1962
1963		this.accept = $.isFunction(accept) ? accept : function(d) {
1964			return d.is(accept);
1965		};
1966
1967		this.proportions = function( /* valueToWrite */ ) {
1968			if ( arguments.length ) {
1969				// Store the droppable's proportions
1970				proportions = arguments[ 0 ];
1971			} else {
1972				// Retrieve or derive the droppable's proportions
1973				return proportions ?
1974					proportions :
1975					proportions = {
1976						width: this.element[ 0 ].offsetWidth,
1977						height: this.element[ 0 ].offsetHeight
1978					};
1979			}
1980		};
1981
1982		// Add the reference and positions to the manager
1983		$.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
1984		$.ui.ddmanager.droppables[o.scope].push(this);
1985
1986		(o.addClasses && this.element.addClass("ui-droppable"));
1987
1988	},
1989
1990	_destroy: function() {
1991		var i = 0,
1992			drop = $.ui.ddmanager.droppables[this.options.scope];
1993
1994		for ( ; i < drop.length; i++ ) {
1995			if ( drop[i] === this ) {
1996				drop.splice(i, 1);
1997			}
1998		}
1999
2000		this.element.removeClass("ui-droppable ui-droppable-disabled");
2001	},
2002
2003	_setOption: function(key, value) {
2004
2005		if(key === "accept") {
2006			this.accept = $.isFunction(value) ? value : function(d) {
2007				return d.is(value);
2008			};
2009		}
2010		$.Widget.prototype._setOption.apply(this, arguments);
2011	},
2012
2013	_activate: function(event) {
2014		var draggable = $.ui.ddmanager.current;
2015		if(this.options.activeClass) {
2016			this.element.addClass(this.options.activeClass);
2017		}
2018		if(draggable){
2019			this._trigger("activate", event, this.ui(draggable));
2020		}
2021	},
2022
2023	_deactivate: function(event) {
2024		var draggable = $.ui.ddmanager.current;
2025		if(this.options.activeClass) {
2026			this.element.removeClass(this.options.activeClass);
2027		}
2028		if(draggable){
2029			this._trigger("deactivate", event, this.ui(draggable));
2030		}
2031	},
2032
2033	_over: function(event) {
2034
2035		var draggable = $.ui.ddmanager.current;
2036
2037		// Bail if draggable and droppable are same element
2038		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2039			return;
2040		}
2041
2042		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2043			if(this.options.hoverClass) {
2044				this.element.addClass(this.options.hoverClass);
2045			}
2046			this._trigger("over", event, this.ui(draggable));
2047		}
2048
2049	},
2050
2051	_out: function(event) {
2052
2053		var draggable = $.ui.ddmanager.current;
2054
2055		// Bail if draggable and droppable are same element
2056		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2057			return;
2058		}
2059
2060		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2061			if(this.options.hoverClass) {
2062				this.element.removeClass(this.options.hoverClass);
2063			}
2064			this._trigger("out", event, this.ui(draggable));
2065		}
2066
2067	},
2068
2069	_drop: function(event,custom) {
2070
2071		var draggable = custom || $.ui.ddmanager.current,
2072			childrenIntersection = false;
2073
2074		// Bail if draggable and droppable are same element
2075		if (!draggable || (draggable.currentItem || draggable.element)[0] === this.element[0]) {
2076			return false;
2077		}
2078
2079		this.element.find(":data(ui-droppable)").not(".ui-draggable-dragging").each(function() {
2080			var inst = $.data(this, "ui-droppable");
2081			if(
2082				inst.options.greedy &&
2083				!inst.options.disabled &&
2084				inst.options.scope === draggable.options.scope &&
2085				inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element)) &&
2086				$.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
2087			) { childrenIntersection = true; return false; }
2088		});
2089		if(childrenIntersection) {
2090			return false;
2091		}
2092
2093		if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2094			if(this.options.activeClass) {
2095				this.element.removeClass(this.options.activeClass);
2096			}
2097			if(this.options.hoverClass) {
2098				this.element.removeClass(this.options.hoverClass);
2099			}
2100			this._trigger("drop", event, this.ui(draggable));
2101			return this.element;
2102		}
2103
2104		return false;
2105
2106	},
2107
2108	ui: function(c) {
2109		return {
2110			draggable: (c.currentItem || c.element),
2111			helper: c.helper,
2112			position: c.position,
2113			offset: c.positionAbs
2114		};
2115	}
2116
2117});
2118
2119$.ui.intersect = function(draggable, droppable, toleranceMode) {
2120
2121	if (!droppable.offset) {
2122		return false;
2123	}
2124
2125	var draggableLeft, draggableTop,
2126		x1 = (draggable.positionAbs || draggable.position.absolute).left,
2127		y1 = (draggable.positionAbs || draggable.position.absolute).top,
2128		x2 = x1 + draggable.helperProportions.width,
2129		y2 = y1 + draggable.helperProportions.height,
2130		l = droppable.offset.left,
2131		t = droppable.offset.top,
2132		r = l + droppable.proportions().width,
2133		b = t + droppable.proportions().height;
2134
2135	switch (toleranceMode) {
2136		case "fit":
2137			return (l <= x1 && x2 <= r && t <= y1 && y2 <= b);
2138		case "intersect":
2139			return (l < x1 + (draggable.helperProportions.width / 2) && // Right Half
2140				x2 - (draggable.helperProportions.width / 2) < r && // Left Half
2141				t < y1 + (draggable.helperProportions.height / 2) && // Bottom Half
2142				y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
2143		case "pointer":
2144			draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left);
2145			draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top);
2146			return isOverAxis( draggableTop, t, droppable.proportions().height ) && isOverAxis( draggableLeft, l, droppable.proportions().width );
2147		case "touch":
2148			return (
2149				(y1 >= t && y1 <= b) ||	// Top edge touching
2150				(y2 >= t && y2 <= b) ||	// Bottom edge touching
2151				(y1 < t && y2 > b)		// Surrounded vertically
2152			) && (
2153				(x1 >= l && x1 <= r) ||	// Left edge touching
2154				(x2 >= l && x2 <= r) ||	// Right edge touching
2155				(x1 < l && x2 > r)		// Surrounded horizontally
2156			);
2157		default:
2158			return false;
2159		}
2160
2161};
2162
2163/*
2164	This manager tracks offsets of draggables and droppables
2165*/
2166$.ui.ddmanager = {
2167	current: null,
2168	droppables: { "default": [] },
2169	prepareOffsets: function(t, event) {
2170
2171		var i, j,
2172			m = $.ui.ddmanager.droppables[t.options.scope] || [],
2173			type = event ? event.type : null, // workaround for #2317
2174			list = (t.currentItem || t.element).find(":data(ui-droppable)").addBack();
2175
2176		droppablesLoop: for (i = 0; i < m.length; i++) {
2177
2178			//No disabled and non-accepted
2179			if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) {
2180				continue;
2181			}
2182
2183			// Filter out elements in the current dragged item
2184			for (j=0; j < list.length; j++) {
2185				if(list[j] === m[i].element[0]) {
2186					m[i].proportions().height = 0;
2187					continue droppablesLoop;
2188				}
2189			}
2190
2191			m[i].visible = m[i].element.css("display") !== "none";
2192			if(!m[i].visible) {
2193				continue;
2194			}
2195
2196			//Activate the droppable if used directly from draggables
2197			if(type === "mousedown") {
2198				m[i]._activate.call(m[i], event);
2199			}
2200
2201			m[ i ].offset = m[ i ].element.offset();
2202			m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight });
2203
2204		}
2205
2206	},
2207	drop: function(draggable, event) {
2208
2209		var dropped = false;
2210		// Create a copy of the droppables in case the list changes during the drop (#9116)
2211		$.each(($.ui.ddmanager.droppables[draggable.options.scope] || []).slice(), function() {
2212
2213			if(!this.options) {
2214				return;
2215			}
2216			if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance)) {
2217				dropped = this._drop.call(this, event) || dropped;
2218			}
2219
2220			if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2221				this.isout = true;
2222				this.isover = false;
2223				this._deactivate.call(this, event);
2224			}
2225
2226		});
2227		return dropped;
2228
2229	},
2230	dragStart: function( draggable, event ) {
2231		//Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
2232		draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
2233			if( !draggable.options.refreshPositions ) {
2234				$.ui.ddmanager.prepareOffsets( draggable, event );
2235			}
2236		});
2237	},
2238	drag: function(draggable, event) {
2239
2240		//If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
2241		if(draggable.options.refreshPositions) {
2242			$.ui.ddmanager.prepareOffsets(draggable, event);
2243		}
2244
2245		//Run through all droppables and check their positions based on specific tolerance options
2246		$.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
2247
2248			if(this.options.disabled || this.greedyChild || !this.visible) {
2249				return;
2250			}
2251
2252			var parentInstance, scope, parent,
2253				intersects = $.ui.intersect(draggable, this, this.options.tolerance),
2254				c = !intersects && this.isover ? "isout" : (intersects && !this.isover ? "isover" : null);
2255			if(!c) {
2256				return;
2257			}
2258
2259			if (this.options.greedy) {
2260				// find droppable parents with same scope
2261				scope = this.options.scope;
2262				parent = this.element.parents(":data(ui-droppable)").filter(function () {
2263					return $.data(this, "ui-droppable").options.scope === scope;
2264				});
2265
2266				if (parent.length) {
2267					parentInstance = $.data(parent[0], "ui-droppable");
2268					parentInstance.greedyChild = (c === "isover");
2269				}
2270			}
2271
2272			// we just moved into a greedy child
2273			if (parentInstance && c === "isover") {
2274				parentInstance.isover = false;
2275				parentInstance.isout = true;
2276				parentInstance._out.call(parentInstance, event);
2277			}
2278
2279			this[c] = true;
2280			this[c === "isout" ? "isover" : "isout"] = false;
2281			this[c === "isover" ? "_over" : "_out"].call(this, event);
2282
2283			// we just moved out of a greedy child
2284			if (parentInstance && c === "isout") {
2285				parentInstance.isout = false;
2286				parentInstance.isover = true;
2287				parentInstance._over.call(parentInstance, event);
2288			}
2289		});
2290
2291	},
2292	dragStop: function( draggable, event ) {
2293		draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
2294		//Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
2295		if( !draggable.options.refreshPositions ) {
2296			$.ui.ddmanager.prepareOffsets( draggable, event );
2297		}
2298	}
2299};
2300
2301})(jQuery);
2302
2303(function( $, undefined ) {
2304
2305function num(v) {
2306	return parseInt(v, 10) || 0;
2307}
2308
2309function isNumber(value) {
2310	return !isNaN(parseInt(value, 10));
2311}
2312
2313$.widget("ui.resizable", $.ui.mouse, {
2314	version: "1.10.4",
2315	widgetEventPrefix: "resize",
2316	options: {
2317		alsoResize: false,
2318		animate: false,
2319		animateDuration: "slow",
2320		animateEasing: "swing",
2321		aspectRatio: false,
2322		autoHide: false,
2323		containment: false,
2324		ghost: false,
2325		grid: false,
2326		handles: "e,s,se",
2327		helper: false,
2328		maxHeight: null,
2329		maxWidth: null,
2330		minHeight: 10,
2331		minWidth: 10,
2332		// See #7960
2333		zIndex: 90,
2334
2335		// callbacks
2336		resize: null,
2337		start: null,
2338		stop: null
2339	},
2340	_create: function() {
2341
2342		var n, i, handle, axis, hname,
2343			that = this,
2344			o = this.options;
2345		this.element.addClass("ui-resizable");
2346
2347		$.extend(this, {
2348			_aspectRatio: !!(o.aspectRatio),
2349			aspectRatio: o.aspectRatio,
2350			originalElement: this.element,
2351			_proportionallyResizeElements: [],
2352			_helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
2353		});
2354
2355		//Wrap the element if it cannot hold child nodes
2356		if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
2357
2358			//Create a wrapper element and set the wrapper to the new current internal element
2359			this.element.wrap(
2360				$("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
2361					position: this.element.css("position"),
2362					width: this.element.outerWidth(),
2363					height: this.element.outerHeight(),
2364					top: this.element.css("top"),
2365					left: this.element.css("left")
2366				})
2367			);
2368
2369			//Overwrite the original this.element
2370			this.element = this.element.parent().data(
2371				"ui-resizable", this.element.data("ui-resizable")
2372			);
2373
2374			this.elementIsWrapper = true;
2375
2376			//Move margins to the wrapper
2377			this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
2378			this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
2379
2380			//Prevent Safari textarea resize
2381			this.originalResizeStyle = this.originalElement.css("resize");
2382			this.originalElement.css("resize", "none");
2383
2384			//Push the actual element to our proportionallyResize internal array
2385			this._proportionallyResizeElements.push(this.originalElement.css({ position: "static", zoom: 1, display: "block" }));
2386
2387			// avoid IE jump (hard set the margin)
2388			this.originalElement.css({ margin: this.originalElement.css("margin") });
2389
2390			// fix handlers offset
2391			this._proportionallyResize();
2392
2393		}
2394
2395		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" });
2396		if(this.handles.constructor === String) {
2397
2398			if ( this.handles === "all") {
2399				this.handles = "n,e,s,w,se,sw,ne,nw";
2400			}
2401
2402			n = this.handles.split(",");
2403			this.handles = {};
2404
2405			for(i = 0; i < n.length; i++) {
2406
2407				handle = $.trim(n[i]);
2408				hname = "ui-resizable-"+handle;
2409				axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
2410
2411				// Apply zIndex to all handles - see #7960
2412				axis.css({ zIndex: o.zIndex });
2413
2414				//TODO : What's going on here?
2415				if ("se" === handle) {
2416					axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
2417				}
2418
2419				//Insert into internal handles object and append to element
2420				this.handles[handle] = ".ui-resizable-"+handle;
2421				this.element.append(axis);
2422			}
2423
2424		}
2425
2426		this._renderAxis = function(target) {
2427
2428			var i, axis, padPos, padWrapper;
2429
2430			target = target || this.element;
2431
2432			for(i in this.handles) {
2433
2434				if(this.handles[i].constructor === String) {
2435					this.handles[i] = $(this.handles[i], this.element).show();
2436				}
2437
2438				//Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
2439				if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
2440
2441					axis = $(this.handles[i], this.element);
2442
2443					//Checking the correct pad and border
2444					padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
2445
2446					//The padding type i have to apply...
2447					padPos = [ "padding",
2448						/ne|nw|n/.test(i) ? "Top" :
2449						/se|sw|s/.test(i) ? "Bottom" :
2450						/^e$/.test(i) ? "Right" : "Left" ].join("");
2451
2452					target.css(padPos, padWrapper);
2453
2454					this._proportionallyResize();
2455
2456				}
2457
2458				//TODO: What's that good for? There's not anything to be executed left
2459				if(!$(this.handles[i]).length) {
2460					continue;
2461				}
2462			}
2463		};
2464
2465		//TODO: make renderAxis a prototype function
2466		this._renderAxis(this.element);
2467
2468		this._handles = $(".ui-resizable-handle", this.element)
2469			.disableSelection();
2470
2471		//Matching axis name
2472		this._handles.mouseover(function() {
2473			if (!that.resizing) {
2474				if (this.className) {
2475					axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
2476				}
2477				//Axis, default = se
2478				that.axis = axis && axis[1] ? axis[1] : "se";
2479			}
2480		});
2481
2482		//If we want to auto hide the elements
2483		if (o.autoHide) {
2484			this._handles.hide();
2485			$(this.element)
2486				.addClass("ui-resizable-autohide")
2487				.mouseenter(function() {
2488					if (o.disabled) {
2489						return;
2490					}
2491					$(this).removeClass("ui-resizable-autohide");
2492					that._handles.show();
2493				})
2494				.mouseleave(function(){
2495					if (o.disabled) {
2496						return;
2497					}
2498					if (!that.resizing) {
2499						$(this).addClass("ui-resizable-autohide");
2500						that._handles.hide();
2501					}
2502				});
2503		}
2504
2505		//Initialize the mouse interaction
2506		this._mouseInit();
2507
2508	},
2509
2510	_destroy: function() {
2511
2512		this._mouseDestroy();
2513
2514		var wrapper,
2515			_destroy = function(exp) {
2516				$(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
2517					.removeData("resizable").removeData("ui-resizable").unbind(".resizable").find(".ui-resizable-handle").remove();
2518			};
2519
2520		//TODO: Unwrap at same DOM position
2521		if (this.elementIsWrapper) {
2522			_destroy(this.element);
2523			wrapper = this.element;
2524			this.originalElement.css({
2525				position: wrapper.css("position"),
2526				width: wrapper.outerWidth(),
2527				height: wrapper.outerHeight(),
2528				top: wrapper.css("top"),
2529				left: wrapper.css("left")
2530			}).insertAfter( wrapper );
2531			wrapper.remove();
2532		}
2533
2534		this.originalElement.css("resize", this.originalResizeStyle);
2535		_destroy(this.originalElement);
2536
2537		return this;
2538	},
2539
2540	_mouseCapture: function(event) {
2541		var i, handle,
2542			capture = false;
2543
2544		for (i in this.handles) {
2545			handle = $(this.handles[i])[0];
2546			if (handle === event.target || $.contains(handle, event.target)) {
2547				capture = true;
2548			}
2549		}
2550
2551		return !this.options.disabled && capture;
2552	},
2553
2554	_mouseStart: function(event) {
2555
2556		var curleft, curtop, cursor,
2557			o = this.options,
2558			iniPos = this.element.position(),
2559			el = this.element;
2560
2561		this.resizing = true;
2562
2563		// bugfix for http://dev.jquery.com/ticket/1749
2564		if ( (/absolute/).test( el.css("position") ) ) {
2565			el.css({ position: "absolute", top: el.css("top"), left: el.css("left") });
2566		} else if (el.is(".ui-draggable")) {
2567			el.css({ position: "absolute", top: iniPos.top, left: iniPos.left });
2568		}
2569
2570		this._renderProxy();
2571
2572		curleft = num(this.helper.css("left"));
2573		curtop = num(this.helper.css("top"));
2574
2575		if (o.containment) {
2576			curleft += $(o.containment).scrollLeft() || 0;
2577			curtop += $(o.containment).scrollTop() || 0;
2578		}
2579
2580		//Store needed variables
2581		this.offset = this.helper.offset();
2582		this.position = { left: curleft, top: curtop };
2583		this.size = this._helper ? { width: this.helper.width(), height: this.helper.height() } : { width: el.width(), height: el.height() };
2584		this.originalSize = this._helper ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
2585		this.originalPosition = { left: curleft, top: curtop };
2586		this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
2587		this.originalMousePosition = { left: event.pageX, top: event.pageY };
2588
2589		//Aspect Ratio
2590		this.aspectRatio = (typeof o.aspectRatio === "number") ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);
2591
2592		cursor = $(".ui-resizable-" + this.axis).css("cursor");
2593		$("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
2594
2595		el.addClass("ui-resizable-resizing");
2596		this._propagate("start", event);
2597		return true;
2598	},
2599
2600	_mouseDrag: function(event) {
2601
2602		//Increase performance, avoid regex
2603		var data,
2604			el = this.helper, props = {},
2605			smp = this.originalMousePosition,
2606			a = this.axis,
2607			prevTop = this.position.top,
2608			prevLeft = this.position.left,
2609			prevWidth = this.size.width,
2610			prevHeight = this.size.height,
2611			dx = (event.pageX-smp.left)||0,
2612			dy = (event.pageY-smp.top)||0,
2613			trigger = this._change[a];
2614
2615		if (!trigger) {
2616			return false;
2617		}
2618
2619		// Calculate the attrs that will be change
2620		data = trigger.apply(this, [event, dx, dy]);
2621
2622		// Put this in the mouseDrag handler since the user can start pressing shift while resizing
2623		this._updateVirtualBoundaries(event.shiftKey);
2624		if (this._aspectRatio || event.shiftKey) {
2625			data = this._updateRatio(data, event);
2626		}
2627
2628		data = this._respectSize(data, event);
2629
2630		this._updateCache(data);
2631
2632		// plugins callbacks need to be called first
2633		this._propagate("resize", event);
2634
2635		if (this.position.top !== prevTop) {
2636			props.top = this.position.top + "px";
2637		}
2638		if (this.position.left !== prevLeft) {
2639			props.left = this.position.left + "px";
2640		}
2641		if (this.size.width !== prevWidth) {
2642			props.width = this.size.width + "px";
2643		}
2644		if (this.size.height !== prevHeight) {
2645			props.height = this.size.height + "px";
2646		}
2647		el.css(props);
2648
2649		if (!this._helper && this._proportionallyResizeElements.length) {
2650			this._proportionallyResize();
2651		}
2652
2653		// Call the user callback if the element was resized
2654		if ( ! $.isEmptyObject(props) ) {
2655			this._trigger("resize", event, this.ui());
2656		}
2657
2658		return false;
2659	},
2660
2661	_mouseStop: function(event) {
2662
2663		this.resizing = false;
2664		var pr, ista, soffseth, soffsetw, s, left, top,
2665			o = this.options, that = this;
2666
2667		if(this._helper) {
2668
2669			pr = this._proportionallyResizeElements;
2670			ista = pr.length && (/textarea/i).test(pr[0].nodeName);
2671			soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height;
2672			soffsetw = ista ? 0 : that.sizeDiff.width;
2673
2674			s = { width: (that.helper.width()  - soffsetw), height: (that.helper.height() - soffseth) };
2675			left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null;
2676			top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2677
2678			if (!o.animate) {
2679				this.element.css($.extend(s, { top: top, left: left }));
2680			}
2681
2682			that.helper.height(that.size.height);
2683			that.helper.width(that.size.width);
2684
2685			if (this._helper && !o.animate) {
2686				this._proportionallyResize();
2687			}
2688		}
2689
2690		$("body").css("cursor", "auto");
2691
2692		this.element.removeClass("ui-resizable-resizing");
2693
2694		this._propagate("stop", event);
2695
2696		if (this._helper) {
2697			this.helper.remove();
2698		}
2699
2700		return false;
2701
2702	},
2703
2704	_updateVirtualBoundaries: function(forceAspectRatio) {
2705		var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
2706			o = this.options;
2707
2708		b = {
2709			minWidth: isNumber(o.minWidth) ? o.minWidth : 0,
2710			maxWidth: isNumber(o.maxWidth) ? o.maxWidth : Infinity,
2711			minHeight: isNumber(o.minHeight) ? o.minHeight : 0,
2712			maxHeight: isNumber(o.maxHeight) ? o.maxHeight : Infinity
2713		};
2714
2715		if(this._aspectRatio || forceAspectRatio) {
2716			// We want to create an enclosing box whose aspect ration is the requested one
2717			// First, compute the "projected" size for each dimension based on the aspect ratio and other dimension
2718			pMinWidth = b.minHeight * this.aspectRatio;
2719			pMinHeight = b.minWidth / this.aspectRatio;
2720			pMaxWidth = b.maxHeight * this.aspectRatio;
2721			pMaxHeight = b.maxWidth / this.aspectRatio;
2722
2723			if(pMinWidth > b.minWidth) {
2724				b.minWidth = pMinWidth;
2725			}
2726			if(pMinHeight > b.minHeight) {
2727				b.minHeight = pMinHeight;
2728			}
2729			if(pMaxWidth < b.maxWidth) {
2730				b.maxWidth = pMaxWidth;
2731			}
2732			if(pMaxHeight < b.maxHeight) {
2733				b.maxHeight = pMaxHeight;
2734			}
2735		}
2736		this._vBoundaries = b;
2737	},
2738
2739	_updateCache: function(data) {
2740		this.offset = this.helper.offset();
2741		if (isNumber(data.left)) {
2742			this.position.left = data.left;
2743		}
2744		if (isNumber(data.top)) {
2745			this.position.top = data.top;
2746		}
2747		if (isNumber(data.height)) {
2748			this.size.height = data.height;
2749		}
2750		if (isNumber(data.width)) {
2751			this.size.width = data.width;
2752		}
2753	},
2754
2755	_updateRatio: function( data ) {
2756
2757		var cpos = this.position,
2758			csize = this.size,
2759			a = this.axis;
2760
2761		if (isNumber(data.height)) {
2762			data.width = (data.height * this.aspectRatio);
2763		} else if (isNumber(data.width)) {
2764			data.height = (data.width / this.aspectRatio);
2765		}
2766
2767		if (a === "sw") {
2768			data.left = cpos.left + (csize.width - data.width);
2769			data.top = null;
2770		}
2771		if (a === "nw") {
2772			data.top = cpos.top + (csize.height - data.height);
2773			data.left = cpos.left + (csize.width - data.width);
2774		}
2775
2776		return data;
2777	},
2778
2779	_respectSize: function( data ) {
2780
2781		var o = this._vBoundaries,
2782			a = this.axis,
2783			ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
2784			isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
2785			dw = this.originalPosition.left + this.originalSize.width,
2786			dh = this.position.top + this.size.height,
2787			cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
2788		if (isminw) {
2789			data.width = o.minWidth;
2790		}
2791		if (isminh) {
2792			data.height = o.minHeight;
2793		}
2794		if (ismaxw) {
2795			data.width = o.maxWidth;
2796		}
2797		if (ismaxh) {
2798			data.height = o.maxHeight;
2799		}
2800
2801		if (isminw && cw) {
2802			data.left = dw - o.minWidth;
2803		}
2804		if (ismaxw && cw) {
2805			data.left = dw - o.maxWidth;
2806		}
2807		if (isminh && ch) {
2808			data.top = dh - o.minHeight;
2809		}
2810		if (ismaxh && ch) {
2811			data.top = dh - o.maxHeight;
2812		}
2813
2814		// fixing jump error on top/left - bug #2330
2815		if (!data.width && !data.height && !data.left && data.top) {
2816			data.top = null;
2817		} else if (!data.width && !data.height && !data.top && data.left) {
2818			data.left = null;
2819		}
2820
2821		return data;
2822	},
2823
2824	_proportionallyResize: function() {
2825
2826		if (!this._proportionallyResizeElements.length) {
2827			return;
2828		}
2829
2830		var i, j, borders, paddings, prel,
2831			element = this.helper || this.element;
2832
2833		for ( i=0; i < this._proportionallyResizeElements.length; i++) {
2834
2835			prel = this._proportionallyResizeElements[i];
2836
2837			if (!this.borderDif) {
2838				this.borderDif = [];
2839				borders = [prel.css("borderTopWidth"), prel.css("borderRightWidth"), prel.css("borderBottomWidth"), prel.css("borderLeftWidth")];
2840				paddings = [prel.css("paddingTop"), prel.css("paddingRight"), prel.css("paddingBottom"), prel.css("paddingLeft")];
2841
2842				for ( j = 0; j < borders.length; j++ ) {
2843					this.borderDif[ j ] = ( parseInt( borders[ j ], 10 ) || 0 ) + ( parseInt( paddings[ j ], 10 ) || 0 );
2844				}
2845			}
2846
2847			prel.css({
2848				height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
2849				width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
2850			});
2851
2852		}
2853
2854	},
2855
2856	_renderProxy: function() {
2857
2858		var el = this.element, o = this.options;
2859		this.elementOffset = el.offset();
2860
2861		if(this._helper) {
2862
2863			this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
2864
2865			this.helper.addClass(this._helper).css({
2866				width: this.element.outerWidth() - 1,
2867				height: this.element.outerHeight() - 1,
2868				position: "absolute",
2869				left: this.elementOffset.left +"px",
2870				top: this.elementOffset.top +"px",
2871				zIndex: ++o.zIndex //TODO: Don't modify option
2872			});
2873
2874			this.helper
2875				.appendTo("body")
2876				.disableSelection();
2877
2878		} else {
2879			this.helper = this.element;
2880		}
2881
2882	},
2883
2884	_change: {
2885		e: function(event, dx) {
2886			return { width: this.originalSize.width + dx };
2887		},
2888		w: function(event, dx) {
2889			var cs = this.originalSize, sp = this.originalPosition;
2890			return { left: sp.left + dx, width: cs.width - dx };
2891		},
2892		n: function(event, dx, dy) {
2893			var cs = this.originalSize, sp = this.originalPosition;
2894			return { top: sp.top + dy, height: cs.height - dy };
2895		},
2896		s: function(event, dx, dy) {
2897			return { height: this.originalSize.height + dy };
2898		},
2899		se: function(event, dx, dy) {
2900			return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2901		},
2902		sw: function(event, dx, dy) {
2903			return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2904		},
2905		ne: function(event, dx, dy) {
2906			return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
2907		},
2908		nw: function(event, dx, dy) {
2909			return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
2910		}
2911	},
2912
2913	_propagate: function(n, event) {
2914		$.ui.plugin.call(this, n, [event, this.ui()]);
2915		(n !== "resize" && this._trigger(n, event, this.ui()));
2916	},
2917
2918	plugins: {},
2919
2920	ui: function() {
2921		return {
2922			originalElement: this.originalElement,
2923			element: this.element,
2924			helper: this.helper,
2925			position: this.position,
2926			size: this.size,
2927			originalSize: this.originalSize,
2928			originalPosition: this.originalPosition
2929		};
2930	}
2931
2932});
2933
2934/*
2935 * Resizable Extensions
2936 */
2937
2938$.ui.plugin.add("resizable", "animate", {
2939
2940	stop: function( event ) {
2941		var that = $(this).data("ui-resizable"),
2942			o = that.options,
2943			pr = that._proportionallyResizeElements,
2944			ista = pr.length && (/textarea/i).test(pr[0].nodeName),
2945			soffseth = ista && $.ui.hasScroll(pr[0], "left") /* TODO - jump height */ ? 0 : that.sizeDiff.height,
2946			soffsetw = ista ? 0 : that.sizeDiff.width,
2947			style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
2948			left = (parseInt(that.element.css("left"), 10) + (that.position.left - that.originalPosition.left)) || null,
2949			top = (parseInt(that.element.css("top"), 10) + (that.position.top - that.originalPosition.top)) || null;
2950
2951		that.element.animate(
2952			$.extend(style, top && left ? { top: top, left: left } : {}), {
2953				duration: o.animateDuration,
2954				easing: o.animateEasing,
2955				step: function() {
2956
2957					var data = {
2958						width: parseInt(that.element.css("width"), 10),
2959						height: parseInt(that.element.css("height"), 10),
2960						top: parseInt(that.element.css("top"), 10),
2961						left: parseInt(that.element.css("left"), 10)
2962					};
2963
2964					if (pr && pr.length) {
2965						$(pr[0]).css({ width: data.width, height: data.height });
2966					}
2967
2968					// propagating resize, and updating values for each animation step
2969					that._updateCache(data);
2970					that._propagate("resize", event);
2971
2972				}
2973			}
2974		);
2975	}
2976
2977});
2978
2979$.ui.plugin.add("resizable", "containment", {
2980
2981	start: function() {
2982		var element, p, co, ch, cw, width, height,
2983			that = $(this).data("ui-resizable"),
2984			o = that.options,
2985			el = that.element,
2986			oc = o.containment,
2987			ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
2988
2989		if (!ce) {
2990			return;
2991		}
2992
2993		that.containerElement = $(ce);
2994
2995		if (/document/.test(oc) || oc === document) {
2996			that.containerOffset = { left: 0, top: 0 };
2997			that.containerPosition = { left: 0, top: 0 };
2998
2999			that.parentData = {
3000				element: $(document), left: 0, top: 0,
3001				width: $(document).width(), height: $(document).height() || document.body.parentNode.scrollHeight
3002			};
3003		}
3004
3005		// i'm a node, so compute top, left, right, bottom
3006		else {
3007			element = $(ce);
3008			p = [];
3009			$([ "Top", "Right", "Left", "Bottom" ]).each(function(i, name) { p[i] = num(element.css("padding" + name)); });
3010
3011			that.containerOffset = element.offset();
3012			that.containerPosition = element.position();
3013			that.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };
3014
3015			co = that.containerOffset;
3016			ch = that.containerSize.height;
3017			cw = that.containerSize.width;
3018			width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw );
3019			height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);
3020
3021			that.parentData = {
3022				element: ce, left: co.left, top: co.top, width: width, height: height
3023			};
3024		}
3025	},
3026
3027	resize: function( event ) {
3028		var woset, hoset, isParent, isOffsetRelative,
3029			that = $(this).data("ui-resizable"),
3030			o = that.options,
3031			co = that.containerOffset, cp = that.position,
3032			pRatio = that._aspectRatio || event.shiftKey,
3033			cop = { top:0, left:0 }, ce = that.containerElement;
3034
3035		if (ce[0] !== document && (/static/).test(ce.css("position"))) {
3036			cop = co;
3037		}
3038
3039		if (cp.left < (that._helper ? co.left : 0)) {
3040			that.size.width = that.size.width + (that._helper ? (that.position.left - co.left) : (that.position.left - cop.left));
3041			if (pRatio) {
3042				that.size.height = that.size.width / that.aspectRatio;
3043			}
3044			that.position.left = o.helper ? co.left : 0;
3045		}
3046
3047		if (cp.top < (that._helper ? co.top : 0)) {
3048			that.size.height = that.size.height + (that._helper ? (that.position.top - co.top) : that.position.top);
3049			if (pRatio) {
3050				that.size.width = that.size.height * that.aspectRatio;
3051			}
3052			that.position.top = that._helper ? co.top : 0;
3053		}
3054
3055		that.offset.left = that.parentData.left+that.position.left;
3056		that.offset.top = that.parentData.top+that.position.top;
3057
3058		woset = Math.abs( (that._helper ? that.offset.left - cop.left : (that.offset.left - cop.left)) + that.sizeDiff.width );
3059		hoset = Math.abs( (that._helper ? that.offset.top - cop.top : (that.offset.top - co.top)) + that.sizeDiff.height );
3060
3061		isParent = that.containerElement.get(0) === that.element.parent().get(0);
3062		isOffsetRelative = /relative|absolute/.test(that.containerElement.css("position"));
3063
3064		if ( isParent && isOffsetRelative ) {
3065			woset -= Math.abs( that.parentData.left );
3066		}
3067
3068		if (woset + that.size.width >= that.parentData.width) {
3069			that.size.width = that.parentData.width - woset;
3070			if (pRatio) {
3071				that.size.height = that.size.width / that.aspectRatio;
3072			}
3073		}
3074
3075		if (hoset + that.size.height >= that.parentData.height) {
3076			that.size.height = that.parentData.height - hoset;
3077			if (pRatio) {
3078				that.size.width = that.size.height * that.aspectRatio;
3079			}
3080		}
3081	},
3082
3083	stop: function(){
3084		var that = $(this).data("ui-resizable"),
3085			o = that.options,
3086			co = that.containerOffset,
3087			cop = that.containerPosition,
3088			ce = that.containerElement,
3089			helper = $(that.helper),
3090			ho = helper.offset(),
3091			w = helper.outerWidth() - that.sizeDiff.width,
3092			h = helper.outerHeight() - that.sizeDiff.height;
3093
3094		if (that._helper && !o.animate && (/relative/).test(ce.css("position"))) {
3095			$(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
3096		}
3097
3098		if (that._helper && !o.animate && (/static/).test(ce.css("position"))) {
3099			$(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });
3100		}
3101
3102	}
3103});
3104
3105$.ui.plugin.add("resizable", "alsoResize", {
3106
3107	start: function () {
3108		var that = $(this).data("ui-resizable"),
3109			o = that.options,
3110			_store = function (exp) {
3111				$(exp).each(function() {
3112					var el = $(this);
3113					el.data("ui-resizable-alsoresize", {
3114						width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
3115						left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
3116					});
3117				});
3118			};
3119
3120		if (typeof(o.alsoResize) === "object" && !o.alsoResize.parentNode) {
3121			if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0]; _store(o.alsoResize); }
3122			else { $.each(o.alsoResize, function (exp) { _store(exp); }); }
3123		}else{
3124			_store(o.alsoResize);
3125		}
3126	},
3127
3128	resize: function (event, ui) {
3129		var that = $(this).data("ui-resizable"),
3130			o = that.options,
3131			os = that.originalSize,
3132			op = that.originalPosition,
3133			delta = {
3134				height: (that.size.height - os.height) || 0, width: (that.size.width - os.width) || 0,
3135				top: (that.position.top - op.top) || 0, left: (that.position.left - op.left) || 0
3136			},
3137
3138			_alsoResize = function (exp, c) {
3139				$(exp).each(function() {
3140					var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
3141						css = c && c.length ? c : el.parents(ui.originalElement[0]).length ? ["width", "height"] : ["width", "height", "top", "left"];
3142
3143					$.each(css, function (i, prop) {
3144						var sum = (start[prop]||0) + (delta[prop]||0);
3145						if (sum && sum >= 0) {
3146							style[prop] = sum || null;
3147						}
3148					});
3149
3150					el.css(style);
3151				});
3152			};
3153
3154		if (typeof(o.alsoResize) === "object" && !o.alsoResize.nodeType) {
3155			$.each(o.alsoResize, function (exp, c) { _alsoResize(exp, c); });
3156		}else{
3157			_alsoResize(o.alsoResize);
3158		}
3159	},
3160
3161	stop: function () {
3162		$(this).removeData("resizable-alsoresize");
3163	}
3164});
3165
3166$.ui.plugin.add("resizable", "ghost", {
3167
3168	start: function() {
3169
3170		var that = $(this).data("ui-resizable"), o = that.options, cs = that.size;
3171
3172		that.ghost = that.originalElement.clone();
3173		that.ghost
3174			.css({ opacity: 0.25, display: "block", position: "relative", height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 })
3175			.addClass("ui-resizable-ghost")
3176			.addClass(typeof o.ghost === "string" ? o.ghost : "");
3177
3178		that.ghost.appendTo(that.helper);
3179
3180	},
3181
3182	resize: function(){
3183		var that = $(this).data("ui-resizable");
3184		if (that.ghost) {
3185			that.ghost.css({ position: "relative", height: that.size.height, width: that.size.width });
3186		}
3187	},
3188
3189	stop: function() {
3190		var that = $(this).data("ui-resizable");
3191		if (that.ghost && that.helper) {
3192			that.helper.get(0).removeChild(that.ghost.get(0));
3193		}
3194	}
3195
3196});
3197
3198$.ui.plugin.add("resizable", "grid", {
3199
3200	resize: function() {
3201		var that = $(this).data("ui-resizable"),
3202			o = that.options,
3203			cs = that.size,
3204			os = that.originalSize,
3205			op = that.originalPosition,
3206			a = that.axis,
3207			grid = typeof o.grid === "number" ? [o.grid, o.grid] : o.grid,
3208			gridX = (grid[0]||1),
3209			gridY = (grid[1]||1),
3210			ox = Math.round((cs.width - os.width) / gridX) * gridX,
3211			oy = Math.round((cs.height - os.height) / gridY) * gridY,
3212			newWidth = os.width + ox,
3213			newHeight = os.height + oy,
3214			isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
3215			isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
3216			isMinWidth = o.minWidth && (o.minWidth > newWidth),
3217			isMinHeight = o.minHeight && (o.minHeight > newHeight);
3218
3219		o.grid = grid;
3220
3221		if (isMinWidth) {
3222			newWidth = newWidth + gridX;
3223		}
3224		if (isMinHeight) {
3225			newHeight = newHeight + gridY;
3226		}
3227		if (isMaxWidth) {
3228			newWidth = newWidth - gridX;
3229		}
3230		if (isMaxHeight) {
3231			newHeight = newHeight - gridY;
3232		}
3233
3234		if (/^(se|s|e)$/.test(a)) {
3235			that.size.width = newWidth;
3236			that.size.height = newHeight;
3237		} else if (/^(ne)$/.test(a)) {
3238			that.size.width = newWidth;
3239			that.size.height = newHeight;
3240			that.position.top = op.top - oy;
3241		} else if (/^(sw)$/.test(a)) {
3242			that.size.width = newWidth;
3243			that.size.height = newHeight;
3244			that.position.left = op.left - ox;
3245		} else {
3246			if ( newHeight - gridY > 0 ) {
3247				that.size.height = newHeight;
3248				that.position.top = op.top - oy;
3249			} else {
3250				that.size.height = gridY;
3251				that.position.top = op.top + os.height - gridY;
3252			}
3253			if ( newWidth - gridX > 0 ) {
3254				that.size.width = newWidth;
3255				that.position.left = op.left - ox;
3256			} else {
3257				that.size.width = gridX;
3258				that.position.left = op.left + os.width - gridX;
3259			}
3260		}
3261	}
3262
3263});
3264
3265})(jQuery);
3266
3267(function( $, undefined ) {
3268
3269$.widget("ui.selectable", $.ui.mouse, {
3270	version: "1.10.4",
3271	options: {
3272		appendTo: "body",
3273		autoRefresh: true,
3274		distance: 0,
3275		filter: "*",
3276		tolerance: "touch",
3277
3278		// callbacks
3279		selected: null,
3280		selecting: null,
3281		start: null,
3282		stop: null,
3283		unselected: null,
3284		unselecting: null
3285	},
3286	_create: function() {
3287		var selectees,
3288			that = this;
3289
3290		this.element.addClass("ui-selectable");
3291
3292		this.dragged = false;
3293
3294		// cache selectee children based on filter
3295		this.refresh = function() {
3296			selectees = $(that.options.filter, that.element[0]);
3297			selectees.addClass("ui-selectee");
3298			selectees.each(function() {
3299				var $this = $(this),
3300					pos = $this.offset();
3301				$.data(this, "selectable-item", {
3302					element: this,
3303					$element: $this,
3304					left: pos.left,
3305					top: pos.top,
3306					right: pos.left + $this.outerWidth(),
3307					bottom: pos.top + $this.outerHeight(),
3308					startselected: false,
3309					selected: $this.hasClass("ui-selected"),
3310					selecting: $this.hasClass("ui-selecting"),
3311					unselecting: $this.hasClass("ui-unselecting")
3312				});
3313			});
3314		};
3315		this.refresh();
3316
3317		this.selectees = selectees.addClass("ui-selectee");
3318
3319		this._mouseInit();
3320
3321		this.helper = $("<div class='ui-selectable-helper'></div>");
3322	},
3323
3324	_destroy: function() {
3325		this.selectees
3326			.removeClass("ui-selectee")
3327			.removeData("selectable-item");
3328		this.element
3329			.removeClass("ui-selectable ui-selectable-disabled");
3330		this._mouseDestroy();
3331	},
3332
3333	_mouseStart: function(event) {
3334		var that = this,
3335			options = this.options;
3336
3337		this.opos = [event.pageX, event.pageY];
3338
3339		if (this.options.disabled) {
3340			return;
3341		}
3342
3343		this.selectees = $(options.filter, this.element[0]);
3344
3345		this._trigger("start", event);
3346
3347		$(options.appendTo).append(this.helper);
3348		// position helper (lasso)
3349		this.helper.css({
3350			"left": event.pageX,
3351			"top": event.pageY,
3352			"width": 0,
3353			"height": 0
3354		});
3355
3356		if (options.autoRefresh) {
3357			this.refresh();
3358		}
3359
3360		this.selectees.filter(".ui-selected").each(function() {
3361			var selectee = $.data(this, "selectable-item");
3362			selectee.startselected = true;
3363			if (!event.metaKey && !event.ctrlKey) {
3364				selectee.$element.removeClass("ui-selected");
3365				selectee.selected = false;
3366				selectee.$element.addClass("ui-unselecting");
3367				selectee.unselecting = true;
3368				// selectable UNSELECTING callback
3369				that._trigger("unselecting", event, {
3370					unselecting: selectee.element
3371				});
3372			}
3373		});
3374
3375		$(event.target).parents().addBack().each(function() {
3376			var doSelect,
3377				selectee = $.data(this, "selectable-item");
3378			if (selectee) {
3379				doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
3380				selectee.$element
3381					.removeClass(doSelect ? "ui-unselecting" : "ui-selected")
3382					.addClass(doSelect ? "ui-selecting" : "ui-unselecting");
3383				selectee.unselecting = !doSelect;
3384				selectee.selecting = doSelect;
3385				selectee.selected = doSelect;
3386				// selectable (UN)SELECTING callback
3387				if (doSelect) {
3388					that._trigger("selecting", event, {
3389						selecting: selectee.element
3390					});
3391				} else {
3392					that._trigger("unselecting", event, {
3393						unselecting: selectee.element
3394					});
3395				}
3396				return false;
3397			}
3398		});
3399
3400	},
3401
3402	_mouseDrag: function(event) {
3403
3404		this.dragged = true;
3405
3406		if (this.options.disabled) {
3407			return;
3408		}
3409
3410		var tmp,
3411			that = this,
3412			options = this.options,
3413			x1 = this.opos[0],
3414			y1 = this.opos[1],
3415			x2 = event.pageX,
3416			y2 = event.pageY;
3417
3418		if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
3419		if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
3420		this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
3421
3422		this.selectees.each(function() {
3423			var selectee = $.data(this, "selectable-item"),
3424				hit = false;
3425
3426			//prevent helper from being selected if appendTo: selectable
3427			if (!selectee || selectee.element === that.element[0]) {
3428				return;
3429			}
3430
3431			if (options.tolerance === "touch") {
3432				hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
3433			} else if (options.tolerance === "fit") {
3434				hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
3435			}
3436
3437			if (hit) {
3438				// SELECT
3439				if (selectee.selected) {
3440					selectee.$element.removeClass("ui-selected");
3441					selectee.selected = false;
3442				}
3443				if (selectee.unselecting) {
3444					selectee.$element.removeClass("ui-unselecting");
3445					selectee.unselecting = false;
3446				}
3447				if (!selectee.selecting) {
3448					selectee.$element.addClass("ui-selecting");
3449					selectee.selecting = true;
3450					// selectable SELECTING callback
3451					that._trigger("selecting", event, {
3452						selecting: selectee.element
3453					});
3454				}
3455			} else {
3456				// UNSELECT
3457				if (selectee.selecting) {
3458					if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
3459						selectee.$element.removeClass("ui-selecting");
3460						selectee.selecting = false;
3461						selectee.$element.addClass("ui-selected");
3462						selectee.selected = true;
3463					} else {
3464						selectee.$element.removeClass("ui-selecting");
3465						selectee.selecting = false;
3466						if (selectee.startselected) {
3467							selectee.$element.addClass("ui-unselecting");
3468							selectee.unselecting = true;
3469						}
3470						// selectable UNSELECTING callback
3471						that._trigger("unselecting", event, {
3472							unselecting: selectee.element
3473						});
3474					}
3475				}
3476				if (selectee.selected) {
3477					if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
3478						selectee.$element.removeClass("ui-selected");
3479						selectee.selected = false;
3480
3481						selectee.$element.addClass("ui-unselecting");
3482						selectee.unselecting = true;
3483						// selectable UNSELECTING callback
3484						that._trigger("unselecting", event, {
3485							unselecting: selectee.element
3486						});
3487					}
3488				}
3489			}
3490		});
3491
3492		return false;
3493	},
3494
3495	_mouseStop: function(event) {
3496		var that = this;
3497
3498		this.dragged = false;
3499
3500		$(".ui-unselecting", this.element[0]).each(function() {
3501			var selectee = $.data(this, "selectable-item");
3502			selectee.$element.removeClass("ui-unselecting");
3503			selectee.unselecting = false;
3504			selectee.startselected = false;
3505			that._trigger("unselected", event, {
3506				unselected: selectee.element
3507			});
3508		});
3509		$(".ui-selecting", this.element[0]).each(function() {
3510			var selectee = $.data(this, "selectable-item");
3511			selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
3512			selectee.selecting = false;
3513			selectee.selected = true;
3514			selectee.startselected = true;
3515			that._trigger("selected", event, {
3516				selected: selectee.element
3517			});
3518		});
3519		this._trigger("stop", event);
3520
3521		this.helper.remove();
3522
3523		return false;
3524	}
3525
3526});
3527
3528})(jQuery);
3529
3530(function( $, undefined ) {
3531
3532function isOverAxis( x, reference, size ) {
3533	return ( x > reference ) && ( x < ( reference + size ) );
3534}
3535
3536function isFloating(item) {
3537	return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
3538}
3539
3540$.widget("ui.sortable", $.ui.mouse, {
3541	version: "1.10.4",
3542	widgetEventPrefix: "sort",
3543	ready: false,
3544	options: {
3545		appendTo: "parent",
3546		axis: false,
3547		connectWith: false,
3548		containment: false,
3549		cursor: "auto",
3550		cursorAt: false,
3551		dropOnEmpty: true,
3552		forcePlaceholderSize: false,
3553		forceHelperSize: false,
3554		grid: false,
3555		handle: false,
3556		helper: "original",
3557		items: "> *",
3558		opacity: false,
3559		placeholder: false,
3560		revert: false,
3561		scroll: true,
3562		scrollSensitivity: 20,
3563		scrollSpeed: 20,
3564		scope: "default",
3565		tolerance: "intersect",
3566		zIndex: 1000,
3567
3568		// callbacks
3569		activate: null,
3570		beforeStop: null,
3571		change: null,
3572		deactivate: null,
3573		out: null,
3574		over: null,
3575		receive: null,
3576		remove: null,
3577		sort: null,
3578		start: null,
3579		stop: null,
3580		update: null
3581	},
3582	_create: function() {
3583
3584		var o = this.options;
3585		this.containerCache = {};
3586		this.element.addClass("ui-sortable");
3587
3588		//Get the items
3589		this.refresh();
3590
3591		//Let's determine if the items are being displayed horizontally
3592		this.floating = this.items.length ? o.axis === "x" || isFloating(this.items[0].item) : false;
3593
3594		//Let's determine the parent's offset
3595		this.offset = this.element.offset();
3596
3597		//Initialize mouse events for interaction
3598		this._mouseInit();
3599
3600		//We're ready to go
3601		this.ready = true;
3602
3603	},
3604
3605	_destroy: function() {
3606		this.element
3607			.removeClass("ui-sortable ui-sortable-disabled");
3608		this._mouseDestroy();
3609
3610		for ( var i = this.items.length - 1; i >= 0; i-- ) {
3611			this.items[i].item.removeData(this.widgetName + "-item");
3612		}
3613
3614		return this;
3615	},
3616
3617	_setOption: function(key, value){
3618		if ( key === "disabled" ) {
3619			this.options[ key ] = value;
3620
3621			this.widget().toggleClass( "ui-sortable-disabled", !!value );
3622		} else {
3623			// Don't call widget base _setOption for disable as it adds ui-state-disabled class
3624			$.Widget.prototype._setOption.apply(this, arguments);
3625		}
3626	},
3627
3628	_mouseCapture: function(event, overrideHandle) {
3629		var currentItem = null,
3630			validHandle = false,
3631			that = this;
3632
3633		if (this.reverting) {
3634			return false;
3635		}
3636
3637		if(this.options.disabled || this.options.type === "static") {
3638			return false;
3639		}
3640
3641		//We have to refresh the items data once first
3642		this._refreshItems(event);
3643
3644		//Find out if the clicked node (or one of its parents) is a actual item in this.items
3645		$(event.target).parents().each(function() {
3646			if($.data(this, that.widgetName + "-item") === that) {
3647				currentItem = $(this);
3648				return false;
3649			}
3650		});
3651		if($.data(event.target, that.widgetName + "-item") === that) {
3652			currentItem = $(event.target);
3653		}
3654
3655		if(!currentItem) {
3656			return false;
3657		}
3658		if(this.options.handle && !overrideHandle) {
3659			$(this.options.handle, currentItem).find("*").addBack().each(function() {
3660				if(this === event.target) {
3661					validHandle = true;
3662				}
3663			});
3664			if(!validHandle) {
3665				return false;
3666			}
3667		}
3668
3669		this.currentItem = currentItem;
3670		this._removeCurrentsFromItems();
3671		return true;
3672
3673	},
3674
3675	_mouseStart: function(event, overrideHandle, noActivation) {
3676
3677		var i, body,
3678			o = this.options;
3679
3680		this.currentContainer = this;
3681
3682		//We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
3683		this.refreshPositions();
3684
3685		//Create and append the visible helper
3686		this.helper = this._createHelper(event);
3687
3688		//Cache the helper size
3689		this._cacheHelperProportions();
3690
3691		/*
3692		 * - Position generation -
3693		 * This block generates everything position related - it's the core of draggables.
3694		 */
3695
3696		//Cache the margins of the original element
3697		this._cacheMargins();
3698
3699		//Get the next scrolling parent
3700		this.scrollParent = this.helper.scrollParent();
3701
3702		//The element's absolute position on the page minus margins
3703		this.offset = this.currentItem.offset();
3704		this.offset = {
3705			top: this.offset.top - this.margins.top,
3706			left: this.offset.left - this.margins.left
3707		};
3708
3709		$.extend(this.offset, {
3710			click: { //Where the click happened, relative to the element
3711				left: event.pageX - this.offset.left,
3712				top: event.pageY - this.offset.top
3713			},
3714			parent: this._getParentOffset(),
3715			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
3716		});
3717
3718		// Only after we got the offset, we can change the helper's position to absolute
3719		// TODO: Still need to figure out a way to make relative sorting possible
3720		this.helper.css("position", "absolute");
3721		this.cssPosition = this.helper.css("position");
3722
3723		//Generate the original position
3724		this.originalPosition = this._generatePosition(event);
3725		this.originalPageX = event.pageX;
3726		this.originalPageY = event.pageY;
3727
3728		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied
3729		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
3730
3731		//Cache the former DOM position
3732		this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
3733
3734		//If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
3735		if(this.helper[0] !== this.currentItem[0]) {
3736			this.currentItem.hide();
3737		}
3738
3739		//Create the placeholder
3740		this._createPlaceholder();
3741
3742		//Set a containment if given in the options
3743		if(o.containment) {
3744			this._setContainment();
3745		}
3746
3747		if( o.cursor && o.cursor !== "auto" ) { // cursor option
3748			body = this.document.find( "body" );
3749
3750			// support: IE
3751			this.storedCursor = body.css( "cursor" );
3752			body.css( "cursor", o.cursor );
3753
3754			this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
3755		}
3756
3757		if(o.opacity) { // opacity option
3758			if (this.helper.css("opacity")) {
3759				this._storedOpacity = this.helper.css("opacity");
3760			}
3761			this.helper.css("opacity", o.opacity);
3762		}
3763
3764		if(o.zIndex) { // zIndex option
3765			if (this.helper.css("zIndex")) {
3766				this._storedZIndex = this.helper.css("zIndex");
3767			}
3768			this.helper.css("zIndex", o.zIndex);
3769		}
3770
3771		//Prepare scrolling
3772		if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
3773			this.overflowOffset = this.scrollParent.offset();
3774		}
3775
3776		//Call callbacks
3777		this._trigger("start", event, this._uiHash());
3778
3779		//Recache the helper size
3780		if(!this._preserveHelperProportions) {
3781			this._cacheHelperProportions();
3782		}
3783
3784
3785		//Post "activate" events to possible containers
3786		if( !noActivation ) {
3787			for ( i = this.containers.length - 1; i >= 0; i-- ) {
3788				this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
3789			}
3790		}
3791
3792		//Prepare possible droppables
3793		if($.ui.ddmanager) {
3794			$.ui.ddmanager.current = this;
3795		}
3796
3797		if ($.ui.ddmanager && !o.dropBehaviour) {
3798			$.ui.ddmanager.prepareOffsets(this, event);
3799		}
3800
3801		this.dragging = true;
3802
3803		this.helper.addClass("ui-sortable-helper");
3804		this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
3805		return true;
3806
3807	},
3808
3809	_mouseDrag: function(event) {
3810		var i, item, itemElement, intersection,
3811			o = this.options,
3812			scrolled = false;
3813
3814		//Compute the helpers position
3815		this.position = this._generatePosition(event);
3816		this.positionAbs = this._convertPositionTo("absolute");
3817
3818		if (!this.lastPositionAbs) {
3819			this.lastPositionAbs = this.positionAbs;
3820		}
3821
3822		//Do scrolling
3823		if(this.options.scroll) {
3824			if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {
3825
3826				if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
3827					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
3828				} else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
3829					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
3830				}
3831
3832				if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
3833					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
3834				} else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
3835					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
3836				}
3837
3838			} else {
3839
3840				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
3841					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
3842				} else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
3843					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
3844				}
3845
3846				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
3847					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
3848				} else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
3849					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
3850				}
3851
3852			}
3853
3854			if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
3855				$.ui.ddmanager.prepareOffsets(this, event);
3856			}
3857		}
3858
3859		//Regenerate the absolute position used for position checks
3860		this.positionAbs = this._convertPositionTo("absolute");
3861
3862		//Set the helper position
3863		if(!this.options.axis || this.options.axis !== "y") {
3864			this.helper[0].style.left = this.position.left+"px";
3865		}
3866		if(!this.options.axis || this.options.axis !== "x") {
3867			this.helper[0].style.top = this.position.top+"px";
3868		}
3869
3870		//Rearrange
3871		for (i = this.items.length - 1; i >= 0; i--) {
3872
3873			//Cache variables and intersection, continue if no intersection
3874			item = this.items[i];
3875			itemElement = item.item[0];
3876			intersection = this._intersectsWithPointer(item);
3877			if (!intersection) {
3878				continue;
3879			}
3880
3881			// Only put the placeholder inside the current Container, skip all
3882			// items from other containers. This works because when moving
3883			// an item from one container to another the
3884			// currentContainer is switched before the placeholder is moved.
3885			//
3886			// Without this, moving items in "sub-sortables" can cause
3887			// the placeholder to jitter beetween the outer and inner container.
3888			if (item.instance !== this.currentContainer) {
3889				continue;
3890			}
3891
3892			// cannot intersect with itself
3893			// no useless actions that have been done before
3894			// no action if the item moved is the parent of the item checked
3895			if (itemElement !== this.currentItem[0] &&
3896				this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
3897				!$.contains(this.placeholder[0], itemElement) &&
3898				(this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
3899			) {
3900
3901				this.direction = intersection === 1 ? "down" : "up";
3902
3903				if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
3904					this._rearrange(event, item);
3905				} else {
3906					break;
3907				}
3908
3909				this._trigger("change", event, this._uiHash());
3910				break;
3911			}
3912		}
3913
3914		//Post events to containers
3915		this._contactContainers(event);
3916
3917		//Interconnect with droppables
3918		if($.ui.ddmanager) {
3919			$.ui.ddmanager.drag(this, event);
3920		}
3921
3922		//Call callbacks
3923		this._trigger("sort", event, this._uiHash());
3924
3925		this.lastPositionAbs = this.positionAbs;
3926		return false;
3927
3928	},
3929
3930	_mouseStop: function(event, noPropagation) {
3931
3932		if(!event) {
3933			return;
3934		}
3935
3936		//If we are using droppables, inform the manager about the drop
3937		if ($.ui.ddmanager && !this.options.dropBehaviour) {
3938			$.ui.ddmanager.drop(this, event);
3939		}
3940
3941		if(this.options.revert) {
3942			var that = this,
3943				cur = this.placeholder.offset(),
3944				axis = this.options.axis,
3945				animation = {};
3946
3947			if ( !axis || axis === "x" ) {
3948				animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollLeft);
3949			}
3950			if ( !axis || axis === "y" ) {
3951				animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === document.body ? 0 : this.offsetParent[0].scrollTop);
3952			}
3953			this.reverting = true;
3954			$(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
3955				that._clear(event);
3956			});
3957		} else {
3958			this._clear(event, noPropagation);
3959		}
3960
3961		return false;
3962
3963	},
3964
3965	cancel: function() {
3966
3967		if(this.dragging) {
3968
3969			this._mouseUp({ target: null });
3970
3971			if(this.options.helper === "original") {
3972				this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
3973			} else {
3974				this.currentItem.show();
3975			}
3976
3977			//Post deactivating events to containers
3978			for (var i = this.containers.length - 1; i >= 0; i--){
3979				this.containers[i]._trigger("deactivate", null, this._uiHash(this));
3980				if(this.containers[i].containerCache.over) {
3981					this.containers[i]._trigger("out", null, this._uiHash(this));
3982					this.containers[i].containerCache.over = 0;
3983				}
3984			}
3985
3986		}
3987
3988		if (this.placeholder) {
3989			//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
3990			if(this.placeholder[0].parentNode) {
3991				this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
3992			}
3993			if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
3994				this.helper.remove();
3995			}
3996
3997			$.extend(this, {
3998				helper: null,
3999				dragging: false,
4000				reverting: false,
4001				_noFinalSort: null
4002			});
4003
4004			if(this.domPosition.prev) {
4005				$(this.domPosition.prev).after(this.currentItem);
4006			} else {
4007				$(this.domPosition.parent).prepend(this.currentItem);
4008			}
4009		}
4010
4011		return this;
4012
4013	},
4014
4015	serialize: function(o) {
4016
4017		var items = this._getItemsAsjQuery(o && o.connected),
4018			str = [];
4019		o = o || {};
4020
4021		$(items).each(function() {
4022			var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
4023			if (res) {
4024				str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
4025			}
4026		});
4027
4028		if(!str.length && o.key) {
4029			str.push(o.key + "=");
4030		}
4031
4032		return str.join("&");
4033
4034	},
4035
4036	toArray: function(o) {
4037
4038		var items = this._getItemsAsjQuery(o && o.connected),
4039			ret = [];
4040
4041		o = o || {};
4042
4043		items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
4044		return ret;
4045
4046	},
4047
4048	/* Be careful with the following core functions */
4049	_intersectsWith: function(item) {
4050
4051		var x1 = this.positionAbs.left,
4052			x2 = x1 + this.helperProportions.width,
4053			y1 = this.positionAbs.top,
4054			y2 = y1 + this.helperProportions.height,
4055			l = item.left,
4056			r = l + item.width,
4057			t = item.top,
4058			b = t + item.height,
4059			dyClick = this.offset.click.top,
4060			dxClick = this.offset.click.left,
4061			isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
4062			isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
4063			isOverElement = isOverElementHeight && isOverElementWidth;
4064
4065		if ( this.options.tolerance === "pointer" ||
4066			this.options.forcePointerForContainers ||
4067			(this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
4068		) {
4069			return isOverElement;
4070		} else {
4071
4072			return (l < x1 + (this.helperProportions.width / 2) && // Right Half
4073				x2 - (this.helperProportions.width / 2) < r && // Left Half
4074				t < y1 + (this.helperProportions.height / 2) && // Bottom Half
4075				y2 - (this.helperProportions.height / 2) < b ); // Top Half
4076
4077		}
4078	},
4079
4080	_intersectsWithPointer: function(item) {
4081
4082		var isOverElementHeight = (this.options.axis === "x") || isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
4083			isOverElementWidth = (this.options.axis === "y") || isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
4084			isOverElement = isOverElementHeight && isOverElementWidth,
4085			verticalDirection = this._getDragVerticalDirection(),
4086			horizontalDirection = this._getDragHorizontalDirection();
4087
4088		if (!isOverElement) {
4089			return false;
4090		}
4091
4092		return this.floating ?
4093			( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
4094			: ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
4095
4096	},
4097
4098	_intersectsWithSides: function(item) {
4099
4100		var isOverBottomHalf = isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
4101			isOverRightHalf = isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
4102			verticalDirection = this._getDragVerticalDirection(),
4103			horizontalDirection = this._getDragHorizontalDirection();
4104
4105		if (this.floating && horizontalDirection) {
4106			return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
4107		} else {
4108			return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
4109		}
4110
4111	},
4112
4113	_getDragVerticalDirection: function() {
4114		var delta = this.positionAbs.top - this.lastPositionAbs.top;
4115		return delta !== 0 && (delta > 0 ? "down" : "up");
4116	},
4117
4118	_getDragHorizontalDirection: function() {
4119		var delta = this.positionAbs.left - this.lastPositionAbs.left;
4120		return delta !== 0 && (delta > 0 ? "right" : "left");
4121	},
4122
4123	refresh: function(event) {
4124		this._refreshItems(event