/*!

 *

 * Released under the MIT license.

 */

//>>label: Droppable

//>>group: Interactions

//>>description: Enables drop targets for draggable elements.

( function( factory ) {

	"use strict";

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

		// AMD. Register as an anonymous module.

		define( [

			"jquery",

			"./draggable",

			"./mouse",

		], factory );

	} else {

		// Browser globals

		factory( jQuery );

	}

} )( function( $ ) {

"use strict";

$.widget( "ui.droppable", {

	widgetEventPrefix: "drop",

	options: {

		accept: "*",

		addClasses: true,

		greedy: false,

		scope: "default",

		tolerance: "intersect",

		// Callbacks

		activate: null,

		deactivate: null,

		drop: null,

		out: null,

		over: null

	},

	_create: function() {

		var proportions,

			o = this.options,

			accept = o.accept;

		this.isover = false;

		this.isout = true;

		this.accept = typeof accept === "function" ? accept : function( d ) {

			return d.is( accept );

		};

		this.proportions = function( /* valueToWrite */ ) {

			if ( arguments.length ) {

				// Store the droppable's proportions

				proportions = arguments[ 0 ];

			} else {

				// Retrieve or derive the droppable's proportions

				return proportions ?

					proportions :

					proportions = {

						width: this.element[ 0 ].offsetWidth,

						height: this.element[ 0 ].offsetHeight

					};

			}

		};

		this._addToManager( o.scope );

		if ( o.addClasses ) {

			this._addClass( "ui-droppable" );

		}

	},

	_addToManager: function( scope ) {

		// Add the reference and positions to the manager

		$.ui.ddmanager.droppables[ scope ] = $.ui.ddmanager.droppables[ scope ] || [];

		$.ui.ddmanager.droppables[ scope ].push( this );

	},

	_splice: function( drop ) {

		var i = 0;

		for ( ; i < drop.length; i++ ) {

			if ( drop[ i ] === this ) {

				drop.splice( i, 1 );

			}

		}

	},

	_destroy: function() {

		var drop = $.ui.ddmanager.droppables[ this.options.scope ];

		this._splice( drop );

	},

	_setOption: function( key, value ) {

		if ( key === "accept" ) {

			this.accept = typeof value === "function" ? value : function( d ) {

				return d.is( value );

			};

		} else if ( key === "scope" ) {

			var drop = $.ui.ddmanager.droppables[ this.options.scope ];

			this._splice( drop );

			this._addToManager( value );

		}

		this._super( key, value );

	},

	_activate: function( event ) {

		var draggable = $.ui.ddmanager.current;

		this._addActiveClass();

		if ( draggable ) {

			this._trigger( "activate", event, this.ui( draggable ) );

		}

	},

	_deactivate: function( event ) {

		var draggable = $.ui.ddmanager.current;

		this._removeActiveClass();

		if ( draggable ) {

			this._trigger( "deactivate", event, this.ui( draggable ) );

		}

	},

	_over: function( event ) {

		var draggable = $.ui.ddmanager.current;

		// Bail if draggable and droppable are same element

		if ( !draggable || ( draggable.currentItem ||

			return;

		}

		if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem ||

			this._addHoverClass();

			this._trigger( "over", event, this.ui( draggable ) );

		}

	},

	_out: function( event ) {

		var draggable = $.ui.ddmanager.current;

		// Bail if draggable and droppable are same element

		if ( !draggable || ( draggable.currentItem ||

			return;

		}

		if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem ||

			this._removeHoverClass();

			this._trigger( "out", event, this.ui( draggable ) );

		}

	},

	_drop: function( event, custom ) {

		var draggable = custom || $.ui.ddmanager.current,

			childrenIntersection = false;

		// Bail if draggable and droppable are same element

		if ( !draggable || ( draggable.currentItem ||

			return false;

		}

		this.element

			.find( ":data(ui-droppable)" )

			.not( ".ui-draggable-dragging" )

			.each( function() {

				var inst = $( this ).droppable( "instance" );

				if (

					inst.options.greedy &&

					!inst.options.disabled &&

					inst.options.scope === draggable.options.scope &&

					inst.accept.call(

						inst.element[ 0 ], ( draggable.currentItem || draggable.element )

					) &&

					$.ui.intersect(

						draggable,

						$.extend( inst, { offset: inst.element.offset() } ),

						inst.options.tolerance, event

					)

				) {

					childrenIntersection = true;

					return false;

				}

			} );

		if ( childrenIntersection ) {

			return false;

		}

		if ( this.accept.call( this.element[ 0 ],

			this._removeActiveClass();

			this._removeHoverClass();

			this._trigger( "drop", event, this.ui( draggable ) );

			return this.element;

		}

		return false;

	},

	ui: function( c ) {

		return {

			draggable: ( c.currentItem || c.element ),

			helper: c.helper,

			position: c.position,

			offset: c.positionAbs

		};

	},

	// Extension points just to make backcompat sane and avoid duplicating logic

	// TODO: Remove in 1.14 along with call to it below

	_addHoverClass: function() {

		this._addClass( "ui-droppable-hover" );

	},

	_removeHoverClass: function() {

		this._removeClass( "ui-droppable-hover" );

	},

	_addActiveClass: function() {

		this._addClass( "ui-droppable-active" );

	},

	_removeActiveClass: function() {

		this._removeClass( "ui-droppable-active" );

	}

} );

$.ui.intersect = ( function() {

	function isOverAxis( x, reference, size ) {

		return ( x >= reference ) && ( x < ( reference + size ) );

	}

	return function( draggable, droppable, toleranceMode, event ) {

		if ( !droppable.offset ) {

			return false;

		}

		var x1 = ( draggable.positionAbs ||

				draggable.position.absolute ).left + draggable.margins.left,

			y1 = ( draggable.positionAbs ||

				draggable.position.absolute ).top + draggable.margins.top,

			x2 = x1 + draggable.helperProportions.width,

			y2 = y1 + draggable.helperProportions.height,

			l = droppable.offset.left,

			t = droppable.offset.top,

			r = l + droppable.proportions().width,

			b = t + droppable.proportions().height;

		switch ( toleranceMode ) {

		}

	};

} )();

/*

	This manager tracks offsets of draggables and droppables

*/

$.ui.ddmanager = {

	current: null,

	droppables: { "default": [] },

	prepareOffsets: function( t, event ) {

		var i, j,

			m = $.ui.ddmanager.droppables[ t.options.scope ] || [],

			type = event ? event.type : null, // workaround for #2317

			list = ( t.currentItem || t.element ).find( ":data(ui-droppable)" ).addBack();

		droppablesLoop: for ( i = 0; i < m.length; i++ ) {

			// No disabled and non-accepted

			if ( m[ i ].options.disabled || ( t && !m[ i ].accept.call( m[ i ].element[ 0 ],

				continue;

			}

			// Filter out elements in the current dragged item

			for ( j = 0; j < list.length; j++ ) {

				if ( list[ j ] === m[ i ].element[ 0 ] ) {

					m[ i ].proportions().height = 0;

					continue droppablesLoop;

				}

			}

			m[ i ].visible = m[ i ].element.css( "display" ) !== "none";

			if ( !m[ i ].visible ) {

				continue;

			}