https://auraf.ru/bitrix/templates/aura-flowers-new/js/jquery-ui-1.9.2.custom.js?1715628634235068

1/*! jQuery UI - v1.9.2 - 2013-11-19
2* http://jqueryui.com
3* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.position.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.ui.datepicker.js
4* Copyright 2013 jQuery Foundation and other contributors; Licensed MIT */
5
6(function( $, undefined ) {
7
8var uuid = 0,
9	runiqueId = /^ui-id-\d+$/;
10
11// prevent duplicate loading
12// this is only a problem because we proxy existing functions
13// and we don't want to double proxy them
14$.ui = $.ui || {};
15if ( $.ui.version ) {
16	return;
17}
18
19$.extend( $.ui, {
20	version: "1.9.2",
21
22	keyCode: {
23		BACKSPACE: 8,
24		COMMA: 188,
25		DELETE: 46,
26		DOWN: 40,
27		END: 35,
28		ENTER: 13,
29		ESCAPE: 27,
30		HOME: 36,
31		LEFT: 37,
32		NUMPAD_ADD: 107,
33		NUMPAD_DECIMAL: 110,
34		NUMPAD_DIVIDE: 111,
35		NUMPAD_ENTER: 108,
36		NUMPAD_MULTIPLY: 106,
37		NUMPAD_SUBTRACT: 109,
38		PAGE_DOWN: 34,
39		PAGE_UP: 33,
40		PERIOD: 190,
41		RIGHT: 39,
42		SPACE: 32,
43		TAB: 9,
44		UP: 38
45	}
46});
47
48// plugins
49$.fn.extend({
50	_focus: $.fn.focus,
51	focus: function( delay, fn ) {
52		return typeof delay === "number" ?
53			this.each(function() {
54				var elem = this;
55				setTimeout(function() {
56					$( elem ).focus();
57					if ( fn ) {
58						fn.call( elem );
59					}
60				}, delay );
61			}) :
62			this._focus.apply( this, arguments );
63	},
64
65	scrollParent: function() {
66		var scrollParent;
67		if (($.ui.ie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
68			scrollParent = this.parents().filter(function() {
69				return (/(relative|absolute|fixed)/).test($.css(this,'position')) && (/(auto|scroll)/).test($.css(this,'overflow')+$.css(this,'overflow-y')+$.css(this,'overflow-x'));
70			}).eq(0);
71		} else {
72			scrollParent = this.parents().filter(function() {
73				return (/(auto|scroll)/).test($.css(this,'overflow')+$.css(this,'overflow-y')+$.css(this,'overflow-x'));
74			}).eq(0);
75		}
76
77		return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
78	},
79
80	zIndex: function( zIndex ) {
81		if ( zIndex !== undefined ) {
82			return this.css( "zIndex", zIndex );
83		}
84
85		if ( this.length ) {
86			var elem = $( this[ 0 ] ), position, value;
87			while ( elem.length && elem[ 0 ] !== document ) {
88				// Ignore z-index if position is set to a value where z-index is ignored by the browser
89				// This makes behavior of this function consistent across browsers
90				// WebKit always returns auto if the element is positioned
91				position = elem.css( "position" );
92				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
93					// IE returns 0 when zIndex is not specified
94					// other browsers return a string
95					// we ignore the case of nested elements with an explicit value of 0
96					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
97					value = parseInt( elem.css( "zIndex" ), 10 );
98					if ( !isNaN( value ) && value !== 0 ) {
99						return value;
100					}
101				}
102				elem = elem.parent();
103			}
104		}
105
106		return 0;
107	},
108
109	uniqueId: function() {
110		return this.each(function() {
111			if ( !this.id ) {
112				this.id = "ui-id-" + (++uuid);
113			}
114		});
115	},
116
117	removeUniqueId: function() {
118		return this.each(function() {
119			if ( runiqueId.test( this.id ) ) {
120				$( this ).removeAttr( "id" );
121			}
122		});
123	}
124});
125
126// selectors
127function focusable( element, isTabIndexNotNaN ) {
128	var map, mapName, img,
129		nodeName = element.nodeName.toLowerCase();
130	if ( "area" === nodeName ) {
131		map = element.parentNode;
132		mapName = map.name;
133		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
134			return false;
135		}
136		img = $( "img[usemap=#" + mapName + "]" )[0];
137		return !!img && visible( img );
138	}
139	return ( /input|select|textarea|button|object/.test( nodeName ) ?
140		!element.disabled :
141		"a" === nodeName ?
142			element.href || isTabIndexNotNaN :
143			isTabIndexNotNaN) &&
144		// the element and all of its ancestors must be visible
145		visible( element );
146}
147
148function visible( element ) {
149	return $.expr.filters.visible( element ) &&
150		!$( element ).parents().andSelf().filter(function() {
151			return $.css( this, "visibility" ) === "hidden";
152		}).length;
153}
154
155$.extend( $.expr[ ":" ], {
156	data: $.expr.createPseudo ?
157		$.expr.createPseudo(function( dataName ) {
158			return function( elem ) {
159				return !!$.data( elem, dataName );
160			};
161		}) :
162		// support: jQuery <1.8
163		function( elem, i, match ) {
164			return !!$.data( elem, match[ 3 ] );
165		},
166
167	focusable: function( element ) {
168		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
169	},
170
171	tabbable: function( element ) {
172		var tabIndex = $.attr( element, "tabindex" ),
173			isTabIndexNaN = isNaN( tabIndex );
174		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
175	}
176});
177
178// support
179$(function() {
180	var body = document.body,
181		div = body.appendChild( div = document.createElement( "div" ) );
182
183	// access offsetHeight before setting the style to prevent a layout bug
184	// in IE 9 which causes the element to continue to take up space even
185	// after it is removed from the DOM (#8026)
186	div.offsetHeight;
187
188	$.extend( div.style, {
189		minHeight: "100px",
190		height: "auto",
191		padding: 0,
192		borderWidth: 0
193	});
194
195	$.support.minHeight = div.offsetHeight === 100;
196	$.support.selectstart = "onselectstart" in div;
197
198	// set display to none to avoid a layout bug in IE
199	// http://dev.jquery.com/ticket/4014
200	body.removeChild( div ).style.display = "none";
201});
202
203// support: jQuery <1.8
204if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
205	$.each( [ "Width", "Height" ], function( i, name ) {
206		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
207			type = name.toLowerCase(),
208			orig = {
209				innerWidth: $.fn.innerWidth,
210				innerHeight: $.fn.innerHeight,
211				outerWidth: $.fn.outerWidth,
212				outerHeight: $.fn.outerHeight
213			};
214
215		function reduce( elem, size, border, margin ) {
216			$.each( side, function() {
217				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
218				if ( border ) {
219					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
220				}
221				if ( margin ) {
222					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
223				}
224			});
225			return size;
226		}
227

228		$.fn[ "inner" + name ] = function( size ) {
229			if ( size === undefined ) {
230				return orig[ "inner" + name ].call( this );
231			}
232
233			return this.each(function() {
234				$( this ).css( type, reduce( this, size ) + "px" );
235			});
236		};
237
238		$.fn[ "outer" + name] = function( size, margin ) {
239			if ( typeof size !== "number" ) {
240				return orig[ "outer" + name ].call( this, size );
241			}
242
243			return this.each(function() {
244				$( this).css( type, reduce( this, size, true, margin ) + "px" );
245			});
246		};
247	});
248}
249
250// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
251if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
252	$.fn.removeData = (function( removeData ) {
253		return function( key ) {
254			if ( arguments.length ) {
255				return removeData.call( this, $.camelCase( key ) );
256			} else {
257				return removeData.call( this );
258			}
259		};
260	})( $.fn.removeData );
261}
262
263
264
265
266
267// deprecated
268
269(function() {
270	var uaMatch = /msie ([\w.]+)/.exec( navigator.userAgent.toLowerCase() ) || [];
271	$.ui.ie = uaMatch.length ? true : false;
272	$.ui.ie6 = parseFloat( uaMatch[ 1 ], 10 ) === 6;
273})();
274
275$.fn.extend({
276	disableSelection: function() {
277		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
278			".ui-disableSelection", function( event ) {
279				event.preventDefault();
280			});
281	},
282
283	enableSelection: function() {
284		return this.unbind( ".ui-disableSelection" );
285	}
286});
287
288$.extend( $.ui, {
289	// $.ui.plugin is deprecated.  Use the proxy pattern instead.
290	plugin: {
291		add: function( module, option, set ) {
292			var i,
293				proto = $.ui[ module ].prototype;
294			for ( i in set ) {
295				proto.plugins[ i ] = proto.plugins[ i ] || [];
296				proto.plugins[ i ].push( [ option, set[ i ] ] );
297			}
298		},
299		call: function( instance, name, args ) {
300			var i,
301				set = instance.plugins[ name ];
302			if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {
303				return;
304			}
305
306			for ( i = 0; i < set.length; i++ ) {
307				if ( instance.options[ set[ i ][ 0 ] ] ) {
308					set[ i ][ 1 ].apply( instance.element, args );
309				}
310			}
311		}
312	},
313
314	contains: $.contains,
315
316	// only used by resizable
317	hasScroll: function( el, a ) {
318
319		//If overflow is hidden, the element might have extra content, but the user wants to hide it
320		if ( $( el ).css( "overflow" ) === "hidden") {
321			return false;
322		}
323
324		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
325			has = false;
326
327		if ( el[ scroll ] > 0 ) {
328			return true;
329		}
330
331		// TODO: determine which cases actually cause this to happen
332		// if the element doesn't have the scroll set, see if it's possible to
333		// set the scroll
334		el[ scroll ] = 1;
335		has = ( el[ scroll ] > 0 );
336		el[ scroll ] = 0;
337		return has;
338	},
339
340	// these are odd functions, fix the API or move into individual plugins
341	isOverAxis: function( x, reference, size ) {
342		//Determines when x coordinate is over "b" element axis
343		return ( x > reference ) && ( x < ( reference + size ) );
344	},
345	isOver: function( y, x, top, left, height, width ) {
346		//Determines when x, y coordinates is over "b" element
347		return $.ui.isOverAxis( y, top, height ) && $.ui.isOverAxis( x, left, width );
348	}
349});
350
351})( jQuery );
352(function( $, undefined ) {
353
354var uuid = 0,
355	slice = Array.prototype.slice,
356	_cleanData = $.cleanData;
357$.cleanData = function( elems ) {
358	for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
359		try {
360			$( elem ).triggerHandler( "remove" );
361		// http://bugs.jquery.com/ticket/8235
362		} catch( e ) {}
363	}
364	_cleanData( elems );
365};
366
367$.widget = function( name, base, prototype ) {
368	var fullName, existingConstructor, constructor, basePrototype,
369		namespace = name.split( "." )[ 0 ];
370
371	name = name.split( "." )[ 1 ];
372	fullName = namespace + "-" + name;
373
374	if ( !prototype ) {
375		prototype = base;
376		base = $.Widget;
377	}
378
379	// create selector for plugin
380	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
381		return !!$.data( elem, fullName );
382	};
383
384	$[ namespace ] = $[ namespace ] || {};
385	existingConstructor = $[ namespace ][ name ];
386	constructor = $[ namespace ][ name ] = function( options, element ) {
387		// allow instantiation without "new" keyword
388		if ( !this._createWidget ) {
389			return new constructor( options, element );
390		}
391
392		// allow instantiation without initializing for simple inheritance
393		// must use "new" keyword (the code above always passes args)
394		if ( arguments.length ) {
395			this._createWidget( options, element );
396		}
397	};
398	// extend with the existing constructor to carry over any static properties
399	$.extend( constructor, existingConstructor, {
400		version: prototype.version,
401		// copy the object used to create the prototype in case we need to
402		// redefine the widget later
403		_proto: $.extend( {}, prototype ),
404		// track widgets that inherit from this widget in case this widget is
405		// redefined after a widget inherits from it
406		_childConstructors: []
407	});
408
409	basePrototype = new base();
410	// we need to make the options hash a property directly on the new instance
411	// otherwise we'll modify the options hash on the prototype that we're
412	// inheriting from
413	basePrototype.options = $.widget.extend( {}, basePrototype.options );
414	$.each( prototype, function( prop, value ) {
415		if ( $.isFunction( value ) ) {
416			prototype[ prop ] = (function() {
417				var _super = function() {
418						return base.prototype[ prop ].apply( this, arguments );
419					},
420					_superApply = function( args ) {
421						return base.prototype[ prop ].apply( this, args );
422					};
423				return function() {
424					var __super = this._super,
425						__superApply = this._superApply,
426						returnValue;
427
428					this._super = _super;
429					this._superApply = _superApply;
430

431					returnValue = value.apply( this, arguments );
432
433					this._super = __super;
434					this._superApply = __superApply;
435
436					return returnValue;
437				};
438			})();
439		}
440	});
441	constructor.prototype = $.widget.extend( basePrototype, {
442		// TODO: remove support for widgetEventPrefix
443		// always use the name + a colon as the prefix, e.g., draggable:start
444		// don't prefix for widgets that aren't DOM-based
445		widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name
446	}, prototype, {
447		constructor: constructor,
448		namespace: namespace,
449		widgetName: name,
450		// TODO remove widgetBaseClass, see #8155
451		widgetBaseClass: fullName,
452		widgetFullName: fullName
453	});
454
455	// If this widget is being redefined then we need to find all widgets that
456	// are inheriting from it and redefine all of them so that they inherit from
457	// the new version of this widget. We're essentially trying to replace one
458	// level in the prototype chain.
459	if ( existingConstructor ) {
460		$.each( existingConstructor._childConstructors, function( i, child ) {
461			var childPrototype = child.prototype;
462
463			// redefine the child widget using the same prototype that was
464			// originally used, but inherit from the new version of the base
465			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
466		});
467		// remove the list of existing child constructors from the old constructor
468		// so the old child constructors can be garbage collected
469		delete existingConstructor._childConstructors;
470	} else {
471		base._childConstructors.push( constructor );
472	}
473
474	$.widget.bridge( name, constructor );
475};
476
477$.widget.extend = function( target ) {
478	var input = slice.call( arguments, 1 ),
479		inputIndex = 0,
480		inputLength = input.length,
481		key,
482		value;
483	for ( ; inputIndex < inputLength; inputIndex++ ) {
484		for ( key in input[ inputIndex ] ) {
485			value = input[ inputIndex ][ key ];
486			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
487				// Clone objects
488				if ( $.isPlainObject( value ) ) {
489					target[ key ] = $.isPlainObject( target[ key ] ) ?
490						$.widget.extend( {}, target[ key ], value ) :
491						// Don't extend strings, arrays, etc. with objects
492						$.widget.extend( {}, value );
493				// Copy everything else by reference
494				} else {
495					target[ key ] = value;
496				}
497			}
498		}
499	}
500	return target;
501};
502
503$.widget.bridge = function( name, object ) {
504	var fullName = object.prototype.widgetFullName || name;
505	$.fn[ name ] = function( options ) {
506		var isMethodCall = typeof options === "string",
507			args = slice.call( arguments, 1 ),
508			returnValue = this;
509
510		// allow multiple hashes to be passed on init
511		options = !isMethodCall && args.length ?
512			$.widget.extend.apply( null, [ options ].concat(args) ) :
513			options;
514
515		if ( isMethodCall ) {
516			this.each(function() {
517				var methodValue,
518					instance = $.data( this, fullName );
519				if ( !instance ) {
520					return $.error( "cannot call methods on " + name + " prior to initialization; " +
521						"attempted to call method '" + options + "'" );
522				}
523				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
524					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
525				}
526				methodValue = instance[ options ].apply( instance, args );
527				if ( methodValue !== instance && methodValue !== undefined ) {
528					returnValue = methodValue && methodValue.jquery ?
529						returnValue.pushStack( methodValue.get() ) :
530						methodValue;
531					return false;
532				}
533			});
534		} else {
535			this.each(function() {
536				var instance = $.data( this, fullName );
537				if ( instance ) {
538					instance.option( options || {} )._init();
539				} else {
540					$.data( this, fullName, new object( options, this ) );
541				}
542			});
543		}
544
545		return returnValue;
546	};
547};
548
549$.Widget = function( /* options, element */ ) {};
550$.Widget._childConstructors = [];
551
552$.Widget.prototype = {
553	widgetName: "widget",
554	widgetEventPrefix: "",
555	defaultElement: "<div>",
556	options: {
557		disabled: false,
558
559		// callbacks
560		create: null
561	},
562	_createWidget: function( options, element ) {
563		element = $( element || this.defaultElement || this )[ 0 ];
564		this.element = $( element );
565		this.uuid = uuid++;
566		this.eventNamespace = "." + this.widgetName + this.uuid;
567		this.options = $.widget.extend( {},
568			this.options,
569			this._getCreateOptions(),
570			options );
571
572		this.bindings = $();
573		this.hoverable = $();
574		this.focusable = $();
575
576		if ( element !== this ) {
577			// 1.9 BC for #7810
578			// TODO remove dual storage
579			$.data( element, this.widgetName, this );
580			$.data( element, this.widgetFullName, this );
581			this._on( true, this.element, {
582				remove: function( event ) {
583					if ( event.target === element ) {
584						this.destroy();
585					}
586				}
587			});
588			this.document = $( element.style ?
589				// element within the document
590				element.ownerDocument :
591				// element is window or document
592				element.document || element );
593			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
594		}
595
596		this._create();
597		this._trigger( "create", null, this._getCreateEventData() );
598		this._init();
599	},
600	_getCreateOptions: $.noop,
601	_getCreateEventData: $.noop,
602	_create: $.noop,
603	_init: $.noop,
604
605	destroy: function() {
606		this._destroy();
607		// we can probably remove the unbind calls in 2.0
608		// all event bindings should go through this._on()
609		this.element
610			.unbind( this.eventNamespace )
611			// 1.9 BC for #7810
612			// TODO remove dual storage
613			.removeData( this.widgetName )
614			.removeData( this.widgetFullName )
615			// support: jquery <1.6.3
616			// http://bugs.jquery.com/ticket/9413
617			.removeData( $.camelCase( this.widgetFullName ) );
618		this.widget()
619			.unbind( this.eventNamespace )
620			.removeAttr( "aria-disabled" )
621			.removeClass(
622				this.widgetFullName + "-disabled " +
623				"ui-state-disabled" );
624
625		// clean up events and states
626		this.bindings.unbind( this.eventNamespace );
627		this.hoverable.removeClass( "ui-state-hover" );
628		this.focusable.removeClass( "ui-state-focus" );
629	},
630	_destroy: $.noop,
631
632	widget: function() {
633		return this.element;
634	},
635
636	option: function( key, value ) {
637		var options = key,
638			parts,
639			curOption,
640			i;
641
642		if ( arguments.length === 0 ) {
643			// don't return a reference to the internal hash
644			return $.widget.extend( {}, this.options );
645		}
646
647		if ( typeof key === "string" ) {
648			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
649			options = {};
650			parts = key.split( "." );
651			key = parts.shift();
652			if ( parts.length ) {
653				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
654				for ( i = 0; i < parts.length - 1; i++ ) {
655					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
656					curOption = curOption[ parts[ i ] ];
657				}
658				key = parts.pop();
659				if ( value === undefined ) {
660					return curOption[ key ] === undefined ? null : curOption[ key ];
661				}
662				curOption[ key ] = value;
663			} else {
664				if ( value === undefined ) {
665					return this.options[ key ] === undefined ? null : this.options[ key ];
666				}
667				options[ key ] = value;
668			}
669		}
670
671		this._setOptions( options );
672
673		return this;
674	},
675	_setOptions: function( options ) {
676		var key;
677
678		for ( key in options ) {
679			this._setOption( key, options[ key ] );
680		}
681
682		return this;
683	},
684	_setOption: function( key, value ) {
685		this.options[ key ] = value;
686
687		if ( key === "disabled" ) {
688			this.widget()
689				.toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )
690				.attr( "aria-disabled", value );
691			this.hoverable.removeClass( "ui-state-hover" );
692			this.focusable.removeClass( "ui-state-focus" );
693		}
694
695		return this;
696	},
697
698	enable: function() {
699		return this._setOption( "disabled", false );
700	},
701	disable: function() {
702		return this._setOption( "disabled", true );
703	},
704
705	_on: function( suppressDisabledCheck, element, handlers ) {
706		var delegateElement,
707			instance = this;
708
709		// no suppressDisabledCheck flag, shuffle arguments
710		if ( typeof suppressDisabledCheck !== "boolean" ) {
711			handlers = element;
712			element = suppressDisabledCheck;
713			suppressDisabledCheck = false;
714		}
715
716		// no element argument, shuffle and use this.element
717		if ( !handlers ) {
718			handlers = element;
719			element = this.element;
720			delegateElement = this.widget();
721		} else {
722			// accept selectors, DOM elements
723			element = delegateElement = $( element );
724			this.bindings = this.bindings.add( element );
725		}
726
727		$.each( handlers, function( event, handler ) {
728			function handlerProxy() {
729				// allow widgets to customize the disabled handling
730				// - disabled as an array instead of boolean
731				// - disabled class as method for disabling individual parts
732				if ( !suppressDisabledCheck &&
733						( instance.options.disabled === true ||
734							$( this ).hasClass( "ui-state-disabled" ) ) ) {
735					return;
736				}
737				return ( typeof handler === "string" ? instance[ handler ] : handler )
738					.apply( instance, arguments );
739			}
740
741			// copy the guid so direct unbinding works
742			if ( typeof handler !== "string" ) {
743				handlerProxy.guid = handler.guid =
744					handler.guid || handlerProxy.guid || $.guid++;
745			}
746
747			var match = event.match( /^(\w+)\s*(.*)$/ ),
748				eventName = match[1] + instance.eventNamespace,
749				selector = match[2];
750			if ( selector ) {
751				delegateElement.delegate( selector, eventName, handlerProxy );
752			} else {
753				element.bind( eventName, handlerProxy );
754			}
755		});
756	},
757
758	_off: function( element, eventName ) {
759		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
760		element.unbind( eventName ).undelegate( eventName );
761	},
762
763	_delay: function( handler, delay ) {
764		function handlerProxy() {
765			return ( typeof handler === "string" ? instance[ handler ] : handler )
766				.apply( instance, arguments );
767		}
768		var instance = this;
769		return setTimeout( handlerProxy, delay || 0 );
770	},
771
772	_hoverable: function( element ) {
773		this.hoverable = this.hoverable.add( element );
774		this._on( element, {
775			mouseenter: function( event ) {
776				$( event.currentTarget ).addClass( "ui-state-hover" );
777			},
778			mouseleave: function( event ) {
779				$( event.currentTarget ).removeClass( "ui-state-hover" );
780			}
781		});
782	},
783
784	_focusable: function( element ) {
785		this.focusable = this.focusable.add( element );
786		this._on( element, {
787			focusin: function( event ) {
788				$( event.currentTarget ).addClass( "ui-state-focus" );
789			},
790			focusout: function( event ) {
791				$( event.currentTarget ).removeClass( "ui-state-focus" );
792			}
793		});
794	},
795
796	_trigger: function( type, event, data ) {
797		var prop, orig,
798			callback = this.options[ type ];
799
800		data = data || {};
801		event = $.Event( event );
802		event.type = ( type === this.widgetEventPrefix ?
803			type :
804			this.widgetEventPrefix + type ).toLowerCase();
805		// the original event may come from any element
806		// so we need to reset the target on the new event
807		event.target = this.element[ 0 ];
808
809		// copy original event properties over to the new event
810		orig = event.originalEvent;
811		if ( orig ) {
812			for ( prop in orig ) {
813				if ( !( prop in event ) ) {
814					event[ prop ] = orig[ prop ];
815				}
816			}
817		}
818
819		this.element.trigger( event, data );
820		return !( $.isFunction( callback ) &&
821			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
822			event.isDefaultPrevented() );
823	}
824};
825
826$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
827	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
828		if ( typeof options === "string" ) {
829			options = { effect: options };
830		}
831		var hasOptions,
832			effectName = !options ?
833				method :
834				options === true || typeof options === "number" ?
835					defaultEffect :
836					options.effect || defaultEffect;
837		options = options || {};
838		if ( typeof options === "number" ) {
839			options = { duration: options };
840		}
841		hasOptions = !$.isEmptyObject( options );
842		options.complete = callback;
843		if ( options.delay ) {
844			element.delay( options.delay );
845		}
846		if ( hasOptions && $.effects && ( $.effects.effect[ effectName ] || $.uiBackCompat !== false && $.effects[ effectName ] ) ) {
847			element[ method ]( options );
848		} else if ( effectName !== method && element[ effectName ] ) {

849			element[ effectName ]( options.duration, options.easing, callback );
850		} else {
851			element.queue(function( next ) {
852				$( this )[ method ]();
853				if ( callback ) {
854					callback.call( element[ 0 ] );
855				}
856				next();
857			});
858		}
859	};
860});
861
862// DEPRECATED
863if ( $.uiBackCompat !== false ) {
864	$.Widget.prototype._getCreateOptions = function() {
865		return $.metadata && $.metadata.get( this.element[0] )[ this.widgetName ];
866	};
867}
868
869})( jQuery );
870(function( $, undefined ) {
871
872var mouseHandled = false;
873$( document ).mouseup( function( e ) {
874	mouseHandled = false;
875});
876
877$.widget("ui.mouse", {
878	version: "1.9.2",
879	options: {
880		cancel: 'input,textarea,button,select,option',
881		distance: 1,
882		delay: 0
883	},
884	_mouseInit: function() {
885		var that = this;
886
887		this.element
888			.bind('mousedown.'+this.widgetName, function(event) {
889				return that._mouseDown(event);
890			})
891			.bind('click.'+this.widgetName, function(event) {
892				if (true === $.data(event.target, that.widgetName + '.preventClickEvent')) {
893					$.removeData(event.target, that.widgetName + '.preventClickEvent');
894					event.stopImmediatePropagation();
895					return false;
896				}
897			});
898
899		this.started = false;
900	},
901
902	// TODO: make sure destroying one instance of mouse doesn't mess with
903	// other instances of mouse
904	_mouseDestroy: function() {
905		this.element.unbind('.'+this.widgetName);
906		if ( this._mouseMoveDelegate ) {
907			$(document)
908				.unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
909				.unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
910		}
911	},
912
913	_mouseDown: function(event) {
914		// don't let more than one widget handle mouseStart
915		if( mouseHandled ) { return; }
916
917		// we may have missed mouseup (out of window)
918		(this._mouseStarted && this._mouseUp(event));
919
920		this._mouseDownEvent = event;
921
922		var that = this,
923			btnIsLeft = (event.which === 1),
924			// event.target.nodeName works around a bug in IE 8 with
925			// disabled inputs (#7620)
926			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
927		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
928			return true;
929		}
930
931		this.mouseDelayMet = !this.options.delay;
932		if (!this.mouseDelayMet) {
933			this._mouseDelayTimer = setTimeout(function() {
934				that.mouseDelayMet = true;
935			}, this.options.delay);
936		}
937
938		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
939			this._mouseStarted = (this._mouseStart(event) !== false);
940			if (!this._mouseStarted) {
941				event.preventDefault();
942				return true;
943			}
944		}
945
946		// Click event may never have fired (Gecko & Opera)
947		if (true === $.data(event.target, this.widgetName + '.preventClickEvent')) {
948			$.removeData(event.target, this.widgetName + '.preventClickEvent');
949		}
950
951		// these delegates are required to keep context
952		this._mouseMoveDelegate = function(event) {
953			return that._mouseMove(event);
954		};
955		this._mouseUpDelegate = function(event) {
956			return that._mouseUp(event);
957		};
958		$(document)
959			.bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
960			.bind('mouseup.'+this.widgetName, this._mouseUpDelegate);
961
962		event.preventDefault();
963
964		mouseHandled = true;
965		return true;
966	},
967
968	_mouseMove: function(event) {
969		// IE mouseup check - mouseup happened when mouse was out of window
970		if ($.ui.ie && !(document.documentMode >= 9) && !event.button) {
971			return this._mouseUp(event);
972		}
973
974		if (this._mouseStarted) {
975			this._mouseDrag(event);
976			return event.preventDefault();
977		}
978
979		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
980			this._mouseStarted =
981				(this._mouseStart(this._mouseDownEvent, event) !== false);
982			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
983		}
984
985		return !this._mouseStarted;
986	},
987
988	_mouseUp: function(event) {
989		$(document)
990			.unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
991			.unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
992
993		if (this._mouseStarted) {
994			this._mouseStarted = false;
995
996			if (event.target === this._mouseDownEvent.target) {
997				$.data(event.target, this.widgetName + '.preventClickEvent', true);
998			}
999
1000			this._mouseStop(event);
1001		}
1002
1003		return false;

1004	},
1005
1006	_mouseDistanceMet: function(event) {
1007		return (Math.max(
1008				Math.abs(this._mouseDownEvent.pageX - event.pageX),
1009				Math.abs(this._mouseDownEvent.pageY - event.pageY)
1010			) >= this.options.distance
1011		);
1012	},
1013
1014	_mouseDelayMet: function(event) {
1015		return this.mouseDelayMet;
1016	},
1017
1018	// These are placeholder methods, to be overriden by extending plugin
1019	_mouseStart: function(event) {},
1020	_mouseDrag: function(event) {},
1021	_mouseStop: function(event) {},
1022	_mouseCapture: function(event) { return true; }
1023});
1024
1025})(jQuery);
1026(function( $, undefined ) {
1027
1028$.ui = $.ui || {};
1029
1030var cachedScrollbarWidth,
1031	max = Math.max,
1032	abs = Math.abs,
1033	round = Math.round,
1034	rhorizontal = /left|center|right/,
1035	rvertical = /top|center|bottom/,
1036	roffset = /[\+\-]\d+%?/,
1037	rposition = /^\w+/,
1038	rpercent = /%$/,
1039	_position = $.fn.position;
1040
1041function getOffsets( offsets, width, height ) {
1042	return [
1043		parseInt( offsets[ 0 ], 10 ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1044		parseInt( offsets[ 1 ], 10 ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1045	];
1046}
1047function parseCss( element, property ) {
1048	return parseInt( $.css( element, property ), 10 ) || 0;
1049}
1050
1051$.position = {
1052	scrollbarWidth: function() {
1053		if ( cachedScrollbarWidth !== undefined ) {
1054			return cachedScrollbarWidth;
1055		}
1056		var w1, w2,
1057			div = $( "<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1058			innerDiv = div.children()[0];
1059
1060		$( "body" ).append( div );
1061		w1 = innerDiv.offsetWidth;
1062		div.css( "overflow", "scroll" );
1063
1064		w2 = innerDiv.offsetWidth;
1065
1066		if ( w1 === w2 ) {
1067			w2 = div[0].clientWidth;
1068		}
1069
1070		div.remove();
1071
1072		return (cachedScrollbarWidth = w1 - w2);
1073	},
1074	getScrollInfo: function( within ) {
1075		var overflowX = within.isWindow ? "" : within.element.css( "overflow-x" ),
1076			overflowY = within.isWindow ? "" : within.element.css( "overflow-y" ),
1077			hasOverflowX = overflowX === "scroll" ||
1078				( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1079			hasOverflowY = overflowY === "scroll" ||
1080				( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1081		return {
1082			width: hasOverflowX ? $.position.scrollbarWidth() : 0,
1083			height: hasOverflowY ? $.position.scrollbarWidth() : 0
1084		};
1085	},
1086	getWithinInfo: function( element ) {
1087		var withinElement = $( element || window ),
1088			isWindow = $.isWindow( withinElement[0] );
1089		return {
1090			element: withinElement,
1091			isWindow: isWindow,
1092			offset: withinElement.offset() || { left: 0, top: 0 },
1093			scrollLeft: withinElement.scrollLeft(),
1094			scrollTop: withinElement.scrollTop(),
1095			width: isWindow ? withinElement.width() : withinElement.outerWidth(),
1096			height: isWindow ? withinElement.height() : withinElement.outerHeight()
1097		};
1098	}
1099};
1100
1101$.fn.position = function( options ) {
1102	if ( !options || !options.of ) {
1103		return _position.apply( this, arguments );
1104	}
1105
1106	// make a copy, we don't want to modify arguments
1107	options = $.extend( {}, options );
1108
1109	var atOffset, targetWidth, targetHeight, targetOffset, basePosition,
1110		target = $( options.of ),
1111		within = $.position.getWithinInfo( options.within ),
1112		scrollInfo = $.position.getScrollInfo( within ),
1113		targetElem = target[0],
1114		collision = ( options.collision || "flip" ).split( " " ),
1115		offsets = {};
1116
1117	if ( targetElem.nodeType === 9 ) {
1118		targetWidth = target.width();
1119		targetHeight = target.height();
1120		targetOffset = { top: 0, left: 0 };
1121	} else if ( $.isWindow( targetElem ) ) {
1122		targetWidth = target.width();
1123		targetHeight = target.height();
1124		targetOffset = { top: target.scrollTop(), left: target.scrollLeft() };
1125	} else if ( targetElem.preventDefault ) {
1126		// force left top to allow flipping
1127		options.at = "left top";
1128		targetWidth = targetHeight = 0;
1129		targetOffset = { top: targetElem.pageY, left: targetElem.pageX };
1130	} else {
1131		targetWidth = target.outerWidth();
1132		targetHeight = target.outerHeight();
1133		targetOffset = target.offset();
1134	}
1135	// clone to reuse original targetOffset later
1136	basePosition = $.extend( {}, targetOffset );
1137
1138	// force my and at to have valid horizontal and vertical positions
1139	// if a value is missing or invalid, it will be converted to center
1140	$.each( [ "my", "at" ], function() {
1141		var pos = ( options[ this ] || "" ).split( " " ),
1142			horizontalOffset,
1143			verticalOffset;
1144
1145		if ( pos.length === 1) {
1146			pos = rhorizontal.test( pos[ 0 ] ) ?

1147				pos.concat( [ "center" ] ) :
1148				rvertical.test( pos[ 0 ] ) ?
1149					[ "center" ].concat( pos ) :
1150					[ "center", "center" ];
1151		}
1152		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1153		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1154
1155		// calculate offsets
1156		horizontalOffset = roffset.exec( pos[ 0 ] );
1157		verticalOffset = roffset.exec( pos[ 1 ] );
1158		offsets[ this ] = [
1159			horizontalOffset ? horizontalOffset[ 0 ] : 0,
1160			verticalOffset ? verticalOffset[ 0 ] : 0
1161		];
1162
1163		// reduce to just the positions without the offsets
1164		options[ this ] = [
1165			rposition.exec( pos[ 0 ] )[ 0 ],
1166			rposition.exec( pos[ 1 ] )[ 0 ]
1167		];
1168	});
1169
1170	// normalize collision option
1171	if ( collision.length === 1 ) {
1172		collision[ 1 ] = collision[ 0 ];
1173	}
1174
1175	if ( options.at[ 0 ] === "right" ) {
1176		basePosition.left += targetWidth;
1177	} else if ( options.at[ 0 ] === "center" ) {
1178		basePosition.left += targetWidth / 2;
1179	}
1180
1181	if ( options.at[ 1 ] === "bottom" ) {
1182		basePosition.top += targetHeight;
1183	} else if ( options.at[ 1 ] === "center" ) {
1184		basePosition.top += targetHeight / 2;
1185	}
1186
1187	atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1188	basePosition.left += atOffset[ 0 ];
1189	basePosition.top += atOffset[ 1 ];
1190
1191	return this.each(function() {
1192		var collisionPosition, using,
1193			elem = $( this ),
1194			elemWidth = elem.outerWidth(),
1195			elemHeight = elem.outerHeight(),
1196			marginLeft = parseCss( this, "marginLeft" ),
1197			marginTop = parseCss( this, "marginTop" ),
1198			collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1199			collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1200			position = $.extend( {}, basePosition ),
1201			myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1202
1203		if ( options.my[ 0 ] === "right" ) {
1204			position.left -= elemWidth;
1205		} else if ( options.my[ 0 ] === "center" ) {
1206			position.left -= elemWidth / 2;
1207		}
1208
1209		if ( options.my[ 1 ] === "bottom" ) {
1210			position.top -= elemHeight;
1211		} else if ( options.my[ 1 ] === "center" ) {
1212			position.top -= elemHeight / 2;
1213		}
1214
1215		position.left += myOffset[ 0 ];
1216		position.top += myOffset[ 1 ];
1217
1218		// if the browser doesn't support fractions, then round for consistent results
1219		if ( !$.support.offsetFractions ) {
1220			position.left = round( position.left );
1221			position.top = round( position.top );
1222		}
1223
1224		collisionPosition = {
1225			marginLeft: marginLeft,
1226			marginTop: marginTop
1227		};
1228
1229		$.each( [ "left", "top" ], function( i, dir ) {
1230			if ( $.ui.position[ collision[ i ] ] ) {
1231				$.ui.position[ collision[ i ] ][ dir ]( position, {
1232					targetWidth: targetWidth,
1233					targetHeight: targetHeight,
1234					elemWidth: elemWidth,
1235					elemHeight: elemHeight,
1236					collisionPosition: collisionPosition,
1237					collisionWidth: collisionWidth,
1238					collisionHeight: collisionHeight,
1239					offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1240					my: options.my,
1241					at: options.at,
1242					within: within,
1243					elem : elem
1244				});
1245			}
1246		});
1247
1248		if ( $.fn.bgiframe ) {
1249			elem.bgiframe();
1250		}
1251
1252		if ( options.using ) {
1253			// adds feedback as second argument to using callback, if present
1254			using = function( props ) {
1255				var left = targetOffset.left - position.left,
1256					right = left + targetWidth - elemWidth,
1257					top = targetOffset.top - position.top,
1258					bottom = top + targetHeight - elemHeight,
1259					feedback = {
1260						target: {
1261							element: target,
1262							left: targetOffset.left,
1263							top: targetOffset.top,
1264							width: targetWidth,
1265							height: targetHeight
1266						},
1267						element: {
1268							element: elem,
1269							left: position.left,
1270							top: position.top,
1271							width: elemWidth,
1272							height: elemHeight
1273						},
1274						horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1275						vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1276					};
1277				if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1278					feedback.horizontal = "center";
1279				}
1280				if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1281					feedback.vertical = "middle";
1282				}
1283				if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1284					feedback.important = "horizontal";
1285				} else {
1286					feedback.important = "vertical";
1287				}
1288				options.using.call( this, props, feedback );
1289			};
1290		}
1291
1292		elem.offset( $.extend( position, { using: using } ) );
1293	});
1294};
1295
1296$.ui.position = {
1297	fit: {
1298		left: function( position, data ) {
1299			var within = data.within,
1300				withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1301				outerWidth = within.width,
1302				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1303				overLeft = withinOffset - collisionPosLeft,
1304				overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1305				newOverRight;
1306
1307			// element is wider than within
1308			if ( data.collisionWidth > outerWidth ) {
1309				// element is initially over the left side of within
1310				if ( overLeft > 0 && overRight <= 0 ) {
1311					newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1312					position.left += overLeft - newOverRight;
1313				// element is initially over right side of within
1314				} else if ( overRight > 0 && overLeft <= 0 ) {
1315					position.left = withinOffset;
1316				// element is initially over both left and right sides of within
1317				} else {
1318					if ( overLeft > overRight ) {
1319						position.left = withinOffset + outerWidth - data.collisionWidth;
1320					} else {
1321						position.left = withinOffset;
1322					}
1323				}
1324			// too far left -> align with left edge
1325			} else if ( overLeft > 0 ) {
1326				position.left += overLeft;
1327			// too far right -> align with right edge
1328			} else if ( overRight > 0 ) {
1329				position.left -= overRight;
1330			// adjust based on position and margin
1331			} else {
1332				position.left = max( position.left - collisionPosLeft, position.left );
1333			}
1334		},
1335		top: function( position, data ) {
1336			var within = data.within,
1337				withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1338				outerHeight = data.within.height,
1339				collisionPosTop = position.top - data.collisionPosition.marginTop,
1340				overTop = withinOffset - collisionPosTop,
1341				overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1342				newOverBottom;
1343
1344			// element is taller than within
1345			if ( data.collisionHeight > outerHeight ) {
1346				// element is initially over the top of within
1347				if ( overTop > 0 && overBottom <= 0 ) {
1348					newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1349					position.top += overTop - newOverBottom;
1350				// element is initially over bottom of within
1351				} else if ( overBottom > 0 && overTop <= 0 ) {
1352					position.top = withinOffset;
1353				// element is initially over both top and bottom of within
1354				} else {
1355					if ( overTop > overBottom ) {
1356						position.top = withinOffset + outerHeight - data.collisionHeight;
1357					} else {
1358						position.top = withinOffset;
1359					}
1360				}
1361			// too far up -> align with top
1362			} else if ( overTop > 0 ) {
1363				position.top += overTop;
1364			// too far down -> align with bottom edge
1365			} else if ( overBottom > 0 ) {
1366				position.top -= overBottom;
1367			// adjust based on position and margin
1368			} else {
1369				position.top = max( position.top - collisionPosTop, position.top );
1370			}
1371		}
1372	},
1373	flip: {
1374		left: function( position, data ) {
1375			var within = data.within,
1376				withinOffset = within.offset.left + within.scrollLeft,
1377				outerWidth = within.width,
1378				offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1379				collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1380				overLeft = collisionPosLeft - offsetLeft,
1381				overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1382				myOffset = data.my[ 0 ] === "left" ?
1383					-data.elemWidth :
1384					data.my[ 0 ] === "right" ?
1385						data.elemWidth :
1386						0,
1387				atOffset = data.at[ 0 ] === "left" ?
1388					data.targetWidth :
1389					data.at[ 0 ] === "right" ?
1390						-data.targetWidth :
1391						0,
1392				offset = -2 * data.offset[ 0 ],
1393				newOverRight,
1394				newOverLeft;
1395
1396			if ( overLeft < 0 ) {
1397				newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1398				if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1399					position.left += myOffset + atOffset + offset;
1400				}
1401			}
1402			else if ( overRight > 0 ) {
1403				newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1404				if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1405					position.left += myOffset + atOffset + offset;
1406				}
1407			}
1408		},
1409		top: function( position, data ) {
1410			var within = data.within,
1411				withinOffset = within.offset.top + within.scrollTop,
1412				outerHeight = within.height,
1413				offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1414				collisionPosTop = position.top - data.collisionPosition.marginTop,
1415				overTop = collisionPosTop - offsetTop,
1416				overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1417				top = data.my[ 1 ] === "top",
1418				myOffset = top ?
1419					-data.elemHeight :
1420					data.my[ 1 ] === "bottom" ?
1421						data.elemHeight :
1422						0,
1423				atOffset = data.at[ 1 ] === "top" ?
1424					data.targetHeight :
1425					data.at[ 1 ] === "bottom" ?
1426						-data.targetHeight :
1427						0,
1428				offset = -2 * data.offset[ 1 ],
1429				newOverTop,
1430				newOverBottom;
1431			if ( overTop < 0 ) {
1432				newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1433				if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
1434					position.top += myOffset + atOffset + offset;
1435				}
1436			}
1437			else if ( overBottom > 0 ) {
1438				newOverTop = position.top -  data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1439				if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
1440					position.top += myOffset + atOffset + offset;
1441				}
1442			}
1443		}
1444	},
1445	flipfit: {
1446		left: function() {
1447			$.ui.position.flip.left.apply( this, arguments );
1448			$.ui.position.fit.left.apply( this, arguments );
1449		},
1450		top: function() {
1451			$.ui.position.flip.top.apply( this, arguments );
1452			$.ui.position.fit.top.apply( this, arguments );
1453		}
1454	}
1455};
1456
1457// fraction support test
1458(function () {
1459	var testElement, testElementParent, testElementStyle, offsetLeft, i,
1460		body = document.getElementsByTagName( "body" )[ 0 ],
1461		div = document.createElement( "div" );
1462
1463	//Create a "fake body" for testing based on method used in jQuery.support
1464	testElement = document.createElement( body ? "div" : "body" );
1465	testElementStyle = {
1466		visibility: "hidden",
1467		width: 0,
1468		height: 0,
1469		border: 0,
1470		margin: 0,
1471		background: "none"
1472	};
1473	if ( body ) {
1474		$.extend( testElementStyle, {
1475			position: "absolute",
1476			left: "-1000px",
1477			top: "-1000px"
1478		});
1479	}
1480	for ( i in testElementStyle ) {
1481		testElement.style[ i ] = testElementStyle[ i ];
1482	}
1483	testElement.appendChild( div );
1484	testElementParent = body || document.documentElement;
1485	testElementParent.insertBefore( testElement, testElementParent.firstChild );
1486
1487	div.style.cssText = "position: absolute; left: 10.7432222px;";
1488
1489	offsetLeft = $( div ).offset().left;
1490	$.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
1491
1492	testElement.innerHTML = "";
1493	testElementParent.removeChild( testElement );
1494})();
1495
1496// DEPRECATED
1497if ( $.uiBackCompat !== false ) {
1498	// offset option
1499	(function( $ ) {
1500		var _position = $.fn.position;
1501		$.fn.position = function( options ) {
1502			if ( !options || !options.offset ) {
1503				return _position.call( this, options );
1504			}
1505			var offset = options.offset.split( " " ),
1506				at = options.at.split( " " );
1507			if ( offset.length === 1 ) {
1508				offset[ 1 ] = offset[ 0 ];
1509			}
1510			if ( /^\d/.test( offset[ 0 ] ) ) {
1511				offset[ 0 ] = "+" + offset[ 0 ];
1512			}
1513			if ( /^\d/.test( offset[ 1 ] ) ) {
1514				offset[ 1 ] = "+" + offset[ 1 ];
1515			}
1516			if ( at.length === 1 ) {
1517				if ( /left|center|right/.test( at[ 0 ] ) ) {
1518					at[ 1 ] = "center";
1519				} else {
1520					at[ 1 ] = at[ 0 ];
1521					at[ 0 ] = "center";
1522				}
1523			}
1524			return _position.call( this, $.extend( options, {
1525				at: at[ 0 ] + offset[ 0 ] + " " + at[ 1 ] + offset[ 1 ],
1526				offset: undefined
1527			} ) );
1528		};
1529	}( jQuery ) );
1530}
1531
1532}( jQuery ) );
1533(function( $, undefined ) {
1534
1535$.widget("ui.draggable", $.ui.mouse, {
1536	version: "1.9.2",
1537	widgetEventPrefix: "drag",
1538	options: {
1539		addClasses: true,
1540		appendTo: "parent",
1541		axis: false,
1542		connectToSortable: false,
1543		containment: false,
1544		cursor: "auto",

1545		cursorAt: false,
1546		grid: false,
1547		handle: false,
1548		helper: "original",
1549		iframeFix: false,
1550		opacity: false,
1551		refreshPositions: false,
1552		revert: false,
1553		revertDuration: 500,
1554		scope: "default",
1555		scroll: true,
1556		scrollSensitivity: 20,
1557		scrollSpeed: 20,
1558		snap: false,
1559		snapMode: "both",
1560		snapTolerance: 20,
1561		stack: false,
1562		zIndex: false
1563	},
1564	_create: function() {
1565
1566		if (this.options.helper == 'original' && !(/^(?:r|a|f)/).test(this.element.css("position")))
1567			this.element[0].style.position = 'relative';
1568
1569		(this.options.addClasses && this.element.addClass("ui-draggable"));
1570		(this.options.disabled && this.element.addClass("ui-draggable-disabled"));
1571
1572		this._mouseInit();
1573
1574	},
1575
1576	_destroy: function() {
1577		this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
1578		this._mouseDestroy();
1579	},
1580
1581	_mouseCapture: function(event) {
1582
1583		var o = this.options;
1584
1585		// among others, prevent a drag on a resizable-handle
1586		if (this.helper || o.disabled || $(event.target).is('.ui-resizable-handle'))
1587			return false;
1588
1589		//Quit if we're not on a valid handle
1590		this.handle = this._getHandle(event);
1591		if (!this.handle)
1592			return false;
1593
1594		$(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
1595			$('<div class="ui-draggable-iframeFix" style="background: #fff;"></div>')
1596			.css({
1597				width: this.offsetWidth+"px", height: this.offsetHeight+"px",
1598				position: "absolute", opacity: "0.001", zIndex: 1000
1599			})
1600			.css($(this).offset())
1601			.appendTo("body");
1602		});
1603
1604		return true;
1605
1606	},
1607
1608	_mouseStart: function(event) {
1609
1610		var o = this.options;
1611
1612		//Create and append the visible helper
1613		this.helper = this._createHelper(event);
1614
1615		this.helper.addClass("ui-draggable-dragging");
1616
1617		//Cache the helper size
1618		this._cacheHelperProportions();
1619
1620		//If ddmanager is used for droppables, set the global draggable
1621		if($.ui.ddmanager)
1622			$.ui.ddmanager.current = this;
1623
1624		/*
1625		 * - Position generation -
1626		 * This block generates everything position related - it's the core of draggables.
1627		 */
1628
1629		//Cache the margins of the original element
1630		this._cacheMargins();
1631
1632		//Store the helper's css position
1633		this.cssPosition = this.helper.css("position");
1634		this.scrollParent = this.helper.scrollParent();
1635
1636		//The element's absolute position on the page minus margins
1637		this.offset = this.positionAbs = this.element.offset();
1638		this.offset = {
1639			top: this.offset.top - this.margins.top,
1640			left: this.offset.left - this.margins.left
1641		};
1642
1643		$.extend(this.offset, {
1644			click: { //Where the click happened, relative to the element
1645				left: event.pageX - this.offset.left,
1646				top: event.pageY - this.offset.top
1647			},
1648			parent: this._getParentOffset(),
1649			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
1650		});
1651
1652		//Generate the original position
1653		this.originalPosition = this.position = this._generatePosition(event);
1654		this.originalPageX = event.pageX;
1655		this.originalPageY = event.pageY;
1656
1657		//Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
1658		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
1659
1660		//Set a containment if given in the options
1661		if(o.containment)
1662			this._setContainment();
1663
1664		//Trigger event + callbacks
1665		if(this._trigger("start", event) === false) {
1666			this._clear();
1667			return false;
1668		}
1669
1670		//Recache the helper size
1671		this._cacheHelperProportions();
1672
1673		//Prepare the droppable offsets
1674		if ($.ui.ddmanager && !o.dropBehaviour)
1675			$.ui.ddmanager.prepareOffsets(this, event);
1676
1677
1678		this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
1679
1680		//If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
1681		if ( $.ui.ddmanager ) $.ui.ddmanager.dragStart(this, event);
1682
1683		return true;
1684	},
1685
1686	_mouseDrag: function(event, noPropagation) {
1687
1688		//Compute the helpers position
1689		this.position = this._generatePosition(event);
1690		this.positionAbs = this._convertPositionTo("absolute");
1691
1692		//Call plugins and callbacks and use the resulting position if something is returned
1693		if (!noPropagation) {
1694			var ui = this._uiHash();
1695			if(this._trigger('drag', event, ui) === false) {
1696				this._mouseUp({});
1697				return false;

1698			}
1699			this.position = ui.position;
1700		}
1701
1702		if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px';
1703		if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px';
1704		if($.ui.ddmanager) $.ui.ddmanager.drag(this, event);
1705
1706		return false;
1707	},
1708
1709	_mouseStop: function(event) {
1710
1711		//If we are using droppables, inform the manager about the drop
1712		var dropped = false;
1713		if ($.ui.ddmanager && !this.options.dropBehaviour)
1714			dropped = $.ui.ddmanager.drop(this, event);
1715
1716		//if a drop comes from outside (a sortable)
1717		if(this.dropped) {
1718			dropped = this.dropped;
1719			this.dropped = false;
1720		}
1721
1722		//if the original element is no longer in the DOM don't bother to continue (see #8269)
1723		var element = this.element[0], elementInDom = false;
1724		while ( element && (element = element.parentNode) ) {
1725			if (element == document ) {
1726				elementInDom = true;
1727			}
1728		}
1729		if ( !elementInDom && this.options.helper === "original" )
1730			return false;
1731
1732		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))) {
1733			var that = this;
1734			$(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
1735				if(that._trigger("stop", event) !== false) {
1736					that._clear();
1737				}
1738			});
1739		} else {
1740			if(this._trigger("stop", event) !== false) {
1741				this._clear();
1742			}
1743		}
1744
1745		return false;
1746	},
1747
1748	_mouseUp: function(event) {
1749		//Remove frame helpers
1750		$("div.ui-draggable-iframeFix").each(function() {
1751			this.parentNode.removeChild(this);
1752		});
1753
1754		//If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
1755		if( $.ui.ddmanager ) $.ui.ddmanager.dragStop(this, event);
1756
1757		return $.ui.mouse.prototype._mouseUp.call(this, event);
1758	},
1759
1760	cancel: function() {
1761
1762		if(this.helper.is(".ui-draggable-dragging")) {
1763			this._mouseUp({});
1764		} else {
1765			this._clear();
1766		}
1767
1768		return this;
1769
1770	},
1771
1772	_getHandle: function(event) {
1773
1774		var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
1775		$(this.options.handle, this.element)
1776			.find("*")
1777			.andSelf()
1778			.each(function() {
1779				if(this == event.target) handle = true;
1780			});
1781
1782		return handle;
1783
1784	},
1785
1786	_createHelper: function(event) {
1787
1788		var o = this.options;
1789		var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper == 'clone' ? this.element.clone().removeAttr('id') : this.element);
1790
1791		if(!helper.parents('body').length)
1792			helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));
1793
1794		if(helper[0] != this.element[0] && !(/(fixed|absolute)/).test(helper.css("position")))
1795			helper.css("position", "absolute");
1796
1797		return helper;
1798
1799	},
1800
1801	_adjustOffsetFromHelper: function(obj) {
1802		if (typeof obj == 'string') {
1803			obj = obj.split(' ');
1804		}
1805		if ($.isArray(obj)) {
1806			obj = {left: +obj[0], top: +obj[1] || 0};
1807		}
1808		if ('left' in obj) {
1809			this.offset.click.left = obj.left + this.margins.left;
1810		}
1811		if ('right' in obj) {
1812			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
1813		}
1814		if ('top' in obj) {
1815			this.offset.click.top = obj.top + this.margins.top;
1816		}
1817		if ('bottom' in obj) {
1818			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
1819		}
1820	},
1821
1822	_getParentOffset: function() {
1823
1824		//Get the offsetParent and cache its position
1825		this.offsetParent = this.helper.offsetParent();
1826		var po = this.offsetParent.offset();
1827
1828		// This is a special case where we need to modify a offset calculated on start, since the following happened:
1829		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
1830		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
1831		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
1832		if(this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
1833			po.left += this.scrollParent.scrollLeft();
1834			po.top += this.scrollParent.scrollTop();
1835		}
1836
1837		if((this.offsetParent[0] == document.body) //This needs to be actually done for all browsers, since pageX/pageY includes this information
1838		|| (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.ui.ie)) //Ugly IE fix
1839			po = { top: 0, left: 0 };
1840
1841		return {
1842			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),

184210) || 0),
1843			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
1844		};
1845
1846	},
1847
1848	_getRelativeOffset: function() {
1849
1850		if(this.cssPosition == "relative") {
1851			var p = this.element.position();
1852			return {
1853				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
1854				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
1855			};
1856		} else {
1857			return { top: 0, left: 0 };
1858		}
1859
1860	},
1861
1862	_cacheMargins: function() {
1863		this.margins = {
1864			left: (parseInt(this.element.css("marginLeft"),10) || 0),
1865			top: (parseInt(this.element.css("marginTop"),10) || 0),
1866			right: (parseInt(this.element.css("marginRight"),10) || 0),
1867			bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
1868		};
1869	},
1870
1871	_cacheHelperProportions: function() {
1872		this.helperProportions = {
1873			width: this.helper.outerWidth(),
1874			height: this.helper.outerHeight()
1875		};
1876	},
1877
1878	_setContainment: function() {
1879
1880		var o = this.options;
1881		if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
1882		if(o.containment == 'document' || o.containment == 'window') this.containment = [
1883			o.containment == 'document' ? 0 : $(window).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
1884			o.containment == 'document' ? 0 : $(window).scrollTop() - this.offset.relative.top - this.offset.parent.top,
1885			(o.containment == 'document' ? 0 : $(window).scrollLeft()) + $(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left,
1886			(o.containment == 'document' ? 0 : $(window).scrollTop()) + ($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
1887		];
1888
1889		if(!(/^(document|window|parent)$/).test(o.containment) && o.containment.constructor != Array) {
1890			var c = $(o.containment);
1891			var ce = c[0]; if(!ce) return;
1892			var co = c.offset();
1893			var over = ($(ce).css("overflow") != 'hidden');
1894
1895			this.containment = [
1896				(parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0),
1897				(parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0),

1898				(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left - this.margins.right,
1899				(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top  - this.margins.bottom
1900			];
1901			this.relative_container = c;
1902
1903		} else if(o.containment.constructor == Array) {
1904			this.containment = o.containment;
1905		}
1906
1907	},
1908
1909	_convertPositionTo: function(d, pos) {
1910
1911		if(!pos) pos = this.position;
1912		var mod = d == "absolute" ? 1 : -1;
1913		var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
1914
1915		return {
1916			top: (
1917				pos.top																	// The absolute mouse position
1918				+ this.offset.relative.top * mod										// Only for relative positioned nodes: Relative offset from element to offset parent
1919				+ this.offset.parent.top * mod											// The offsetParent's offset without borders (offset + border)
1920				- ( ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
1921			),
1922			left: (
1923				pos.left																// The absolute mouse position
1924				+ this.offset.relative.left * mod										// Only for relative positioned nodes: Relative offset from element to offset parent
1925				+ this.offset.parent.left * mod											// The offsetParent's offset without borders (offset + border)
1926				- ( ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
1927			)
1928		};
1929
1930	},
1931
1932	_generatePosition: function(event) {
1933
1934		var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
1935		var pageX = event.pageX;
1936		var pageY = event.pageY;
1937
1938		/*
1939		 * - Position constraining -
1940		 * Constrain the position to a mix of grid, containment.
1941		 */
1942
1943		if(this.originalPosition) { //If we are not dragging yet, we won't check for options
1944			var containment;
1945			if(this.containment) {
1946			if (this.relative_container){
1947				var co = this.relative_container.offset();
1948				containment = [ this.containment[0] + co.left,
1949					this.containment[1] + co.top,
1950					this.containment[2] + co.left,
1951					this.containment[3] + co.top ];
1952			}
1953			else {
1954				containment = this.containment;
1955			}
1956
1957				if(event.pageX - this.offset.click.left < containment[0]) pageX = containment[0] + this.offset.click.left;
1958				if(event.pageY - this.offset.click.top < containment[1]) pageY = containment[1] + this.offset.click.top;
1959				if(event.pageX - this.offset.click.left > containment[2]) pageX = containment[2] + this.offset.click.left;
1960				if(event.pageY - this.offset.click.top > containment[3]) pageY = containment[3] + this.offset.click.top;
1961			}
1962
1963			if(o.grid) {
1964				//Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
1965				var top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
1966				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;
1967
1968				var left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
1969				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;
1970			}
1971
1972		}
1973
1974		return {
1975			top: (
1976				pageY																// The absolute mouse position
1977				- this.offset.click.top													// Click offset (relative to the element)
1978				- this.offset.relative.top												// Only for relative positioned nodes: Relative offset from element to offset parent
1979				- this.offset.parent.top												// The offsetParent's offset without borders (offset + border)
1980				+ ( ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
1981			),
1982			left: (
1983				pageX																// The absolute mouse position
1984				- this.offset.click.left												// Click offset (relative to the element)
1985				- this.offset.relative.left												// Only for relative positioned nodes: Relative offset from element to offset parent
1986				- this.offset.parent.left												// The offsetParent's offset without borders (offset + border)
1987				+ ( ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
1988			)
1989		};
1990
1991	},
1992
1993	_clear: function() {
1994		this.helper.removeClass("ui-draggable-dragging");
1995		if(this.helper[0] != this.element[0] && !this.cancelHelperRemoval) this.helper.remove();
1996		//if($.ui.ddmanager) $.ui.ddmanager.current = null;
1997		this.helper = null;
1998		this.cancelHelperRemoval = false;

1999	},
2000
2001	// From now on bulk stuff - mainly helpers
2002
2003	_trigger: function(type, event, ui) {
2004		ui = ui || this._uiHash();
2005		$.ui.plugin.call(this, type, [event, ui]);
2006		if(type == "drag") this.positionAbs = this._convertPositionTo("absolute"); //The absolute position has to be recalculated after plugins
2007		return $.Widget.prototype._trigger.call(this, type, event, ui);
2008	},
2009
2010	plugins: {},
2011
2012	_uiHash: function(event) {
2013		return {
2014			helper: this.helper,
2015			position: this.position,
2016			originalPosition: this.originalPosition,
2017			offset: this.positionAbs
2018		};
2019	}
2020
2021});
2022
2023$.ui.plugin.add("draggable", "connectToSortable", {
2024	start: function(event, ui) {
2025
2026		var inst = $(this).data("draggable"), o = inst.options,
2027			uiSortable = $.extend({}, ui, { item: inst.element });
2028		inst.sortables = [];
2029		$(o.connectToSortable).each(function() {
2030			var sortable = $.data(this, 'sortable');
2031			if (sortable && !sortable.options.disabled) {
2032				inst.sortables.push({
2033					instance: sortable,
2034					shouldRevert: sortable.options.revert
2035				});
2036				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).
2037				sortable._trigger("activate", event, uiSortable);
2038			}
2039		});
2040
2041	},
2042	stop: function(event, ui) {
2043
2044		//If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
2045		var inst = $(this).data("draggable"),
2046			uiSortable = $.extend({}, ui, { item: inst.element });
2047
2048		$.each(inst.sortables, function() {
2049			if(this.instance.isOver) {
2050
2051				this.instance.isOver = 0;
2052
2053				inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
2054				this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
2055
2056				//The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: 'valid/invalid'
2057				if(this.shouldRevert) this.instance.options.revert = true;
2058
2059				//Trigger the stop of the sortable
2060				this.instance._mouseStop(event);
2061
2062				this.instance.options.helper = this.instance.options._helper;
2063
2064				//If the helper has been the original item, restore properties in the sortable
2065				if(inst.options.helper == 'original')
2066					this.instance.currentItem.css({ top: 'auto', left: 'auto' });
2067
2068			} else {
2069				this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
2070				this.instance._trigger("deactivate", event, uiSortable);
2071			}
2072
2073		});
2074
2075	},
2076	drag: function(event, ui) {
2077
2078		var inst = $(this).data("draggable"), that = this;
2079
2080		var checkPos = function(o) {
2081			var dyClick = this.offset.click.top, dxClick = this.offset.click.left;
2082			var helperTop = this.positionAbs.top, helperLeft = this.positionAbs.left;
2083			var itemHeight = o.height, itemWidth = o.width;
2084			var itemTop = o.top, itemLeft = o.left;
2085
2086			return $.ui.isOver(helperTop + dyClick, helperLeft + dxClick, itemTop, itemLeft, itemHeight, itemWidth);
2087		};
2088
2089		$.each(inst.sortables, function(i) {
2090
2091			var innermostIntersecting = false;
2092			var thisSortable = this;
2093			//Copy over some variables to allow calling the sortable's native _intersectsWith
2094			this.instance.positionAbs = inst.positionAbs;
2095			this.instance.helperProportions = inst.helperProportions;
2096			this.instance.offset.click = inst.offset.click;
2097
2098			if(this.instance._intersectsWith(this.instance.containerCache)) {
2099				innermostIntersecting = true;
2100				$.each(inst.sortables, function () {
2101					this.instance.positionAbs = inst.positionAbs;
2102					this.instance.helperProportions = inst.helperProportions;
2103					this.instance.offset.click = inst.offset.click;
2104					if  (this != thisSortable
2105						&& this.instance._intersectsWith(this.instance.containerCache)
2106						&& $.ui.contains(thisSortable.instance.element[0], this.instance.element[0]))
2107						innermostIntersecting = false;
2108						return innermostIntersecting;
2109				});
2110			}
2111
2112
2113			if(innermostIntersecting) {
2114				//If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
2115				if(!this.instance.isOver) {
2116
2117					this.instance.isOver = 1;
2118					//Now we fake the start of dragging for the sortable instance,
2119					//by cloning the list group item, appending it to the sortable and using it as inst.currentItem
2120					//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)
2121					this.instance.currentItem = $(that).clone().removeAttr('id').appendTo(this.instance.element).data("sortable-item", true);
2122					this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
2123					this.instance.options.helper = function() { return ui.helper[0]; };
2124
2125					event.target = this.instance.currentItem[0];
2126					this.instance._mouseCapture(event, true);
2127					this.instance._mouseStart(event, true, true);
2128

2129					//Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
2130					this.instance.offset.click.top = inst.offset.click.top;
2131					this.instance.offset.click.left = inst.offset.click.left;
2132					this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
2133					this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
2134
2135					inst._trigger("toSortable", event);
2136					inst.dropped = this.instance.element; //draggable revert needs that
2137					//hack so receive/update callbacks work (mostly)
2138					inst.currentItem = inst.element;
2139					this.instance.fromOutside = inst;
2140
2141				}
2142
2143				//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
2144				if(this.instance.currentItem) this.instance._mouseDrag(event);
2145
2146			} else {
2147
2148				//If it doesn't intersect with the sortable, and it intersected before,
2149				//we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
2150				if(this.instance.isOver) {
2151
2152					this.instance.isOver = 0;
2153					this.instance.cancelHelperRemoval = true;
2154
2155					//Prevent reverting on this forced stop
2156					this.instance.options.revert = false;
2157
2158					// The out event needs to be triggered independently
2159					this.instance._trigger('out', event, this.instance._uiHash(this.instance));
2160
2161					this.instance._mouseStop(event, true);
2162					this.instance.options.helper = this.instance.options._helper;
2163
2164					//Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
2165					this.instance.currentItem.remove();
2166					if(this.instance.placeholder) this.instance.placeholder.remove();
2167
2168					inst._trigger("fromSortable", event);
2169					inst.dropped = false; //draggable revert needs that
2170				}
2171
2172			};
2173
2174		});
2175
2176	}
2177});
2178
2179$.ui.plugin.add("draggable", "cursor", {
2180	start: function(event, ui) {
2181		var t = $('body'), o = $(this).data('draggable').options;
2182		if (t.css("cursor")) o._cursor = t.css("cursor");
2183		t.css("cursor", o.cursor);
2184	},
2185	stop: function(event, ui) {
2186		var o = $(this).data('draggable').options;
2187		if (o._cursor) $('body').css("cursor", o._cursor);
2188	}
2189});
2190
2191$.ui.plugin.add("draggable", "opacity", {
2192	start: function(event, ui) {
2193		var t = $(ui.helper), o = $(this).data('draggable').options;
2194		if(t.css("opacity")) o._opacity = t.css("opacity");
2195		t.css('opacity', o.opacity);
2196	},
2197	stop: function(event, ui) {
2198		var o = $(this).data('draggable').options;
2199		if(o._opacity) $(ui.helper).css('opacity', o._opacity);
2200	}
2201});
2202
2203$.ui.plugin.add("draggable", "scroll", {
2204	start: function(event, ui) {
2205		var i = $(this).data("draggable");
2206		if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') i.overflowOffset = i.scrollParent.offset();
2207	},
2208	drag: function(event, ui) {
2209
2210		var i = $(this).data("draggable"), o = i.options, scrolled = false;
2211
2212		if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') {
2213
2214			if(!o.axis || o.axis != 'x') {
2215				if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
2216					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
2217				else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity)
2218					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
2219			}
2220
2221			if(!o.axis || o.axis != 'y') {
2222				if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
2223					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
2224				else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity)
2225					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
2226			}
2227
2228		} else {
2229
2230			if(!o.axis || o.axis != 'x') {
2231				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity)
2232					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
2233				else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
2234					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
2235			}
2236
2237			if(!o.axis || o.axis != 'y') {
2238				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
2239					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
2240				else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
2241					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
2242			}
2243
2244		}
2245
2246		if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
2247			$.ui.ddmanager.prepareOffsets(i, event);
2248
2249	}
2250});
2251
2252$.ui.plugin.add("draggable", "snap", {
2253	start: function(event, ui) {
2254
2255		var i = $(this).data("draggable"), o = i.options;
2256		i.snapElements = [];
2257
2258		$(o.snap.constructor != String ? ( o.snap.items || ':data(draggable)' ) : o.snap).each(function() {
2259			var $t = $(this); var $o = $t.offset();
2260			if(this != i.element[0]) i.snapElements.push({
2261				item: this,
2262				width: $t.outerWidth(), height: $t.outerHeight(),
2263				top: $o.top, left: $o.left
2264			});
2265		});
2266
2267	},
2268	drag: function(event, ui) {
2269
2270		var inst = $(this).data("draggable"), o = inst.options;
2271		var d = o.snapTolerance;
2272
2273		var x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
2274			y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
2275
2276		for (var i = inst.snapElements.length - 1; i >= 0; i--){
2277
2278			var l = inst.snapElements[i].left, r = l + inst.snapElements[i].width,
2279				t = inst.snapElements[i].top, b = t + inst.snapElements[i].height;
2280
2281			//Yes, I know, this is insane ;)
2282			if(!((l-d < x1 && x1 < r+d && t-d < y1 && y1 < b+d) || (l-d < x1 && x1 < r+d && t-d < y2 && y2 < b+d) || (l-d < x2 && x2 < r+d && t-d < y1 && y1 < b+d) || (l-d < x2 && x2 < r+d && t-d < y2 && y2 < b+d))) {
2283				if(inst.snapElements[i].snapping) (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
2284				inst.snapElements[i].snapping = false;

2285				continue;
2286			}
2287
2288			if(o.snapMode != 'inner') {
2289				var ts = Math.abs(t - y2) <= d;
2290				var bs = Math.abs(b - y1) <= d;
2291				var ls = Math.abs(l - x2) <= d;
2292				var rs = Math.abs(r - x1) <= d;
2293				if(ts) ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
2294				if(bs) ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
2295				if(ls) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
2296				if(rs) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
2297			}
2298
2299			var first = (ts || bs || ls || rs);
2300
2301			if(o.snapMode != 'outer') {
2302				var ts = Math.abs(t - y1) <= d;
2303				var bs = Math.abs(b - y2) <= d;
2304				var ls = Math.abs(l - x1) <= d;
2305				var rs = Math.abs(r - x2) <= d;
2306				if(ts) ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
2307				if(bs) ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
2308				if(ls) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
2309				if(rs) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
2310			}
2311
2312			if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first))
2313				(inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
2314			inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
2315
2316		};
2317
2318	}
2319});
2320
2321$.ui.plugin.add("draggable", "stack", {
2322	start: function(event, ui) {
2323
2324		var o = $(this).data("draggable").options;
2325
2326		var group = $.makeArray($(o.stack)).sort(function(a,b) {
2327			return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
2328		});
2329		if (!group.length) { return; }
2330
2331		var min = parseInt(group[0].style.zIndex) || 0;
2332		$(group).each(function(i) {
2333			this.style.zIndex = min + i;
2334		});
2335
2336		this[0].style.zIndex = min + group.length;
2337
2338	}
2339});
2340
2341$.ui.plugin.add("draggable", "zIndex", {
2342	start: function(event, ui) {
2343		var t = $(ui.helper), o = $(this).data("draggable").options;
2344		if(t.css("zIndex")) o._zIndex = t.css("zIndex");
2345		t.css('zIndex', o.zIndex);
2346	},
2347	stop: function(event, ui) {
2348		var o = $(this).data("draggable").options;
2349		if(o._zIndex) $(ui.helper).css('zIndex', o._zIndex);
2350	}
2351});
2352
2353})(jQuery);
2354(function( $, undefined ) {
2355
2356$.widget("ui.droppable", {
2357	version: "1.9.2",
2358	widgetEventPrefix: "drop",
2359	options: {
2360		accept: '*',
2361		activeClass: false,
2362		addClasses: true,
2363		greedy: false,
2364		hoverClass: false,
2365		scope: 'default',
2366		tolerance: 'intersect'
2367	},
2368	_create: function() {
2369
2370		var o = this.options, accept = o.accept;
2371		this.isover = 0; this.isout = 1;
2372
2373		this.accept = $.isFunction(accept) ? accept : function(d) {
2374			return d.is(accept);
2375		};
2376
2377		//Store the droppable's proportions
2378		this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
2379
2380		// Add the reference and positions to the manager
2381		$.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
2382		$.ui.ddmanager.droppables[o.scope].push(this);
2383
2384		(o.addClasses && this.element.addClass("ui-droppable"));
2385
2386	},
2387
2388	_destroy: function() {
2389		var drop = $.ui.ddmanager.droppables[this.options.scope];
2390		for ( var i = 0; i < drop.length; i++ )
2391			if ( drop[i] == this )
2392				drop.splice(i, 1);
2393
2394		this.element.removeClass("ui-droppable ui-droppable-disabled");
2395	},
2396
2397	_setOption: function(key, value) {
2398
2399		if(key == 'accept') {
2400			this.accept = $.isFunction(value) ? value : function(d) {
2401				return d.is(value);
2402			};
2403		}
2404		$.Widget.prototype._setOption.apply(this, arguments);
2405	},
2406
2407	_activate: function(event) {
2408		var draggable = $.ui.ddmanager.current;
2409		if(this.options.activeClass) this.element.addClass(this.options.activeClass);
2410		(draggable && this._trigger('activate', event, this.ui(draggable)));
2411	},
2412
2413	_deactivate: function(event) {
2414		var draggable = $.ui.ddmanager.current;
2415		if(this.options.activeClass) this.element.removeClass(this.options.activeClass);
2416		(draggable && this._trigger('deactivate', event, this.ui(draggable)));
2417	},
2418
2419	_over: function(event) {
2420
2421		var draggable = $.ui.ddmanager.current;
2422		if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
2423
2424		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2425			if(this.options.hoverClass) this.element.addClass(this.options.hoverClass);
2426			this._trigger('over', event, this.ui(draggable));
2427		}
2428
2429	},
2430
2431	_out: function(event) {
2432
2433		var draggable = $.ui.ddmanager.current;
2434		if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
2435
2436		if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2437			if(this.options.hoverClass) this.element.removeClass(this.options.hoverClass);
2438			this._trigger('out', event, this.ui(draggable));
2439		}
2440
2441	},
2442
2443	_drop: function(event,custom) {
2444
2445		var draggable = custom || $.ui.ddmanager.current;
2446		if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return false; // Bail if draggable and droppable are same element
2447
2448		var childrenIntersection = false;

2449		this.element.find(":data(droppable)").not(".ui-draggable-dragging").each(function() {
2450			var inst = $.data(this, 'droppable');
2451			if(
2452				inst.options.greedy
2453				&& !inst.options.disabled
2454				&& inst.options.scope == draggable.options.scope
2455				&& inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element))
2456				&& $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
2457			) { childrenIntersection = true; return false; }
2458		});
2459		if(childrenIntersection) return false;
2460
2461		if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2462			if(this.options.activeClass) this.element.removeClass(this.options.activeClass);
2463			if(this.options.hoverClass) this.element.removeClass(this.options.hoverClass);
2464			this._trigger('drop', event, this.ui(draggable));
2465			return this.element;
2466		}
2467
2468		return false;
2469
2470	},
2471
2472	ui: function(c) {
2473		return {
2474			draggable: (c.currentItem || c.element),
2475			helper: c.helper,
2476			position: c.position,
2477			offset: c.positionAbs
2478		};
2479	}
2480
2481});
2482
2483$.ui.intersect = function(draggable, droppable, toleranceMode) {
2484
2485	if (!droppable.offset) return false;
2486
2487	var x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
2488		y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height;
2489	var l = droppable.offset.left, r = l + droppable.proportions.width,
2490		t = droppable.offset.top, b = t + droppable.proportions.height;
2491
2492	switch (toleranceMode) {
2493		case 'fit':
2494			return (l <= x1 && x2 <= r
2495				&& t <= y1 && y2 <= b);
2496			break;
2497		case 'intersect':
2498			return (l < x1 + (draggable.helperProportions.width / 2) // Right Half
2499				&& x2 - (draggable.helperProportions.width / 2) < r // Left Half
2500				&& t < y1 + (draggable.helperProportions.height / 2) // Bottom Half
2501				&& y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
2502			break;
2503		case 'pointer':
2504			var draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left),
2505				draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top),
2506				isOver = $.ui.isOver(draggableTop, draggableLeft, t, l, droppable.proportions.height, droppable.proportions.width);
2507			return isOver;
2508			break;
2509		case 'touch':
2510			return (
2511					(y1 >= t && y1 <= b) ||	// Top edge touching
2512					(y2 >= t && y2 <= b) ||	// Bottom edge touching
2513					(y1 < t && y2 > b)		// Surrounded vertically
2514				) && (
2515					(x1 >= l && x1 <= r) ||	// Left edge touching
2516					(x2 >= l && x2 <= r) ||	// Right edge touching
2517					(x1 < l && x2 > r)		// Surrounded horizontally
2518				);
2519			break;
2520		default:
2521			return false;
2522			break;
2523		}
2524
2525};
2526
2527/*
2528	This manager tracks offsets of draggables and droppables
2529*/
2530$.ui.ddmanager = {
2531	current: null,
2532	droppables: { 'default': [] },
2533	prepareOffsets: function(t, event) {
2534
2535		var m = $.ui.ddmanager.droppables[t.options.scope] || [];
2536		var type = event ? event.type : null; // workaround for #2317
2537		var list = (t.currentItem || t.element).find(":data(droppable)").andSelf();
2538
2539		droppablesLoop: for (var i = 0; i < m.length; i++) {
2540
2541			if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) continue;	//No disabled and non-accepted
2542			for (var j=0; j < list.length; j++) { if(list[j] == m[i].element[0]) { m[i].proportions.height = 0; continue droppablesLoop; } }; //Filter out elements in the current dragged item
2543			m[i].visible = m[i].element.css("display") != "none"; if(!m[i].visible) continue; 									//If the element is not visible, continue
2544
2545			if(type == "mousedown") m[i]._activate.call(m[i], event); //Activate the droppable if used directly from draggables
2546
2547			m[i].offset = m[i].element.offset();
2548			m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
2549
2550		}
2551
2552	},
2553	drop: function(draggable, event) {
2554
2555		var dropped = false;
2556		$.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
2557
2558			if(!this.options) return;
2559			if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance))
2560				dropped = this._drop.call(this, event) || dropped;
2561
2562			if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
2563				this.isout = 1; this.isover = 0;
2564				this._deactivate.call(this, event);
2565			}
2566
2567		});
2568		return dropped;
2569
2570	},
2571	dragStart: function( draggable, event ) {
2572		//Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
2573		draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {

2574			if( !draggable.options.refreshPositions ) $.ui.ddmanager.prepareOffsets( draggable, event );
2575		});
2576	},
2577	drag: function(draggable, event) {
2578
2579		//If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
2580		if(draggable.options.refreshPositions) $.ui.ddmanager.prepareOffsets(draggable, event);
2581
2582		//Run through all droppables and check their positions based on specific tolerance options
2583		$.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
2584
2585			if(this.options.disabled || this.greedyChild || !this.visible) return;
2586			var intersects = $.ui.intersect(draggable, this, this.options.tolerance);
2587
2588			var c = !intersects && this.isover == 1 ? 'isout' : (intersects && this.isover == 0 ? 'isover' : null);
2589			if(!c) return;
2590
2591			var parentInstance;
2592			if (this.options.greedy) {
2593				// find droppable parents with same scope
2594				var scope = this.options.scope;
2595				var parent = this.element.parents(':data(droppable)').filter(function () {
2596					return $.data(this, 'droppable').options.scope === scope;
2597				});
2598
2599				if (parent.length) {
2600					parentInstance = $.data(parent[0], 'droppable');
2601					parentInstance.greedyChild = (c == 'isover' ? 1 : 0);
2602				}
2603			}
2604
2605			// we just moved into a greedy child
2606			if (parentInstance && c == 'isover') {
2607				parentInstance['isover'] = 0;
2608				parentInstance['isout'] = 1;
2609				parentInstance._out.call(parentInstance, event);
2610			}
2611
2612			this[c] = 1; this[c == 'isout' ? 'isover' : 'isout'] = 0;
2613			this[c == "isover" ? "_over" : "_out"].call(this, event);
2614
2615			// we just moved out of a greedy child
2616			if (parentInstance && c == 'isout') {
2617				parentInstance['isout'] = 0;
2618				parentInstance['isover'] = 1;
2619				parentInstance._over.call(parentInstance, event);
2620			}
2621		});
2622
2623	},
2624	dragStop: function( draggable, event ) {
2625		draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
2626		//Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
2627		if( !draggable.options.refreshPositions ) $.ui.ddmanager.prepareOffsets( draggable, event );
2628	}
2629};
2630
2631})(jQuery);
2632(function( $, undefined ) {
2633
2634$.widget("ui.resizable", $.ui.mouse, {
2635	version: "1.9.2",
2636	widgetEventPrefix: "resize",
2637	options: {
2638		alsoResize: false,
2639		animate: false,
2640		animateDuration: "slow",
2641		animateEasing: "swing",
2642		aspectRatio: false,
2643		autoHide: false,
2644		containment: false,
2645		ghost: false,
2646		grid: false,
2647		handles: "e,s,se",
2648		helper: false,
2649		maxHeight: null,
2650		maxWidth: null,
2651		minHeight: 10,
2652		minWidth: 10,
2653		zIndex: 1000
2654	},
2655	_create: function() {
2656
2657		var that = this, o = this.options;
2658		this.element.addClass("ui-resizable");
2659
2660		$.extend(this, {
2661			_aspectRatio: !!(o.aspectRatio),
2662			aspectRatio: o.aspectRatio,
2663			originalElement: this.element,
2664			_proportionallyResizeElements: [],
2665			_helper: o.helper || o.ghost || o.animate ? o.helper || 'ui-resizable-helper' : null
2666		});
2667
2668		//Wrap the element if it cannot hold child nodes
2669		if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {
2670
2671			//Create a wrapper element and set the wrapper to the new current internal element
2672			this.element.wrap(
2673				$('<div class="ui-wrapper" style="overflow: hidden;"></div>').css({
2674					position: this.element.css('position'),
2675					width: this.element.outerWidth(),
2676					height: this.element.outerHeight(),
2677					top: this.element.css('top'),
2678					left: this.element.css('left')
2679				})
2680			);
2681
2682			//Overwrite the original this.element
2683			this.element = this.element.parent().data(
2684				"resizable", this.element.data('resizable')
2685			);
2686
2687			this.elementIsWrapper = true;
2688
2689			//Move margins to the wrapper
2690			this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
2691			this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
2692
2693			//Prevent Safari textarea resize
2694			this.originalResizeStyle = this.originalElement.css('resize');
2695			this.originalElement.css('resize', 'none');
2696
2697			//Push the actual element to our proportionallyResize internal array
2698			this._proportionallyResizeElements.push(this.originalElement.css({ position: 'static', zoom: 1, display: 'block' }));
2699
2700			// avoid IE jump (hard set the margin)
2701			this.originalElement.css({ margin: this.originalElement.css('margin') });
2702
2703			// fix handlers offset
2704			this._proportionallyResize();
2705
2706		}
2707
2708		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' });
2709		if(this.handles.constructor == String) {
2710
2711			if(this.handles == 'all') this.handles = 'n,e,s,w,se,sw,ne,nw';
2712			var n = this.handles.split(","); this.handles = {};
2713
2714			for(var i = 0; i < n.length; i++) {
2715
2716				var handle = $.trim(n[i]), hname = 'ui-resizable-'+handle;
2717				var axis = $('<div class="ui-resizable-handle ' + hname + '"></div>');
2718
2719				// Apply zIndex to all handles - see #7960
2720				axis.css({ zIndex: o.zIndex });
2721
2722				//TODO : What's going on here?
2723				if ('se' == handle) {
2724					axis.addClass('ui-icon ui-icon-gripsmall-diagonal-se');
2725				};
2726
2727				//Insert into internal handles object and append to element
2728				this.handles[handle] = '.ui-resizable-'+handle;
2729				this.element.append(axis);
2730			}
2731
2732		}
2733
2734		this._renderAxis = function(target) {
2735
2736			target = target || this.element;
2737
2738			for(var i in this.handles) {
2739
2740				if(this.handles[i].constructor == String)
2741					this.handles[i] = $(this.handles[i], this.element).show();
2742
2743				//Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
2744				if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {
2745
2746					var axis = $(this.handles[i], this.element), padWrapper = 0;
2747
2748					//Checking the correct pad and border
2749					padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
2750
2751					//The padding type i have to apply...
2752					var padPos = [ 'padding',