/*

 * jQuery UI Sortable 1.8.1

 *

 * Copyright (c) 2010 AUTHORS.txt (http://jqueryui.com/about)

 * Dual licensed under the MIT (MIT-LICENSE.txt)

 * and GPL (GPL-LICENSE.txt) licenses.

 *

 * http://docs.jquery.com/UI/Sortables

 *

 * Depends:

 *	jquery.ui.core.js

 *	jquery.ui.mouse.js

 *	jquery.ui.widget.js

 */

(function($) {

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

	widgetEventPrefix: "sort",

	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

	},

	_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 floating

		this.floating = this.items.length ? (/left|right/).test(this.items[0].item.css('float')) : false;

		//Let's determine the parent's offset

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

		//Initialize mouse events for interaction

		this._mouseInit();

	},

	destroy: function() {

		this.element

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

			.removeData("sortable")

			.unbind(".sortable");

		this._mouseDestroy();

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

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

		return this;

	},

	_setOption: function(key, value){

		if ( key === "disabled" ) {

			this.options[ key ] = value;

			this.widget()

				[ value ? "addClass" : "removeClass"]( "ui-sortable-disabled" );

		} else {

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

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

		}

	},

	_mouseCapture: function(event, overrideHandle) {

		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

		var currentItem = null, self = this, nodes = $(event.target).parents().each(function() {

			if($.data(this, 'sortable-item') == self) {

				currentItem = $(this);

				return false;

			}

		});

		if($.data(event.target, 'sortable-item') == self) currentItem = $(event.target);

		if(!currentItem) return false;

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

			var validHandle = false;

			$(this.options.handle, currentItem).find("*").andSelf().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 o = this.options, self = this;

		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

		};

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

		$.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

		});

		//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) { // cursor option

			if ($('body').css("cursor")) this._storedCursor = $('body').css("cursor");

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

		}

		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 (var i = this.containers.length - 1; i >= 0; i--) { this.containers[i]._trigger("activate", event, self._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) {

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

			var o = this.options, scrolled = false;

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

		//Rearrange

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

			//Cache variables and intersection, continue if no intersection

			var item = this.items[i], itemElement = item.item[0], intersection = this._intersectsWithPointer(item);

			if (!intersection) continue;

			if(itemElement != this.currentItem[0] //cannot intersect with itself

				&&	this.placeholder[intersection == 1 ? "next" : "prev"]()[0] != itemElement //no useless actions that have been done before

				&&	!$.ui.contains(this.placeholder[0], itemElement) //no action if the item moved is the parent of the item checked

				&& (this.options.type == 'semi-dynamic' ? !$.ui.contains(this.element[0], itemElement) : true)

				//&& itemElement.parentNode == this.placeholder[0].parentNode // only rearrange items within the same container

			) {

				this.direction = intersection == 1 ? "down" : "up";

				if (this.options.tolerance == "pointer" || this._intersectsWithSides(item)) {

					this._rearrange(event, item);

				} else {

					break;

				}

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

				break;

			}

		}

		//Post events to containers

		this._contactContainers(event);

		//Interconnect with droppables

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

		//Call callbacks

		this._trigger('sort', event, this._uiHash());

		this.lastPositionAbs = this.positionAbs;

		return false;

	},

	_mouseStop: function(event, noPropagation) {

		if(!event) return;

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

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

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

		if(this.options.revert) {

			var self = this;

			var cur = self.placeholder.offset();

			self.reverting = true;

			$(this.helper).animate({

				left: cur.left - this.offset.parent.left - self.margins.left + (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft),