/*!

 * jQuery UI Draggable 1.12.1

 * http://jqueryui.com

 *

 * Copyright jQuery Foundation and other contributors

 * Released under the MIT license.

 * http://jquery.org/license

 */

//>>label: Draggable

//>>group: Interactions

//>>description: Enables dragging functionality for any element.

//>>docs: http://api.jqueryui.com/draggable/

//>>demos: http://jqueryui.com/draggable/

//>>css.structure: ../../themes/base/draggable.css

( function( factory ) {

	if ( typeof define === "function" && define.amd ) {

		// AMD. Register as an anonymous module.

		define( [

			"jquery",

			"./mouse",

			"./core"

		], factory );

	} else {

		// Browser globals

		factory( jQuery );

	}

}( function( $ ) {

$.widget( "ui.draggable", $.ui.mouse, {

	version: "1.12.1",

	widgetEventPrefix: "drag",

	options: {

		addClasses: true,

		appendTo: "parent",

		axis: false,

		connectToSortable: false,

		containment: false,

		cursor: "auto",

		cursorAt: false,

		grid: false,

		handle: false,

		helper: "original",

		iframeFix: false,

		opacity: false,

		refreshPositions: false,

		revert: false,

		revertDuration: 500,

		scope: "default",

		scroll: true,

		scrollSensitivity: 20,

		scrollSpeed: 20,

		snap: false,

		snapMode: "both",

		snapTolerance: 20,

		stack: false,

		zIndex: false,

		// Callbacks

		drag: null,

		start: null,

		stop: null

	},

	_create: function() {

		if ( this.options.helper === "original" ) {

			this._setPositionRelative();

		}

		if ( this.options.addClasses ) {

			this._addClass( "ui-draggable" );

		}

		this._setHandleClassName();

		this._mouseInit();

	},

	_setOption: function( key, value ) {

		this._super( key, value );

		if ( key === "handle" ) {

			this._removeHandleClassName();

			this._setHandleClassName();

		}

	},

	_destroy: function() {

		if ( ( this.helper || this.element ).is( ".ui-draggable-dragging" ) ) {

			this.destroyOnClear = true;

			return;

		}

		this._removeHandleClassName();

		this._mouseDestroy();

	},

	_mouseCapture: function( event ) {

		var o = this.options;

		// Among others, prevent a drag on a resizable-handle

		if ( this.helper || o.disabled ||

				$( event.target ).closest( ".ui-resizable-handle" ).length > 0 ) {

			return false;

		}

		//Quit if we're not on a valid handle

		this.handle = this._getHandle( event );

		if ( !this.handle ) {

			return false;

		}

		this._blurActiveElement( event );

		this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix );

		return true;

	},

	_blockFrames: function( selector ) {

		this.iframeBlocks = this.document.find( selector ).map( function() {

			var iframe = $( this );

			return $( "<div>" )

				.css( "position", "absolute" )

				.appendTo( iframe.parent() )

				.outerWidth( iframe.outerWidth() )

				.outerHeight( iframe.outerHeight() )

				.offset( iframe.offset() )[ 0 ];

		} );

	},

	_unblockFrames: function() {

		if ( this.iframeBlocks ) {

			this.iframeBlocks.remove();

			delete this.iframeBlocks;

		}

	},

	_blurActiveElement: function( event ) {

		var activeElement = $.ui.safeActiveElement( this.document[ 0 ] ),

			target = $( event.target );

		// Don't blur if the event occurred on an element that is within

		// the currently focused element

		// See #10527, #12472

		if ( target.closest( activeElement ).length ) {

			return;

		}

		// Blur any element that currently has focus, see #4261

		$.ui.safeBlur( activeElement );

	},

	_mouseStart: function( event ) {

		var o = this.options;

		//Create and append the visible helper

		this.helper = this._createHelper( event );

		this._addClass( this.helper, "ui-draggable-dragging" );

		//Cache the helper size

		this._cacheHelperProportions();

		//If ddmanager is used for droppables, set the global draggable

		if ( $.ui.ddmanager ) {

			$.ui.ddmanager.current = this;

		}

		/*

		 * - Position generation -

		 * This block generates everything position related - it's the core of draggables.

		 */

		//Cache the margins of the original element

		this._cacheMargins();

		//Store the helper's css position

		this.cssPosition = this.helper.css( "position" );

		this.scrollParent = this.helper.scrollParent( true );

		this.offsetParent = this.helper.offsetParent();

		this.hasFixedAncestor = this.helper.parents().filter( function() {

				return $( this ).css( "position" ) === "fixed";

			} ).length > 0;

		//The element's absolute position on the page minus margins

		this.positionAbs = this.element.offset();

		this._refreshOffsets( event );

		//Generate the original position

		this.originalPosition = this.position = this._generatePosition( event, false );

		this.originalPageX = event.pageX;

		this.originalPageY = event.pageY;

		//Adjust the mouse offset relative to the helper if "cursorAt" is supplied

		( o.cursorAt && this._adjustOffsetFromHelper( o.cursorAt ) );

		//Set a containment if given in the options

		this._setContainment();

		//Trigger event + callbacks

		if ( this._trigger( "start", event ) === false ) {

			this._clear();

			return false;

		}

		//Recache the helper size

		this._cacheHelperProportions();

		//Prepare the droppable offsets

		if ( $.ui.ddmanager && !o.dropBehaviour ) {

			$.ui.ddmanager.prepareOffsets( this, event );

		}

		// Execute the drag once - this causes the helper not to be visible before getting its

		// correct position

		this._mouseDrag( event, true );

		// If the ddmanager is used for droppables, inform the manager that dragging has started

		// (see #5003)

		if ( $.ui.ddmanager ) {

			$.ui.ddmanager.dragStart( this, event );

		}

		return true;

	},

	_refreshOffsets: function( event ) {

		this.offset = {

			top: this.positionAbs.top - this.margins.top,

			left: this.positionAbs.left - this.margins.left,

			scroll: false,

			parent: this._getParentOffset(),

			relative: this._getRelativeOffset()

		};

		this.offset.click = {

			left: event.pageX - this.offset.left,

			top: event.pageY - this.offset.top

		};

	},

	_mouseDrag: function( event, noPropagation ) {

		// reset any necessary cached properties (see #5009)

		if ( this.hasFixedAncestor ) {

			this.offset.parent = this._getParentOffset();

		}

		//Compute the helpers position

		this.position = this._generatePosition( event, true );

		this.positionAbs = this._convertPositionTo( "absolute" );

		//Call plugins and callbacks and use the resulting position if something is returned

		if ( !noPropagation ) {

			var ui = this._uiHash();

			if ( this._trigger( "drag", event, ui ) === false ) {

				this._mouseUp( new $.Event( "mouseup", event ) );

				return false;

			}

			this.position = ui.position;

		}

		this.helper[ 0 ].style.left = this.position.left + "px";

		this.helper[ 0 ].style.top = this.position.top + "px";

		if ( $.ui.ddmanager ) {

			$.ui.ddmanager.drag( this, event );

		}

		return false;

	},

	_mouseStop: function( event ) {

		//If we are using droppables, inform the manager about the drop

		var that = this,

			dropped = false;

		if ( $.ui.ddmanager && !this.options.dropBehaviour ) {

			dropped = $.ui.ddmanager.drop( this, event );

		}

		//if a drop comes from outside (a sortable)

		if ( this.dropped ) {

			dropped = this.dropped;

			this.dropped = false;

		}

		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 ) )

		) {

			$( this.helper ).animate(

				this.originalPosition,

				parseInt( this.options.revertDuration, 10 ),

				function() {

					if ( that._trigger( "stop", event ) !== false ) {

						that._clear();

					}

				}

			);

		} else {

			if ( this._trigger( "stop", event ) !== false ) {

				this._clear();

			}

		}

		return false;

	},

	_mouseUp: function( event ) {

		this._unblockFrames();

		// If the ddmanager is used for droppables, inform the manager that dragging has stopped

		// (see #5003)

		if ( $.ui.ddmanager ) {

			$.ui.ddmanager.dragStop( this, event );

		}

		// Only need to focus if the event occurred on the draggable itself, see #10527

		if ( this.handleElement.is( event.target ) ) {

			// The interaction is over; whether or not the click resulted in a drag,

			// focus the element

			this.element.trigger( "focus" );

		}

		return $.ui.mouse.prototype._mouseUp.call( this, event );

	},

	cancel: function() {

		if ( this.helper.is( ".ui-draggable-dragging" ) ) {

			this._mouseUp( new $.Event( "mouseup", { target: this.element[ 0 ] } ) );

		} else {

			this._clear();

		}

		return this;

	},

	_getHandle: function( event ) {

		return this.options.handle ?

			!!$( event.target ).closest( this.element.find( this.options.handle ) ).length :

			true;

	},

	_setHandleClassName: function() {

		this.handleElement = this.options.handle ?

			this.element.find( this.options.handle ) : this.element;

		this._addClass( this.handleElement, "ui-draggable-handle" );

	},

	_removeHandleClassName: function() {

		this._removeClass( this.handleElement, "ui-draggable-handle" );

	},

	_createHelper: function( event ) {

		var o = this.options,

			helperIsFunction = $.isFunction( o.helper ),

			helper = helperIsFunction ?

				$( o.helper.apply( this.element[ 0 ], [ event ] ) ) :