/*

 * jQuery UI Sortable 1.6

 *

 * Copyright (c) 2008 AUTHORS.txt (http://ui.jquery.com/about)

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

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

 *

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

 *

 * Depends:

 *	ui.core.js

 */

(function($) {

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

	_init: 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");

	},

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

		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

		});

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

		if(o.cursorAt)

			this._adjustOffsetFromHelper(o.cursorAt);

		//Generate the original position

		this.originalPosition = this._generatePosition(event);

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

		//Call plugins and callbacks

		this._propagate("start", event);

		//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]._propagate("activate", event, 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;

		}

		//Call the internal plugins

		$.ui.plugin.call(this, "sort", [event, this._ui()]);

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

			) {

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

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

					this.options.sortIndicator.call(this, event, item);

				} else {

					break;

				}

				this._propagate("change", event); //Call plugins and callbacks

				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._ui());

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

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

			}, parseInt(this.options.revert, 10) || 500, function() {

				self._clear(event);

			});

		} else {

			this._clear(event, noPropagation);

		}

		return false;

	},

	cancel: function() {

		if(this.dragging) {

			this._mouseUp();

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

				this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");

			else

				this.currentItem.show();

			//Post deactivating events to containers

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

				this.containers[i]._propagate("deactivate", null, this);

				if(this.containers[i].containerCache.over) {

					this.containers[i]._propagate("out", null, this);

					this.containers[i].containerCache.over = 0;

				}

			}

		}

		//$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!

		if(this.placeholder[0].parentNode) this.placeholder[0].parentNode.removeChild(this.placeholder[0]);

		if(this.options.helper != "original" && this.helper && this.helper[0].parentNode) this.helper.remove();

		$.extend(this, {

			helper: null,

			dragging: false,

			reverting: false,

			_noFinalSort: null

		});

		if(this.domPosition.prev) {

			$(this.domPosition.prev).after(this.currentItem);

		} else {

			$(this.domPosition.parent).prepend(this.currentItem);

		}

		return true;

	},

	serialize: function(o) {

		var items = this._getItemsAsjQuery(o && o.connected);

		var str = []; o = o || {};

		$(items).each(function() {

			var res = ($(o.item || this).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));

			if(res) str.push((o.key || res[1]+'[]')+'='+(o.key && o.expression ? res[1] : res[2]));

		});

		return str.join('&');

	},

	toArray: function(o) {

		var items = this._getItemsAsjQuery(o && o.connected);

		var ret = []; o = o || {};

		items.each(function() { ret.push($(o.item || this).attr(o.attribute || 'id') || ''); });

		return ret;

	},

	/* Be careful with the following core functions */

	_intersectsWith: function(item) {

		var x1 = this.positionAbs.left,

			x2 = x1 + this.helperProportions.width,

			y1 = this.positionAbs.top,

			y2 = y1 + this.helperProportions.height;

		var l = item.left,

			r = l + item.width,

			t = item.top,

			b = t + item.height;

		var dyClick = this.offset.click.top,

			dxClick = this.offset.click.left;

		var isOverElement = (y1 + dyClick) > t && (y1 + dyClick) < b && (x1 + dxClick) > l && (x1 + dxClick) < r;

		if(	   this.options.tolerance == "pointer"

			|| this.options.forcePointerForContainers

			|| (this.options.tolerance != "pointer" && this.helperProportions[this.floating ? 'width' : 'height'] > item[this.floating ? 'width' : 'height'])

		) {

			return isOverElement;

		} else {

			return (l < x1 + (this.helperProportions.width / 2) // Right Half

				&& x2 - (this.helperProportions.width / 2) < r // Left Half

				&& t < y1 + (this.helperProportions.height / 2) // Bottom Half

				&& y2 - (this.helperProportions.height / 2) < b ); // Top Half

		}

	},

	_intersectsWithPointer: function(item) {

		var isOverElementHeight = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),

			isOverElementWidth = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),

			isOverElement = isOverElementHeight && isOverElementWidth,

			verticalDirection = this._getDragVerticalDirection(),

			horizontalDirection = this._getDragHorizontalDirection();

		if (!isOverElement)

			return false;

		return this.floating ?

			( ((horizontalDirection && horizontalDirection == "right") || verticalDirection == "down") ? 2 : 1 )

			: ( verticalDirection && (verticalDirection == "down" ? 2 : 1) );

	},

	_intersectsWithSides: function(item) {

		var isOverBottomHalf = $.ui.isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),

			isOverRightHalf = $.ui.isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),

			verticalDirection = this._getDragVerticalDirection(),

			horizontalDirection = this._getDragHorizontalDirection();

		if (this.floating && horizontalDirection) {

			return ((horizontalDirection == "right" && isOverRightHalf) || (horizontalDirection == "left" && !isOverRightHalf));

		} else {

			return verticalDirection && ((verticalDirection == "down" && isOverBottomHalf) || (verticalDirection == "up" && !isOverBottomHalf));

		}

	},

	_getDragVerticalDirection: function() {

		var delta = this.positionAbs.top - this.lastPositionAbs.top;

		return delta != 0 && (delta > 0 ? "down" : "up");

	},

	_getDragHorizontalDirection: function() {

		var delta = this.positionAbs.left - this.lastPositionAbs.left;

		return delta != 0 && (delta > 0 ? "right" : "left");

	},

	refresh: function(event) {

		this._refreshItems(event);

		this.refreshPositions();

	},

	_getItemsAsjQuery: function(connected) {

		var self = this;

		var items = [];

		var queries = [];

		if(this.options.connectWith && connected) {

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

				var cur = $(this.options.connectWith[i]);

				for (var j = cur.length - 1; j >= 0; j--){

					var inst = $.data(cur[j], 'sortable');

					if(inst && inst != this && !inst.options.disabled) {

						queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper"), inst]);

					}

				};

			};

		}

		queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper"), this]);

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

			queries[i][0].each(function() {

				items.push(this);

			});

		};

		return $(items);

	},

	_removeCurrentsFromItems: function() {

		var list = this.currentItem.find(":data(sortable-item)");

		for (var i=0; i < this.items.length; i++) {

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

				if(list[j] == this.items[i].item[0])

					this.items.splice(i,1);

			};

		};

	},

	_refreshItems: function(event) {

		this.items = [];

		this.containers = [this];

		var items = this.items;

		var self = this;

		var queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]];

		if(this.options.connectWith) {

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

				var cur = $(this.options.connectWith[i]);

				for (var j = cur.length - 1; j >= 0; j--){

					var inst = $.data(cur[j], 'sortable');

					if(inst && inst != this && !inst.options.disabled) {

						queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);

						this.containers.push(inst);

					}

				};

			};

		}

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

			var targetData = queries[i][1];

			var _queries = queries[i][0];

			for (var j=0, queriesLength = _queries.length; j < queriesLength; j++) {

				var item = $(_queries[j]);

				item.data('sortable-item', targetData); // Data for target checking (mouse manager)

				items.push({

					item: item,

					instance: targetData,

					width: 0, height: 0,

					left: 0, top: 0

				});

			};

		};

	},

	refreshPositions: function(fast) {

		//This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change

		if(this.offsetParent && this.helper) {

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

		}

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

			var item = this.items[i];

			//We ignore calculating positions of all connected containers when we're not over them

			if(item.instance != this.currentContainer && this.currentContainer && item.item[0] != this.currentItem[0])

				continue;

			var t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;

			if (!fast) {

				if (this.options.accurateIntersection) {

					item.width = t.outerWidth();

					item.height = t.outerHeight();

				}

				else {

					item.width = t[0].offsetWidth;

					item.height = t[0].offsetHeight;

				}

			}

			var p = t.offset();

			item.left = p.left;

			item.top = p.top;

		};