/*!

 * jQuery UI Sortable 1.10.3

 * http://jqueryui.com

 *

 * Copyright 2013 jQuery Foundation and other contributors

 * Released under the MIT license.

 * http://jquery.org/license

 *

 * http://api.jqueryui.com/sortable/

 *

 * Depends:

 *	jquery.ui.core.js

 *	jquery.ui.mouse.js

 *	jquery.ui.widget.js

 */

(function( $, undefined ) {

/*jshint loopfunc: true */

function isOverAxis( x, reference, size ) {

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

}

function isFloating(item) {

	return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));

}

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

	version: "1.10.3",

	widgetEventPrefix: "sort",

	ready: false,

	options: {

		appendTo: "parent",

		axis: false,

		connectWith: false,

		containment: false,

		cursor: "auto",

		cursorAt: false,

		dropOnEmpty: true,

		forcePlaceholderSize: false,

		forceHelperSize: false,

		grid: false,

		handle: false,

		helper: "original",

		items: "> *",

		opacity: false,

		placeholder: false,

		revert: false,

		scroll: true,

		scrollSensitivity: 20,

		scrollSpeed: 20,

		scope: "default",

		tolerance: "intersect",

		zIndex: 1000,

		// callbacks

		activate: null,

		beforeStop: null,

		change: null,

		deactivate: null,

		out: null,

		over: null,

		receive: null,

		remove: null,

		sort: null,

		start: null,

		stop: null,

		update: null

	},

	_create: function() {

		var o = this.options;

		this.containerCache = {};

		this.element.addClass("ui-sortable");

		//Get the items

		this.refresh();

		//Let's determine if the items are being displayed horizontally

		this.floating = this.items.length ? o.axis === "x" || isFloating(this.items[0].item) : false;

		//Let's determine the parent's offset

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

		//Initialize mouse events for interaction

		this._mouseInit();

		//We're ready to go

		this.ready = true;

	},

	_destroy: function() {

		this.element

			.removeClass("ui-sortable ui-sortable-disabled");

		this._mouseDestroy();

		for ( var i = this.items.length - 1; i >= 0; i-- ) {

			this.items[i].item.removeData(this.widgetName + "-item");

		}

		return this;

	},

	_setOption: function(key, value){

		if ( key === "disabled" ) {

			this.options[ key ] = value;

			this.widget().toggleClass( "ui-sortable-disabled", !!value );

		} else {

			// Don't call widget base _setOption for disable as it adds ui-state-disabled class

			$.Widget.prototype._setOption.apply(this, arguments);

		}

	},

	_mouseCapture: function(event, overrideHandle) {

		var currentItem = null,

			validHandle = false,

			that = this;

		if (this.reverting) {

			return false;

		}

		if(this.options.disabled || this.options.type === "static") {

			return false;

		}

		//We have to refresh the items data once first

		this._refreshItems(event);

		//Find out if the clicked node (or one of its parents) is a actual item in this.items

		$(event.target).parents().each(function() {

			if($.data(this, that.widgetName + "-item") === that) {

				currentItem = $(this);

				return false;

			}

		});

		if($.data(event.target, that.widgetName + "-item") === that) {

			currentItem = $(event.target);

		}

		if(!currentItem) {

			return false;

		}

		if(this.options.handle && !overrideHandle) {

			$(this.options.handle, currentItem).find("*").addBack().each(function() {

				if(this === event.target) {

					validHandle = true;

				}

			});

			if(!validHandle) {

				return false;

			}

		}

		this.currentItem = currentItem;

		this._removeCurrentsFromItems();

		return true;

	},

	_mouseStart: function(event, overrideHandle, noActivation) {

		var i, body,

			o = this.options;

		this.currentContainer = this;

		//We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture

		this.refreshPositions();

		//Create and append the visible helper

		this.helper = this._createHelper(event);

		//Cache the helper size

		this._cacheHelperProportions();

		/*

		 * - Position generation -

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

		 */

		//Cache the margins of the original element

		this._cacheMargins();

		//Get the next scrolling parent

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

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

		this.offset = this.currentItem.offset();

		this.offset = {

			top: this.offset.top - this.margins.top,

			left: this.offset.left - this.margins.left

		};

		$.extend(this.offset, {

			click: { //Where the click happened, relative to the element

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

				top: event.pageY - this.offset.top

			},

			parent: this._getParentOffset(),

			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper

		});

		// Only after we got the offset, we can change the helper's position to absolute

		// TODO: Still need to figure out a way to make relative sorting possible

		this.helper.css("position", "absolute");

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

		//Generate the original position

		this.originalPosition = this._generatePosition(event);

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

		//Cache the former DOM position

		this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };

		//If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way

		if(this.helper[0] !== this.currentItem[0]) {

			this.currentItem.hide();

		}

		//Create the placeholder

		this._createPlaceholder();

		//Set a containment if given in the options

		if(o.containment) {

			this._setContainment();

		}

		if( o.cursor && o.cursor !== "auto" ) { // cursor option

			body = this.document.find( "body" );

			// support: IE

			this.storedCursor = body.css( "cursor" );

			body.css( "cursor", o.cursor );

			this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );

		}

		if(o.opacity) { // opacity option

			if (this.helper.css("opacity")) {

				this._storedOpacity = this.helper.css("opacity");

			}

			this.helper.css("opacity", o.opacity);

		}

		if(o.zIndex) { // zIndex option

			if (this.helper.css("zIndex")) {

				this._storedZIndex = this.helper.css("zIndex");

			}

			this.helper.css("zIndex", o.zIndex);

		}

		//Prepare scrolling

		if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {

			this.overflowOffset = this.scrollParent.offset();

		}

		//Call callbacks

		this._trigger("start", event, this._uiHash());

		//Recache the helper size

		if(!this._preserveHelperProportions) {

			this._cacheHelperProportions();

		}

		//Post "activate" events to possible containers

		if( !noActivation ) {

			for ( i = this.containers.length - 1; i >= 0; i-- ) {

				this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );

			}

		}

		//Prepare possible droppables

		if($.ui.ddmanager) {

			$.ui.ddmanager.current = this;

		}

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

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

		}

		this.dragging = true;

		this.helper.addClass("ui-sortable-helper");

		this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position

		return true;

	},

	_mouseDrag: function(event) {

		var i, item, itemElement, intersection,

			o = this.options,

			scrolled = false;

		//Compute the helpers position

		this.position = this._generatePosition(event);

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

		if (!this.lastPositionAbs) {

			this.lastPositionAbs = this.positionAbs;

		}

		//Do scrolling

		if(this.options.scroll) {

			if(this.scrollParent[0] !== document && this.scrollParent[0].tagName !== "HTML") {

				if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {

					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;

				} else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {

					this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;

				}

				if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {

					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;

				} else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {

					this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;

				}

			} else {

				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity) {

					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);

				} else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {

					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);

				}

				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {

					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);

				} else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {

					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);

				}

			}

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

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

			}

		}

		//Regenerate the absolute position used for position checks

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

		//Set the helper position

		if(!this.options.axis || this.options.axis !== "y") {

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

		}

		if(!this.options.axis || this.options.axis !== "x") {

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

		}