From 13685f50ee91d2086fae21a8192f8a7f298e9138 Mon Sep 17 00:00:00 2001
From: =?utf8?q?Scott=20Gonz=C3=A1lez?= <scott.gonzalez@gmail.com>
Date: Sun, 1 Jun 2008 23:36:34 +0000
Subject: [PATCH] unindentation

---
 ui/source/ui.accordion.js  |  509 +++++++-------
 ui/source/ui.core.js       |  477 +++++++-------
 ui/source/ui.datepicker.js |    2 +-
 ui/source/ui.dialog.js     |  798 +++++++++++-----------
 ui/source/ui.draggable.js  | 1015 ++++++++++++++--------------
 ui/source/ui.droppable.js  |  505 +++++++-------
 ui/source/ui.resizable.js  | 1284 ++++++++++++++++++------------------
 ui/source/ui.selectable.js |  470 ++++++-------
 ui/source/ui.slider.js     |  744 ++++++++++-----------
 ui/source/ui.sortable.js   | 1030 +++++++++++++++--------------
 ui/source/ui.tabs.js       | 1040 ++++++++++++++---------------
 11 files changed, 3935 insertions(+), 3939 deletions(-)

diff --git a/ui/source/ui.accordion.js b/ui/source/ui.accordion.js
index a4bd59327..bf46714f6 100644
--- a/ui/source/ui.accordion.js
+++ b/ui/source/ui.accordion.js
@@ -12,292 +12,291 @@
  *
  * Revision: $Id: ui.accordion.js 5656 2008-05-21 19:35:33Z braeker $
  */
-
 ;(function($) {
 
-	$.widget("ui.accordion", {
-		init: function() {
-			var options = this.options;
-			
-			if ( options.navigation ) {
-				var current = this.element.find("a").filter(options.navigationFilter);
-				if ( current.length ) {
-					if ( current.filter(options.header).length ) {
-						options.active = current;
-					} else {
-						options.active = current.parent().parent().prev();
-						current.addClass("current");
-					}
-				}
-			}
-			
-			// calculate active if not specified, using the first header
-			options.headers = this.element.find(options.header);
-			options.active = findActive(options.headers, options.active);
-			
-			// IE7-/Win - Extra vertical space in Lists fixed
-			if ($.browser.msie) {
-				this.element.find('a').css('zoom', '1');
-			}
-			
-			if (!this.element.hasClass("ui-accordion")) {
-				this.element.addClass("ui-accordion");
-				$("<span class='ui-accordion-left'/>").insertBefore(options.headers);
-				$("<span class='ui-accordion-right'/>").appendTo(options.headers);
-				options.headers.addClass("ui-accordion-header").attr("tabindex", "0");
-			}
-			
-			var maxHeight;
-			if ( options.fillSpace ) {
-				maxHeight = this.element.parent().height();
-				options.headers.each(function() {
-					maxHeight -= $(this).outerHeight();
-				});
-				var maxPadding = 0;
-				options.headers.next().each(function() {
-					maxPadding = Math.max(maxPadding, $(this).innerHeight() - $(this).height());
-				}).height(maxHeight - maxPadding);
-			} else if ( options.autoHeight ) {
-				maxHeight = 0;
-				options.headers.next().each(function() {
-					maxHeight = Math.max(maxHeight, $(this).outerHeight());
-				}).height(maxHeight);
-			}
+$.widget("ui.accordion", {
+	init: function() {
+		var options = this.options;
 		
-			options.headers
-				.not(options.active || "")
-				.next()
-				.hide();
-			options.active.parent().andSelf().addClass(options.selectedClass);
-			
-			if (options.event) {
-				this.element.bind((options.event) + ".accordion", clickHandler);
-			}
-		},
-		activate: function(index) {
-			// call clickHandler with custom event
-			clickHandler.call(this.element[0], {
-				target: findActive( this.options.headers, index )[0]
-			});
-		},
-		destroy: function() {
-			this.options.headers.next().css("display", "");
-			if ( this.options.fillSpace || this.options.autoHeight ) {
-				this.options.headers.next().css("height", "");
+		if ( options.navigation ) {
+			var current = this.element.find("a").filter(options.navigationFilter);
+			if ( current.length ) {
+				if ( current.filter(options.header).length ) {
+					options.active = current;
+				} else {
+					options.active = current.parent().parent().prev();
+					current.addClass("current");
+				}
 			}
-			$.removeData(this.element[0], "accordion");
-			this.element.removeClass("ui-accordion").unbind(".accordion");
 		}
-	});
-	
-	function scopeCallback(callback, scope) {
-		return function() {
-			return callback.apply(scope, arguments);
-		};
-	};
-	
-	function completed(cancel) {
-		// if removed while animated data can be empty
-		if (!$.data(this, "accordion")) {
-			return;
+		
+		// calculate active if not specified, using the first header
+		options.headers = this.element.find(options.header);
+		options.active = findActive(options.headers, options.active);
+		
+		// IE7-/Win - Extra vertical space in Lists fixed
+		if ($.browser.msie) {
+			this.element.find('a').css('zoom', '1');
 		}
 		
-		var instance = $.data(this, "accordion");
-		var options = instance.options;
-		options.running = cancel ? 0 : --options.running;
-		if ( options.running ) {
-			return;
+		if (!this.element.hasClass("ui-accordion")) {
+			this.element.addClass("ui-accordion");
+			$("<span class='ui-accordion-left'/>").insertBefore(options.headers);
+			$("<span class='ui-accordion-right'/>").appendTo(options.headers);
+			options.headers.addClass("ui-accordion-header").attr("tabindex", "0");
 		}
-		if ( options.clearStyle ) {
-			options.toShow.add(options.toHide).css({
-				height: "",
-				overflow: ""
+		
+		var maxHeight;
+		if ( options.fillSpace ) {
+			maxHeight = this.element.parent().height();
+			options.headers.each(function() {
+				maxHeight -= $(this).outerHeight();
 			});
+			var maxPadding = 0;
+			options.headers.next().each(function() {
+				maxPadding = Math.max(maxPadding, $(this).innerHeight() - $(this).height());
+			}).height(maxHeight - maxPadding);
+		} else if ( options.autoHeight ) {
+			maxHeight = 0;
+			options.headers.next().each(function() {
+				maxHeight = Math.max(maxHeight, $(this).outerHeight());
+			}).height(maxHeight);
 		}
-		$(this).triggerHandler("accordionchange", [options.data], options.change);
-	}
 	
-	function toggle(toShow, toHide, data, clickedActive, down) {
-		var options = $.data(this, "accordion").options;
-		options.toShow = toShow;
-		options.toHide = toHide;
-		options.data = data;
-		var complete = scopeCallback(completed, this);
-		
-		// count elements to animate
-		options.running = toHide.size() === 0 ? toShow.size() : toHide.size();
+		options.headers
+			.not(options.active || "")
+			.next()
+			.hide();
+		options.active.parent().andSelf().addClass(options.selectedClass);
 		
-		if ( options.animated ) {
-			if ( !options.alwaysOpen && clickedActive ) {
-				$.ui.accordion.animations[options.animated]({
-					toShow: jQuery([]),
-					toHide: toHide,
-					complete: complete,
-					down: down,
-					autoHeight: options.autoHeight
-				});
-			} else {
-				$.ui.accordion.animations[options.animated]({
-					toShow: toShow,
-					toHide: toHide,
-					complete: complete,
-					down: down,
-					autoHeight: options.autoHeight
-				});
-			}
-		} else {
-			if ( !options.alwaysOpen && clickedActive ) {
-				toShow.toggle();
-			} else {
-				toHide.hide();
-				toShow.show();
-			}
-			complete(true);
+		if (options.event) {
+			this.element.bind((options.event) + ".accordion", clickHandler);
+		}
+	},
+	activate: function(index) {
+		// call clickHandler with custom event
+		clickHandler.call(this.element[0], {
+			target: findActive( this.options.headers, index )[0]
+		});
+	},
+	destroy: function() {
+		this.options.headers.next().css("display", "");
+		if ( this.options.fillSpace || this.options.autoHeight ) {
+			this.options.headers.next().css("height", "");
 		}
+		$.removeData(this.element[0], "accordion");
+		this.element.removeClass("ui-accordion").unbind(".accordion");
+	}
+});
+
+function scopeCallback(callback, scope) {
+	return function() {
+		return callback.apply(scope, arguments);
+	};
+};
+
+function completed(cancel) {
+	// if removed while animated data can be empty
+	if (!$.data(this, "accordion")) {
+		return;
 	}
 	
-	function clickHandler(event) {
-		var options = $.data(this, "accordion").options;
-		if (options.disabled) {
-			return false;
-		}
-		
-		// called only when using activate(false) to close all parts programmatically
-		if ( !event.target && !options.alwaysOpen ) {
-			options.active.parent().andSelf().toggleClass(options.selectedClass);
-			var toHide = options.active.next(),
-				data = {
-					instance: this,
-					options: options,
-					newHeader: jQuery([]),
-					oldHeader: options.active,
-					newContent: jQuery([]),
-					oldContent: toHide
-				},
-				toShow = (options.active = $([]));
-			toggle.call(this, toShow, toHide, data );
-			return false;
-		}
-		// get the click target
-		var clicked = $(event.target);
-		
-		// due to the event delegation model, we have to check if one
-		// of the parent elements is our actual header, and find that
-		if ( clicked.parents(options.header).length ) {
-			while ( !clicked.is(options.header) ) {
-				clicked = clicked.parent();
-			}
-		}
-		
-		var clickedActive = clicked[0] == options.active[0];
-		
-		// if animations are still active, or the active header is the target, ignore click
-		if (options.running || (options.alwaysOpen && clickedActive)) {
-			return false;
+	var instance = $.data(this, "accordion");
+	var options = instance.options;
+	options.running = cancel ? 0 : --options.running;
+	if ( options.running ) {
+		return;
+	}
+	if ( options.clearStyle ) {
+		options.toShow.add(options.toHide).css({
+			height: "",
+			overflow: ""
+		});
+	}
+	$(this).triggerHandler("accordionchange", [options.data], options.change);
+}
+
+function toggle(toShow, toHide, data, clickedActive, down) {
+	var options = $.data(this, "accordion").options;
+	options.toShow = toShow;
+	options.toHide = toHide;
+	options.data = data;
+	var complete = scopeCallback(completed, this);
+	
+	// count elements to animate
+	options.running = toHide.size() === 0 ? toShow.size() : toHide.size();
+	
+	if ( options.animated ) {
+		if ( !options.alwaysOpen && clickedActive ) {
+			$.ui.accordion.animations[options.animated]({
+				toShow: jQuery([]),
+				toHide: toHide,
+				complete: complete,
+				down: down,
+				autoHeight: options.autoHeight
+			});
+		} else {
+			$.ui.accordion.animations[options.animated]({
+				toShow: toShow,
+				toHide: toHide,
+				complete: complete,
+				down: down,
+				autoHeight: options.autoHeight
+			});
 		}
-		if (!clicked.is(options.header)) {
-			return;
+	} else {
+		if ( !options.alwaysOpen && clickedActive ) {
+			toShow.toggle();
+		} else {
+			toHide.hide();
+			toShow.show();
 		}
-		
-		// switch classes
+		complete(true);
+	}
+}
+
+function clickHandler(event) {
+	var options = $.data(this, "accordion").options;
+	if (options.disabled) {
+		return false;
+	}
+	
+	// called only when using activate(false) to close all parts programmatically
+	if ( !event.target && !options.alwaysOpen ) {
 		options.active.parent().andSelf().toggleClass(options.selectedClass);
-		if ( !clickedActive ) {
-			clicked.parent().andSelf().addClass(options.selectedClass);
-		}
-		
-		// find elements to show and hide
-		var toShow = clicked.next(),
-			toHide = options.active.next(),
-			//data = [clicked, options.active, toShow, toHide],
+		var toHide = options.active.next(),
 			data = {
 				instance: this,
 				options: options,
-				newHeader: clicked,
+				newHeader: jQuery([]),
 				oldHeader: options.active,
-				newContent: toShow,
+				newContent: jQuery([]),
 				oldContent: toHide
 			},
-			down = options.headers.index( options.active[0] ) > options.headers.index( clicked[0] );
-		
-		options.active = clickedActive ? $([]) : clicked;
-		toggle.call(this, toShow, toHide, data, clickedActive, down );
+			toShow = (options.active = $([]));
+		toggle.call(this, toShow, toHide, data );
+		return false;
+	}
+	// get the click target
+	var clicked = $(event.target);
+	
+	// due to the event delegation model, we have to check if one
+	// of the parent elements is our actual header, and find that
+	if ( clicked.parents(options.header).length ) {
+		while ( !clicked.is(options.header) ) {
+			clicked = clicked.parent();
+		}
+	}
+	
+	var clickedActive = clicked[0] == options.active[0];
 	
+	// if animations are still active, or the active header is the target, ignore click
+	if (options.running || (options.alwaysOpen && clickedActive)) {
 		return false;
-	};
+	}
+	if (!clicked.is(options.header)) {
+		return;
+	}
 	
-	function findActive(headers, selector) {
-		return selector != undefined
-			? typeof selector == "number"
-				? headers.filter(":eq(" + selector + ")")
-				: headers.not(headers.not(selector))
-			: selector === false
-				? $([])
-				: headers.filter(":eq(0)");
+	// switch classes
+	options.active.parent().andSelf().toggleClass(options.selectedClass);
+	if ( !clickedActive ) {
+		clicked.parent().andSelf().addClass(options.selectedClass);
 	}
 	
-	$.extend($.ui.accordion, {
-		defaults: {
-			selectedClass: "selected",
-			alwaysOpen: true,
-			animated: 'slide',
-			event: "click",
-			header: "a",
-			autoHeight: true,
-			running: 0,
-			navigationFilter: function() {
-				return this.href.toLowerCase() == location.href.toLowerCase();
-			}
+	// find elements to show and hide
+	var toShow = clicked.next(),
+		toHide = options.active.next(),
+		//data = [clicked, options.active, toShow, toHide],
+		data = {
+			instance: this,
+			options: options,
+			newHeader: clicked,
+			oldHeader: options.active,
+			newContent: toShow,
+			oldContent: toHide
 		},
-		animations: {
-			slide: function(options, additions) {
-				options = $.extend({
-					easing: "swing",
-					duration: 300
-				}, options, additions);
-				if ( !options.toHide.size() ) {
-					options.toShow.animate({height: "show"}, options);
-					return;
-				}
-				var hideHeight = options.toHide.height(),
-					showHeight = options.toShow.height(),
-					difference = showHeight / hideHeight;
-				options.toShow.css({ height: 0, overflow: 'hidden' }).show();
-				options.toHide.filter(":hidden").each(options.complete).end().filter(":visible").animate({height:"hide"},{
-					step: function(now) {
-						var current = (hideHeight - now) * difference;
-						if ($.browser.msie || $.browser.opera) {
-							current = Math.ceil(current);
-						}
-						options.toShow.height( current );
-					},
-					duration: options.duration,
-					easing: options.easing,
-					complete: function() {
-						if ( !options.autoHeight ) {
-							options.toShow.css("height", "auto");
-						}
-						options.complete();
-					}
-				});
-			},
-			bounceslide: function(options) {
-				this.slide(options, {
-					easing: options.down ? "bounceout" : "swing",
-					duration: options.down ? 1000 : 200
-				});
-			},
-			easeslide: function(options) {
-				this.slide(options, {
-					easing: "easeinout",
-					duration: 700
-				});
+		down = options.headers.index( options.active[0] ) > options.headers.index( clicked[0] );
+	
+	options.active = clickedActive ? $([]) : clicked;
+	toggle.call(this, toShow, toHide, data, clickedActive, down );
+
+	return false;
+};
+
+function findActive(headers, selector) {
+	return selector != undefined
+		? typeof selector == "number"
+			? headers.filter(":eq(" + selector + ")")
+			: headers.not(headers.not(selector))
+		: selector === false
+			? $([])
+			: headers.filter(":eq(0)");
+}
+
+$.extend($.ui.accordion, {
+	defaults: {
+		selectedClass: "selected",
+		alwaysOpen: true,
+		animated: 'slide',
+		event: "click",
+		header: "a",
+		autoHeight: true,
+		running: 0,
+		navigationFilter: function() {
+			return this.href.toLowerCase() == location.href.toLowerCase();
+		}
+	},
+	animations: {
+		slide: function(options, additions) {
+			options = $.extend({
+				easing: "swing",
+				duration: 300
+			}, options, additions);
+			if ( !options.toHide.size() ) {
+				options.toShow.animate({height: "show"}, options);
+				return;
 			}
+			var hideHeight = options.toHide.height(),
+				showHeight = options.toShow.height(),
+				difference = showHeight / hideHeight;
+			options.toShow.css({ height: 0, overflow: 'hidden' }).show();
+			options.toHide.filter(":hidden").each(options.complete).end().filter(":visible").animate({height:"hide"},{
+				step: function(now) {
+					var current = (hideHeight - now) * difference;
+					if ($.browser.msie || $.browser.opera) {
+						current = Math.ceil(current);
+					}
+					options.toShow.height( current );
+				},
+				duration: options.duration,
+				easing: options.easing,
+				complete: function() {
+					if ( !options.autoHeight ) {
+						options.toShow.css("height", "auto");
+					}
+					options.complete();
+				}
+			});
+		},
+		bounceslide: function(options) {
+			this.slide(options, {
+				easing: options.down ? "bounceout" : "swing",
+				duration: options.down ? 1000 : 200
+			});
+		},
+		easeslide: function(options) {
+			this.slide(options, {
+				easing: "easeinout",
+				duration: 700
+			});
 		}
-	});
-	
-	// deprecated, use accordion("activate", index) instead
-	$.fn.activate = function(index) {
-		return this.accordion("activate", index);
-	};
+	}
+});
+
+// deprecated, use accordion("activate", index) instead
+$.fn.activate = function(index) {
+	return this.accordion("activate", index);
+};
 
 })(jQuery);
diff --git a/ui/source/ui.core.js b/ui/source/ui.core.js
index 722794bd3..77713e937 100644
--- a/ui/source/ui.core.js
+++ b/ui/source/ui.core.js
@@ -10,267 +10,268 @@
  * $Id: ui.core.js 5587 2008-05-13 19:56:42Z scott.gonzalez $
  */
 ;(function($) {
-	
-	$.ui = {
-		plugin: {
-			add: function(module, option, set) {
-				var proto = $.ui[module].prototype;
-				for(var i in set) {
-					proto.plugins[i] = proto.plugins[i] || [];
-					proto.plugins[i].push([option, set[i]]);
-				}
-			},
-			call: function(instance, name, args) {
-				var set = instance.plugins[name];
-				if(!set) { return; }
-				
-				for (var i = 0; i < set.length; i++) {
-					if (instance.options[set[i][0]]) {
-						set[i][1].apply(instance.element, args);
-					}
-				}
-			}	
+
+$.ui = {
+	plugin: {
+		add: function(module, option, set) {
+			var proto = $.ui[module].prototype;
+			for(var i in set) {
+				proto.plugins[i] = proto.plugins[i] || [];
+				proto.plugins[i].push([option, set[i]]);
+			}
 		},
-		cssCache: {},
-		css: function(name) {
-			if ($.ui.cssCache[name]) { return $.ui.cssCache[name]; }
-			var tmp = $('<div class="ui-resizable-gen">').addClass(name).css({position:'absolute', top:'-5000px', left:'-5000px', display:'block'}).appendTo('body');
-			
-			//if (!$.browser.safari)
-				//tmp.appendTo('body'); 
+		call: function(instance, name, args) {
+			var set = instance.plugins[name];
+			if(!set) { return; }
 			
-			//Opera and Safari set width and height to 0px instead of auto
-			//Safari returns rgba(0,0,0,0) when bgcolor is not set
-			$.ui.cssCache[name] = !!(
-				(!(/auto|default/).test(tmp.css('cursor')) || (/^[1-9]/).test(tmp.css('height')) || (/^[1-9]/).test(tmp.css('width')) || 
-				!(/none/).test(tmp.css('backgroundImage')) || !(/transparent|rgba\(0, 0, 0, 0\)/).test(tmp.css('backgroundColor')))
-			);
-			try { $('body').get(0).removeChild(tmp.get(0));	} catch(e){}
-			return $.ui.cssCache[name];
-		},
-		disableSelection: function(e) {
-			e.unselectable = "on";
-			e.onselectstart = function() { return false; };
-			if (e.style) { e.style.MozUserSelect = "none"; }
-		},
-		enableSelection: function(e) {
-			e.unselectable = "off";
-			e.onselectstart = function() { return true; };
-			if (e.style) { e.style.MozUserSelect = ""; }
-		},
-		hasScroll: function(e, a) {
-			var scroll = /top/.test(a||"top") ? 'scrollTop' : 'scrollLeft', has = false;
-			if (e[scroll] > 0) return true; e[scroll] = 1;
-			has = e[scroll] > 0 ? true : false; e[scroll] = 0;
-			return has;
-		}
-	};
-	
+			for (var i = 0; i < set.length; i++) {
+				if (instance.options[set[i][0]]) {
+					set[i][1].apply(instance.element, args);
+				}
+			}
+		}	
+	},
+	cssCache: {},
+	css: function(name) {
+		if ($.ui.cssCache[name]) { return $.ui.cssCache[name]; }
+		var tmp = $('<div class="ui-resizable-gen">').addClass(name).css({position:'absolute', top:'-5000px', left:'-5000px', display:'block'}).appendTo('body');
+		
+		//if (!$.browser.safari)
+			//tmp.appendTo('body'); 
+		
+		//Opera and Safari set width and height to 0px instead of auto
+		//Safari returns rgba(0,0,0,0) when bgcolor is not set
+		$.ui.cssCache[name] = !!(
+			(!(/auto|default/).test(tmp.css('cursor')) || (/^[1-9]/).test(tmp.css('height')) || (/^[1-9]/).test(tmp.css('width')) || 
+			!(/none/).test(tmp.css('backgroundImage')) || !(/transparent|rgba\(0, 0, 0, 0\)/).test(tmp.css('backgroundColor')))
+		);
+		try { $('body').get(0).removeChild(tmp.get(0));	} catch(e){}
+		return $.ui.cssCache[name];
+	},
+	disableSelection: function(e) {
+		e.unselectable = "on";
+		e.onselectstart = function() { return false; };
+		if (e.style) { e.style.MozUserSelect = "none"; }
+	},
+	enableSelection: function(e) {
+		e.unselectable = "off";
+		e.onselectstart = function() { return true; };
+		if (e.style) { e.style.MozUserSelect = ""; }
+	},
+	hasScroll: function(e, a) {
+		var scroll = /top/.test(a||"top") ? 'scrollTop' : 'scrollLeft', has = false;
+		if (e[scroll] > 0) return true; e[scroll] = 1;
+		has = e[scroll] > 0 ? true : false; e[scroll] = 0;
+		return has;
+	}
+};
+
+
+/** jQuery core modifications and additions **/
+
+var _remove = $.fn.remove;
+$.fn.remove = function() {
+	$("*", this).add(this).trigger("remove");
+	return _remove.apply(this, arguments );
+};
+
+// $.widget is a factory to create jQuery plugins
+// taking some boilerplate code out of the plugin code
+// created by Scott González and Jörn Zaefferer
+function getter(namespace, plugin, method) {
+	var methods = $[namespace][plugin].getter || [];
+	methods = (typeof methods == "string" ? methods.split(/,?\s+/) : methods);
+	return ($.inArray(method, methods) != -1);
+}
+
+var widgetPrototype = {
+	init: function() {},
+	destroy: function() {
+		this.element.removeData(this.widgetName);
+	},
 	
-	/** jQuery core modifications and additions **/
+	getData: function(key) {
+		return this.options[key];
+	},
+	setData: function(key, value) {
+		this.options[key] = value;
+	},
 	
-	var _remove = $.fn.remove;
-	$.fn.remove = function() {
-		$("*", this).add(this).trigger("remove");
-		return _remove.apply(this, arguments );
-	};
-	
-	// $.widget is a factory to create jQuery plugins
-	// taking some boilerplate code out of the plugin code
-	// created by Scott González and Jörn Zaefferer
-	function getter(namespace, plugin, method) {
-		var methods = $[namespace][plugin].getter || [];
-		methods = (typeof methods == "string" ? methods.split(/,?\s+/) : methods);
-		return ($.inArray(method, methods) != -1);
+	enable: function() {
+		this.setData('disabled', false);
+	},
+	disable: function() {
+		this.setData('disabled', true);
 	}
-	
-	var widgetPrototype = {
-		init: function() {},
-		destroy: function() {
-			this.element.removeData(this.widgetName);
-		},
+};
+
+$.widget = function(name, prototype) {
+	var namespace = name.split(".")[0];
+	name = name.split(".")[1];
+	// create plugin method
+	$.fn[name] = function(options) {
+		var isMethodCall = (typeof options == 'string'),
+			args = Array.prototype.slice.call(arguments, 1);
 		
-		getData: function(key) {
-			return this.options[key];
-		},
-		setData: function(key, value) {
-			this.options[key] = value;
-		},
-		
-		enable: function() {
-			this.setData('disabled', false);
-		},
-		disable: function() {
-			this.setData('disabled', true);
+		if (isMethodCall && getter(namespace, name, options)) {
+			var instance = $.data(this[0], name);
+			return (instance ? instance[options].apply(instance, args)
+				: undefined);
 		}
+		
+		return this.each(function() {
+			var instance = $.data(this, name);
+			if (!instance) {
+				$.data(this, name, new $[namespace][name](this, options));
+			} else if (isMethodCall) {
+				instance[options].apply(instance, args);
+			}
+		});
 	};
 	
-	$.widget = function(name, prototype) {
-		var namespace = name.split(".")[0];
-		name = name.split(".")[1];
-		// create plugin method
-		$.fn[name] = function(options) {
-			var isMethodCall = (typeof options == 'string'),
-				args = Array.prototype.slice.call(arguments, 1);
-			
-			if (isMethodCall && getter(namespace, name, options)) {
-				var instance = $.data(this[0], name);
-				return (instance ? instance[options].apply(instance, args)
-					: undefined);
-			}
-			
-			return this.each(function() {
-				var instance = $.data(this, name);
-				if (!instance) {
-					$.data(this, name, new $[namespace][name](this, options));
-				} else if (isMethodCall) {
-					instance[options].apply(instance, args);
-				}
-			});
-		};
+	// create widget constructor
+	$[namespace][name] = function(element, options) {
+		var self = this;
 		
-		// create widget constructor
-		$[namespace][name] = function(element, options) {
-			var self = this;
-			
-			this.widgetName = name;
-			
-			this.options = $.extend({}, $[namespace][name].defaults, options);
-			this.element = $(element)
-				.bind('setData.' + name, function(e, key, value) {
-					return self.setData(key, value);
-				})
-				.bind('getData.' + name, function(e, key) {
-					return self.getData(key);
-				})
-				.bind('remove', function() {
-					return self.destroy();
-				});
-			this.init();
-		};
+		this.widgetName = name;
 		
-		// add widget prototype
-		$[namespace][name].prototype = $.extend({}, widgetPrototype, prototype);
+		this.options = $.extend({}, $[namespace][name].defaults, options);
+		this.element = $(element)
+			.bind('setData.' + name, function(e, key, value) {
+				return self.setData(key, value);
+			})
+			.bind('getData.' + name, function(e, key) {
+				return self.getData(key);
+			})
+			.bind('remove', function() {
+				return self.destroy();
+			});
+		this.init();
 	};
 	
+	// add widget prototype
+	$[namespace][name].prototype = $.extend({}, widgetPrototype, prototype);
+};
+
+
+/** Mouse Interaction Plugin **/
+
+$.ui.mouse = {
+	mouseInit: function() {
+		var self = this;
 	
-	/** Mouse Interaction Plugin **/
+		this.element.bind('mousedown.'+this.widgetName, function(e) {
+			return self.mouseDown(e);
+		});
+		
+		// Prevent text selection in IE
+		if ($.browser.msie) {
+			this._mouseUnselectable = this.element.attr('unselectable');
+			this.element.attr('unselectable', 'on');
+		}
+		
+		this.started = false;
+	},
 	
-	$.ui.mouse = {
-		mouseInit: function() {
-			var self = this;
+	// TODO: make sure destroying one instance of mouse doesn't mess with
+	// other instances of mouse
+	mouseDestroy: function() {
+		this.element.unbind('.'+this.widgetName);
 		
-			this.element.bind('mousedown.'+this.widgetName, function(e) {
-				return self.mouseDown(e);
-			});
-			
-			// Prevent text selection in IE
-			if ($.browser.msie) {
-				this._mouseUnselectable = this.element.attr('unselectable');
-				this.element.attr('unselectable', 'on');
-			}
-			
-			this.started = false;
-		},
+		// Restore text selection in IE
+		($.browser.msie
+			&& this.element.attr('unselectable', this._mouseUnselectable));
+	},
+	
+	mouseDown: function(e) {
+		// we may have missed mouseup (out of window)
+		(this._mouseStarted && this.mouseUp(e));
 		
-		// TODO: make sure destroying one instance of mouse doesn't mess with
-		// other instances of mouse
-		mouseDestroy: function() {
-			this.element.unbind('.'+this.widgetName);
-			
-			// Restore text selection in IE
-			($.browser.msie
-				&& this.element.attr('unselectable', this._mouseUnselectable));
-		},
+		this._mouseDownEvent = e;
 		
-		mouseDown: function(e) {
-			// we may have missed mouseup (out of window)
-			(this._mouseStarted && this.mouseUp(e));
-			
-			this._mouseDownEvent = e;
-			
-			var self = this,
-				btnIsLeft = (e.which == 1),
-				elIsCancel = ($(e.target).is(this.options.cancel));
-			if (!btnIsLeft || elIsCancel) {
-				return true;
-			}
-			
-			this._mouseDelayMet = !this.options.delay;
-			if (!this._mouseDelayMet) {
-				this._mouseDelayTimer = setTimeout(function() {
-					self._mouseDelayMet = true;
-				}, this.options.delay);
-			}
-			
-			// these delegates are required to keep context
-			this._mouseMoveDelegate = function(e) {
-				return self.mouseMove(e);
-			};
-			this._mouseUpDelegate = function(e) {
-				return self.mouseUp(e);
-			};
-			$(document)
-				.bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
-				.bind('mouseup.'+this.widgetName, this._mouseUpDelegate);
-			
-			return false;
-		},
+		var self = this,
+			btnIsLeft = (e.which == 1),
+			elIsCancel = ($(e.target).is(this.options.cancel));
+		if (!btnIsLeft || elIsCancel) {
+			return true;
+		}
 		
-		mouseMove: function(e) {
-			// IE mouseup check - mouseup happened when mouse was out of window
-			if ($.browser.msie && !e.button) {
-				return this.mouseUp(e);
-			}
-			
-			if (this._mouseStarted) {
-				this.mouseDrag(e);
-				return false;
-			}
-			
-			if (this.mouseDistanceMet(e) && this.mouseDelayMet(e)) {
-				this._mouseStarted =
-					(this.mouseStart(this._mouseDownEvent, e) !== false);
-				(this._mouseStarted || this.mouseUp(e));
-			}
-			
-			return !this._mouseStarted;
-		},
+		this._mouseDelayMet = !this.options.delay;
+		if (!this._mouseDelayMet) {
+			this._mouseDelayTimer = setTimeout(function() {
+				self._mouseDelayMet = true;
+			}, this.options.delay);
+		}
 		
-		mouseUp: function(e) {
-			$(document)
-				.unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
-				.unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
-			
-			if (this._mouseStarted) {
-				this._mouseStarted = false;
-				this.mouseStop(e);
-			}
-			
+		// these delegates are required to keep context
+		this._mouseMoveDelegate = function(e) {
+			return self.mouseMove(e);
+		};
+		this._mouseUpDelegate = function(e) {
+			return self.mouseUp(e);
+		};
+		$(document)
+			.bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
+			.bind('mouseup.'+this.widgetName, this._mouseUpDelegate);
+		
+		return false;
+	},
+	
+	mouseMove: function(e) {
+		// IE mouseup check - mouseup happened when mouse was out of window
+		if ($.browser.msie && !e.button) {
+			return this.mouseUp(e);
+		}
+		
+		if (this._mouseStarted) {
+			this.mouseDrag(e);
 			return false;
-		},
+		}
 		
-		mouseDistanceMet: function(e) {
-			return (Math.max(
-					Math.abs(this._mouseDownEvent.pageX - e.pageX),
-					Math.abs(this._mouseDownEvent.pageY - e.pageY)
-				) >= this.options.distance
-			);
-		},
+		if (this.mouseDistanceMet(e) && this.mouseDelayMet(e)) {
+			this._mouseStarted =
+				(this.mouseStart(this._mouseDownEvent, e) !== false);
+			(this._mouseStarted || this.mouseUp(e));
+		}
 		
-		mouseDelayMet: function(e) {
-			return this._mouseDelayMet;
-		},
+		return !this._mouseStarted;
+	},
+	
+	mouseUp: function(e) {
+		$(document)
+			.unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
+			.unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
 		
-		// These are placeholder methods, to be overriden by extending plugin
-		mouseStart: function(e) {},
-		mouseDrag: function(e) {},
-		mouseStop: function(e) {}
-	};
+		if (this._mouseStarted) {
+			this._mouseStarted = false;
+			this.mouseStop(e);
+		}
+		
+		return false;
+	},
 	
-	$.ui.mouse.defaults = {
-		cancel: null,
-		distance: 0,
-		delay: 0
-	};
+	mouseDistanceMet: function(e) {
+		return (Math.max(
+				Math.abs(this._mouseDownEvent.pageX - e.pageX),
+				Math.abs(this._mouseDownEvent.pageY - e.pageY)
+			) >= this.options.distance
+		);
+	},
+	
+	mouseDelayMet: function(e) {
+		return this._mouseDelayMet;
+	},
+	
+	// These are placeholder methods, to be overriden by extending plugin
+	mouseStart: function(e) {},
+	mouseDrag: function(e) {},
+	mouseStop: function(e) {}
+};
+
+$.ui.mouse.defaults = {
+	cancel: null,
+	distance: 0,
+	delay: 0
+};
+
 })(jQuery);
diff --git a/ui/source/ui.datepicker.js b/ui/source/ui.datepicker.js
index 2715c38be..3f0b629ca 100644
--- a/ui/source/ui.datepicker.js
+++ b/ui/source/ui.datepicker.js
@@ -1443,4 +1443,4 @@ $(document).ready(function() {
 		.mousedown($.datepicker._checkExternalClick);
 });
 
-})(jQuery);
\ No newline at end of file
+})(jQuery);
diff --git a/ui/source/ui.dialog.js b/ui/source/ui.dialog.js
index a2f98a820..4c1f9b0f7 100644
--- a/ui/source/ui.dialog.js
+++ b/ui/source/ui.dialog.js
@@ -15,434 +15,434 @@
  * Revision: $Id: ui.dialog.js 5608 2008-05-15 14:41:12Z scott.gonzalez $
  */
 ;(function($) {
-	
-	var setDataSwitch = {
-		dragStart: "start.draggable",
-		drag: "drag.draggable",
-		dragStop: "stop.draggable",
-		maxHeight: "maxHeight.resizable",
-		minHeight: "minHeight.resizable",
-		maxWidth: "maxWidth.resizable",
-		minWidth: "minWidth.resizable",
-		resizeStart: "start.resizable",
-		resize: "drag.resizable",
-		resizeStop: "stop.resizable"
-	};
-	
-	$.widget("ui.dialog", {
-		init: function() {
-			var self = this;
-			var options = this.options;
-			
-			var uiDialogContent = this.element.addClass('ui-dialog-content');
-			
-			if (!uiDialogContent.parent().length) {
-				uiDialogContent.appendTo('body');
-			}
-			uiDialogContent
-				.wrap(document.createElement('div'))
-				.wrap(document.createElement('div'));
-			var uiDialogContainer = uiDialogContent.parent().addClass('ui-dialog-container').css({position: 'relative'});
-			var uiDialog = (this.uiDialog = uiDialogContainer.parent()).hide()
-				.addClass('ui-dialog').addClass(options.dialogClass)
-				.css({position: 'absolute', width: options.width, height: options.height, overflow: 'hidden'}); 
-	
-			var classNames = uiDialogContent.attr('className').split(' ');
-	
-			// Add content classes to dialog, to inherit theme at top level of element
-			$.each(classNames, function(i, className) {
-				((className != 'ui-dialog-content')
-					&& uiDialog.addClass(className));
-			});
-	
-			if ($.fn.resizable) {
-				uiDialog.append('<div class="ui-resizable-n ui-resizable-handle"></div>')
-					.append('<div class="ui-resizable-s ui-resizable-handle"></div>')
-					.append('<div class="ui-resizable-e ui-resizable-handle"></div>')
-					.append('<div class="ui-resizable-w ui-resizable-handle"></div>')
-					.append('<div class="ui-resizable-ne ui-resizable-handle"></div>')
-					.append('<div class="ui-resizable-se ui-resizable-handle"></div>')
-					.append('<div class="ui-resizable-sw ui-resizable-handle"></div>')
-					.append('<div class="ui-resizable-nw ui-resizable-handle"></div>');
-				uiDialog.resizable({
-					maxWidth: options.maxWidth,
-					maxHeight: options.maxHeight,
-					minWidth: options.minWidth,
-					minHeight: options.minHeight,
-					start: options.resizeStart,
-					resize: options.resize,
-					stop: function(e, ui) {
-						(options.resizeStop && options.resizeStop.apply(this, arguments));
-						$.ui.dialog.overlay.resize();
-					}
-				});
-				(!options.resizable && uiDialog.resizable('disable'));
-			}
-	
-			uiDialogContainer.prepend('<div class="ui-dialog-titlebar"></div>');
-			var uiDialogTitlebar = $('.ui-dialog-titlebar', uiDialogContainer);
-			this.uiDialogTitlebar = uiDialogTitlebar;
-			var title = (options.title) ? options.title : (uiDialogContent.attr('title')) ? uiDialogContent.attr('title') : '';
-			uiDialogTitlebar.append('<span class="ui-dialog-title">' + title + '</span>');
-			uiDialogTitlebar.append('<a href="#" class="ui-dialog-titlebar-close"><span>X</span></a>');
-			this.uiDialogTitlebarClose = $('.ui-dialog-titlebar-close', uiDialogTitlebar)
-				.hover(function() { $(this).addClass('ui-dialog-titlebar-close-hover'); }, 
-					function() { $(this).removeClass('ui-dialog-titlebar-close-hover'); }
-				)
-				.mousedown(function(ev) {
-					ev.stopPropagation();
-				})
-				.click(function() {
-					self.close();
-					return false;
-				});
-			
-			// setting tabindex makes the div focusable
-			// setting outline to 0 prevents a border on focus in Mozilla
-			uiDialog.attr('tabindex', -1).css('outline', 0).keydown(function(ev) {
-				if (options.closeOnEscape) {
-					var ESC = 27;
-					(ev.keyCode && ev.keyCode == ESC && self.close());
+
+var setDataSwitch = {
+	dragStart: "start.draggable",
+	drag: "drag.draggable",
+	dragStop: "stop.draggable",
+	maxHeight: "maxHeight.resizable",
+	minHeight: "minHeight.resizable",
+	maxWidth: "maxWidth.resizable",
+	minWidth: "minWidth.resizable",
+	resizeStart: "start.resizable",
+	resize: "drag.resizable",
+	resizeStop: "stop.resizable"
+};
+
+$.widget("ui.dialog", {
+	init: function() {
+		var self = this;
+		var options = this.options;
+		
+		var uiDialogContent = this.element.addClass('ui-dialog-content');
+		
+		if (!uiDialogContent.parent().length) {
+			uiDialogContent.appendTo('body');
+		}
+		uiDialogContent
+			.wrap(document.createElement('div'))
+			.wrap(document.createElement('div'));
+		var uiDialogContainer = uiDialogContent.parent().addClass('ui-dialog-container').css({position: 'relative'});
+		var uiDialog = (this.uiDialog = uiDialogContainer.parent()).hide()
+			.addClass('ui-dialog').addClass(options.dialogClass)
+			.css({position: 'absolute', width: options.width, height: options.height, overflow: 'hidden'}); 
+
+		var classNames = uiDialogContent.attr('className').split(' ');
+
+		// Add content classes to dialog, to inherit theme at top level of element
+		$.each(classNames, function(i, className) {
+			((className != 'ui-dialog-content')
+				&& uiDialog.addClass(className));
+		});
+
+		if ($.fn.resizable) {
+			uiDialog.append('<div class="ui-resizable-n ui-resizable-handle"></div>')
+				.append('<div class="ui-resizable-s ui-resizable-handle"></div>')
+				.append('<div class="ui-resizable-e ui-resizable-handle"></div>')
+				.append('<div class="ui-resizable-w ui-resizable-handle"></div>')
+				.append('<div class="ui-resizable-ne ui-resizable-handle"></div>')
+				.append('<div class="ui-resizable-se ui-resizable-handle"></div>')
+				.append('<div class="ui-resizable-sw ui-resizable-handle"></div>')
+				.append('<div class="ui-resizable-nw ui-resizable-handle"></div>');
+			uiDialog.resizable({
+				maxWidth: options.maxWidth,
+				maxHeight: options.maxHeight,
+				minWidth: options.minWidth,
+				minHeight: options.minHeight,
+				start: options.resizeStart,
+				resize: options.resize,
+				stop: function(e, ui) {
+					(options.resizeStop && options.resizeStop.apply(this, arguments));
+					$.ui.dialog.overlay.resize();
 				}
 			});
-			
-			var hasButtons = false;
-			$.each(options.buttons, function() { return !(hasButtons = true); });
-			if (hasButtons) {
-				var uiDialogButtonPane = $('<div class="ui-dialog-buttonpane"/>')
-					.appendTo(uiDialog);
-				$.each(options.buttons, function(name, fn) {
-					$(document.createElement('button'))
-						.text(name)
-						.click(function() { fn.apply(self.element, arguments); })
-						.appendTo(uiDialogButtonPane);
-				});
-			}
-			
-			if ($.fn.draggable) {
-				uiDialog.draggable({
-					handle: '.ui-dialog-titlebar',
-					start: function(e, ui) {
-						self.activate();
-						(options.dragStart && options.dragStart.apply(this, arguments));
-					},
-					drag: options.drag,
-					stop: function(e, ui) {
-						(options.dragStop && options.dragStop.apply(this, arguments));
-						$.ui.dialog.overlay.resize();
-					}
-				});
-				(!options.draggable && uiDialog.draggable('disable'));
+			(!options.resizable && uiDialog.resizable('disable'));
+		}
+
+		uiDialogContainer.prepend('<div class="ui-dialog-titlebar"></div>');
+		var uiDialogTitlebar = $('.ui-dialog-titlebar', uiDialogContainer);
+		this.uiDialogTitlebar = uiDialogTitlebar;
+		var title = (options.title) ? options.title : (uiDialogContent.attr('title')) ? uiDialogContent.attr('title') : '';
+		uiDialogTitlebar.append('<span class="ui-dialog-title">' + title + '</span>');
+		uiDialogTitlebar.append('<a href="#" class="ui-dialog-titlebar-close"><span>X</span></a>');
+		this.uiDialogTitlebarClose = $('.ui-dialog-titlebar-close', uiDialogTitlebar)
+			.hover(function() { $(this).addClass('ui-dialog-titlebar-close-hover'); }, 
+				function() { $(this).removeClass('ui-dialog-titlebar-close-hover'); }
+			)
+			.mousedown(function(ev) {
+				ev.stopPropagation();
+			})
+			.click(function() {
+				self.close();
+				return false;
+			});
+		
+		// setting tabindex makes the div focusable
+		// setting outline to 0 prevents a border on focus in Mozilla
+		uiDialog.attr('tabindex', -1).css('outline', 0).keydown(function(ev) {
+			if (options.closeOnEscape) {
+				var ESC = 27;
+				(ev.keyCode && ev.keyCode == ESC && self.close());
 			}
+		});
 		
-			uiDialog.mousedown(function() {
-				self.activate();
+		var hasButtons = false;
+		$.each(options.buttons, function() { return !(hasButtons = true); });
+		if (hasButtons) {
+			var uiDialogButtonPane = $('<div class="ui-dialog-buttonpane"/>')
+				.appendTo(uiDialog);
+			$.each(options.buttons, function(name, fn) {
+				$(document.createElement('button'))
+					.text(name)
+					.click(function() { fn.apply(self.element, arguments); })
+					.appendTo(uiDialogButtonPane);
 			});
-			uiDialogTitlebar.click(function() {
-				self.activate();
+		}
+		
+		if ($.fn.draggable) {
+			uiDialog.draggable({
+				handle: '.ui-dialog-titlebar',
+				start: function(e, ui) {
+					self.activate();
+					(options.dragStart && options.dragStart.apply(this, arguments));
+				},
+				drag: options.drag,
+				stop: function(e, ui) {
+					(options.dragStop && options.dragStop.apply(this, arguments));
+					$.ui.dialog.overlay.resize();
+				}
 			});
-			
-			(options.bgiframe && $.fn.bgiframe && uiDialog.bgiframe());
-			
-			(options.autoOpen && this.open());
-		},
+			(!options.draggable && uiDialog.draggable('disable'));
+		}
+	
+		uiDialog.mousedown(function() {
+			self.activate();
+		});
+		uiDialogTitlebar.click(function() {
+			self.activate();
+		});
 		
-		setData: function(key, value){
-			(setDataSwitch[key] && this.uiDialog.data(setDataSwitch[key], value));
-			switch (key) {
-				case "draggable":
-					this.uiDialog.draggable(value ? 'enable' : 'disable');
-					break;
-				case "height":
-					this.uiDialog.height(value);
-					break;
-				case "position":
-					this.position(value);
+		(options.bgiframe && $.fn.bgiframe && uiDialog.bgiframe());
+		
+		(options.autoOpen && this.open());
+	},
+	
+	setData: function(key, value){
+		(setDataSwitch[key] && this.uiDialog.data(setDataSwitch[key], value));
+		switch (key) {
+			case "draggable":
+				this.uiDialog.draggable(value ? 'enable' : 'disable');
+				break;
+			case "height":
+				this.uiDialog.height(value);
+				break;
+			case "position":
+				this.position(value);
+				break;
+			case "resizable":
+				this.uiDialog.resizable(value ? 'enable' : 'disable');
+				break;
+			case "title":
+				$(".ui-dialog-title", this.uiDialogTitlebar).text(value);
+				break;
+			case "width":
+				this.uiDialog.width(value);
+				break;
+		}
+		this.options[key] = value;
+	},
+	
+	position: function(pos) {
+		var wnd = $(window), doc = $(document),
+			pTop = doc.scrollTop(), pLeft = doc.scrollLeft(),
+			minTop = pTop;
+		
+		if ($.inArray(pos, ['center','top','right','bottom','left']) >= 0) {
+			pos = [
+				pos == 'right' || pos == 'left' ? pos : 'center',
+				pos == 'top' || pos == 'bottom' ? pos : 'middle'
+			];
+		}
+		if (pos.constructor != Array) {
+			pos = ['center', 'middle'];
+		}
+		if (pos[0].constructor == Number) {
+			pLeft += pos[0];
+		} else {
+			switch (pos[0]) {
+				case 'left':
+					pLeft += 0;
 					break;
-				case "resizable":
-					this.uiDialog.resizable(value ? 'enable' : 'disable');
+				case 'right':
+					pLeft += (wnd.width()) - (this.uiDialog.width());
 					break;
-				case "title":
-					$(".ui-dialog-title", this.uiDialogTitlebar).text(value);
+				default:
+				case 'center':
+					pLeft += (wnd.width() / 2) - (this.uiDialog.width() / 2);
+			}
+		}
+		if (pos[1].constructor == Number) {
+			pTop += pos[1];
+		} else {
+			switch (pos[1]) {
+				case 'top':
+					pTop += 0;
 					break;
-				case "width":
-					this.uiDialog.width(value);
+				case 'bottom':
+					pTop += (wnd.height()) - (this.uiDialog.height());
 					break;
+				default:
+				case 'middle':
+					pTop += (wnd.height() / 2) - (this.uiDialog.height() / 2);
 			}
-			this.options[key] = value;
-		},
-		
-		position: function(pos) {
-			var wnd = $(window), doc = $(document),
-				pTop = doc.scrollTop(), pLeft = doc.scrollLeft(),
-				minTop = pTop;
-			
-			if ($.inArray(pos, ['center','top','right','bottom','left']) >= 0) {
-				pos = [
-					pos == 'right' || pos == 'left' ? pos : 'center',
-					pos == 'top' || pos == 'bottom' ? pos : 'middle'
-				];
-			}
-			if (pos.constructor != Array) {
-				pos = ['center', 'middle'];
-			}
-			if (pos[0].constructor == Number) {
-				pLeft += pos[0];
-			} else {
-				switch (pos[0]) {
-					case 'left':
-						pLeft += 0;
-						break;
-					case 'right':
-						pLeft += (wnd.width()) - (this.uiDialog.width());
-						break;
-					default:
-					case 'center':
-						pLeft += (wnd.width() / 2) - (this.uiDialog.width() / 2);
-				}
-			}
-			if (pos[1].constructor == Number) {
-				pTop += pos[1];
-			} else {
-				switch (pos[1]) {
-					case 'top':
-						pTop += 0;
-						break;
-					case 'bottom':
-						pTop += (wnd.height()) - (this.uiDialog.height());
-						break;
-					default:
-					case 'middle':
-						pTop += (wnd.height() / 2) - (this.uiDialog.height() / 2);
-				}
-			}
-			
-			// prevent the dialog from being too high (make sure the titlebar
-			// is accessible)
-			pTop = Math.max(pTop, minTop);
-			this.uiDialog.css({top: pTop, left: pLeft});
-		},
+		}
 		
-		open: function() {
-			this.overlay = this.options.modal ? new $.ui.dialog.overlay(this) : null;
-			this.uiDialog.appendTo('body');
-			this.position(this.options.position);
-			this.uiDialog.show();
-			this.moveToTop();
-			this.activate();
-			
-			// CALLBACK: open
-			var openEV = null;
-			var openUI = {
-				options: this.options
-			};
-			this.uiDialogTitlebarClose.focus();
-			this.element.triggerHandler("dialogopen", [openEV, openUI], this.options.open);
-		},
+		// prevent the dialog from being too high (make sure the titlebar
+		// is accessible)
+		pTop = Math.max(pTop, minTop);
+		this.uiDialog.css({top: pTop, left: pLeft});
+	},
 	
-		activate: function() {
-			// Move modeless dialogs to the top when they're activated. Even
-			// if there is a modal dialog in the window, the modeless dialog
-			// should be on top because it must have been opened after the modal
-			// dialog. Modal dialogs don't get moved to the top because that
-			// would make any modeless dialogs that it spawned unusable until
-			// the modal dialog is closed.
-			(!this.options.modal && this.moveToTop());
-		},
-			
-		moveToTop: function() {
-			var maxZ = this.options.zIndex, options = this.options;
-			$('.ui-dialog:visible').each(function() {
-				maxZ = Math.max(maxZ, parseInt($(this).css('z-index'), 10) || options.zIndex);
-			});
-			(this.overlay && this.overlay.$el.css('z-index', ++maxZ));
-			this.uiDialog.css('z-index', ++maxZ);
-		},
-			
-		close: function() {
-			(this.overlay && this.overlay.destroy());
-			this.uiDialog.hide();
+	open: function() {
+		this.overlay = this.options.modal ? new $.ui.dialog.overlay(this) : null;
+		this.uiDialog.appendTo('body');
+		this.position(this.options.position);
+		this.uiDialog.show();
+		this.moveToTop();
+		this.activate();
+		
+		// CALLBACK: open
+		var openEV = null;
+		var openUI = {
+			options: this.options
+		};
+		this.uiDialogTitlebarClose.focus();
+		this.element.triggerHandler("dialogopen", [openEV, openUI], this.options.open);
+	},
 
-			// CALLBACK: close
-			var closeEV = null;
-			var closeUI = {
-				options: this.options
-			};
-			this.element.triggerHandler("dialogclose", [closeEV, closeUI], this.options.close);
-			$.ui.dialog.overlay.resize();
-		},
+	activate: function() {
+		// Move modeless dialogs to the top when they're activated. Even
+		// if there is a modal dialog in the window, the modeless dialog
+		// should be on top because it must have been opened after the modal
+		// dialog. Modal dialogs don't get moved to the top because that
+		// would make any modeless dialogs that it spawned unusable until
+		// the modal dialog is closed.
+		(!this.options.modal && this.moveToTop());
+	},
 		
-		destroy: function() {
-			(this.overlay && this.overlay.destroy());
-			this.uiDialog.hide();
-			this.element
-				.unbind('.dialog')
-				.removeData('dialog')
-				.removeClass('ui-dialog-content')
-				.hide().appendTo('body');
-			this.uiDialog.remove();
-		}
-	});
-	
-	$.extend($.ui.dialog, {
-		defaults: {
-			autoOpen: true,
-			bgiframe: false,
-			buttons: {},
-			closeOnEscape: true,
-			draggable: true,
-			height: 200,
-			minHeight: 100,
-			minWidth: 150,
-			modal: false,
-			overlay: {},
-			position: 'center',
-			resizable: true,
-			width: 300,
-			zIndex: 1000
-		},
+	moveToTop: function() {
+		var maxZ = this.options.zIndex, options = this.options;
+		$('.ui-dialog:visible').each(function() {
+			maxZ = Math.max(maxZ, parseInt($(this).css('z-index'), 10) || options.zIndex);
+		});
+		(this.overlay && this.overlay.$el.css('z-index', ++maxZ));
+		this.uiDialog.css('z-index', ++maxZ);
+	},
 		
-		overlay: function(dialog) {
-			this.$el = $.ui.dialog.overlay.create(dialog);
-		}
-	});
+	close: function() {
+		(this.overlay && this.overlay.destroy());
+		this.uiDialog.hide();
+
+		// CALLBACK: close
+		var closeEV = null;
+		var closeUI = {
+			options: this.options
+		};
+		this.element.triggerHandler("dialogclose", [closeEV, closeUI], this.options.close);
+		$.ui.dialog.overlay.resize();
+	},
 	
-	$.extend($.ui.dialog.overlay, {
-		instances: [],
-		events: $.map('focus,mousedown,mouseup,keydown,keypress,click'.split(','),
-			function(e) { return e + '.dialog-overlay'; }).join(' '),
-		create: function(dialog) {
-			if (this.instances.length === 0) {
-				// prevent use of anchors and inputs
-				// we use a setTimeout in case the overlay is created from an
-				// event that we're going to be cancelling (see #2804)
-				setTimeout(function() {
-					$('a, :input').bind($.ui.dialog.overlay.events, function() {
-						// allow use of the element if inside a dialog and
-						// - there are no modal dialogs
-						// - there are modal dialogs, but we are in front of the topmost modal
-						var allow = false;
-						var $dialog = $(this).parents('.ui-dialog');
-						if ($dialog.length) {
-							var $overlays = $('.ui-dialog-overlay');
-							if ($overlays.length) {
-								var maxZ = parseInt($overlays.css('z-index'), 10);
-								$overlays.each(function() {
-									maxZ = Math.max(maxZ, parseInt($(this).css('z-index'), 10));
-								});
-								allow = parseInt($dialog.css('z-index'), 10) > maxZ;
-							} else {
-								allow = true;
-							}
+	destroy: function() {
+		(this.overlay && this.overlay.destroy());
+		this.uiDialog.hide();
+		this.element
+			.unbind('.dialog')
+			.removeData('dialog')
+			.removeClass('ui-dialog-content')
+			.hide().appendTo('body');
+		this.uiDialog.remove();
+	}
+});
+
+$.extend($.ui.dialog, {
+	defaults: {
+		autoOpen: true,
+		bgiframe: false,
+		buttons: {},
+		closeOnEscape: true,
+		draggable: true,
+		height: 200,
+		minHeight: 100,
+		minWidth: 150,
+		modal: false,
+		overlay: {},
+		position: 'center',
+		resizable: true,
+		width: 300,
+		zIndex: 1000
+	},
+	
+	overlay: function(dialog) {
+		this.$el = $.ui.dialog.overlay.create(dialog);
+	}
+});
+
+$.extend($.ui.dialog.overlay, {
+	instances: [],
+	events: $.map('focus,mousedown,mouseup,keydown,keypress,click'.split(','),
+		function(e) { return e + '.dialog-overlay'; }).join(' '),
+	create: function(dialog) {
+		if (this.instances.length === 0) {
+			// prevent use of anchors and inputs
+			// we use a setTimeout in case the overlay is created from an
+			// event that we're going to be cancelling (see #2804)
+			setTimeout(function() {
+				$('a, :input').bind($.ui.dialog.overlay.events, function() {
+					// allow use of the element if inside a dialog and
+					// - there are no modal dialogs
+					// - there are modal dialogs, but we are in front of the topmost modal
+					var allow = false;
+					var $dialog = $(this).parents('.ui-dialog');
+					if ($dialog.length) {
+						var $overlays = $('.ui-dialog-overlay');
+						if ($overlays.length) {
+							var maxZ = parseInt($overlays.css('z-index'), 10);
+							$overlays.each(function() {
+								maxZ = Math.max(maxZ, parseInt($(this).css('z-index'), 10));
+							});
+							allow = parseInt($dialog.css('z-index'), 10) > maxZ;
+						} else {
+							allow = true;
 						}
-						return allow;
-					});
-				}, 1);
-				
-				// allow closing by pressing the escape key
-				$(document).bind('keydown.dialog-overlay', function(e) {
-					var ESC = 27;
-					(e.keyCode && e.keyCode == ESC && dialog.close()); 
+					}
+					return allow;
 				});
-				
-				// handle window resize
-				$(window).bind('resize.dialog-overlay', $.ui.dialog.overlay.resize);
-			}
-			
-			var $el = $('<div/>').appendTo(document.body)
-				.addClass('ui-dialog-overlay').css($.extend({
-					borderWidth: 0, margin: 0, padding: 0,
-					position: 'absolute', top: 0, left: 0,
-					width: this.width(),
-					height: this.height()
-				}, dialog.options.overlay));
+			}, 1);
 			
-			(dialog.options.bgiframe && $.fn.bgiframe && $el.bgiframe());
+			// allow closing by pressing the escape key
+			$(document).bind('keydown.dialog-overlay', function(e) {
+				var ESC = 27;
+				(e.keyCode && e.keyCode == ESC && dialog.close()); 
+			});
 			
-			this.instances.push($el);
-			return $el;
-		},
+			// handle window resize
+			$(window).bind('resize.dialog-overlay', $.ui.dialog.overlay.resize);
+		}
 		
-		destroy: function($el) {
-			this.instances.splice($.inArray(this.instances, $el), 1);
-			
-			if (this.instances.length === 0) {
-				$('a, :input').add([document, window]).unbind('.dialog-overlay');
-			}
-			
-			$el.remove();
-		},
+		var $el = $('<div/>').appendTo(document.body)
+			.addClass('ui-dialog-overlay').css($.extend({
+				borderWidth: 0, margin: 0, padding: 0,
+				position: 'absolute', top: 0, left: 0,
+				width: this.width(),
+				height: this.height()
+			}, dialog.options.overlay));
 		
-		height: function() {
-			if ($.browser.msie && $.browser.version < 7) {
-				var scrollHeight = Math.max(
-					document.documentElement.scrollHeight,
-					document.body.scrollHeight
-				);
-				var offsetHeight = Math.max(
-					document.documentElement.offsetHeight,
-					document.body.offsetHeight
-				);
-				
-				if (scrollHeight < offsetHeight) {
-					return $(window).height() + 'px';
-				} else {
-					return scrollHeight + 'px';
-				}
-			} else {
-				return $(document).height() + 'px';
-			}
-		},
+		(dialog.options.bgiframe && $.fn.bgiframe && $el.bgiframe());
 		
-		width: function() {
-			if ($.browser.msie && $.browser.version < 7) {
-				var scrollWidth = Math.max(
-					document.documentElement.scrollWidth,
-					document.body.scrollWidth
-				);
-				var offsetWidth = Math.max(
-					document.documentElement.offsetWidth,
-					document.body.offsetWidth
-				);
-				
-				if (scrollWidth < offsetWidth) {
-					return $(window).width() + 'px';
-				} else {
-					return scrollWidth + 'px';
-				}
-			} else {
-				return $(document).width() + 'px';
-			}
-		},
+		this.instances.push($el);
+		return $el;
+	},
+	
+	destroy: function($el) {
+		this.instances.splice($.inArray(this.instances, $el), 1);
 		
-		resize: function() {
-			/* If the dialog is draggable and the user drags it past the
-			 * right edge of the window, the document becomes wider so we
-			 * need to stretch the overlay. If the user then drags the
-			 * dialog back to the left, the document will become narrower,
-			 * so we need to shrink the overlay to the appropriate size.
-			 * This is handled by shrinking the overlay before setting it
-			 * to the full document size.
-			 */
-			var $overlays = $([]);
-			$.each($.ui.dialog.overlay.instances, function() {
-				$overlays = $overlays.add(this);
-			});
+		if (this.instances.length === 0) {
+			$('a, :input').add([document, window]).unbind('.dialog-overlay');
+		}
+		
+		$el.remove();
+	},
+	
+	height: function() {
+		if ($.browser.msie && $.browser.version < 7) {
+			var scrollHeight = Math.max(
+				document.documentElement.scrollHeight,
+				document.body.scrollHeight
+			);
+			var offsetHeight = Math.max(
+				document.documentElement.offsetHeight,
+				document.body.offsetHeight
+			);
 			
-			$overlays.css({
-				width: 0,
-				height: 0
-			}).css({
-				width: $.ui.dialog.overlay.width(),
-				height: $.ui.dialog.overlay.height()
-			});
+			if (scrollHeight < offsetHeight) {
+				return $(window).height() + 'px';
+			} else {
+				return scrollHeight + 'px';
+			}
+		} else {
+			return $(document).height() + 'px';
 		}
-	});
+	},
 	
-	$.extend($.ui.dialog.overlay.prototype, {
-		destroy: function() {
-			$.ui.dialog.overlay.destroy(this.$el);
+	width: function() {
+		if ($.browser.msie && $.browser.version < 7) {
+			var scrollWidth = Math.max(
+				document.documentElement.scrollWidth,
+				document.body.scrollWidth
+			);
+			var offsetWidth = Math.max(
+				document.documentElement.offsetWidth,
+				document.body.offsetWidth
+			);
+			
+			if (scrollWidth < offsetWidth) {
+				return $(window).width() + 'px';
+			} else {
+				return scrollWidth + 'px';
+			}
+		} else {
+			return $(document).width() + 'px';
 		}
-	});
+	},
+	
+	resize: function() {
+		/* If the dialog is draggable and the user drags it past the
+		 * right edge of the window, the document becomes wider so we
+		 * need to stretch the overlay. If the user then drags the
+		 * dialog back to the left, the document will become narrower,
+		 * so we need to shrink the overlay to the appropriate size.
+		 * This is handled by shrinking the overlay before setting it
+		 * to the full document size.
+		 */
+		var $overlays = $([]);
+		$.each($.ui.dialog.overlay.instances, function() {
+			$overlays = $overlays.add(this);
+		});
+		
+		$overlays.css({
+			width: 0,
+			height: 0
+		}).css({
+			width: $.ui.dialog.overlay.width(),
+			height: $.ui.dialog.overlay.height()
+		});
+	}
+});
+
+$.extend($.ui.dialog.overlay.prototype, {
+	destroy: function() {
+		$.ui.dialog.overlay.destroy(this.$el);
+	}
+});
 
 })(jQuery);
diff --git a/ui/source/ui.draggable.js b/ui/source/ui.draggable.js
index 291618c35..b95194078 100644
--- a/ui/source/ui.draggable.js
+++ b/ui/source/ui.draggable.js
@@ -12,545 +12,544 @@
  *
  * Revision: $Id: ui.draggable.js 5672 2008-05-23 04:11:30Z braeker $
  */
-
 ;(function($) {
-	
-	$.widget("ui.draggable", $.extend($.ui.mouse, {
-		init: function() {
-			
-			//Initialize needed constants
-			var o = this.options;
 
-			//Position the node
-			if (o.helper == 'original' && !(/(relative|absolute|fixed)/).test(this.element.css('position')))
-				this.element.css('position', 'relative');
+$.widget("ui.draggable", $.extend($.ui.mouse, {
+	init: function() {
+		
+		//Initialize needed constants
+		var o = this.options;
 
-			this.element.addClass('ui-draggable');
-			(o.disabled && this.element.addClass('ui-draggable-disabled'));
-			
-			this.mouseInit();
-			
-		},
-		setData: function(key, value) {
-			(key == 'disabled' && this.element[(value ? 'add' : 'remove') + 'Class']('ui-draggable-disabled'));
-			this.options[key] = value;
-		},
-		mouseStart: function(e) {
-			var o = this.options;
-			
-			if (this.helper || o.disabled || $(e.target).is('.ui-resizable-handle')) return false;
-			
-			var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
-			if(!handle) $(this.options.handle, this.element).each(function() {
-				if(this == e.target) handle = true;
-			});
-			if (!handle) return false;
-			
-			if($.ui.ddmanager) $.ui.ddmanager.current = this;
-			
-			//Create and append the visible helper
-			this.helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [e])) : (o.helper == 'clone' ? this.element.clone() : this.element);
-			if(!this.helper.parents('body').length) this.helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));
-			if(this.helper[0] != this.element[0] && !(/(fixed|absolute)/).test(this.helper.css("position"))) this.helper.css("position", "absolute");
-			
-			/*
-			 * - Position generation -
-			 * This block generates everything position related - it's the core of draggables.
-			 */
-			
-			this.margins = {																				//Cache the margins
-				left: (parseInt(this.element.css("marginLeft"),10) || 0),
-				top: (parseInt(this.element.css("marginTop"),10) || 0)
-			};		
-			
-			this.cssPosition = this.helper.css("position");													//Store the helper's css position
-			this.offset = this.element.offset();															//The element's absolute position on the page
-			this.offset = {																					//Substract the margins from the element's absolute offset
-				top: this.offset.top - this.margins.top,
-				left: this.offset.left - this.margins.left
-			};
-			
-			this.offset.click = {																			//Where the click happened, relative to the element
-				left: e.pageX - this.offset.left,
-				top: e.pageY - this.offset.top
-			};
-			
-			this.offsetParent = this.helper.offsetParent(); var po = this.offsetParent.offset();			//Get the offsetParent and cache its position
-			this.offset.parent = {																			//Store its position plus border
-				top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
-				left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
-			};
-			
-			var p = this.element.position();																//This is a relative to absolute position minus the actual position calculation - only used for relative positioned helpers
-			this.offset.relative = this.cssPosition == "relative" ? {
-				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.offsetParent[0].scrollTop,
-				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.offsetParent[0].scrollLeft
-			} : { top: 0, left: 0 };
-			
-			this.originalPosition = this.generatePosition(e);												//Generate the original position
-			this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() };//Cache the helper size
-			
-			if(o.cursorAt) {
-				if(o.cursorAt.left != undefined) this.offset.click.left = o.cursorAt.left;
-				if(o.cursorAt.right != undefined) this.offset.click.left = this.helperProportions.width - o.cursorAt.right;
-				if(o.cursorAt.top != undefined) this.offset.click.top = o.cursorAt.top;
-				if(o.cursorAt.bottom != undefined) this.offset.click.top = this.helperProportions.height - o.cursorAt.bottom;
-			}
-			
-			
-			/*
-			 * - Position constraining -
-			 * Here we prepare position constraining like grid and containment.
-			 */	
-			
-			if(o.containment) {
-				if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
-				if(o.containment == 'document') this.containment = [0,0,$(document).width(), ($(document).height() || document.body.parentNode.scrollHeight)];
-				if(!(/^(document|window|parent)$/).test(o.containment)) {
-					var ce = $(o.containment)[0];
-					var co = $(o.containment).offset();
-					
-					this.containment = [
-						co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.relative.left - this.offset.parent.left,
-						co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.relative.top - this.offset.parent.top,
-						co.left+Math.max(ce.scrollWidth,ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.relative.left - this.offset.parent.left - this.helperProportions.width - this.margins.left - (parseInt(this.element.css("marginRight"),10) || 0),
-						co.top+Math.max(ce.scrollHeight,ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.relative.top - this.offset.parent.top - this.helperProportions.height - this.margins.top - (parseInt(this.element.css("marginBottom"),10) || 0)
-					];
-				}
-			}
-			
-			//Call plugins and callbacks
-			this.propagate("start", e);
-			
-			this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() };//Recache the helper size
-			if ($.ui.ddmanager && !o.dropBehaviour) $.ui.ddmanager.prepareOffsets(this, e);
-			
-			this.helper.addClass("ui-draggable-dragging");
-			this.mouseDrag(e); //Execute the drag once - this causes the helper not to be visible before getting its correct position
-			return true;
-		},
-		convertPositionTo: function(d, pos) {
-			if(!pos) pos = this.position;
-			var mod = d == "absolute" ? 1 : -1;
-			return {
-				top: (
-					pos.top																	// the calculated relative position
-					+ this.offset.relative.top	* mod										// Only for relative positioned nodes: Relative offset from element to offset parent
-					+ this.offset.parent.top * mod											// The offsetParent's offset without borders (offset + border)
-					- (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollTop) * mod	// The offsetParent's scroll position, not if the element is fixed
-					+ (this.cssPosition == "fixed" ? this.offsetParent[0].scrollTop : 0) * mod
-					+ this.margins.top * mod												//Add the margin (you don't want the margin counting in intersection methods)
-				),
-				left: (
-					pos.left																// the calculated relative position
-					+ this.offset.relative.left	* mod										// Only for relative positioned nodes: Relative offset from element to offset parent
-					+ this.offset.parent.left * mod											// The offsetParent's offset without borders (offset + border)
-					- (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollLeft) * mod	// The offsetParent's scroll position, not if the element is fixed
-					+ (this.cssPosition == "fixed" ? this.offsetParent[0].scrollLeft : 0) * mod
-					+ this.margins.left * mod												//Add the margin (you don't want the margin counting in intersection methods)
-				)
-			};
-		},
-		generatePosition: function(e) {
-			
-			var o = this.options;
-			var position = {
-				top: (
-					e.pageY																	// The absolute mouse position
-					- this.offset.click.top													// Click offset (relative to the element)
-					- this.offset.relative.top												// Only for relative positioned nodes: Relative offset from element to offset parent
-					- this.offset.parent.top												// The offsetParent's offset without borders (offset + border)
-					+ (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollTop)	// The offsetParent's scroll position, not if the element is fixed
-					- (this.cssPosition == "fixed" ? this.offsetParent[0].scrollTop : 0)
-				),
-				left: (
-					e.pageX																	// The absolute mouse position
-					- this.offset.click.left												// Click offset (relative to the element)
-					- this.offset.relative.left												// Only for relative positioned nodes: Relative offset from element to offset parent
-					- this.offset.parent.left												// The offsetParent's offset without borders (offset + border)
-					+ (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollLeft)	// The offsetParent's scroll position, not if the element is fixed
-					- (this.cssPosition == "fixed" ? this.offsetParent[0].scrollLeft : 0)
-				)
-			};
-			
-			if(!this.originalPosition) return position;										//If we are not dragging yet, we won't check for options
-			
-			/*
-			 * - Position constraining -
-			 * Constrain the position to a mix of grid, containment.
-			 */
-			if(this.containment) {
-				if(position.left < this.containment[0]) position.left = this.containment[0];
-				if(position.top < this.containment[1]) position.top = this.containment[1];
-				if(position.left > this.containment[2]) position.left = this.containment[2];
-				if(position.top > this.containment[3]) position.top = this.containment[3];
-			}
-			
-			if(o.grid) {
-				var top = this.originalPosition.top + Math.round((position.top - this.originalPosition.top) / o.grid[1]) * o.grid[1];
-				position.top = this.containment ? (!(top < this.containment[1] || top > this.containment[3]) ? top : (!(top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
-				
-				var left = this.originalPosition.left + Math.round((position.left - this.originalPosition.left) / o.grid[0]) * o.grid[0];
-				position.left = this.containment ? (!(left < this.containment[0] || left > this.containment[2]) ? left : (!(left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
-			}
-			
-			return position;
-		},
-		mouseDrag: function(e) {
-			
-			//Compute the helpers position
-			this.position = this.generatePosition(e);
-			this.positionAbs = this.convertPositionTo("absolute");
-			
-			//Call plugins and callbacks and use the resulting position if something is returned		
-			this.position = this.propagate("drag", e) || this.position;
-			
-			if(!this.options.axis || this.options.axis == "x") this.helper[0].style.left = this.position.left+'px';
-			if(!this.options.axis || this.options.axis == "y") this.helper[0].style.top = this.position.top+'px';
-			if($.ui.ddmanager) $.ui.ddmanager.drag(this, e);
-			
-			return false;
-		},
-		mouseStop: function(e) {
-			
-			//If we are using droppables, inform the manager about the drop
-			if ($.ui.ddmanager && !this.options.dropBehaviour)
-				$.ui.ddmanager.drop(this, e);
+		//Position the node
+		if (o.helper == 'original' && !(/(relative|absolute|fixed)/).test(this.element.css('position')))
+			this.element.css('position', 'relative');
+
+		this.element.addClass('ui-draggable');
+		(o.disabled && this.element.addClass('ui-draggable-disabled'));
+		
+		this.mouseInit();
+		
+	},
+	setData: function(key, value) {
+		(key == 'disabled' && this.element[(value ? 'add' : 'remove') + 'Class']('ui-draggable-disabled'));
+		this.options[key] = value;
+	},
+	mouseStart: function(e) {
+		var o = this.options;
+		
+		if (this.helper || o.disabled || $(e.target).is('.ui-resizable-handle')) return false;
+		
+		var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
+		if(!handle) $(this.options.handle, this.element).each(function() {
+			if(this == e.target) handle = true;
+		});
+		if (!handle) return false;
+		
+		if($.ui.ddmanager) $.ui.ddmanager.current = this;
+		
+		//Create and append the visible helper
+		this.helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [e])) : (o.helper == 'clone' ? this.element.clone() : this.element);
+		if(!this.helper.parents('body').length) this.helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));
+		if(this.helper[0] != this.element[0] && !(/(fixed|absolute)/).test(this.helper.css("position"))) this.helper.css("position", "absolute");
+		
+		/*
+		 * - Position generation -
+		 * This block generates everything position related - it's the core of draggables.
+		 */
+		
+		this.margins = {																				//Cache the margins
+			left: (parseInt(this.element.css("marginLeft"),10) || 0),
+			top: (parseInt(this.element.css("marginTop"),10) || 0)
+		};		
+		
+		this.cssPosition = this.helper.css("position");													//Store the helper's css position
+		this.offset = this.element.offset();															//The element's absolute position on the page
+		this.offset = {																					//Substract the margins from the element's absolute offset
+			top: this.offset.top - this.margins.top,
+			left: this.offset.left - this.margins.left
+		};
+		
+		this.offset.click = {																			//Where the click happened, relative to the element
+			left: e.pageX - this.offset.left,
+			top: e.pageY - this.offset.top
+		};
+		
+		this.offsetParent = this.helper.offsetParent(); var po = this.offsetParent.offset();			//Get the offsetParent and cache its position
+		this.offset.parent = {																			//Store its position plus border
+			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
+			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
+		};
+		
+		var p = this.element.position();																//This is a relative to absolute position minus the actual position calculation - only used for relative positioned helpers
+		this.offset.relative = this.cssPosition == "relative" ? {
+			top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.offsetParent[0].scrollTop,
+			left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.offsetParent[0].scrollLeft
+		} : { top: 0, left: 0 };
+		
+		this.originalPosition = this.generatePosition(e);												//Generate the original position
+		this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() };//Cache the helper size
+		
+		if(o.cursorAt) {
+			if(o.cursorAt.left != undefined) this.offset.click.left = o.cursorAt.left;
+			if(o.cursorAt.right != undefined) this.offset.click.left = this.helperProportions.width - o.cursorAt.right;
+			if(o.cursorAt.top != undefined) this.offset.click.top = o.cursorAt.top;
+			if(o.cursorAt.bottom != undefined) this.offset.click.top = this.helperProportions.height - o.cursorAt.bottom;
+		}
+		
+		
+		/*
+		 * - Position constraining -
+		 * Here we prepare position constraining like grid and containment.
+		 */	
+		
+		if(o.containment) {
+			if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
+			if(o.containment == 'document') this.containment = [0,0,$(document).width(), ($(document).height() || document.body.parentNode.scrollHeight)];
+			if(!(/^(document|window|parent)$/).test(o.containment)) {
+				var ce = $(o.containment)[0];
+				var co = $(o.containment).offset();
 				
-			if(this.options.revert) {
-				var self = this;
-				$(this.helper).animate(this.originalPosition, parseInt(this.options.revert, 10) || 500, function() {
-					self.propagate("stop", e);
-					self.clear();
-				});
-			} else {
-				this.propagate("stop", e);
-				this.clear();
+				this.containment = [
+					co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.relative.left - this.offset.parent.left,
+					co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.relative.top - this.offset.parent.top,
+					co.left+Math.max(ce.scrollWidth,ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.relative.left - this.offset.parent.left - this.helperProportions.width - this.margins.left - (parseInt(this.element.css("marginRight"),10) || 0),
+					co.top+Math.max(ce.scrollHeight,ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.relative.top - this.offset.parent.top - this.helperProportions.height - this.margins.top - (parseInt(this.element.css("marginBottom"),10) || 0)
+				];
 			}
-			
-			return false;
-		},
-		clear: function() {
-			this.helper.removeClass("ui-draggable-dragging");
-			if(this.options.helper != 'original' && !this.cancelHelperRemoval) this.helper.remove();
-			if($.ui.ddmanager) $.ui.ddmanager.current = null;
-			this.helper = null;
-			this.cancelHelperRemoval = false;
-		},
-		
-		// From now on bulk stuff - mainly helpers
-		plugins: {},
-		uiHash: function(e) {
-			return {
-				helper: this.helper,
-				position: this.position,
-				absolutePosition: this.positionAbs,
-				options: this.options			
-			};
-		},
-		propagate: function(n,e) {
-			$.ui.plugin.call(this, n, [e, this.uiHash()]);
-			return this.element.triggerHandler(n == "drag" ? n : "drag"+n, [e, this.uiHash()], this.options[n]);
-		},
-		destroy: function() {
-			if(!this.element.data('draggable')) return;
-			this.element.removeData("draggable").unbind(".draggable").removeClass('ui-draggable');
-			this.mouseDestroy();
 		}
-	}));
-
-	$.extend($.ui.draggable, {
-		defaults: {
-			distance: 0,
-			delay: 0,
-			cancel: ":input,button",
-			helper: "original",
-			appendTo: "parent"
+		
+		//Call plugins and callbacks
+		this.propagate("start", e);
+		
+		this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() };//Recache the helper size
+		if ($.ui.ddmanager && !o.dropBehaviour) $.ui.ddmanager.prepareOffsets(this, e);
+		
+		this.helper.addClass("ui-draggable-dragging");
+		this.mouseDrag(e); //Execute the drag once - this causes the helper not to be visible before getting its correct position
+		return true;
+	},
+	convertPositionTo: function(d, pos) {
+		if(!pos) pos = this.position;
+		var mod = d == "absolute" ? 1 : -1;
+		return {
+			top: (
+				pos.top																	// the calculated relative position
+				+ this.offset.relative.top	* mod										// Only for relative positioned nodes: Relative offset from element to offset parent
+				+ this.offset.parent.top * mod											// The offsetParent's offset without borders (offset + border)
+				- (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollTop) * mod	// The offsetParent's scroll position, not if the element is fixed
+				+ (this.cssPosition == "fixed" ? this.offsetParent[0].scrollTop : 0) * mod
+				+ this.margins.top * mod												//Add the margin (you don't want the margin counting in intersection methods)
+			),
+			left: (
+				pos.left																// the calculated relative position
+				+ this.offset.relative.left	* mod										// Only for relative positioned nodes: Relative offset from element to offset parent
+				+ this.offset.parent.left * mod											// The offsetParent's offset without borders (offset + border)
+				- (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollLeft) * mod	// The offsetParent's scroll position, not if the element is fixed
+				+ (this.cssPosition == "fixed" ? this.offsetParent[0].scrollLeft : 0) * mod
+				+ this.margins.left * mod												//Add the margin (you don't want the margin counting in intersection methods)
+			)
+		};
+	},
+	generatePosition: function(e) {
+		
+		var o = this.options;
+		var position = {
+			top: (
+				e.pageY																	// The absolute mouse position
+				- this.offset.click.top													// Click offset (relative to the element)
+				- this.offset.relative.top												// Only for relative positioned nodes: Relative offset from element to offset parent
+				- this.offset.parent.top												// The offsetParent's offset without borders (offset + border)
+				+ (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollTop)	// The offsetParent's scroll position, not if the element is fixed
+				- (this.cssPosition == "fixed" ? this.offsetParent[0].scrollTop : 0)
+			),
+			left: (
+				e.pageX																	// The absolute mouse position
+				- this.offset.click.left												// Click offset (relative to the element)
+				- this.offset.relative.left												// Only for relative positioned nodes: Relative offset from element to offset parent
+				- this.offset.parent.left												// The offsetParent's offset without borders (offset + border)
+				+ (this.cssPosition == "fixed" || (this.cssPosition == "absolute" && this.offsetParent[0] == document.body) ? 0 : this.offsetParent[0].scrollLeft)	// The offsetParent's scroll position, not if the element is fixed
+				- (this.cssPosition == "fixed" ? this.offsetParent[0].scrollLeft : 0)
+			)
+		};
+		
+		if(!this.originalPosition) return position;										//If we are not dragging yet, we won't check for options
+		
+		/*
+		 * - Position constraining -
+		 * Constrain the position to a mix of grid, containment.
+		 */
+		if(this.containment) {
+			if(position.left < this.containment[0]) position.left = this.containment[0];
+			if(position.top < this.containment[1]) position.top = this.containment[1];
+			if(position.left > this.containment[2]) position.left = this.containment[2];
+			if(position.top > this.containment[3]) position.top = this.containment[3];
 		}
-	});
-
-	$.ui.plugin.add("draggable", "cursor", {
-		start: function(e, ui) {
-			var t = $('body');
-			if (t.css("cursor")) ui.options._cursor = t.css("cursor");
-			t.css("cursor", ui.options.cursor);
-		},
-		stop: function(e, ui) {
-			if (ui.options._cursor) $('body').css("cursor", ui.options._cursor);
+		
+		if(o.grid) {
+			var top = this.originalPosition.top + Math.round((position.top - this.originalPosition.top) / o.grid[1]) * o.grid[1];
+			position.top = this.containment ? (!(top < this.containment[1] || top > this.containment[3]) ? top : (!(top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
+			
+			var left = this.originalPosition.left + Math.round((position.left - this.originalPosition.left) / o.grid[0]) * o.grid[0];
+			position.left = this.containment ? (!(left < this.containment[0] || left > this.containment[2]) ? left : (!(left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
 		}
-	});
-	
-	$.ui.plugin.add("draggable", "zIndex", {
-		start: function(e, ui) {
-			var t = $(ui.helper);
-			if(t.css("zIndex")) ui.options._zIndex = t.css("zIndex");
-			t.css('zIndex', ui.options.zIndex);
-		},
-		stop: function(e, ui) {
-			if(ui.options._zIndex) $(ui.helper).css('zIndex', ui.options._zIndex);
+		
+		return position;
+	},
+	mouseDrag: function(e) {
+		
+		//Compute the helpers position
+		this.position = this.generatePosition(e);
+		this.positionAbs = this.convertPositionTo("absolute");
+		
+		//Call plugins and callbacks and use the resulting position if something is returned		
+		this.position = this.propagate("drag", e) || this.position;
+		
+		if(!this.options.axis || this.options.axis == "x") this.helper[0].style.left = this.position.left+'px';
+		if(!this.options.axis || this.options.axis == "y") this.helper[0].style.top = this.position.top+'px';
+		if($.ui.ddmanager) $.ui.ddmanager.drag(this, e);
+		
+		return false;
+	},
+	mouseStop: function(e) {
+		
+		//If we are using droppables, inform the manager about the drop
+		if ($.ui.ddmanager && !this.options.dropBehaviour)
+			$.ui.ddmanager.drop(this, e);
+			
+		if(this.options.revert) {
+			var self = this;
+			$(this.helper).animate(this.originalPosition, parseInt(this.options.revert, 10) || 500, function() {
+				self.propagate("stop", e);
+				self.clear();
+			});
+		} else {
+			this.propagate("stop", e);
+			this.clear();
 		}
-	});
+		
+		return false;
+	},
+	clear: function() {
+		this.helper.removeClass("ui-draggable-dragging");
+		if(this.options.helper != 'original' && !this.cancelHelperRemoval) this.helper.remove();
+		if($.ui.ddmanager) $.ui.ddmanager.current = null;
+		this.helper = null;
+		this.cancelHelperRemoval = false;
+	},
 	
-	$.ui.plugin.add("draggable", "opacity", {
-		start: function(e, ui) {
-			var t = $(ui.helper);
-			if(t.css("opacity")) ui.options._opacity = t.css("opacity");
-			t.css('opacity', ui.options.opacity);
-		},
-		stop: function(e, ui) {
-			if(ui.options._opacity) $(ui.helper).css('opacity', ui.options._opacity);
+	// From now on bulk stuff - mainly helpers
+	plugins: {},
+	uiHash: function(e) {
+		return {
+			helper: this.helper,
+			position: this.position,
+			absolutePosition: this.positionAbs,
+			options: this.options			
+		};
+	},
+	propagate: function(n,e) {
+		$.ui.plugin.call(this, n, [e, this.uiHash()]);
+		return this.element.triggerHandler(n == "drag" ? n : "drag"+n, [e, this.uiHash()], this.options[n]);
+	},
+	destroy: function() {
+		if(!this.element.data('draggable')) return;
+		this.element.removeData("draggable").unbind(".draggable").removeClass('ui-draggable');
+		this.mouseDestroy();
+	}
+}));
+
+$.extend($.ui.draggable, {
+	defaults: {
+		distance: 0,
+		delay: 0,
+		cancel: ":input,button",
+		helper: "original",
+		appendTo: "parent"
+	}
+});
+
+$.ui.plugin.add("draggable", "cursor", {
+	start: function(e, ui) {
+		var t = $('body');
+		if (t.css("cursor")) ui.options._cursor = t.css("cursor");
+		t.css("cursor", ui.options.cursor);
+	},
+	stop: function(e, ui) {
+		if (ui.options._cursor) $('body').css("cursor", ui.options._cursor);
+	}
+});
+
+$.ui.plugin.add("draggable", "zIndex", {
+	start: function(e, ui) {
+		var t = $(ui.helper);
+		if(t.css("zIndex")) ui.options._zIndex = t.css("zIndex");
+		t.css('zIndex', ui.options.zIndex);
+	},
+	stop: function(e, ui) {
+		if(ui.options._zIndex) $(ui.helper).css('zIndex', ui.options._zIndex);
+	}
+});
+
+$.ui.plugin.add("draggable", "opacity", {
+	start: function(e, ui) {
+		var t = $(ui.helper);
+		if(t.css("opacity")) ui.options._opacity = t.css("opacity");
+		t.css('opacity', ui.options.opacity);
+	},
+	stop: function(e, ui) {
+		if(ui.options._opacity) $(ui.helper).css('opacity', ui.options._opacity);
+	}
+});
+
+$.ui.plugin.add("draggable", "iframeFix", {
+	start: function(e, ui) {
+		$(ui.options.iframeFix === true ? "iframe" : ui.options.iframeFix).each(function() {					
+			$('<div class="ui-draggable-iframeFix" style="background: #fff;"></div>')
+			.css({
+				width: this.offsetWidth+"px", height: this.offsetHeight+"px",
+				position: "absolute", opacity: "0.001", zIndex: 1000
+			})
+			.css($(this).offset())
+			.appendTo("body");
+		});
+	},
+	stop: function(e, ui) {
+		$("div.DragDropIframeFix").each(function() { this.parentNode.removeChild(this); }); //Remove frame helpers	
+	}
+});
+
+$.ui.plugin.add("draggable", "scroll", {
+	start: function(e, ui) {
+		var o = ui.options;
+		var i = $(this).data("draggable");
+		o.scrollSensitivity	= o.scrollSensitivity || 20;
+		o.scrollSpeed		= o.scrollSpeed || 20;
+		
+		i.overflowY = function(el) {
+			do { if(/auto|scroll/.test(el.css('overflow')) || (/auto|scroll/).test(el.css('overflow-y'))) return el; el = el.parent(); } while (el[0].parentNode);
+			return $(document);
+		}(this);
+		i.overflowX = function(el) {
+			do { if(/auto|scroll/.test(el.css('overflow')) || (/auto|scroll/).test(el.css('overflow-x'))) return el; el = el.parent(); } while (el[0].parentNode);
+			return $(document);
+		}(this);
+		
+		if(i.overflowY[0] != document && i.overflowY[0].tagName != 'HTML') i.overflowYOffset = i.overflowY.offset();
+		if(i.overflowX[0] != document && i.overflowX[0].tagName != 'HTML') i.overflowXOffset = i.overflowX.offset();
+		
+	},
+	drag: function(e, ui) {
+		
+		var o = ui.options;
+		var i = $(this).data("draggable");
+		
+		if(i.overflowY[0] != document && i.overflowY[0].tagName != 'HTML') {
+			if((i.overflowYOffset.top + i.overflowY[0].offsetHeight) - e.pageY < o.scrollSensitivity)
+				i.overflowY[0].scrollTop = i.overflowY[0].scrollTop + o.scrollSpeed;
+			if(e.pageY - i.overflowYOffset.top < o.scrollSensitivity)
+				i.overflowY[0].scrollTop = i.overflowY[0].scrollTop - o.scrollSpeed;
+							
+		} else {
+			if(e.pageY - $(document).scrollTop() < o.scrollSensitivity)
+				$(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
+			if($(window).height() - (e.pageY - $(document).scrollTop()) < o.scrollSensitivity)
+				$(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
 		}
-	});
-	
-	$.ui.plugin.add("draggable", "iframeFix", {
-		start: function(e, ui) {
-			$(ui.options.iframeFix === true ? "iframe" : ui.options.iframeFix).each(function() {					
-				$('<div class="ui-draggable-iframeFix" style="background: #fff;"></div>')
-				.css({
-					width: this.offsetWidth+"px", height: this.offsetHeight+"px",
-					position: "absolute", opacity: "0.001", zIndex: 1000
-				})
-				.css($(this).offset())
-				.appendTo("body");
-			});
-		},
-		stop: function(e, ui) {
-			$("div.DragDropIframeFix").each(function() { this.parentNode.removeChild(this); }); //Remove frame helpers	
+		
+		if(i.overflowX[0] != document && i.overflowX[0].tagName != 'HTML') {
+			if((i.overflowXOffset.left + i.overflowX[0].offsetWidth) - e.pageX < o.scrollSensitivity)
+				i.overflowX[0].scrollLeft = i.overflowX[0].scrollLeft + o.scrollSpeed;
+			if(e.pageX - i.overflowXOffset.left < o.scrollSensitivity)
+				i.overflowX[0].scrollLeft = i.overflowX[0].scrollLeft - o.scrollSpeed;
+		} else {
+			if(e.pageX - $(document).scrollLeft() < o.scrollSensitivity)
+				$(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
+			if($(window).width() - (e.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
+				$(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
 		}
-	});
-	
-	$.ui.plugin.add("draggable", "scroll", {
-		start: function(e, ui) {
-			var o = ui.options;
-			var i = $(this).data("draggable");
-			o.scrollSensitivity	= o.scrollSensitivity || 20;
-			o.scrollSpeed		= o.scrollSpeed || 20;
-			
-			i.overflowY = function(el) {
-				do { if(/auto|scroll/.test(el.css('overflow')) || (/auto|scroll/).test(el.css('overflow-y'))) return el; el = el.parent(); } while (el[0].parentNode);
-				return $(document);
-			}(this);
-			i.overflowX = function(el) {
-				do { if(/auto|scroll/.test(el.css('overflow')) || (/auto|scroll/).test(el.css('overflow-x'))) return el; el = el.parent(); } while (el[0].parentNode);
-				return $(document);
-			}(this);
-			
-			if(i.overflowY[0] != document && i.overflowY[0].tagName != 'HTML') i.overflowYOffset = i.overflowY.offset();
-			if(i.overflowX[0] != document && i.overflowX[0].tagName != 'HTML') i.overflowXOffset = i.overflowX.offset();
-			
-		},
-		drag: function(e, ui) {
-			
-			var o = ui.options;
-			var i = $(this).data("draggable");
-			
-			if(i.overflowY[0] != document && i.overflowY[0].tagName != 'HTML') {
-				if((i.overflowYOffset.top + i.overflowY[0].offsetHeight) - e.pageY < o.scrollSensitivity)
-					i.overflowY[0].scrollTop = i.overflowY[0].scrollTop + o.scrollSpeed;
-				if(e.pageY - i.overflowYOffset.top < o.scrollSensitivity)
-					i.overflowY[0].scrollTop = i.overflowY[0].scrollTop - o.scrollSpeed;
-								
-			} else {
-				if(e.pageY - $(document).scrollTop() < o.scrollSensitivity)
-					$(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
-				if($(window).height() - (e.pageY - $(document).scrollTop()) < o.scrollSensitivity)
-					$(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
+		
+	}
+});
+
+$.ui.plugin.add("draggable", "snap", {
+	start: function(e, ui) {
+		
+		var inst = $(this).data("draggable");
+		inst.snapElements = [];
+		$(ui.options.snap === true ? '.ui-draggable' : ui.options.snap).each(function() {
+			var $t = $(this); var $o = $t.offset();
+			if(this != inst.element[0]) inst.snapElements.push({
+				item: this,
+				width: $t.outerWidth(), height: $t.outerHeight(),
+				top: $o.top, left: $o.left
+			});
+		});
+		
+	},
+	drag: function(e, ui) {
+		
+		var inst = $(this).data("draggable");
+		var d = ui.options.snapTolerance || 20;
+		var x1 = ui.absolutePosition.left, x2 = x1 + inst.helperProportions.width,
+			y1 = ui.absolutePosition.top, y2 = y1 + inst.helperProportions.height;
+		
+		for (var i = inst.snapElements.length - 1; i >= 0; i--){
+			
+			var l = inst.snapElements[i].left, r = l + inst.snapElements[i].width, 
+				t = inst.snapElements[i].top, b = t + inst.snapElements[i].height;
+			
+			//Yes, I know, this is insane ;)
+			if(!((l-d < x1 && x1 < r+d && t-d < y1 && y1 < b+d) || (l-d < x1 && x1 < r+d && t-d < y2 && y2 < b+d) || (l-d < x2 && x2 < r+d && t-d < y1 && y1 < b+d) || (l-d < x2 && x2 < r+d && t-d < y2 && y2 < b+d))) continue;
+			
+			if(ui.options.snapMode != 'inner') {
+				var ts = Math.abs(t - y2) <= 20;
+				var bs = Math.abs(b - y1) <= 20;
+				var ls = Math.abs(l - x2) <= 20;
+				var rs = Math.abs(r - x1) <= 20;
+				if(ts) ui.position.top = inst.convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
+				if(bs) ui.position.top = inst.convertPositionTo("relative", { top: b, left: 0 }).top;
+				if(ls) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
+				if(rs) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: r }).left;
 			}
 			
-			if(i.overflowX[0] != document && i.overflowX[0].tagName != 'HTML') {
-				if((i.overflowXOffset.left + i.overflowX[0].offsetWidth) - e.pageX < o.scrollSensitivity)
-					i.overflowX[0].scrollLeft = i.overflowX[0].scrollLeft + o.scrollSpeed;
-				if(e.pageX - i.overflowXOffset.left < o.scrollSensitivity)
-					i.overflowX[0].scrollLeft = i.overflowX[0].scrollLeft - o.scrollSpeed;
-			} else {
-				if(e.pageX - $(document).scrollLeft() < o.scrollSensitivity)
-					$(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
-				if($(window).width() - (e.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
-					$(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
+			if(ui.options.snapMode != 'outer') {
+				var ts = Math.abs(t - y1) <= 20;
+				var bs = Math.abs(b - y2) <= 20;
+				var ls = Math.abs(l - x1) <= 20;
+				var rs = Math.abs(r - x2) <= 20;
+				if(ts) ui.position.top = inst.convertPositionTo("relative", { top: t, left: 0 }).top;
+				if(bs) ui.position.top = inst.convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
+				if(ls) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: l }).left;
+				if(rs) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
 			}
 			
-		}
-	});
+		};
+	}
+});
+
+$.ui.plugin.add("draggable", "connectToSortable", {
+	start: function(e,ui) {
 	
-	$.ui.plugin.add("draggable", "snap", {
-		start: function(e, ui) {
-			
-			var inst = $(this).data("draggable");
-			inst.snapElements = [];
-			$(ui.options.snap === true ? '.ui-draggable' : ui.options.snap).each(function() {
-				var $t = $(this); var $o = $t.offset();
-				if(this != inst.element[0]) inst.snapElements.push({
-					item: this,
-					width: $t.outerWidth(), height: $t.outerHeight(),
-					top: $o.top, left: $o.left
+		var inst = $(this).data("draggable");
+		inst.sortables = [];
+		$(ui.options.connectToSortable).each(function() {
+			if($.data(this, 'sortable')) {
+				var sortable = $.data(this, 'sortable');
+				inst.sortables.push({
+					instance: sortable,
+					shouldRevert: sortable.options.revert
 				});
-			});
-			
-		},
-		drag: function(e, ui) {
-			
-			var inst = $(this).data("draggable");
-			var d = ui.options.snapTolerance || 20;
-			var x1 = ui.absolutePosition.left, x2 = x1 + inst.helperProportions.width,
-				y1 = ui.absolutePosition.top, y2 = y1 + inst.helperProportions.height;
-			
-			for (var i = inst.snapElements.length - 1; i >= 0; i--){
+				sortable.refresh();	//Do a one-time refresh at start to refresh the containerCache	
+				sortable.propagate("activate", e, inst);
+			}
+		});
+
+	},
+	stop: function(e,ui) {
+		
+		//If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
+		var inst = $(this).data("draggable");
+		
+		$.each(inst.sortables, function() {
+			if(this.instance.isOver) {
+				this.instance.isOver = 0;
+				inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
+				this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
+				if(this.shouldRevert) this.instance.options.revert = true; //revert here
+				this.instance.mouseStop(e);
 				
-				var l = inst.snapElements[i].left, r = l + inst.snapElements[i].width, 
-					t = inst.snapElements[i].top, b = t + inst.snapElements[i].height;
+				//Also propagate receive event, since the sortable is actually receiving a element
+				this.instance.element.triggerHandler("sortreceive", [e, $.extend(this.instance.ui(), { sender: inst.element })], this.instance.options["receive"]);
+
+				this.instance.options.helper = this.instance.options._helper;
+			} else {
+				this.instance.propagate("deactivate", e, inst);
+			}
+
+		});
+		
+	},
+	drag: function(e,ui) {
+
+		var inst = $(this).data("draggable"), self = this;
+		
+		var checkPos = function(o) {
 				
-				//Yes, I know, this is insane ;)
-				if(!((l-d < x1 && x1 < r+d && t-d < y1 && y1 < b+d) || (l-d < x1 && x1 < r+d && t-d < y2 && y2 < b+d) || (l-d < x2 && x2 < r+d && t-d < y1 && y1 < b+d) || (l-d < x2 && x2 < r+d && t-d < y2 && y2 < b+d))) continue;
+			var l = o.left, r = l + o.width,
+				t = o.top, b = t + o.height;
+
+			return (l < (this.positionAbs.left + this.offset.click.left) && (this.positionAbs.left + this.offset.click.left) < r
+					&& t < (this.positionAbs.top + this.offset.click.top) && (this.positionAbs.top + this.offset.click.top) < b);				
+		};
+		
+		$.each(inst.sortables, function(i) {
+
+			if(checkPos.call(inst, this.instance.containerCache)) {
+
+				//If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
+				if(!this.instance.isOver) {
+					this.instance.isOver = 1;
+
+					//Now we fake the start of dragging for the sortable instance,
+					//by cloning the list group item, appending it to the sortable and using it as inst.currentItem
+					//We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
+					this.instance.currentItem = $(self).clone().appendTo(this.instance.element).data("sortable-item", true);
+					this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
+					this.instance.options.helper = function() { return ui.helper[0]; };
 				
-				if(ui.options.snapMode != 'inner') {
-					var ts = Math.abs(t - y2) <= 20;
-					var bs = Math.abs(b - y1) <= 20;
-					var ls = Math.abs(l - x2) <= 20;
-					var rs = Math.abs(r - x1) <= 20;
-					if(ts) ui.position.top = inst.convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
-					if(bs) ui.position.top = inst.convertPositionTo("relative", { top: b, left: 0 }).top;
-					if(ls) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
-					if(rs) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: r }).left;
-				}
+					e.target = this.instance.currentItem[0];
+					this.instance.mouseStart(e, true, true);
+
+					//Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
+					this.instance.offset.click.top = inst.offset.click.top;
+					this.instance.offset.click.left = inst.offset.click.left;
+					this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
+					this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
+					
+					inst.propagate("toSortable", e);
 				
-				if(ui.options.snapMode != 'outer') {
-					var ts = Math.abs(t - y1) <= 20;
-					var bs = Math.abs(b - y2) <= 20;
-					var ls = Math.abs(l - x1) <= 20;
-					var rs = Math.abs(r - x2) <= 20;
-					if(ts) ui.position.top = inst.convertPositionTo("relative", { top: t, left: 0 }).top;
-					if(bs) ui.position.top = inst.convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
-					if(ls) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: l }).left;
-					if(rs) ui.position.left = inst.convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
 				}
 				
-			};
-		}
-	});
-	
-	$.ui.plugin.add("draggable", "connectToSortable", {
-		start: function(e,ui) {
-		
-			var inst = $(this).data("draggable");
-			inst.sortables = [];
-			$(ui.options.connectToSortable).each(function() {
-				if($.data(this, 'sortable')) {
-					var sortable = $.data(this, 'sortable');
-					inst.sortables.push({
-						instance: sortable,
-						shouldRevert: sortable.options.revert
-					});
-					sortable.refresh();	//Do a one-time refresh at start to refresh the containerCache	
-					sortable.propagate("activate", e, inst);
-				}
-			});
-
-		},
-		stop: function(e,ui) {
-			
-			//If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
-			var inst = $(this).data("draggable");
-			
-			$.each(inst.sortables, function() {
+				//Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
+				if(this.instance.currentItem) this.instance.mouseDrag(e);
+				
+			} else {
+				
+				//If it doesn't intersect with the sortable, and it intersected before,
+				//we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
 				if(this.instance.isOver) {
 					this.instance.isOver = 0;
-					inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
-					this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
-					if(this.shouldRevert) this.instance.options.revert = true; //revert here
-					this.instance.mouseStop(e);
-					
-					//Also propagate receive event, since the sortable is actually receiving a element
-					this.instance.element.triggerHandler("sortreceive", [e, $.extend(this.instance.ui(), { sender: inst.element })], this.instance.options["receive"]);
-
+					this.instance.cancelHelperRemoval = true;
+					this.instance.options.revert = false; //No revert here
+					this.instance.mouseStop(e, true);
 					this.instance.options.helper = this.instance.options._helper;
-				} else {
-					this.instance.propagate("deactivate", e, inst);
-				}
-
-			});
-			
-		},
-		drag: function(e,ui) {
-
-			var inst = $(this).data("draggable"), self = this;
-			
-			var checkPos = function(o) {
 					
-				var l = o.left, r = l + o.width,
-					t = o.top, b = t + o.height;
-	
-				return (l < (this.positionAbs.left + this.offset.click.left) && (this.positionAbs.left + this.offset.click.left) < r
-						&& t < (this.positionAbs.top + this.offset.click.top) && (this.positionAbs.top + this.offset.click.top) < b);				
+					//Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
+					this.instance.currentItem.remove();
+					this.instance.placeholder.remove();
+					
+					inst.propagate("fromSortable", e);
+				}
+				
 			};
-			
-			$.each(inst.sortables, function(i) {
-
-				if(checkPos.call(inst, this.instance.containerCache)) {
-
-					//If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
-					if(!this.instance.isOver) {
-						this.instance.isOver = 1;
 
-						//Now we fake the start of dragging for the sortable instance,
-						//by cloning the list group item, appending it to the sortable and using it as inst.currentItem
-						//We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
-						this.instance.currentItem = $(self).clone().appendTo(this.instance.element).data("sortable-item", true);
-						this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
-						this.instance.options.helper = function() { return ui.helper[0]; };
-					
-						e.target = this.instance.currentItem[0];
-						this.instance.mouseStart(e, true, true);
+		});
 
-						//Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
-						this.instance.offset.click.top = inst.offset.click.top;
-						this.instance.offset.click.left = inst.offset.click.left;
-						this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
-						this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
-						
-						inst.propagate("toSortable", e);
-					
-					}
-					
-					//Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
-					if(this.instance.currentItem) this.instance.mouseDrag(e);
-					
-				} else {
-					
-					//If it doesn't intersect with the sortable, and it intersected before,
-					//we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
-					if(this.instance.isOver) {
-						this.instance.isOver = 0;
-						this.instance.cancelHelperRemoval = true;
-						this.instance.options.revert = false; //No revert here
-						this.instance.mouseStop(e, true);
-						this.instance.options.helper = this.instance.options._helper;
-						
-						//Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
-						this.instance.currentItem.remove();
-						this.instance.placeholder.remove();
-						
-						inst.propagate("fromSortable", e);
-					}
-					
-				};
+	}
+});
 
-			});
+$.ui.plugin.add("draggable", "stack", {
+	start: function(e,ui) {
+		var group = $.makeArray($(ui.options.stack.group)).sort(function(a,b) {
+			return (parseInt($(a).css("zIndex"),10) || ui.options.stack.min) - (parseInt($(b).css("zIndex"),10) || ui.options.stack.min);
+		});
+		
+		$(group).each(function(i) {
+			this.style.zIndex = ui.options.stack.min + i;
+		});
+		
+		this[0].style.zIndex = ui.options.stack.min + group.length;
+	}
+});
 
-		}
-	});
-	
-	$.ui.plugin.add("draggable", "stack", {
-		start: function(e,ui) {
-			var group = $.makeArray($(ui.options.stack.group)).sort(function(a,b) {
-				return (parseInt($(a).css("zIndex"),10) || ui.options.stack.min) - (parseInt($(b).css("zIndex"),10) || ui.options.stack.min);
-			});
-			
-			$(group).each(function(i) {
-				this.style.zIndex = ui.options.stack.min + i;
-			});
-			
-			this[0].style.zIndex = ui.options.stack.min + group.length;
-		}
-	});
-	
 })(jQuery);
diff --git a/ui/source/ui.droppable.js b/ui/source/ui.droppable.js
index 546eda7ff..fd664ff82 100644
--- a/ui/source/ui.droppable.js
+++ b/ui/source/ui.droppable.js
@@ -13,280 +13,279 @@
  *
  * Revision: $Id: ui.droppable.js 5568 2008-05-12 15:07:16Z paul.bakaus $
  */
-
 ;(function($) {
 
-	$.widget("ui.droppable", {
-		init: function() {
-	
-			this.element.addClass("ui-droppable");
-			this.isover = 0; this.isout = 1;
-			
-			//Prepare the passed options
-			var o = this.options, accept = o.accept;
-			o = $.extend(o, {
-				accept: o.accept && o.accept.constructor == Function ? o.accept : function(d) {
-					return $(d).is(accept);
-				}
-			});
-			
-			//Store the droppable's proportions
-			this.proportions = { width: this.element.outerWidth(), height: this.element.outerHeight() };
-			
-			// Add the reference and positions to the manager
-			$.ui.ddmanager.droppables.push(this);
-			
-		},
-		plugins: {},
-		ui: function(c) {
-			return {
-				instance: this,
-				draggable: (c.currentItem || c.element),
-				helper: c.helper,
-				position: c.position,
-				absolutePosition: c.positionAbs,
-				options: this.options,
-				element: this.element
-			};
-		},
-		destroy: function() {
-			var drop = $.ui.ddmanager.droppables;
-			for ( var i = 0; i < drop.length; i++ )
-				if ( drop[i] == this )
-					drop.splice(i, 1);
-			
-			this.element
-				.removeClass("ui-droppable ui-droppable-disabled")
-				.removeData("droppable")
-				.unbind(".droppable");
-		},
-		enable: function() {
-			this.element.removeClass("ui-droppable-disabled");
-			this.options.disabled = false;
-		},
-		disable: function() {
-			this.element.addClass("ui-droppable-disabled");
-			this.options.disabled = true;
-		},
-		over: function(e) {
-			
-			var draggable = $.ui.ddmanager.current;
-			if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
-			
-			if (this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {
-				$.ui.plugin.call(this, 'over', [e, this.ui(draggable)]);
-				this.element.triggerHandler("dropover", [e, this.ui(draggable)], this.options.over);
-			}
-			
-		},
-		out: function(e) {
-			
-			var draggable = $.ui.ddmanager.current;
-			if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
-			
-			if (this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {
-				$.ui.plugin.call(this, 'out', [e, this.ui(draggable)]);
-				this.element.triggerHandler("dropout", [e, this.ui(draggable)], this.options.out);
+$.widget("ui.droppable", {
+	init: function() {
+
+		this.element.addClass("ui-droppable");
+		this.isover = 0; this.isout = 1;
+		
+		//Prepare the passed options
+		var o = this.options, accept = o.accept;
+		o = $.extend(o, {
+			accept: o.accept && o.accept.constructor == Function ? o.accept : function(d) {
+				return $(d).is(accept);
 			}
-			
-		},
-		drop: function(e,custom) {
-			
-			var draggable = custom || $.ui.ddmanager.current;
-			if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return false; // Bail if draggable and droppable are same element
-			
-			var childrenIntersection = false;
-			this.element.find(".ui-droppable").not(".ui-draggable-dragging").each(function() {
-				var inst = $.data(this, 'droppable');
-				if(inst.options.greedy && $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)) {
-					childrenIntersection = true; return false;
-				}
-			});
-			if(childrenIntersection) return false;
-			
-			if(this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {
-				$.ui.plugin.call(this, 'drop', [e, this.ui(draggable)]);
-				this.element.triggerHandler("drop", [e, this.ui(draggable)], this.options.drop);
-				return true;
+		});
+		
+		//Store the droppable's proportions
+		this.proportions = { width: this.element.outerWidth(), height: this.element.outerHeight() };
+		
+		// Add the reference and positions to the manager
+		$.ui.ddmanager.droppables.push(this);
+		
+	},
+	plugins: {},
+	ui: function(c) {
+		return {
+			instance: this,
+			draggable: (c.currentItem || c.element),
+			helper: c.helper,
+			position: c.position,
+			absolutePosition: c.positionAbs,
+			options: this.options,
+			element: this.element
+		};
+	},
+	destroy: function() {
+		var drop = $.ui.ddmanager.droppables;
+		for ( var i = 0; i < drop.length; i++ )
+			if ( drop[i] == this )
+				drop.splice(i, 1);
+		
+		this.element
+			.removeClass("ui-droppable ui-droppable-disabled")
+			.removeData("droppable")
+			.unbind(".droppable");
+	},
+	enable: function() {
+		this.element.removeClass("ui-droppable-disabled");
+		this.options.disabled = false;
+	},
+	disable: function() {
+		this.element.addClass("ui-droppable-disabled");
+		this.options.disabled = true;
+	},
+	over: function(e) {
+		
+		var draggable = $.ui.ddmanager.current;
+		if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
+		
+		if (this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {
+			$.ui.plugin.call(this, 'over', [e, this.ui(draggable)]);
+			this.element.triggerHandler("dropover", [e, this.ui(draggable)], this.options.over);
+		}
+		
+	},
+	out: function(e) {
+		
+		var draggable = $.ui.ddmanager.current;
+		if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
+		
+		if (this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {
+			$.ui.plugin.call(this, 'out', [e, this.ui(draggable)]);
+			this.element.triggerHandler("dropout", [e, this.ui(draggable)], this.options.out);
+		}
+		
+	},
+	drop: function(e,custom) {
+		
+		var draggable = custom || $.ui.ddmanager.current;
+		if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return false; // Bail if draggable and droppable are same element
+		
+		var childrenIntersection = false;
+		this.element.find(".ui-droppable").not(".ui-draggable-dragging").each(function() {
+			var inst = $.data(this, 'droppable');
+			if(inst.options.greedy && $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)) {
+				childrenIntersection = true; return false;
 			}
-			
-			return false;
-			
-		},
-		activate: function(e) {
-			
-			var draggable = $.ui.ddmanager.current;
-			$.ui.plugin.call(this, 'activate', [e, this.ui(draggable)]);
-			if(draggable) this.element.triggerHandler("dropactivate", [e, this.ui(draggable)], this.options.activate);
-			
-		},
-		deactivate: function(e) {
-			
-			var draggable = $.ui.ddmanager.current;
-			$.ui.plugin.call(this, 'deactivate', [e, this.ui(draggable)]);
-			if(draggable) this.element.triggerHandler("dropdeactivate", [e, this.ui(draggable)], this.options.deactivate);
-			
+		});
+		if(childrenIntersection) return false;
+		
+		if(this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {
+			$.ui.plugin.call(this, 'drop', [e, this.ui(draggable)]);
+			this.element.triggerHandler("drop", [e, this.ui(draggable)], this.options.drop);
+			return true;
 		}
-	});
+		
+		return false;
+		
+	},
+	activate: function(e) {
+		
+		var draggable = $.ui.ddmanager.current;
+		$.ui.plugin.call(this, 'activate', [e, this.ui(draggable)]);
+		if(draggable) this.element.triggerHandler("dropactivate", [e, this.ui(draggable)], this.options.activate);
+		
+	},
+	deactivate: function(e) {
+		
+		var draggable = $.ui.ddmanager.current;
+		$.ui.plugin.call(this, 'deactivate', [e, this.ui(draggable)]);
+		if(draggable) this.element.triggerHandler("dropdeactivate", [e, this.ui(draggable)], this.options.deactivate);
+		
+	}
+});
+
+$.extend($.ui.droppable, {
+	defaults: {
+		disabled: false,
+		tolerance: 'intersect'
+	}
+});
+
+$.ui.intersect = function(draggable, droppable, toleranceMode) {
+	
+	if (!droppable.offset) return false;
+	
+	var x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
+		y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height;
+	var l = droppable.offset.left, r = l + droppable.proportions.width,
+		t = droppable.offset.top, b = t + droppable.proportions.height;
 	
-	$.extend($.ui.droppable, {
-		defaults: {
-			disabled: false,
-			tolerance: 'intersect'
+	switch (toleranceMode) {
+		case 'fit':
+			return (l < x1 && x2 < r
+				&& t < y1 && y2 < b);
+			break;
+		case 'intersect':
+			return (l < x1 + (draggable.helperProportions.width / 2) // Right Half
+				&& x2 - (draggable.helperProportions.width / 2) < r // Left Half
+				&& t < y1 + (draggable.helperProportions.height / 2) // Bottom Half
+				&& y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
+			break;
+		case 'pointer':
+			return (l < ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left) && ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left) < r
+				&& t < ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top) && ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top) < b);
+			break;
+		case 'touch':
+			return (
+					(y1 >= t && y1 <= b) ||	// Top edge touching
+					(y2 >= t && y2 <= b) ||	// Bottom edge touching
+					(y1 < t && y2 > b)		// Surrounded vertically
+				) && (
+					(x1 >= l && x1 <= r) ||	// Left edge touching
+					(x2 >= l && x2 <= r) ||	// Right edge touching
+					(x1 < l && x2 > r)		// Surrounded horizontally
+				);
+			break;
+		default:
+			return false;
+			break;
 		}
-	});
 	
-	$.ui.intersect = function(draggable, droppable, toleranceMode) {
+};
+
+/*
+	This manager tracks offsets of draggables and droppables
+*/
+$.ui.ddmanager = {
+	current: null,
+	droppables: [],
+	prepareOffsets: function(t, e) {
 		
-		if (!droppable.offset) return false;
+		var m = $.ui.ddmanager.droppables;
+		var type = e ? e.type : null; // workaround for #2317
+		for (var i = 0; i < m.length; i++) {
+			
+			if(m[i].options.disabled || (t && !m[i].options.accept.call(m[i].element,(t.currentItem || t.element)))) continue;
+			m[i].visible = m[i].element.is(":visible"); if(!m[i].visible) continue; //If the element is not visible, continue
+			m[i].offset = m[i].element.offset();
+			m[i].proportions = { width: m[i].element.outerWidth(), height: m[i].element.outerHeight() };
+			
+			if(type == "dragstart" || type == "sortactivate") m[i].activate.call(m[i], e); //Activate the droppable if used directly from draggables
+		}
 		
-		var x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
-			y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height;
-		var l = droppable.offset.left, r = l + droppable.proportions.width,
-			t = droppable.offset.top, b = t + droppable.proportions.height;
+	},
+	drop: function(draggable, e) {
 		
-		switch (toleranceMode) {
-			case 'fit':
-				return (l < x1 && x2 < r
-					&& t < y1 && y2 < b);
-				break;
-			case 'intersect':
-				return (l < x1 + (draggable.helperProportions.width / 2) // Right Half
-					&& x2 - (draggable.helperProportions.width / 2) < r // Left Half
-					&& t < y1 + (draggable.helperProportions.height / 2) // Bottom Half
-					&& y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
-				break;
-			case 'pointer':
-				return (l < ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left) && ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left) < r
-					&& t < ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top) && ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top) < b);
-				break;
-			case 'touch':
-				return (
-						(y1 >= t && y1 <= b) ||	// Top edge touching
-						(y2 >= t && y2 <= b) ||	// Bottom edge touching
-						(y1 < t && y2 > b)		// Surrounded vertically
-					) && (
-						(x1 >= l && x1 <= r) ||	// Left edge touching
-						(x2 >= l && x2 <= r) ||	// Right edge touching
-						(x1 < l && x2 > r)		// Surrounded horizontally
-					);
-				break;
-			default:
-				return false;
-				break;
+		var dropped = false;
+		$.each($.ui.ddmanager.droppables, function() {
+			
+			if(!this.options) return;
+			if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance))
+				dropped = this.drop.call(this, e);
+			
+			if (!this.options.disabled && this.visible && this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {
+				this.isout = 1; this.isover = 0;
+				this.deactivate.call(this, e);
 			}
+			
+		});
+		return dropped;
 		
-	};
-	
-	/*
-		This manager tracks offsets of draggables and droppables
-	*/
-	$.ui.ddmanager = {
-		current: null,
-		droppables: [],
-		prepareOffsets: function(t, e) {
+	},
+	drag: function(draggable, e) {
+		
+		//If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
+		if(draggable.options.refreshPositions) $.ui.ddmanager.prepareOffsets(draggable, e);
+		
+		//Run through all droppables and check their positions based on specific tolerance options
+		$.each($.ui.ddmanager.droppables, function() {
 			
-			var m = $.ui.ddmanager.droppables;
-			var type = e ? e.type : null; // workaround for #2317
-			for (var i = 0; i < m.length; i++) {
-				
-				if(m[i].options.disabled || (t && !m[i].options.accept.call(m[i].element,(t.currentItem || t.element)))) continue;
-				m[i].visible = m[i].element.is(":visible"); if(!m[i].visible) continue; //If the element is not visible, continue
-				m[i].offset = m[i].element.offset();
-				m[i].proportions = { width: m[i].element.outerWidth(), height: m[i].element.outerHeight() };
-				
-				if(type == "dragstart" || type == "sortactivate") m[i].activate.call(m[i], e); //Activate the droppable if used directly from draggables
-			}
+			if(this.disabled || this.greedyChild || !this.visible) return;
+			var intersects = $.ui.intersect(draggable, this, this.options.tolerance);
 			
-		},
-		drop: function(draggable, e) {
+			var c = !intersects && this.isover == 1 ? 'isout' : (intersects && this.isover == 0 ? 'isover' : null);
+			if(!c) return;
 			
-			var dropped = false;
-			$.each($.ui.ddmanager.droppables, function() {
-				
-				if(!this.options) return;
-				if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance))
-					dropped = this.drop.call(this, e);
-				
-				if (!this.options.disabled && this.visible && this.options.accept.call(this.element,(draggable.currentItem || draggable.element))) {
-					this.isout = 1; this.isover = 0;
-					this.deactivate.call(this, e);
+			var parentInstance;
+			if (this.options.greedy) {
+				var parent = this.element.parents('.ui-droppable:eq(0)');
+				if (parent.length) {
+					parentInstance = $.data(parent[0], 'droppable');
+					parentInstance.greedyChild = (c == 'isover' ? 1 : 0);
 				}
-				
-			});
-			return dropped;
+			}
 			
-		},
-		drag: function(draggable, e) {
+			// we just moved into a greedy child
+			if (parentInstance && c == 'isover') {
+				parentInstance['isover'] = 0;
+				parentInstance['isout'] = 1;
+				parentInstance.out.call(parentInstance, e);
+			}
 			
-			//If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
-			if(draggable.options.refreshPositions) $.ui.ddmanager.prepareOffsets(draggable, e);
+			this[c] = 1; this[c == 'isout' ? 'isover' : 'isout'] = 0;
+			this[c == "isover" ? "over" : "out"].call(this, e);
 			
-			//Run through all droppables and check their positions based on specific tolerance options
-			$.each($.ui.ddmanager.droppables, function() {
-				
-				if(this.disabled || this.greedyChild || !this.visible) return;
-				var intersects = $.ui.intersect(draggable, this, this.options.tolerance);
-				
-				var c = !intersects && this.isover == 1 ? 'isout' : (intersects && this.isover == 0 ? 'isover' : null);
-				if(!c) return;
-				
-				var parentInstance;
-				if (this.options.greedy) {
-					var parent = this.element.parents('.ui-droppable:eq(0)');
-					if (parent.length) {
-						parentInstance = $.data(parent[0], 'droppable');
-						parentInstance.greedyChild = (c == 'isover' ? 1 : 0);
-					}
-				}
-				
-				// we just moved into a greedy child
-				if (parentInstance && c == 'isover') {
-					parentInstance['isover'] = 0;
-					parentInstance['isout'] = 1;
-					parentInstance.out.call(parentInstance, e);
-				}
-				
-				this[c] = 1; this[c == 'isout' ? 'isover' : 'isout'] = 0;
-				this[c == "isover" ? "over" : "out"].call(this, e);
-				
-				// we just moved out of a greedy child
-				if (parentInstance && c == 'isout') {
-					parentInstance['isout'] = 0;
-					parentInstance['isover'] = 1;
-					parentInstance.over.call(parentInstance, e);
-				}
-			});
-			
-		}
-	};
-	
+			// we just moved out of a greedy child
+			if (parentInstance && c == 'isout') {
+				parentInstance['isout'] = 0;
+				parentInstance['isover'] = 1;
+				parentInstance.over.call(parentInstance, e);
+			}
+		});
+		
+	}
+};
+
 /*
  * Droppable Extensions
  */
-	
-	$.ui.plugin.add("droppable", "activeClass", {
-		activate: function(e, ui) {
-			$(this).addClass(ui.options.activeClass);
-		},
-		deactivate: function(e, ui) {
-			$(this).removeClass(ui.options.activeClass);
-		},
-		drop: function(e, ui) {
-			$(this).removeClass(ui.options.activeClass);
-		}
-	});
-	
-	$.ui.plugin.add("droppable", "hoverClass", {
-		over: function(e, ui) {
-			$(this).addClass(ui.options.hoverClass);
-		},
-		out: function(e, ui) {
-			$(this).removeClass(ui.options.hoverClass);
-		},
-		drop: function(e, ui) {
-			$(this).removeClass(ui.options.hoverClass);
-		}
-	});
- 
+
+$.ui.plugin.add("droppable", "activeClass", {
+	activate: function(e, ui) {
+		$(this).addClass(ui.options.activeClass);
+	},
+	deactivate: function(e, ui) {
+		$(this).removeClass(ui.options.activeClass);
+	},
+	drop: function(e, ui) {
+		$(this).removeClass(ui.options.activeClass);
+	}
+});
+
+$.ui.plugin.add("droppable", "hoverClass", {
+	over: function(e, ui) {
+		$(this).addClass(ui.options.hoverClass);
+	},
+	out: function(e, ui) {
+		$(this).removeClass(ui.options.hoverClass);
+	},
+	drop: function(e, ui) {
+		$(this).removeClass(ui.options.hoverClass);
+	}
+});
+
 })(jQuery);
diff --git a/ui/source/ui.resizable.js b/ui/source/ui.resizable.js
index 10a2ce2f5..286f61d7f 100644
--- a/ui/source/ui.resizable.js
+++ b/ui/source/ui.resizable.js
@@ -13,722 +13,722 @@
  * Revision: $Id: ui.resizable.js 5668 2008-05-22 18:17:30Z rdworth $
  */
 ;(function($) {
-	
-	$.widget("ui.resizable", $.extend($.ui.mouse, {
-		init: function() {
 
-			var self = this, o = this.options;
+$.widget("ui.resizable", $.extend($.ui.mouse, {
+	init: function() {
+
+		var self = this, o = this.options;
 
-			var elpos = this.element.css('position');
+		var elpos = this.element.css('position');
+		
+		// simulate .ui-resizable { position: relative; }
+		this.element.addClass("ui-resizable").css({ position: /static/.test(elpos) ? 'relative' : elpos });
+		
+		$.extend(o, {
+			_aspectRatio: !!(o.aspectRatio),
+			proxy: o.proxy || o.ghost || o.animate ? o.proxy || 'proxy' : null,
+			knobHandles: o.knobHandles === true ? 'ui-resizable-knob-handle' : o.knobHandles
+		});
+		
+		//Default Theme
+		var aBorder = '1px solid #DEDEDE';
+		
+		o.defaultTheme = {
+			'ui-resizable': { display: 'block' },
+			'ui-resizable-handle': { position: 'absolute', background: '#F2F2F2', fontSize: '0.1px' },
+			'ui-resizable-n': { cursor: 'n-resize', height: '4px', left: '0px', right: '0px', borderTop: aBorder },
+			'ui-resizable-s': { cursor: 's-resize', height: '4px', left: '0px', right: '0px', borderBottom: aBorder },
+			'ui-resizable-e': { cursor: 'e-resize', width: '4px', top: '0px', bottom: '0px', borderRight: aBorder },
+			'ui-resizable-w': { cursor: 'w-resize', width: '4px', top: '0px', bottom: '0px', borderLeft: aBorder },
+			'ui-resizable-se': { cursor: 'se-resize', width: '4px', height: '4px', borderRight: aBorder, borderBottom: aBorder },
+			'ui-resizable-sw': { cursor: 'sw-resize', width: '4px', height: '4px', borderBottom: aBorder, borderLeft: aBorder },
+			'ui-resizable-ne': { cursor: 'ne-resize', width: '4px', height: '4px', borderRight: aBorder, borderTop: aBorder },
+			'ui-resizable-nw': { cursor: 'nw-resize', width: '4px', height: '4px', borderLeft: aBorder, borderTop: aBorder }
+		};
+		
+		o.knobTheme = {
+			'ui-resizable-handle': { background: '#F2F2F2', border: '1px solid #808080', height: '8px', width: '8px' },
+			'ui-resizable-n': { cursor: 'n-resize', top: '0px', left: '45%' },
+			'ui-resizable-s': { cursor: 's-resize', bottom: '0px', left: '45%' },
+			'ui-resizable-e': { cursor: 'e-resize', right: '0px', top: '45%' },
+			'ui-resizable-w': { cursor: 'w-resize', left: '0px', top: '45%' },
+			'ui-resizable-se': { cursor: 'se-resize', right: '0px', bottom: '0px' },
+			'ui-resizable-sw': { cursor: 'sw-resize', left: '0px', bottom: '0px' },
+			'ui-resizable-nw': { cursor: 'nw-resize', left: '0px', top: '0px' },
+			'ui-resizable-ne': { cursor: 'ne-resize', right: '0px', top: '0px' }
+		};
+		
+		o._nodeName = this.element[0].nodeName;
+		
+		//Wrap the element if it cannot hold child nodes
+		if(o._nodeName.match(/canvas|textarea|input|select|button|img/i)) {
+			var el = this.element;
 			
-			// simulate .ui-resizable { position: relative; }
-			this.element.addClass("ui-resizable").css({ position: /static/.test(elpos) ? 'relative' : elpos });
+			//Opera fixing relative position
+			if (/relative/.test(el.css('position')) && $.browser.opera)
+				el.css({ position: 'relative', top: 'auto', left: 'auto' });
+			
+			//Create a wrapper element and set the wrapper to the new current internal element
+			el.wrap(
+				$('<div class="ui-wrapper"	style="overflow: hidden;"></div>').css( {
+					position: el.css('position'),
+					width: el.outerWidth(),
+					height: el.outerHeight(),
+					top: el.css('top'),
+					left: el.css('left')
+				})
+			);
 			
-			$.extend(o, {
-				_aspectRatio: !!(o.aspectRatio),
-				proxy: o.proxy || o.ghost || o.animate ? o.proxy || 'proxy' : null,
-				knobHandles: o.knobHandles === true ? 'ui-resizable-knob-handle' : o.knobHandles
+			var oel = this.element; this.element = this.element.parent();
+			
+			//Move margins to the wrapper
+			this.element.css({ marginLeft: oel.css("marginLeft"), marginTop: oel.css("marginTop"),
+				marginRight: oel.css("marginRight"), marginBottom: oel.css("marginBottom")
 			});
 			
-			//Default Theme
-			var aBorder = '1px solid #DEDEDE';
+			oel.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
 			
-			o.defaultTheme = {
-				'ui-resizable': { display: 'block' },
-				'ui-resizable-handle': { position: 'absolute', background: '#F2F2F2', fontSize: '0.1px' },
-				'ui-resizable-n': { cursor: 'n-resize', height: '4px', left: '0px', right: '0px', borderTop: aBorder },
-				'ui-resizable-s': { cursor: 's-resize', height: '4px', left: '0px', right: '0px', borderBottom: aBorder },
-				'ui-resizable-e': { cursor: 'e-resize', width: '4px', top: '0px', bottom: '0px', borderRight: aBorder },
-				'ui-resizable-w': { cursor: 'w-resize', width: '4px', top: '0px', bottom: '0px', borderLeft: aBorder },
-				'ui-resizable-se': { cursor: 'se-resize', width: '4px', height: '4px', borderRight: aBorder, borderBottom: aBorder },
-				'ui-resizable-sw': { cursor: 'sw-resize', width: '4px', height: '4px', borderBottom: aBorder, borderLeft: aBorder },
-				'ui-resizable-ne': { cursor: 'ne-resize', width: '4px', height: '4px', borderRight: aBorder, borderTop: aBorder },
-				'ui-resizable-nw': { cursor: 'nw-resize', width: '4px', height: '4px', borderLeft: aBorder, borderTop: aBorder }
-			};
+			//Prevent Safari textarea resize
+			if ($.browser.safari && o.preventDefault) oel.css('resize', 'none');
 			
-			o.knobTheme = {
-				'ui-resizable-handle': { background: '#F2F2F2', border: '1px solid #808080', height: '8px', width: '8px' },
-				'ui-resizable-n': { cursor: 'n-resize', top: '0px', left: '45%' },
-				'ui-resizable-s': { cursor: 's-resize', bottom: '0px', left: '45%' },
-				'ui-resizable-e': { cursor: 'e-resize', right: '0px', top: '45%' },
-				'ui-resizable-w': { cursor: 'w-resize', left: '0px', top: '45%' },
-				'ui-resizable-se': { cursor: 'se-resize', right: '0px', bottom: '0px' },
-				'ui-resizable-sw': { cursor: 'sw-resize', left: '0px', bottom: '0px' },
-				'ui-resizable-nw': { cursor: 'nw-resize', left: '0px', top: '0px' },
-				'ui-resizable-ne': { cursor: 'ne-resize', right: '0px', top: '0px' }
-			};
+			o.proportionallyResize = oel.css({ position: 'static', zoom: 1, display: 'block' });
 			
-			o._nodeName = this.element[0].nodeName;
+			// avoid IE jump
+			this.element.css({ margin: oel.css('margin') });
 			
-			//Wrap the element if it cannot hold child nodes
-			if(o._nodeName.match(/canvas|textarea|input|select|button|img/i)) {
-				var el = this.element;
-				
-				//Opera fixing relative position
-				if (/relative/.test(el.css('position')) && $.browser.opera)
-					el.css({ position: 'relative', top: 'auto', left: 'auto' });
-				
-				//Create a wrapper element and set the wrapper to the new current internal element
-				el.wrap(
-					$('<div class="ui-wrapper"	style="overflow: hidden;"></div>').css( {
-						position: el.css('position'),
-						width: el.outerWidth(),
-						height: el.outerHeight(),
-						top: el.css('top'),
-						left: el.css('left')
-					})
-				);
-				
-				var oel = this.element; this.element = this.element.parent();
-				
-				//Move margins to the wrapper
-				this.element.css({ marginLeft: oel.css("marginLeft"), marginTop: oel.css("marginTop"),
-					marginRight: oel.css("marginRight"), marginBottom: oel.css("marginBottom")
-				});
-				
-				oel.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0});
-				
-				//Prevent Safari textarea resize
-				if ($.browser.safari && o.preventDefault) oel.css('resize', 'none');
+			// fix handlers offset
+			this._proportionallyResize();
+		}
+		
+		if(!o.handles) o.handles = !$('.ui-resizable-handle', this.element).length ? "e,s,se" : { n: '.ui-resizable-n', e: '.ui-resizable-e', s: '.ui-resizable-s', w: '.ui-resizable-w', se: '.ui-resizable-se', sw: '.ui-resizable-sw', ne: '.ui-resizable-ne', nw: '.ui-resizable-nw' };
+		if(o.handles.constructor == String) {
+			
+			o.zIndex = o.zIndex || 1000;
+			
+			if(o.handles == 'all') o.handles = 'n,e,s,w,se,sw,ne,nw';
+			
+			var n = o.handles.split(","); o.handles = {};
+			
+			// insertions are applied when don't have theme loaded
+			var insertionsDefault = {
+				handle: 'position: absolute; display: none; overflow:hidden;',
+				n: 'top: 0pt; width:100%;',
+				e: 'right: 0pt; height:100%;',
+				s: 'bottom: 0pt; width:100%;',
+				w: 'left: 0pt; height:100%;',
+				se: 'bottom: 0pt; right: 0px;',
+				sw: 'bottom: 0pt; left: 0px;',
+				ne: 'top: 0pt; right: 0px;',
+				nw: 'top: 0pt; left: 0px;'
+			};
+			
+			for(var i = 0; i < n.length; i++) {
+				var handle = $.trim(n[i]), dt = o.defaultTheme, hname = 'ui-resizable-'+handle, loadDefault = !$.ui.css(hname) && !o.knobHandles, userKnobClass = $.ui.css('ui-resizable-knob-handle'), 
+							allDefTheme = $.extend(dt[hname], dt['ui-resizable-handle']), allKnobTheme = $.extend(o.knobTheme[hname], !userKnobClass ? o.knobTheme['ui-resizable-handle'] : {});
 				
-				o.proportionallyResize = oel.css({ position: 'static', zoom: 1, display: 'block' });
+				// increase zIndex of sw, se, ne, nw axis
+				var applyZIndex = /sw|se|ne|nw/.test(handle) ? { zIndex: ++o.zIndex } : {};
 				
-				// avoid IE jump
-				this.element.css({ margin: oel.css('margin') });
+				var defCss = (loadDefault ? insertionsDefault[handle] : ''), 
+					axis = $(['<div class="ui-resizable-handle ', hname, '" style="', defCss, insertionsDefault.handle, '"></div>'].join('')).css( applyZIndex );
+				o.handles[handle] = '.ui-resizable-'+handle;
 				
-				// fix handlers offset
-				this._proportionallyResize();
+				this.element.append(
+					//Theme detection, if not loaded, load o.defaultTheme
+					axis.css( loadDefault ? allDefTheme : {} )
+						// Load the knobHandle css, fix width, height, top, left...
+						.css( o.knobHandles ? allKnobTheme : {} ).addClass(o.knobHandles ? 'ui-resizable-knob-handle' : '').addClass(o.knobHandles)
+				);
 			}
 			
-			if(!o.handles) o.handles = !$('.ui-resizable-handle', this.element).length ? "e,s,se" : { n: '.ui-resizable-n', e: '.ui-resizable-e', s: '.ui-resizable-s', w: '.ui-resizable-w', se: '.ui-resizable-se', sw: '.ui-resizable-sw', ne: '.ui-resizable-ne', nw: '.ui-resizable-nw' };
-			if(o.handles.constructor == String) {
-				
-				o.zIndex = o.zIndex || 1000;
-				
-				if(o.handles == 'all') o.handles = 'n,e,s,w,se,sw,ne,nw';
-				
-				var n = o.handles.split(","); o.handles = {};
+			if (o.knobHandles) this.element.addClass('ui-resizable-knob').css( !$.ui.css('ui-resizable-knob') ? { /*border: '1px #fff dashed'*/ } : {} );
+		}
+		
+		this._renderAxis = function(target) {
+			target = target || this.element;
+			
+			for(var i in o.handles) {
+				if(o.handles[i].constructor == String) 
+					o.handles[i] = $(o.handles[i], this.element).show();
 				
-				// insertions are applied when don't have theme loaded
-				var insertionsDefault = {
-					handle: 'position: absolute; display: none; overflow:hidden;',
-					n: 'top: 0pt; width:100%;',
-					e: 'right: 0pt; height:100%;',
-					s: 'bottom: 0pt; width:100%;',
-					w: 'left: 0pt; height:100%;',
-					se: 'bottom: 0pt; right: 0px;',
-					sw: 'bottom: 0pt; left: 0px;',
-					ne: 'top: 0pt; right: 0px;',
-					nw: 'top: 0pt; left: 0px;'
-				};
+				if (o.transparent)
+					o.handles[i].css({opacity:0});
 				
-				for(var i = 0; i < n.length; i++) {
-					var handle = $.trim(n[i]), dt = o.defaultTheme, hname = 'ui-resizable-'+handle, loadDefault = !$.ui.css(hname) && !o.knobHandles, userKnobClass = $.ui.css('ui-resizable-knob-handle'), 
-								allDefTheme = $.extend(dt[hname], dt['ui-resizable-handle']), allKnobTheme = $.extend(o.knobTheme[hname], !userKnobClass ? o.knobTheme['ui-resizable-handle'] : {});
+				//Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
+				if (this.element.is('.ui-wrapper') && 
+					o._nodeName.match(/textarea|input|select|button/i)) {
 					
-					// increase zIndex of sw, se, ne, nw axis
-					var applyZIndex = /sw|se|ne|nw/.test(handle) ? { zIndex: ++o.zIndex } : {};
+					var axis = $(o.handles[i], this.element), padWrapper = 0;
 					
-					var defCss = (loadDefault ? insertionsDefault[handle] : ''), 
-						axis = $(['<div class="ui-resizable-handle ', hname, '" style="', defCss, insertionsDefault.handle, '"></div>'].join('')).css( applyZIndex );
-					o.handles[handle] = '.ui-resizable-'+handle;
+					//Checking the correct pad and border
+					padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
 					
-					this.element.append(
-						//Theme detection, if not loaded, load o.defaultTheme
-						axis.css( loadDefault ? allDefTheme : {} )
-							// Load the knobHandle css, fix width, height, top, left...
-							.css( o.knobHandles ? allKnobTheme : {} ).addClass(o.knobHandles ? 'ui-resizable-knob-handle' : '').addClass(o.knobHandles)
-					);
-				}
-				
-				if (o.knobHandles) this.element.addClass('ui-resizable-knob').css( !$.ui.css('ui-resizable-knob') ? { /*border: '1px #fff dashed'*/ } : {} );
-			}
-			
-			this._renderAxis = function(target) {
-				target = target || this.element;
-				
-				for(var i in o.handles) {
-					if(o.handles[i].constructor == String) 
-						o.handles[i] = $(o.handles[i], this.element).show();
+					//The padding type i have to apply...
+					var padPos = [ 'padding', 
+						/ne|nw|n/.test(i) ? 'Top' :
+						/se|sw|s/.test(i) ? 'Bottom' : 
+						/^e$/.test(i) ? 'Right' : 'Left' ].join(""); 
 					
-					if (o.transparent)
-						o.handles[i].css({opacity:0});
+					if (!o.transparent)
+						target.css(padPos, padWrapper);
 					
-					//Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
-					if (this.element.is('.ui-wrapper') && 
-						o._nodeName.match(/textarea|input|select|button/i)) {
-						
-						var axis = $(o.handles[i], this.element), padWrapper = 0;
-						
-						//Checking the correct pad and border
-						padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
-						
-						//The padding type i have to apply...
-						var padPos = [ 'padding', 
-							/ne|nw|n/.test(i) ? 'Top' :
-							/se|sw|s/.test(i) ? 'Bottom' : 
-							/^e$/.test(i) ? 'Right' : 'Left' ].join(""); 
-						
-						if (!o.transparent)
-							target.css(padPos, padWrapper);
-						
-						this._proportionallyResize();
-					}
-					if(!$(o.handles[i]).length) continue;
+					this._proportionallyResize();
 				}
-			};
-			
-			this._renderAxis(this.element);
-			o._handles = $('.ui-resizable-handle', self.element);
-			
-			if (o.disableSelection)
-				o._handles.each(function(i, e) { $.ui.disableSelection(e); });
-			
-			//Matching axis name
-			o._handles.mouseover(function() {
+				if(!$(o.handles[i]).length) continue;
+			}
+		};
+		
+		this._renderAxis(this.element);
+		o._handles = $('.ui-resizable-handle', self.element);
+		
+		if (o.disableSelection)
+			o._handles.each(function(i, e) { $.ui.disableSelection(e); });
+		
+		//Matching axis name
+		o._handles.mouseover(function() {
+			if (!o.resizing) {
+				if (this.className) 
+					var axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
+				//Axis, default = se
+				self.axis = o.axis = axis && axis[1] ? axis[1] : 'se';
+			}
+		});
+		
+		//If we want to auto hide the elements
+		if (o.autohide) {
+			o._handles.hide();
+			$(self.element).addClass("ui-resizable-autohide").hover(function() {
+				$(this).removeClass("ui-resizable-autohide");
+				o._handles.show();
+			},
+			function(){
 				if (!o.resizing) {
-					if (this.className) 
-						var axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
-					//Axis, default = se
-					self.axis = o.axis = axis && axis[1] ? axis[1] : 'se';
+					$(this).addClass("ui-resizable-autohide");
+					o._handles.hide();
 				}
 			});
+		}
+		
+		this.mouseInit();
+	},
+	plugins: {},
+	ui: function() {
+		return {
+			axis: this.options.axis,
+			options: this.options
+		};
+	},
+	propagate: function(n,e) {
+		$.ui.plugin.call(this, n, [e, this.ui()]);
+		this.element.triggerHandler(n == "resize" ? n : ["resize", n].join(""), [e, this.ui()], this.options[n]);
+	},
+	destroy: function() {
+		var el = this.element, wrapped = el.children(".ui-resizable").get(0);
+		
+		this.mouseDestroy();
+		
+		var _destroy = function(exp) {
+			$(exp).removeClass("ui-resizable ui-resizable-disabled")
+				.removeData("resizable").unbind(".resizable").find('.ui-resizable-handle').remove();
+		};
+		
+		_destroy(el);
+		
+		if (el.is('.ui-wrapper') && wrapped) {
+			el.parent().append(
+				$(wrapped).css({
+					position: el.css('position'),
+					width: el.outerWidth(),
+					height: el.outerHeight(),
+					top: el.css('top'),
+					left: el.css('left')
+				})
+			).end().remove();
+			
+			_destroy(wrapped);
+		}
+	},
+	enable: function() {
+		this.element.removeClass("ui-resizable-disabled");
+		this.options.disabled = false;
+	},
+	disable: function() {
+		this.element.addClass("ui-resizable-disabled");
+		this.options.disabled = true;
+	},
+	mouseStart: function(e) {
+		if(this.options.disabled) return false;
+		
+		var handle = false;
+		for(var i in this.options.handles) {
+			if($(this.options.handles[i])[0] == e.target) handle = true;
+		}
+		if (!handle) return false;
+		
+		var o = this.options, iniPos = this.element.position(), el = this.element, 
+			num = function(v) { return parseInt(v, 10) || 0; }, ie6 = $.browser.msie && $.browser.version < 7;
+		o.resizing = true;
+		o.documentScroll = { top: $(document).scrollTop(), left: $(document).scrollLeft() };
+		
+		// bugfix #1749
+		if (el.is('.ui-draggable') || (/absolute/).test(el.css('position'))) {
 			
-			//If we want to auto hide the elements
-			if (o.autohide) {
-				o._handles.hide();
-				$(self.element).addClass("ui-resizable-autohide").hover(function() {
-					$(this).removeClass("ui-resizable-autohide");
-					o._handles.show();
-				},
-				function(){
-					if (!o.resizing) {
-						$(this).addClass("ui-resizable-autohide");
-						o._handles.hide();
-					}
-				});
-			}
-			
-			this.mouseInit();
-		},
-		plugins: {},
-		ui: function() {
-			return {
-				axis: this.options.axis,
-				options: this.options
-			};
-		},
-		propagate: function(n,e) {
-			$.ui.plugin.call(this, n, [e, this.ui()]);
-			this.element.triggerHandler(n == "resize" ? n : ["resize", n].join(""), [e, this.ui()], this.options[n]);
-		},
-		destroy: function() {
-			var el = this.element, wrapped = el.children(".ui-resizable").get(0);
-			
-			this.mouseDestroy();
-			
-			var _destroy = function(exp) {
-				$(exp).removeClass("ui-resizable ui-resizable-disabled")
-					.removeData("resizable").unbind(".resizable").find('.ui-resizable-handle').remove();
-			};
-			
-			_destroy(el);
-			
-			if (el.is('.ui-wrapper') && wrapped) {
-				el.parent().append(
-					$(wrapped).css({
-						position: el.css('position'),
-						width: el.outerWidth(),
-						height: el.outerHeight(),
-						top: el.css('top'),
-						left: el.css('left')
-					})
-				).end().remove();
-				
-				_destroy(wrapped);
-			}
-		},
-		enable: function() {
-			this.element.removeClass("ui-resizable-disabled");
-			this.options.disabled = false;
-		},
-		disable: function() {
-			this.element.addClass("ui-resizable-disabled");
-			this.options.disabled = true;
-		},
-		mouseStart: function(e) {
-			if(this.options.disabled) return false;
-			
-			var handle = false;
-			for(var i in this.options.handles) {
-				if($(this.options.handles[i])[0] == e.target) handle = true;
-			}
-			if (!handle) return false;
-			
-			var o = this.options, iniPos = this.element.position(), el = this.element, 
-				num = function(v) { return parseInt(v, 10) || 0; }, ie6 = $.browser.msie && $.browser.version < 7;
-			o.resizing = true;
-			o.documentScroll = { top: $(document).scrollTop(), left: $(document).scrollLeft() };
-			
-			// bugfix #1749
-			if (el.is('.ui-draggable') || (/absolute/).test(el.css('position'))) {
-				
-				// sOffset decides if document scrollOffset will be added to the top/left of the resizable element
-				var sOffset = $.browser.msie && !o.containment && (/absolute/).test(el.css('position')) && !(/relative/).test(el.parent().css('position'));
-				var dscrollt = sOffset ? o.documentScroll.top : 0, dscrolll = sOffset ? o.documentScroll.left : 0;
-				
-				el.css({ position: 'absolute', top: (iniPos.top + dscrollt), left: (iniPos.left + dscrolll) });
-			}
-			
-			//Opera fixing relative position
-			if ($.browser.opera && /relative/.test(el.css('position')))
-				el.css({ position: 'relative', top: 'auto', left: 'auto' });
-			
-			this._renderProxy();
-			
-			var curleft = num(this.helper.css('left')), curtop = num(this.helper.css('top'));
-			
-			//Store needed variables
-			this.offset = this.helper.offset();
-			this.position = { left: curleft, top: curtop };
-			this.size = o.proxy || ie6 ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
-			this.originalSize = o.proxy || ie6 ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
-			this.originalPosition = { left: curleft, top: curtop };
-			this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
-			this.originalMousePosition = { left: e.pageX, top: e.pageY };
-			
-			//Aspect Ratio
-			o.aspectRatio = (typeof o.aspectRatio == 'number') ? o.aspectRatio : ((this.originalSize.height / this.originalSize.width)||1);
-			
-			if (o.preserveCursor)
-				$('body').css('cursor', this.axis + '-resize');
-				
-			this.propagate("start", e);
-			return true;
-		},
-		mouseDrag: function(e) {
-			
-			//Increase performance, avoid regex
-			var el = this.helper, o = this.options, props = {},
-				self = this, smp = this.originalMousePosition, a = this.axis;
+			// sOffset decides if document scrollOffset will be added to the top/left of the resizable element
+			var sOffset = $.browser.msie && !o.containment && (/absolute/).test(el.css('position')) && !(/relative/).test(el.parent().css('position'));
+			var dscrollt = sOffset ? o.documentScroll.top : 0, dscrolll = sOffset ? o.documentScroll.left : 0;
 			
-			var dx = (e.pageX-smp.left)||0, dy = (e.pageY-smp.top)||0;
-			var trigger = this._change[a];
-			if (!trigger) return false;
+			el.css({ position: 'absolute', top: (iniPos.top + dscrollt), left: (iniPos.left + dscrolll) });
+		}
+		
+		//Opera fixing relative position
+		if ($.browser.opera && /relative/.test(el.css('position')))
+			el.css({ position: 'relative', top: 'auto', left: 'auto' });
+		
+		this._renderProxy();
+		
+		var curleft = num(this.helper.css('left')), curtop = num(this.helper.css('top'));
+		
+		//Store needed variables
+		this.offset = this.helper.offset();
+		this.position = { left: curleft, top: curtop };
+		this.size = o.proxy || ie6 ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
+		this.originalSize = o.proxy || ie6 ? { width: el.outerWidth(), height: el.outerHeight() } : { width: el.width(), height: el.height() };
+		this.originalPosition = { left: curleft, top: curtop };
+		this.sizeDiff = { width: el.outerWidth() - el.width(), height: el.outerHeight() - el.height() };
+		this.originalMousePosition = { left: e.pageX, top: e.pageY };
+		
+		//Aspect Ratio
+		o.aspectRatio = (typeof o.aspectRatio == 'number') ? o.aspectRatio : ((this.originalSize.height / this.originalSize.width)||1);
+		
+		if (o.preserveCursor)
+			$('body').css('cursor', this.axis + '-resize');
 			
-			// Calculate the attrs that will be change
-			var data = trigger.apply(this, [e, dx, dy]), ie6 = $.browser.msie && $.browser.version < 7, csdif = this.sizeDiff;
+		this.propagate("start", e);
+		return true;
+	},
+	mouseDrag: function(e) {
+		
+		//Increase performance, avoid regex
+		var el = this.helper, o = this.options, props = {},
+			self = this, smp = this.originalMousePosition, a = this.axis;
+		
+		var dx = (e.pageX-smp.left)||0, dy = (e.pageY-smp.top)||0;
+		var trigger = this._change[a];
+		if (!trigger) return false;
+		
+		// Calculate the attrs that will be change
+		var data = trigger.apply(this, [e, dx, dy]), ie6 = $.browser.msie && $.browser.version < 7, csdif = this.sizeDiff;
+		
+		if (o._aspectRatio || e.shiftKey)
+			data = this._updateRatio(data, e);
+		
+		data = this._respectSize(data, e);
+		
+		this.propagate("resize", e);
+		
+		el.css({
+			top: this.position.top + "px", left: this.position.left + "px", 
+			width: this.size.width + "px", height: this.size.height + "px"
+		});
+		
+		if (!o.proxy && o.proportionallyResize)
+			this._proportionallyResize();
+		
+		this._updateCache(data);
+		
+		return false;
+	},
+	mouseStop: function(e) {
+		
+		this.options.resizing = false;
+		var o = this.options, num = function(v) { return parseInt(v, 10) || 0; }, self = this;
+		
+		if(o.proxy) {
+			var pr = o.proportionallyResize, ista = pr && (/textarea/i).test(pr.get(0).nodeName), 
+						soffseth = ista && $.ui.hasScroll(pr.get(0), 'left') /* TODO - jump height */ ? 0 : self.sizeDiff.height,
+							soffsetw = ista ? 0 : self.sizeDiff.width;
 			
-			if (o._aspectRatio || e.shiftKey)
-				data = this._updateRatio(data, e);
+			var s = { width: (self.size.width - soffsetw), height: (self.size.height - soffseth) },
+				left = (parseInt(self.element.css('left'), 10) + (self.position.left - self.originalPosition.left)) || null, 
+				top = (parseInt(self.element.css('top'), 10) + (self.position.top - self.originalPosition.top)) || null;
 			
-			data = this._respectSize(data, e);
+			if (!o.animate)
+				this.element.css($.extend(s, { top: top, left: left }));
 			
-			this.propagate("resize", e);
+			if (o.proxy && !o.animate) this._proportionallyResize();
+			this.helper.remove();
+		}
+		
+		if (o.preserveCursor)
+		$('body').css('cursor', 'auto');
+		
+		this.propagate("stop", e);	
+		return false;
+	},
+	_updateCache: function(data) {
+		var o = this.options;
+		this.offset = this.helper.offset();
+		if (data.left) this.position.left = data.left;
+		if (data.top) this.position.top = data.top;
+		if (data.height) this.size.height = data.height;
+		if (data.width) this.size.width = data.width;
+	},
+	_updateRatio: function(data, e) {
+		var o = this.options, cpos = this.position, csize = this.size, a = this.axis;
+		
+		if (data.height) data.width = (csize.height / o.aspectRatio);
+		else if (data.width) data.height = (csize.width * o.aspectRatio);
+		
+		if (a == 'sw') {
+			data.left = cpos.left + (csize.width - data.width);
+			data.top = null;
+		}
+		if (a == 'nw') { 
+			data.top = cpos.top + (csize.height - data.height);
+			data.left = cpos.left + (csize.width - data.width);
+		}
+		
+		return data;
+	},
+	_respectSize: function(data, e) {
+		
+		var el = this.helper, o = this.options, pRatio = o._aspectRatio || e.shiftKey, a = this.axis, 
+				ismaxw = data.width && o.maxWidth && o.maxWidth < data.width, ismaxh = data.height && o.maxHeight && o.maxHeight < data.height,
+					isminw = data.width && o.minWidth && o.minWidth > data.width, isminh = data.height && o.minHeight && o.minHeight > data.height;
+		
+		if (isminw) data.width = o.minWidth;
+		if (isminh) data.height = o.minHeight;
+		if (ismaxw) data.width = o.maxWidth;
+		if (ismaxh) data.height = o.maxHeight;
+		
+		var dw = this.originalPosition.left + this.originalSize.width, dh = this.position.top + this.size.height;
+		var cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
+		
+		if (isminw && cw) data.left = dw - o.minWidth;
+		if (ismaxw && cw) data.left = dw - o.maxWidth;
+		if (isminh && ch)	data.top = dh - o.minHeight;
+		if (ismaxh && ch)	data.top = dh - o.maxHeight;
+		
+		// fixing jump error on top/left - bug #2330
+		var isNotwh = !data.width && !data.height;
+		if (isNotwh && !data.left && data.top) data.top = null;
+		else if (isNotwh && !data.top && data.left) data.left = null;
+		
+		return data;
+	},
+	_proportionallyResize: function() {
+		var o = this.options;
+		if (!o.proportionallyResize) return;
+		var prel = o.proportionallyResize, el = this.helper || this.element;
+		
+		if (!o.borderDif) {
+			var b = [prel.css('borderTopWidth'), prel.css('borderRightWidth'), prel.css('borderBottomWidth'), prel.css('borderLeftWidth')],
+				p = [prel.css('paddingTop'), prel.css('paddingRight'), prel.css('paddingBottom'), prel.css('paddingLeft')];
 			
-			el.css({
-				top: this.position.top + "px", left: this.position.left + "px", 
-				width: this.size.width + "px", height: this.size.height + "px"
+			o.borderDif = $.map(b, function(v, i) {
+				var border = parseInt(v,10)||0, padding = parseInt(p[i],10)||0;
+				return border + padding; 
+			});
+		}
+		prel.css({
+			height: (el.height() - o.borderDif[0] - o.borderDif[2]) + "px",
+			width: (el.width() - o.borderDif[1] - o.borderDif[3]) + "px"
+		});
+	},
+	_renderProxy: function() {
+		var el = this.element, o = this.options;
+		this.elementOffset = el.offset();
+		
+		if(o.proxy) {
+			this.helper = this.helper || $('<div style="overflow:hidden;"></div>');
+			
+			// fix ie6 offset
+			var ie6 = $.browser.msie && $.browser.version < 7, ie6offset = (ie6 ? 1 : 0),
+			pxyoffset = ( ie6 ? 2 : -1 );
+			
+			this.helper.addClass(o.proxy).css({
+				width: el.outerWidth() + pxyoffset,
+				height: el.outerHeight() + pxyoffset,
+				position: 'absolute',
+				left: this.elementOffset.left - ie6offset +'px',
+				top: this.elementOffset.top - ie6offset +'px',
+				zIndex: ++o.zIndex
 			});
 			
-			if (!o.proxy && o.proportionallyResize)
-				this._proportionallyResize();
+			this.helper.appendTo("body");
 			
-			this._updateCache(data);
+			if (o.disableSelection)
+				$.ui.disableSelection(this.helper.get(0));
 			
-			return false;
+		} else {
+			this.helper = el; 
+		}
+	},
+	_change: {
+		e: function(e, dx, dy) {
+			return { width: this.originalSize.width + dx };
 		},
-		mouseStop: function(e) {
-			
-			this.options.resizing = false;
-			var o = this.options, num = function(v) { return parseInt(v, 10) || 0; }, self = this;
-			
-			if(o.proxy) {
-				var pr = o.proportionallyResize, ista = pr && (/textarea/i).test(pr.get(0).nodeName), 
-							soffseth = ista && $.ui.hasScroll(pr.get(0), 'left') /* TODO - jump height */ ? 0 : self.sizeDiff.height,
-								soffsetw = ista ? 0 : self.sizeDiff.width;
-				
-				var s = { width: (self.size.width - soffsetw), height: (self.size.height - soffseth) },
-					left = (parseInt(self.element.css('left'), 10) + (self.position.left - self.originalPosition.left)) || null, 
-					top = (parseInt(self.element.css('top'), 10) + (self.position.top - self.originalPosition.top)) || null;
-				
-				if (!o.animate)
-					this.element.css($.extend(s, { top: top, left: left }));
-				
-				if (o.proxy && !o.animate) this._proportionallyResize();
-				this.helper.remove();
-			}
-			
-			if (o.preserveCursor)
-			$('body').css('cursor', 'auto');
-			
-			this.propagate("stop", e);	
-			return false;
+		w: function(e, dx, dy) {
+			var o = this.options, cs = this.originalSize, sp = this.originalPosition;
+			return { left: sp.left + dx, width: cs.width - dx };
 		},
-		_updateCache: function(data) {
-			var o = this.options;
-			this.offset = this.helper.offset();
-			if (data.left) this.position.left = data.left;
-			if (data.top) this.position.top = data.top;
-			if (data.height) this.size.height = data.height;
-			if (data.width) this.size.width = data.width;
+		n: function(e, dx, dy) {
+			var o = this.options, cs = this.originalSize, sp = this.originalPosition;
+			return { top: sp.top + dy, height: cs.height - dy };
 		},
-		_updateRatio: function(data, e) {
-			var o = this.options, cpos = this.position, csize = this.size, a = this.axis;
-			
-			if (data.height) data.width = (csize.height / o.aspectRatio);
-			else if (data.width) data.height = (csize.width * o.aspectRatio);
-			
-			if (a == 'sw') {
-				data.left = cpos.left + (csize.width - data.width);
-				data.top = null;
-			}
-			if (a == 'nw') { 
-				data.top = cpos.top + (csize.height - data.height);
-				data.left = cpos.left + (csize.width - data.width);
-			}
-			
-			return data;
+		s: function(e, dx, dy) {
+			return { height: this.originalSize.height + dy };
 		},
-		_respectSize: function(data, e) {
-			
-			var el = this.helper, o = this.options, pRatio = o._aspectRatio || e.shiftKey, a = this.axis, 
-					ismaxw = data.width && o.maxWidth && o.maxWidth < data.width, ismaxh = data.height && o.maxHeight && o.maxHeight < data.height,
-						isminw = data.width && o.minWidth && o.minWidth > data.width, isminh = data.height && o.minHeight && o.minHeight > data.height;
-			
-			if (isminw) data.width = o.minWidth;
-			if (isminh) data.height = o.minHeight;
-			if (ismaxw) data.width = o.maxWidth;
-			if (ismaxh) data.height = o.maxHeight;
-			
-			var dw = this.originalPosition.left + this.originalSize.width, dh = this.position.top + this.size.height;
-			var cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
-			
-			if (isminw && cw) data.left = dw - o.minWidth;
-			if (ismaxw && cw) data.left = dw - o.maxWidth;
-			if (isminh && ch)	data.top = dh - o.minHeight;
-			if (ismaxh && ch)	data.top = dh - o.maxHeight;
-			
-			// fixing jump error on top/left - bug #2330
-			var isNotwh = !data.width && !data.height;
-			if (isNotwh && !data.left && data.top) data.top = null;
-			else if (isNotwh && !data.top && data.left) data.left = null;
-			
-			return data;
+		se: function(e, dx, dy) {
+			return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [e, dx, dy]));
 		},
-		_proportionallyResize: function() {
-			var o = this.options;
-			if (!o.proportionallyResize) return;
-			var prel = o.proportionallyResize, el = this.helper || this.element;
-			
-			if (!o.borderDif) {
-				var b = [prel.css('borderTopWidth'), prel.css('borderRightWidth'), prel.css('borderBottomWidth'), prel.css('borderLeftWidth')],
-					p = [prel.css('paddingTop'), prel.css('paddingRight'), prel.css('paddingBottom'), prel.css('paddingLeft')];
-				
-				o.borderDif = $.map(b, function(v, i) {
-					var border = parseInt(v,10)||0, padding = parseInt(p[i],10)||0;
-					return border + padding; 
-				});
-			}
-			prel.css({
-				height: (el.height() - o.borderDif[0] - o.borderDif[2]) + "px",
-				width: (el.width() - o.borderDif[1] - o.borderDif[3]) + "px"
-			});
+		sw: function(e, dx, dy) {
+			return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [e, dx, dy]));
 		},
-		_renderProxy: function() {
-			var el = this.element, o = this.options;
-			this.elementOffset = el.offset();
-			
-			if(o.proxy) {
-				this.helper = this.helper || $('<div style="overflow:hidden;"></div>');
-				
-				// fix ie6 offset
-				var ie6 = $.browser.msie && $.browser.version < 7, ie6offset = (ie6 ? 1 : 0),
-				pxyoffset = ( ie6 ? 2 : -1 );
-				
-				this.helper.addClass(o.proxy).css({
-					width: el.outerWidth() + pxyoffset,
-					height: el.outerHeight() + pxyoffset,
-					position: 'absolute',
-					left: this.elementOffset.left - ie6offset +'px',
-					top: this.elementOffset.top - ie6offset +'px',
-					zIndex: ++o.zIndex
-				});
-				
-				this.helper.appendTo("body");
-				
-				if (o.disableSelection)
-					$.ui.disableSelection(this.helper.get(0));
-				
-			} else {
-				this.helper = el; 
-			}
+		ne: function(e, dx, dy) {
+			return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [e, dx, dy]));
 		},
-		_change: {
-			e: function(e, dx, dy) {
-				return { width: this.originalSize.width + dx };
-			},
-			w: function(e, dx, dy) {
-				var o = this.options, cs = this.originalSize, sp = this.originalPosition;
-				return { left: sp.left + dx, width: cs.width - dx };
-			},
-			n: function(e, dx, dy) {
-				var o = this.options, cs = this.originalSize, sp = this.originalPosition;
-				return { top: sp.top + dy, height: cs.height - dy };
-			},
-			s: function(e, dx, dy) {
-				return { height: this.originalSize.height + dy };
-			},
-			se: function(e, dx, dy) {
-				return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [e, dx, dy]));
-			},
-			sw: function(e, dx, dy) {
-				return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [e, dx, dy]));
-			},
-			ne: function(e, dx, dy) {
-				return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [e, dx, dy]));
-			},
-			nw: function(e, dx, dy) {
-				return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [e, dx, dy]));
-			}
+		nw: function(e, dx, dy) {
+			return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [e, dx, dy]));
 		}
-	}));
-	
-	$.extend($.ui.resizable, {
-		defaults: {
-			cancel: ":input,button",
-			distance: 0,
-			delay: 0,
-			preventDefault: true,
-			transparent: false,
-			minWidth: 10,
-			minHeight: 10,
-			aspectRatio: false,
-			disableSelection: true,
-			preserveCursor: true,
-			autohide: false,
-			knobHandles: false
-		}
-	});
+	}
+}));
+
+$.extend($.ui.resizable, {
+	defaults: {
+		cancel: ":input,button",
+		distance: 0,
+		delay: 0,
+		preventDefault: true,
+		transparent: false,
+		minWidth: 10,
+		minHeight: 10,
+		aspectRatio: false,
+		disableSelection: true,
+		preserveCursor: true,
+		autohide: false,
+		knobHandles: false
+	}
+});
 
 /*
  * Resizable Extensions
  */
 
-	$.ui.plugin.add("resizable", "containment", {
+$.ui.plugin.add("resizable", "containment", {
+	
+	start: function(e, ui) {
+		var o = ui.options, self = $(this).data("resizable"), el = self.element;
+		var oc = o.containment,	ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
+		if (!ce) return;
 		
-		start: function(e, ui) {
-			var o = ui.options, self = $(this).data("resizable"), el = self.element;
-			var oc = o.containment,	ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
-			if (!ce) return;
-			
-			if (/document/.test(oc) || oc == document) {
-				self.containerOffset = { left: 0, top: 0 };
-				
-				self.parentData = { 
-					element: $(document), left: 0, top: 0, width: $(document).width(),
-					height: $(document).height() || document.body.parentNode.scrollHeight
-				};
-			}
-			
-			// i'm a node, so compute top, left, right, bottom
-			else{
-				self.containerOffset = $(ce).offset();
-				self.containerSize = { height: $(ce).innerHeight(), width: $(ce).innerWidth() };
+		if (/document/.test(oc) || oc == document) {
+			self.containerOffset = { left: 0, top: 0 };
 			
-				var co = self.containerOffset, ch = self.containerSize.height,	cw = self.containerSize.width, 
-							width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw ), height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);
-			
-				self.parentData = { 
-					element: ce, left: co.left, top: co.top, width: width, height: height
-				};
-			}
-		},
+			self.parentData = { 
+				element: $(document), left: 0, top: 0, width: $(document).width(),
+				height: $(document).height() || document.body.parentNode.scrollHeight
+			};
+		}
 		
-		resize: function(e, ui) {
-			var o = ui.options, self = $(this).data("resizable"), ps = self.containerSize, 
-						co = self.containerOffset, cs = self.size, cp = self.position,
-							pRatio = o._aspectRatio || e.shiftKey;
-			
-			if (cp.left < (o.proxy ? co.left : 0)) {
-				self.size.width = self.size.width + (o.proxy ? (self.position.left - co.left) : self.position.left);
-				if (pRatio) self.size.height = self.size.width * o.aspectRatio;
-				self.position.left = o.proxy ? co.left : 0;
-			}
-			
-			if (cp.top < (o.proxy ? co.top : 0)) {
-				self.size.height = self.size.height + (o.proxy ? (self.position.top - co.top) : self.position.top);
-				if (pRatio) self.size.width = self.size.height / o.aspectRatio;
-				self.position.top = o.proxy ? co.top : 0;
-			}
-			
-			var woset = (o.proxy ? self.offset.left - co.left : self.position.left) + self.sizeDiff.width, 
-						hoset = (o.proxy ? self.offset.top - co.top : self.position.top) + self.sizeDiff.height;
-			
-			if (woset + self.size.width >= self.parentData.width) {
-				self.size.width = self.parentData.width - woset;
-				if (pRatio) self.size.height = self.size.width * o.aspectRatio;
-			}
-			
-			if (hoset + self.size.height >= self.parentData.height) {
-				self.size.height = self.parentData.height - hoset;
-				if (pRatio) self.size.width = self.size.height / o.aspectRatio;
-			}
+		// i'm a node, so compute top, left, right, bottom
+		else{
+			self.containerOffset = $(ce).offset();
+			self.containerSize = { height: $(ce).innerHeight(), width: $(ce).innerWidth() };
+		
+			var co = self.containerOffset, ch = self.containerSize.height,	cw = self.containerSize.width, 
+						width = ($.ui.hasScroll(ce, "left") ? ce.scrollWidth : cw ), height = ($.ui.hasScroll(ce) ? ce.scrollHeight : ch);
+		
+			self.parentData = { 
+				element: ce, left: co.left, top: co.top, width: width, height: height
+			};
 		}
-	});
+	},
 	
-	$.ui.plugin.add("resizable", "grid", {
+	resize: function(e, ui) {
+		var o = ui.options, self = $(this).data("resizable"), ps = self.containerSize, 
+					co = self.containerOffset, cs = self.size, cp = self.position,
+						pRatio = o._aspectRatio || e.shiftKey;
 		
-		resize: function(e, ui) {
-			var o = ui.options, self = $(this).data("resizable"), cs = self.size, os = self.originalSize, op = self.originalPosition, a = self.axis, ratio = o._aspectRatio || e.shiftKey;
-			o.grid = typeof o.grid == "number" ? [o.grid, o.grid] : o.grid;
-			var ox = Math.round((cs.width - os.width) / o.grid[0]) * o.grid[0], oy = Math.round((cs.height - os.height) / o.grid[1]) * o.grid[1];
-			
-			if (/^(se|s|e)$/.test(a)) {
-				self.size.width = os.width + ox;
-				self.size.height = os.height + oy;
-			}
-			else if (/^(ne)$/.test(a)) {
-				self.size.width = os.width + ox;
-				self.size.height = os.height + oy;
-				self.position.top = op.top - oy;
-			}
-			else if (/^(sw)$/.test(a)) {
-				self.size.width = os.width + ox;
-				self.size.height = os.height + oy;
-				self.position.left = op.left - ox;
-			}
-			else {
-				self.size.width = os.width + ox;
-				self.size.height = os.height + oy;
-				self.position.top = op.top - oy;
-				self.position.left = op.left - ox;
-			}
+		if (cp.left < (o.proxy ? co.left : 0)) {
+			self.size.width = self.size.width + (o.proxy ? (self.position.left - co.left) : self.position.left);
+			if (pRatio) self.size.height = self.size.width * o.aspectRatio;
+			self.position.left = o.proxy ? co.left : 0;
 		}
 		
-	});
+		if (cp.top < (o.proxy ? co.top : 0)) {
+			self.size.height = self.size.height + (o.proxy ? (self.position.top - co.top) : self.position.top);
+			if (pRatio) self.size.width = self.size.height / o.aspectRatio;
+			self.position.top = o.proxy ? co.top : 0;
+		}
+		
+		var woset = (o.proxy ? self.offset.left - co.left : self.position.left) + self.sizeDiff.width, 
+					hoset = (o.proxy ? self.offset.top - co.top : self.position.top) + self.sizeDiff.height;
+		
+		if (woset + self.size.width >= self.parentData.width) {
+			self.size.width = self.parentData.width - woset;
+			if (pRatio) self.size.height = self.size.width * o.aspectRatio;
+		}
+		
+		if (hoset + self.size.height >= self.parentData.height) {
+			self.size.height = self.parentData.height - hoset;
+			if (pRatio) self.size.width = self.size.height / o.aspectRatio;
+		}
+	}
+});
+
+$.ui.plugin.add("resizable", "grid", {
 	
-	$.ui.plugin.add("resizable", "animate", {
+	resize: function(e, ui) {
+		var o = ui.options, self = $(this).data("resizable"), cs = self.size, os = self.originalSize, op = self.originalPosition, a = self.axis, ratio = o._aspectRatio || e.shiftKey;
+		o.grid = typeof o.grid == "number" ? [o.grid, o.grid] : o.grid;
+		var ox = Math.round((cs.width - os.width) / o.grid[0]) * o.grid[0], oy = Math.round((cs.height - os.height) / o.grid[1]) * o.grid[1];
 		
-		stop: function(e, ui) {
-			var o = ui.options, self = $(this).data("resizable");
-			
-			var pr = o.proportionallyResize, ista = pr && (/textarea/i).test(pr.get(0).nodeName), 
-							soffseth = ista && $.ui.hasScroll(pr.get(0), 'left') /* TODO - jump height */ ? 0 : self.sizeDiff.height,
-								soffsetw = ista ? 0 : self.sizeDiff.width;
-			
-			var style = { width: (self.size.width - soffsetw), height: (self.size.height - soffseth) },
-						left = (parseInt(self.element.css('left'), 10) + (self.position.left - self.originalPosition.left)) || null, 
-							top = (parseInt(self.element.css('top'), 10) + (self.position.top - self.originalPosition.top)) || null; 
-			
-			self.element.animate(
-				$.extend(style, top && left ? { top: top, left: left } : {}), { 
-					duration: o.animateDuration || "slow", easing: o.animateEasing || "swing", 
-					step: function() {
-						
-						var data = {
-							width: parseInt(self.element.css('width'), 10),
-							height: parseInt(self.element.css('height'), 10),
-							top: parseInt(self.element.css('top'), 10),
-							left: parseInt(self.element.css('left'), 10)
-						};
-						
-						if (pr) pr.css({ width: data.width, height: data.height });
-						
-						// propagating resize, and updating values for each animation step
-						self._updateCache(data);
-						self.propagate("animate", e);
-						
-					}
-				}
-			);
+		if (/^(se|s|e)$/.test(a)) {
+			self.size.width = os.width + ox;
+			self.size.height = os.height + oy;
+		}
+		else if (/^(ne)$/.test(a)) {
+			self.size.width = os.width + ox;
+			self.size.height = os.height + oy;
+			self.position.top = op.top - oy;
+		}
+		else if (/^(sw)$/.test(a)) {
+			self.size.width = os.width + ox;
+			self.size.height = os.height + oy;
+			self.position.left = op.left - ox;
 		}
+		else {
+			self.size.width = os.width + ox;
+			self.size.height = os.height + oy;
+			self.position.top = op.top - oy;
+			self.position.left = op.left - ox;
+		}
+	}
+	
+});
+
+$.ui.plugin.add("resizable", "animate", {
+	
+	stop: function(e, ui) {
+		var o = ui.options, self = $(this).data("resizable");
 		
-	});
+		var pr = o.proportionallyResize, ista = pr && (/textarea/i).test(pr.get(0).nodeName), 
+						soffseth = ista && $.ui.hasScroll(pr.get(0), 'left') /* TODO - jump height */ ? 0 : self.sizeDiff.height,
+							soffsetw = ista ? 0 : self.sizeDiff.width;
+		
+		var style = { width: (self.size.width - soffsetw), height: (self.size.height - soffseth) },
+					left = (parseInt(self.element.css('left'), 10) + (self.position.left - self.originalPosition.left)) || null, 
+						top = (parseInt(self.element.css('top'), 10) + (self.position.top - self.originalPosition.top)) || null; 
+		
+		self.element.animate(
+			$.extend(style, top && left ? { top: top, left: left } : {}), { 
+				duration: o.animateDuration || "slow", easing: o.animateEasing || "swing", 
+				step: function() {
+					
+					var data = {
+						width: parseInt(self.element.css('width'), 10),
+						height: parseInt(self.element.css('height'), 10),
+						top: parseInt(self.element.css('top'), 10),
+						left: parseInt(self.element.css('left'), 10)
+					};
+					
+					if (pr) pr.css({ width: data.width, height: data.height });
+					
+					// propagating resize, and updating values for each animation step
+					self._updateCache(data);
+					self.propagate("animate", e);
+					
+				}
+			}
+		);
+	}
+	
+});
+
+$.ui.plugin.add("resizable", "ghost", {
 	
-	$.ui.plugin.add("resizable", "ghost", {
+	start: function(e, ui) {
+		var o = ui.options, self = $(this).data("resizable"), pr = o.proportionallyResize, cs = self.size;
 		
-		start: function(e, ui) {
-			var o = ui.options, self = $(this).data("resizable"), pr = o.proportionallyResize, cs = self.size;
-			
-			if (!pr) self.ghost = self.element.clone();
-			else self.ghost = pr.clone();
-			
-			self.ghost.css(
-				{ opacity: .25, display: 'block', position: 'relative', height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 }
-			)
-			.addClass('ui-resizable-ghost').addClass(typeof o.ghost == 'string' ? o.ghost : '');
-			
-			self.ghost.appendTo(self.helper);
-			
-		},
+		if (!pr) self.ghost = self.element.clone();
+		else self.ghost = pr.clone();
 		
-		resize: function(e, ui){
-			var o = ui.options, self = $(this).data("resizable"), pr = o.proportionallyResize;
-			
-			if (self.ghost) self.ghost.css({ position: 'relative', height: self.size.height, width: self.size.width });
-			
-		},
+		self.ghost.css(
+			{ opacity: .25, display: 'block', position: 'relative', height: cs.height, width: cs.width, margin: 0, left: 0, top: 0 }
+		)
+		.addClass('ui-resizable-ghost').addClass(typeof o.ghost == 'string' ? o.ghost : '');
 		
-		stop: function(e, ui){
-			var o = ui.options, self = $(this).data("resizable"), pr = o.proportionallyResize;
-			if (self.ghost && self.helper) self.helper.get(0).removeChild(self.ghost.get(0));
-		}
+		self.ghost.appendTo(self.helper);
 		
-	});
+	},
 	
-	$.ui.plugin.add("resizable", "alsoResize", {
+	resize: function(e, ui){
+		var o = ui.options, self = $(this).data("resizable"), pr = o.proportionallyResize;
 		
-		start: function(e, ui) {
-			var o = ui.options, self = $(this).data("resizable"), 
-			
-			_store = function(exp) {
-				$(exp).each(function() {
-					$(this).data("resizable-alsoresize", {
-						width: parseInt($(this).width(), 10), height: parseInt($(this).height(), 10),
-						left: parseInt($(this).css('left'), 10), top: parseInt($(this).css('top'), 10)
-					});
+		if (self.ghost) self.ghost.css({ position: 'relative', height: self.size.height, width: self.size.width });
+		
+	},
+	
+	stop: function(e, ui){
+		var o = ui.options, self = $(this).data("resizable"), pr = o.proportionallyResize;
+		if (self.ghost && self.helper) self.helper.get(0).removeChild(self.ghost.get(0));
+	}
+	
+});
+
+$.ui.plugin.add("resizable", "alsoResize", {
+	
+	start: function(e, ui) {
+		var o = ui.options, self = $(this).data("resizable"), 
+		
+		_store = function(exp) {
+			$(exp).each(function() {
+				$(this).data("resizable-alsoresize", {
+					width: parseInt($(this).width(), 10), height: parseInt($(this).height(), 10),
+					left: parseInt($(this).css('left'), 10), top: parseInt($(this).css('top'), 10)
 				});
-			};
-			
-			if (typeof(o.alsoResize) == 'object') {
-				$.each(o.alsoResize, function(exp, c) { _store(exp); });
-			}else{
-				_store(o.alsoResize);
-			} 
+			});
+		};
+		
+		if (typeof(o.alsoResize) == 'object') {
+			$.each(o.alsoResize, function(exp, c) { _store(exp); });
+		}else{
+			_store(o.alsoResize);
+		} 
+	},
+	
+	resize: function(e, ui){
+		var o = ui.options, self = $(this).data("resizable"), os = self.originalSize, op = self.originalPosition;
+		
+		var delta = { 
+			height: (self.size.height - os.height) || 0, width: (self.size.width - os.width) || 0,
+			top: (self.position.top - op.top) || 0, left: (self.position.left - op.left) || 0
 		},
 		
-		resize: function(e, ui){
-			var o = ui.options, self = $(this).data("resizable"), os = self.originalSize, op = self.originalPosition;
-			
-			var delta = { 
-				height: (self.size.height - os.height) || 0, width: (self.size.width - os.width) || 0,
-				top: (self.position.top - op.top) || 0, left: (self.position.left - op.left) || 0
-			},
-			
-			_alsoResize = function(exp, c) {
-				$(exp).each(function() {
-					var start = $(this).data("resizable-alsoresize"), style = {}, css = c && c.length ? c : ['width', 'height', 'top', 'left'];
-					
-					$.each(css || ['width', 'height', 'top', 'left'], function(i, prop) {
-						var sum = (start[prop]||0) + (delta[prop]||0);
-						if (sum && sum >= 0)
-							style[prop] = sum || null;
-					});
-					$(this).css(style);
+		_alsoResize = function(exp, c) {
+			$(exp).each(function() {
+				var start = $(this).data("resizable-alsoresize"), style = {}, css = c && c.length ? c : ['width', 'height', 'top', 'left'];
+				
+				$.each(css || ['width', 'height', 'top', 'left'], function(i, prop) {
+					var sum = (start[prop]||0) + (delta[prop]||0);
+					if (sum && sum >= 0)
+						style[prop] = sum || null;
 				});
-			};
-			
-			if (typeof(o.alsoResize) == 'object') {
-				$.each(o.alsoResize, function(exp, c) { _alsoResize(exp, c); });
-			}else{
-				_alsoResize(o.alsoResize);
-			}
-		},
+				$(this).css(style);
+			});
+		};
 		
-		stop: function(e, ui){
-			$(this).removeData("resizable-alsoresize-start");
+		if (typeof(o.alsoResize) == 'object') {
+			$.each(o.alsoResize, function(exp, c) { _alsoResize(exp, c); });
+		}else{
+			_alsoResize(o.alsoResize);
 		}
-	});
+	},
+	
+	stop: function(e, ui){
+		$(this).removeData("resizable-alsoresize-start");
+	}
+});
 
 })(jQuery);
diff --git a/ui/source/ui.selectable.js b/ui/source/ui.selectable.js
index a27391da6..3c46ce2c5 100644
--- a/ui/source/ui.selectable.js
+++ b/ui/source/ui.selectable.js
@@ -14,261 +14,261 @@
  */
 ;(function($) {
 
-	$.widget("ui.selectable", $.extend($.ui.mouse, {
-		init: function() {
-			var self = this;
-			
-			this.element.addClass("ui-selectable");
-			
-			this.dragged = false;
-	
-			// cache selectee children based on filter
-			var selectees;
-			this.refresh = function() {
-				selectees = $(self.options.filter, self.element[0]);
-				selectees.each(function() {
-					var $this = $(this);
-					var pos = $this.offset();
-					$.data(this, "selectable-item", {
-						element: this,
-						$element: $this,
-						left: pos.left,
-						top: pos.top,
-						right: pos.left + $this.width(),
-						bottom: pos.top + $this.height(),
-						startselected: false,
-						selected: $this.hasClass('ui-selected'),
-						selecting: $this.hasClass('ui-selecting'),
-						unselecting: $this.hasClass('ui-unselecting')
-					});
+$.widget("ui.selectable", $.extend($.ui.mouse, {
+	init: function() {
+		var self = this;
+		
+		this.element.addClass("ui-selectable");
+		
+		this.dragged = false;
+
+		// cache selectee children based on filter
+		var selectees;
+		this.refresh = function() {
+			selectees = $(self.options.filter, self.element[0]);
+			selectees.each(function() {
+				var $this = $(this);
+				var pos = $this.offset();
+				$.data(this, "selectable-item", {
+					element: this,
+					$element: $this,
+					left: pos.left,
+					top: pos.top,
+					right: pos.left + $this.width(),
+					bottom: pos.top + $this.height(),
+					startselected: false,
+					selected: $this.hasClass('ui-selected'),
+					selecting: $this.hasClass('ui-selecting'),
+					unselecting: $this.hasClass('ui-unselecting')
 				});
-			};
-			this.refresh();
-	
-			this.selectees = selectees.addClass("ui-selectee");
-			
-			this.mouseInit();
-			
-			this.helper = $(document.createElement('div')).css({border:'1px dotted black'});
-		},
-		toggle: function() {
-			if(this.options.disabled){
-				this.enable();
-			} else {
-				this.disable();
-			}
-		},
-		destroy: function() {
-			this.element
-				.removeClass("ui-selectable ui-selectable-disabled")
-				.removeData("selectable")
-				.unbind(".selectable");
-			this.mouseDestroy();
-		},
-		enable: function() {
-			this.element.removeClass("ui-selectable-disabled");
-			this.options.disabled = false;
-		},
-		disable: function() {
-			this.element.addClass("ui-selectable-disabled");
-			this.options.disabled = true;
-		},
-		mouseStart: function(e) {
-			var self = this;
-			
-			this.opos = [e.pageX, e.pageY];
-			
-			if (this.options.disabled)
-				return;
+			});
+		};
+		this.refresh();
 
-			var options = this.options;
+		this.selectees = selectees.addClass("ui-selectee");
+		
+		this.mouseInit();
+		
+		this.helper = $(document.createElement('div')).css({border:'1px dotted black'});
+	},
+	toggle: function() {
+		if(this.options.disabled){
+			this.enable();
+		} else {
+			this.disable();
+		}
+	},
+	destroy: function() {
+		this.element
+			.removeClass("ui-selectable ui-selectable-disabled")
+			.removeData("selectable")
+			.unbind(".selectable");
+		this.mouseDestroy();
+	},
+	enable: function() {
+		this.element.removeClass("ui-selectable-disabled");
+		this.options.disabled = false;
+	},
+	disable: function() {
+		this.element.addClass("ui-selectable-disabled");
+		this.options.disabled = true;
+	},
+	mouseStart: function(e) {
+		var self = this;
+		
+		this.opos = [e.pageX, e.pageY];
+		
+		if (this.options.disabled)
+			return;
 
-			this.selectees = $(options.filter, this.element[0]);
+		var options = this.options;
 
-			// selectable START callback
-			this.element.triggerHandler("selectablestart", [e, {
-				"selectable": this.element[0],
-				"options": options
-			}], options.start);
+		this.selectees = $(options.filter, this.element[0]);
 
-			$('body').append(this.helper);
-			// position helper (lasso)
-			this.helper.css({
-				"z-index": 100,
-				"position": "absolute",
-				"left": e.clientX,
-				"top": e.clientY,
-				"width": 0,
-				"height": 0
-			});
+		// selectable START callback
+		this.element.triggerHandler("selectablestart", [e, {
+			"selectable": this.element[0],
+			"options": options
+		}], options.start);
 
-			if (options.autoRefresh) {
-				this.refresh();
+		$('body').append(this.helper);
+		// position helper (lasso)
+		this.helper.css({
+			"z-index": 100,
+			"position": "absolute",
+			"left": e.clientX,
+			"top": e.clientY,
+			"width": 0,
+			"height": 0
+		});
+
+		if (options.autoRefresh) {
+			this.refresh();
+		}
+
+		this.selectees.filter('.ui-selected').each(function() {
+			var selectee = $.data(this, "selectable-item");
+			selectee.startselected = true;
+			if (!e.ctrlKey) {
+				selectee.$element.removeClass('ui-selected');
+				selectee.selected = false;
+				selectee.$element.addClass('ui-unselecting');
+				selectee.unselecting = true;
+				// selectable UNSELECTING callback
+				self.element.triggerHandler("selectableunselecting", [e, {
+					selectable: self.element[0],
+					unselecting: selectee.element,
+					options: options
+				}], options.unselecting);
 			}
+		});
+		
+		var isSelectee = false;
+		$(e.target).parents().andSelf().each(function() {
+			if($.data(this, "selectable-item")) isSelectee = true;
+		});
+		return this.options.keyboard ? !isSelectee : true;
+	},
+	mouseDrag: function(e) {
+		var self = this;
+		this.dragged = true;
+		
+		if (this.options.disabled)
+			return;
+
+		var options = this.options;
 
-			this.selectees.filter('.ui-selected').each(function() {
-				var selectee = $.data(this, "selectable-item");
-				selectee.startselected = true;
-				if (!e.ctrlKey) {
+		var x1 = this.opos[0], y1 = this.opos[1], x2 = e.pageX, y2 = e.pageY;
+		if (x1 > x2) { var tmp = x2; x2 = x1; x1 = tmp; }
+		if (y1 > y2) { var tmp = y2; y2 = y1; y1 = tmp; }
+		this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
+
+		this.selectees.each(function() {
+			var selectee = $.data(this, "selectable-item");
+			//prevent helper from being selected if appendTo: selectable
+			if (!selectee || selectee.element == self.element[0])
+				return;
+			var hit = false;
+			if (options.tolerance == 'touch') {
+				hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
+			} else if (options.tolerance == 'fit') {
+				hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
+			}
+
+			if (hit) {
+				// SELECT
+				if (selectee.selected) {
 					selectee.$element.removeClass('ui-selected');
 					selectee.selected = false;
-					selectee.$element.addClass('ui-unselecting');
-					selectee.unselecting = true;
-					// selectable UNSELECTING callback
-					self.element.triggerHandler("selectableunselecting", [e, {
+				}
+				if (selectee.unselecting) {
+					selectee.$element.removeClass('ui-unselecting');
+					selectee.unselecting = false;
+				}
+				if (!selectee.selecting) {
+					selectee.$element.addClass('ui-selecting');
+					selectee.selecting = true;
+					// selectable SELECTING callback
+					self.element.triggerHandler("selectableselecting", [e, {
 						selectable: self.element[0],
-						unselecting: selectee.element,
+						selecting: selectee.element,
 						options: options
-					}], options.unselecting);
+					}], options.selecting);
 				}
-			});
-			
-			var isSelectee = false;
-			$(e.target).parents().andSelf().each(function() {
-				if($.data(this, "selectable-item")) isSelectee = true;
-			});
-			return this.options.keyboard ? !isSelectee : true;
-		},
-		mouseDrag: function(e) {
-			var self = this;
-			this.dragged = true;
-			
-			if (this.options.disabled)
-				return;
-
-			var options = this.options;
-
-			var x1 = this.opos[0], y1 = this.opos[1], x2 = e.pageX, y2 = e.pageY;
-			if (x1 > x2) { var tmp = x2; x2 = x1; x1 = tmp; }
-			if (y1 > y2) { var tmp = y2; y2 = y1; y1 = tmp; }
-			this.helper.css({left: x1, top: y1, width: x2-x1, height: y2-y1});
-
-			this.selectees.each(function() {
-				var selectee = $.data(this, "selectable-item");
-				//prevent helper from being selected if appendTo: selectable
-				if (!selectee || selectee.element == self.element[0])
-					return;
-				var hit = false;
-				if (options.tolerance == 'touch') {
-					hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
-				} else if (options.tolerance == 'fit') {
-					hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
+			} else {
+				// UNSELECT
+				if (selectee.selecting) {
+					if (e.ctrlKey && selectee.startselected) {
+						selectee.$element.removeClass('ui-selecting');
+						selectee.selecting = false;
+						selectee.$element.addClass('ui-selected');
+						selectee.selected = true;
+					} else {
+						selectee.$element.removeClass('ui-selecting');
+						selectee.selecting = false;
+						if (selectee.startselected) {
+							selectee.$element.addClass('ui-unselecting');
+							selectee.unselecting = true;
+						}
+						// selectable UNSELECTING callback
+						self.element.triggerHandler("selectableunselecting", [e, {
+							selectable: self.element[0],
+							unselecting: selectee.element,
+							options: options
+						}], options.unselecting);
+					}
 				}
-
-				if (hit) {
-					// SELECT
-					if (selectee.selected) {
+				if (selectee.selected) {
+					if (!e.ctrlKey && !selectee.startselected) {
 						selectee.$element.removeClass('ui-selected');
 						selectee.selected = false;
-					}
-					if (selectee.unselecting) {
-						selectee.$element.removeClass('ui-unselecting');
-						selectee.unselecting = false;
-					}
-					if (!selectee.selecting) {
-						selectee.$element.addClass('ui-selecting');
-						selectee.selecting = true;
-						// selectable SELECTING callback
-						self.element.triggerHandler("selectableselecting", [e, {
+
+						selectee.$element.addClass('ui-unselecting');
+						selectee.unselecting = true;
+						// selectable UNSELECTING callback
+						self.element.triggerHandler("selectableunselecting", [e, {
 							selectable: self.element[0],
-							selecting: selectee.element,
+							unselecting: selectee.element,
 							options: options
-						}], options.selecting);
-					}
-				} else {
-					// UNSELECT
-					if (selectee.selecting) {
-						if (e.ctrlKey && selectee.startselected) {
-							selectee.$element.removeClass('ui-selecting');
-							selectee.selecting = false;
-							selectee.$element.addClass('ui-selected');
-							selectee.selected = true;
-						} else {
-							selectee.$element.removeClass('ui-selecting');
-							selectee.selecting = false;
-							if (selectee.startselected) {
-								selectee.$element.addClass('ui-unselecting');
-								selectee.unselecting = true;
-							}
-							// selectable UNSELECTING callback
-							self.element.triggerHandler("selectableunselecting", [e, {
-								selectable: self.element[0],
-								unselecting: selectee.element,
-								options: options
-							}], options.unselecting);
-						}
-					}
-					if (selectee.selected) {
-						if (!e.ctrlKey && !selectee.startselected) {
-							selectee.$element.removeClass('ui-selected');
-							selectee.selected = false;
-
-							selectee.$element.addClass('ui-unselecting');
-							selectee.unselecting = true;
-							// selectable UNSELECTING callback
-							self.element.triggerHandler("selectableunselecting", [e, {
-								selectable: self.element[0],
-								unselecting: selectee.element,
-								options: options
-							}], options.unselecting);
-						}
+						}], options.unselecting);
 					}
 				}
-			});
-			
-			return false;
-		},
-		mouseStop: function(e) {
-			var self = this;
-			
-			this.dragged = false;
-			
-			var options = this.options;
+			}
+		});
+		
+		return false;
+	},
+	mouseStop: function(e) {
+		var self = this;
+		
+		this.dragged = false;
+		
+		var options = this.options;
 
-			$('.ui-unselecting', this.element[0]).each(function() {
-				var selectee = $.data(this, "selectable-item");
-				selectee.$element.removeClass('ui-unselecting');
-				selectee.unselecting = false;
-				selectee.startselected = false;
-				self.element.triggerHandler("selectableunselected", [e, {
-					selectable: self.element[0],
-					unselected: selectee.element,
-					options: options
-				}], options.unselected);
-			});
-			$('.ui-selecting', this.element[0]).each(function() {
-				var selectee = $.data(this, "selectable-item");
-				selectee.$element.removeClass('ui-selecting').addClass('ui-selected');
-				selectee.selecting = false;
-				selectee.selected = true;
-				selectee.startselected = true;
-				self.element.triggerHandler("selectableselected", [e, {
-					selectable: self.element[0],
-					selected: selectee.element,
-					options: options
-				}], options.selected);
-			});
-			this.element.triggerHandler("selectablestop", [e, {
+		$('.ui-unselecting', this.element[0]).each(function() {
+			var selectee = $.data(this, "selectable-item");
+			selectee.$element.removeClass('ui-unselecting');
+			selectee.unselecting = false;
+			selectee.startselected = false;
+			self.element.triggerHandler("selectableunselected", [e, {
 				selectable: self.element[0],
-				options: this.options
-			}], this.options.stop);
-			
-			this.helper.remove();
-			
-			return false;
-		}
-	}));
-	
-	$.extend($.ui.selectable, {
-		defaults: {
-			distance: 0,
-			delay: 0,
-			cancel: ":input,button",
-			appendTo: 'body',
-			autoRefresh: true,
-			filter: '*',
-			tolerance: 'touch'
-		}
-	});
-	
+				unselected: selectee.element,
+				options: options
+			}], options.unselected);
+		});
+		$('.ui-selecting', this.element[0]).each(function() {
+			var selectee = $.data(this, "selectable-item");
+			selectee.$element.removeClass('ui-selecting').addClass('ui-selected');
+			selectee.selecting = false;
+			selectee.selected = true;
+			selectee.startselected = true;
+			self.element.triggerHandler("selectableselected", [e, {
+				selectable: self.element[0],
+				selected: selectee.element,
+				options: options
+			}], options.selected);
+		});
+		this.element.triggerHandler("selectablestop", [e, {
+			selectable: self.element[0],
+			options: this.options
+		}], this.options.stop);
+		
+		this.helper.remove();
+		
+		return false;
+	}
+}));
+
+$.extend($.ui.selectable, {
+	defaults: {
+		distance: 0,
+		delay: 0,
+		cancel: ":input,button",
+		appendTo: 'body',
+		autoRefresh: true,
+		filter: '*',
+		tolerance: 'touch'
+	}
+});
+
 })(jQuery);
diff --git a/ui/source/ui.slider.js b/ui/source/ui.slider.js
index e18fb4756..02c21b9fd 100644
--- a/ui/source/ui.slider.js
+++ b/ui/source/ui.slider.js
@@ -14,417 +14,417 @@
  */
 ;(function($) {
 
-	$.fn.unwrap = $.fn.unwrap || function(expr) {
-	  return this.each(function(){
-	     $(this).parents(expr).eq(0).after(this).remove();
-	  });
-	};
-	
+$.fn.unwrap = $.fn.unwrap || function(expr) {
+  return this.each(function(){
+     $(this).parents(expr).eq(0).after(this).remove();
+  });
+};
 
-	$.widget("ui.slider", {
-		plugins: {},
-		ui: function(e) {
-			return {
-				instance: this,
-				options: this.options,
-				handle: this.currentHandle,
-				value: this.options.axis != "both" || !this.options.axis ? Math.round(this.value(null,this.options.axis == "vertical" ? "y" : "x")) : {
-					x: Math.round(this.value(null,"x")),
-					y: Math.round(this.value(null,"y"))
-				},
-				range: this.getRange()
-			};
-		},
-		propagate: function(n,e) {
-			$.ui.plugin.call(this, n, [e, this.ui()]);
-			this.element.triggerHandler(n == "slide" ? n : "slide"+n, [e, this.ui()], this.options[n]);
-		},
-		destroy: function() {
-			this.element
-				.removeClass("ui-slider ui-slider-disabled")
-				.removeData("slider")
-				.unbind(".slider");
-			this.handle
-				.unwrap("a")
-				.mouse("destroy");
-			this.generated && this.generated.remove();
-		},
-		enable: function() {
-			this.element.removeClass("ui-slider-disabled");
-			this.disabled = false;
-		},
-		disable: function() {
-			this.element.addClass("ui-slider-disabled");
-			this.disabled = true;
-		},
-		setData: function(key, value) {
-			this.options[key] = value;
-			if (/min|max|steps/.test(key)) {
-				this.initBoundaries();
-			}
-		},
 
-		init: function() {
-			
-			var self = this;
-			this.element.addClass("ui-slider");
+$.widget("ui.slider", {
+	plugins: {},
+	ui: function(e) {
+		return {
+			instance: this,
+			options: this.options,
+			handle: this.currentHandle,
+			value: this.options.axis != "both" || !this.options.axis ? Math.round(this.value(null,this.options.axis == "vertical" ? "y" : "x")) : {
+				x: Math.round(this.value(null,"x")),
+				y: Math.round(this.value(null,"y"))
+			},
+			range: this.getRange()
+		};
+	},
+	propagate: function(n,e) {
+		$.ui.plugin.call(this, n, [e, this.ui()]);
+		this.element.triggerHandler(n == "slide" ? n : "slide"+n, [e, this.ui()], this.options[n]);
+	},
+	destroy: function() {
+		this.element
+			.removeClass("ui-slider ui-slider-disabled")
+			.removeData("slider")
+			.unbind(".slider");
+		this.handle
+			.unwrap("a")
+			.mouse("destroy");
+		this.generated && this.generated.remove();
+	},
+	enable: function() {
+		this.element.removeClass("ui-slider-disabled");
+		this.disabled = false;
+	},
+	disable: function() {
+		this.element.addClass("ui-slider-disabled");
+		this.disabled = true;
+	},
+	setData: function(key, value) {
+		this.options[key] = value;
+		if (/min|max|steps/.test(key)) {
 			this.initBoundaries();
-			
-			// Initialize mouse and key events for interaction
-			this.handle = $(this.options.handle, this.element);
-			if (!this.handle.length) {
-				self.handle = self.generated = $(self.options.handles || [0]).map(function() {
-					var handle = $("<div/>").addClass("ui-slider-handle").appendTo(self.element);
-					if (this.id)
-						handle.attr("id", this.id);
-					return handle[0];
-				});
-			}
-			
-			
-			var handleclass = function(el) {
-				this.element = $(el);
-				this.element.data("mouse", this);
-				this.options = self.options;
-				
-				this.element.bind("mousedown", function() {
-					if(self.currentHandle) this.blur(self.currentHandle);
-					self.focus(this,1);
-				});
-				
-				this.mouseInit();
-			};
-			
-			$.extend(handleclass.prototype, $.ui.mouse, {
-				mouseStart: function(e) { return self.start.call(self, e, this.element[0]); },
-				mouseStop: function(e) { return self.stop.call(self, e, this.element[0]); },
-				mouseDrag: function(e) { return self.drag.call(self, e, this.element[0]); },
-				trigger: function(e) { this.mouseDown(e); }
-			});
-			
-			
-			$(this.handle)
-				.each(function() {
-					new handleclass(this);
-				})
-				.wrap('<a href="javascript:void(0)" style="cursor:default;"></a>')
-				.parent()
-					.bind('focus', function(e) { self.focus(this.firstChild); })
-					.bind('blur', function(e) { self.blur(this.firstChild); })
-					.bind('keydown', function(e) { if(!self.options.noKeyboard) self.keydown(e.keyCode, this.firstChild); })
-			;
-			
-			// Bind the click to the slider itself
-			this.element.bind('mousedown.slider', function(e) {
-				self.click.apply(self, [e]);
-				self.currentHandle.data("mouse").trigger(e);
-				self.firstValue = self.firstValue + 1; //This is for always triggering the change event
-			});
-			
-			// Move the first handle to the startValue
-			$.each(this.options.handles || [], function(index, handle) {
-				self.moveTo(handle.start, index, true);
-			});
-			if (!isNaN(this.options.startValue))
-				this.moveTo(this.options.startValue, 0, true);
+		}
+	},
 
-			this.previousHandle = $(this.handle[0]); //set the previous handle to the first to allow clicking before selecting the handle
-			if(this.handle.length == 2 && this.options.range) this.createRange();
-		},
-		initBoundaries: function() {
-			
-			var element = this.element[0], o = this.options;
-			this.actualSize = { width: this.element.outerWidth() , height: this.element.outerHeight() };			
-			
-			$.extend(o, {
-				axis: o.axis || (element.offsetWidth < element.offsetHeight ? 'vertical' : 'horizontal'),
-				max: !isNaN(parseInt(o.max,10)) ? { x: parseInt(o.max, 10), y: parseInt(o.max, 10) } : ({ x: o.max && o.max.x || 100, y: o.max && o.max.y || 100 }),
-				min: !isNaN(parseInt(o.min,10)) ? { x: parseInt(o.min, 10), y: parseInt(o.min, 10) } : ({ x: o.min && o.min.x || 0, y: o.min && o.min.y || 0 })
+	init: function() {
+		
+		var self = this;
+		this.element.addClass("ui-slider");
+		this.initBoundaries();
+		
+		// Initialize mouse and key events for interaction
+		this.handle = $(this.options.handle, this.element);
+		if (!this.handle.length) {
+			self.handle = self.generated = $(self.options.handles || [0]).map(function() {
+				var handle = $("<div/>").addClass("ui-slider-handle").appendTo(self.element);
+				if (this.id)
+					handle.attr("id", this.id);
+				return handle[0];
 			});
-			//Prepare the real maxValue
-			o.realMax = {
-				x: o.max.x - o.min.x,
-				y: o.max.y - o.min.y
-			};
-			//Calculate stepping based on steps
-			o.stepping = {
-				x: o.stepping && o.stepping.x || parseInt(o.stepping, 10) || (o.steps ? o.realMax.x/(o.steps.x || parseInt(o.steps, 10) || o.realMax.x) : 0),
-				y: o.stepping && o.stepping.y || parseInt(o.stepping, 10) || (o.steps ? o.realMax.y/(o.steps.y || parseInt(o.steps, 10) || o.realMax.y) : 0)
-			};
-		},
-
+		}
 		
-		keydown: function(keyCode, handle) {
-			if(/(37|38|39|40)/.test(keyCode)) {
-				this.moveTo({
-					x: /(37|39)/.test(keyCode) ? (keyCode == 37 ? '-' : '+') + '=' + this.oneStep("x") : 0,
-					y: /(38|40)/.test(keyCode) ? (keyCode == 38 ? '-' : '+') + '=' + this.oneStep("y") : 0
-				}, handle);
-			}
-		},
-		focus: function(handle,hard) {
-			this.currentHandle = $(handle).addClass('ui-slider-handle-active');
-			if (hard)
-				this.currentHandle.parent()[0].focus();
-		},
-		blur: function(handle) {
-			$(handle).removeClass('ui-slider-handle-active');
-			if(this.currentHandle && this.currentHandle[0] == handle) { this.previousHandle = this.currentHandle; this.currentHandle = null; };
-		},
-		click: function(e) {
-			// This method is only used if:
-			// - The user didn't click a handle
-			// - The Slider is not disabled
-			// - There is a current, or previous selected handle (otherwise we wouldn't know which one to move)
-			
-			var pointer = [e.pageX,e.pageY];
+		
+		var handleclass = function(el) {
+			this.element = $(el);
+			this.element.data("mouse", this);
+			this.options = self.options;
 			
-			var clickedHandle = false;
-			this.handle.each(function() {
-				if(this == e.target)
-					clickedHandle = true;
+			this.element.bind("mousedown", function() {
+				if(self.currentHandle) this.blur(self.currentHandle);
+				self.focus(this,1);
 			});
-			if (clickedHandle || this.disabled || !(this.currentHandle || this.previousHandle))
-				return;
-
-			// If a previous handle was focussed, focus it again
-			if (!this.currentHandle && this.previousHandle)
-				this.focus(this.previousHandle, true);
 			
-			// propagate only for distance > 0, otherwise propagation is done my drag
-			this.offset = this.element.offset();
+			this.mouseInit();
+		};
+		
+		$.extend(handleclass.prototype, $.ui.mouse, {
+			mouseStart: function(e) { return self.start.call(self, e, this.element[0]); },
+			mouseStop: function(e) { return self.stop.call(self, e, this.element[0]); },
+			mouseDrag: function(e) { return self.drag.call(self, e, this.element[0]); },
+			trigger: function(e) { this.mouseDown(e); }
+		});
+		
+		
+		$(this.handle)
+			.each(function() {
+				new handleclass(this);
+			})
+			.wrap('<a href="javascript:void(0)" style="cursor:default;"></a>')
+			.parent()
+				.bind('focus', function(e) { self.focus(this.firstChild); })
+				.bind('blur', function(e) { self.blur(this.firstChild); })
+				.bind('keydown', function(e) { if(!self.options.noKeyboard) self.keydown(e.keyCode, this.firstChild); })
+		;
+		
+		// Bind the click to the slider itself
+		this.element.bind('mousedown.slider', function(e) {
+			self.click.apply(self, [e]);
+			self.currentHandle.data("mouse").trigger(e);
+			self.firstValue = self.firstValue + 1; //This is for always triggering the change event
+		});
+		
+		// Move the first handle to the startValue
+		$.each(this.options.handles || [], function(index, handle) {
+			self.moveTo(handle.start, index, true);
+		});
+		if (!isNaN(this.options.startValue))
+			this.moveTo(this.options.startValue, 0, true);
 
+		this.previousHandle = $(this.handle[0]); //set the previous handle to the first to allow clicking before selecting the handle
+		if(this.handle.length == 2 && this.options.range) this.createRange();
+	},
+	initBoundaries: function() {
+		
+		var element = this.element[0], o = this.options;
+		this.actualSize = { width: this.element.outerWidth() , height: this.element.outerHeight() };			
+		
+		$.extend(o, {
+			axis: o.axis || (element.offsetWidth < element.offsetHeight ? 'vertical' : 'horizontal'),
+			max: !isNaN(parseInt(o.max,10)) ? { x: parseInt(o.max, 10), y: parseInt(o.max, 10) } : ({ x: o.max && o.max.x || 100, y: o.max && o.max.y || 100 }),
+			min: !isNaN(parseInt(o.min,10)) ? { x: parseInt(o.min, 10), y: parseInt(o.min, 10) } : ({ x: o.min && o.min.x || 0, y: o.min && o.min.y || 0 })
+		});
+		//Prepare the real maxValue
+		o.realMax = {
+			x: o.max.x - o.min.x,
+			y: o.max.y - o.min.y
+		};
+		//Calculate stepping based on steps
+		o.stepping = {
+			x: o.stepping && o.stepping.x || parseInt(o.stepping, 10) || (o.steps ? o.realMax.x/(o.steps.x || parseInt(o.steps, 10) || o.realMax.x) : 0),
+			y: o.stepping && o.stepping.y || parseInt(o.stepping, 10) || (o.steps ? o.realMax.y/(o.steps.y || parseInt(o.steps, 10) || o.realMax.y) : 0)
+		};
+	},
+
+	
+	keydown: function(keyCode, handle) {
+		if(/(37|38|39|40)/.test(keyCode)) {
 			this.moveTo({
-				y: this.convertValue(e.pageY - this.offset.top - this.currentHandle[0].offsetHeight/2, "y"),
-				x: this.convertValue(e.pageX - this.offset.left - this.currentHandle[0].offsetWidth/2, "x")
-			}, null, !this.options.distance);
-		},
+				x: /(37|39)/.test(keyCode) ? (keyCode == 37 ? '-' : '+') + '=' + this.oneStep("x") : 0,
+				y: /(38|40)/.test(keyCode) ? (keyCode == 38 ? '-' : '+') + '=' + this.oneStep("y") : 0
+			}, handle);
+		}
+	},
+	focus: function(handle,hard) {
+		this.currentHandle = $(handle).addClass('ui-slider-handle-active');
+		if (hard)
+			this.currentHandle.parent()[0].focus();
+	},
+	blur: function(handle) {
+		$(handle).removeClass('ui-slider-handle-active');
+		if(this.currentHandle && this.currentHandle[0] == handle) { this.previousHandle = this.currentHandle; this.currentHandle = null; };
+	},
+	click: function(e) {
+		// This method is only used if:
+		// - The user didn't click a handle
+		// - The Slider is not disabled
+		// - There is a current, or previous selected handle (otherwise we wouldn't know which one to move)
+		
+		var pointer = [e.pageX,e.pageY];
 		
+		var clickedHandle = false;
+		this.handle.each(function() {
+			if(this == e.target)
+				clickedHandle = true;
+		});
+		if (clickedHandle || this.disabled || !(this.currentHandle || this.previousHandle))
+			return;
 
+		// If a previous handle was focussed, focus it again
+		if (!this.currentHandle && this.previousHandle)
+			this.focus(this.previousHandle, true);
+		
+		// propagate only for distance > 0, otherwise propagation is done my drag
+		this.offset = this.element.offset();
+
+		this.moveTo({
+			y: this.convertValue(e.pageY - this.offset.top - this.currentHandle[0].offsetHeight/2, "y"),
+			x: this.convertValue(e.pageX - this.offset.left - this.currentHandle[0].offsetWidth/2, "x")
+		}, null, !this.options.distance);
+	},
 	
-		createRange: function() {
-			this.rangeElement = $('<div></div>')
-				.addClass('ui-slider-range')
-				.css({ position: 'absolute' })
-				.appendTo(this.element);
-			this.updateRange();
-		},
-		updateRange: function() {
-				var prop = this.options.axis == "vertical" ? "top" : "left";
-				var size = this.options.axis == "vertical" ? "height" : "width";
-				this.rangeElement.css(prop, parseInt($(this.handle[0]).css(prop),10) + this.handleSize(0, this.options.axis == "vertical" ? "y" : "x")/2);
-				this.rangeElement.css(size, parseInt($(this.handle[1]).css(prop),10) - parseInt($(this.handle[0]).css(prop),10));
-		},
-		getRange: function() {
-			return this.rangeElement ? this.convertValue(parseInt(this.rangeElement.css(this.options.axis == "vertical" ? "height" : "width"),10), this.options.axis == "vertical" ? "y" : "x") : null;
-		},
 
-		handleIndex: function() {
-			return this.handle.index(this.currentHandle[0]);
-		},
-		value: function(handle, axis) {
-			if(this.handle.length == 1) this.currentHandle = this.handle;
-			if(!axis) axis = this.options.axis == "vertical" ? "y" : "x";
 
-			var curHandle = $(handle != undefined && handle !== null ? this.handle[handle] || handle : this.currentHandle);
-			
-			if(curHandle.data("mouse").sliderValue) {
-				return parseInt(curHandle.data("mouse").sliderValue[axis],10);
-			} else {
-				return parseInt(((parseInt(curHandle.css(axis == "x" ? "left" : "top"),10) / (this.actualSize[axis == "x" ? "width" : "height"] - this.handleSize(handle,axis))) * this.options.realMax[axis]) + this.options.min[axis],10);
-			}
+	createRange: function() {
+		this.rangeElement = $('<div></div>')
+			.addClass('ui-slider-range')
+			.css({ position: 'absolute' })
+			.appendTo(this.element);
+		this.updateRange();
+	},
+	updateRange: function() {
+			var prop = this.options.axis == "vertical" ? "top" : "left";
+			var size = this.options.axis == "vertical" ? "height" : "width";
+			this.rangeElement.css(prop, parseInt($(this.handle[0]).css(prop),10) + this.handleSize(0, this.options.axis == "vertical" ? "y" : "x")/2);
+			this.rangeElement.css(size, parseInt($(this.handle[1]).css(prop),10) - parseInt($(this.handle[0]).css(prop),10));
+	},
+	getRange: function() {
+		return this.rangeElement ? this.convertValue(parseInt(this.rangeElement.css(this.options.axis == "vertical" ? "height" : "width"),10), this.options.axis == "vertical" ? "y" : "x") : null;
+	},
 
-		},
-		convertValue: function(value,axis) {
-			return this.options.min[axis] + (value / (this.actualSize[axis == "x" ? "width" : "height"] - this.handleSize(null,axis))) * this.options.realMax[axis];
-		},
+	handleIndex: function() {
+		return this.handle.index(this.currentHandle[0]);
+	},
+	value: function(handle, axis) {
+		if(this.handle.length == 1) this.currentHandle = this.handle;
+		if(!axis) axis = this.options.axis == "vertical" ? "y" : "x";
+
+		var curHandle = $(handle != undefined && handle !== null ? this.handle[handle] || handle : this.currentHandle);
 		
-		translateValue: function(value,axis) {
-			return ((value - this.options.min[axis]) / this.options.realMax[axis]) * (this.actualSize[axis == "x" ? "width" : "height"] - this.handleSize(null,axis));
-		},
-		translateRange: function(value,axis) {
-			if (this.rangeElement) {
-				if (this.currentHandle[0] == this.handle[0] && value >= this.translateValue(this.value(1),axis))
-					value = this.translateValue(this.value(1,axis) - this.oneStep(axis), axis);
-				if (this.currentHandle[0] == this.handle[1] && value <= this.translateValue(this.value(0),axis))
-					value = this.translateValue(this.value(0,axis) + this.oneStep(axis), axis);
-			}
-			if (this.options.handles) {
-				var handle = this.options.handles[this.handleIndex()];
-				if (value < this.translateValue(handle.min,axis)) {
-					value = this.translateValue(handle.min,axis);
-				} else if (value > this.translateValue(handle.max,axis)) {
-					value = this.translateValue(handle.max,axis);
-				}
+		if(curHandle.data("mouse").sliderValue) {
+			return parseInt(curHandle.data("mouse").sliderValue[axis],10);
+		} else {
+			return parseInt(((parseInt(curHandle.css(axis == "x" ? "left" : "top"),10) / (this.actualSize[axis == "x" ? "width" : "height"] - this.handleSize(handle,axis))) * this.options.realMax[axis]) + this.options.min[axis],10);
+		}
+
+	},
+	convertValue: function(value,axis) {
+		return this.options.min[axis] + (value / (this.actualSize[axis == "x" ? "width" : "height"] - this.handleSize(null,axis))) * this.options.realMax[axis];
+	},
+	
+	translateValue: function(value,axis) {
+		return ((value - this.options.min[axis]) / this.options.realMax[axis]) * (this.actualSize[axis == "x" ? "width" : "height"] - this.handleSize(null,axis));
+	},
+	translateRange: function(value,axis) {
+		if (this.rangeElement) {
+			if (this.currentHandle[0] == this.handle[0] && value >= this.translateValue(this.value(1),axis))
+				value = this.translateValue(this.value(1,axis) - this.oneStep(axis), axis);
+			if (this.currentHandle[0] == this.handle[1] && value <= this.translateValue(this.value(0),axis))
+				value = this.translateValue(this.value(0,axis) + this.oneStep(axis), axis);
+		}
+		if (this.options.handles) {
+			var handle = this.options.handles[this.handleIndex()];
+			if (value < this.translateValue(handle.min,axis)) {
+				value = this.translateValue(handle.min,axis);
+			} else if (value > this.translateValue(handle.max,axis)) {
+				value = this.translateValue(handle.max,axis);
 			}
-			return value;
-		},
-		translateLimits: function(value,axis) {
-			if (value >= this.actualSize[axis == "x" ? "width" : "height"] - this.handleSize(null,axis))
-				value = this.actualSize[axis == "x" ? "width" : "height"] - this.handleSize(null,axis);
-			if (value <= 0)
-				value = 0;
-			return value;
-		},
-		handleSize: function(handle,axis) {
-			return $(handle != undefined && handle !== null ? this.handle[handle] : this.currentHandle)[0]["offset"+(axis == "x" ? "Width" : "Height")];	
-		},
-		oneStep: function(axis) {
-			return this.options.stepping[axis] || 1;
-		},
+		}
+		return value;
+	},
+	translateLimits: function(value,axis) {
+		if (value >= this.actualSize[axis == "x" ? "width" : "height"] - this.handleSize(null,axis))
+			value = this.actualSize[axis == "x" ? "width" : "height"] - this.handleSize(null,axis);
+		if (value <= 0)
+			value = 0;
+		return value;
+	},
+	handleSize: function(handle,axis) {
+		return $(handle != undefined && handle !== null ? this.handle[handle] : this.currentHandle)[0]["offset"+(axis == "x" ? "Width" : "Height")];	
+	},
+	oneStep: function(axis) {
+		return this.options.stepping[axis] || 1;
+	},
 
 
-		start: function(e, handle) {
-		
-			var o = this.options;
-			if(this.disabled) return false;
+	start: function(e, handle) {
+	
+		var o = this.options;
+		if(this.disabled) return false;
 
-			// Prepare the outer size
-			this.actualSize = { width: this.element.outerWidth() , height: this.element.outerHeight() };
-		
-			// This is a especially ugly fix for strange blur events happening on mousemove events
-			if (!this.currentHandle)
-				this.focus(this.previousHandle, true); 
+		// Prepare the outer size
+		this.actualSize = { width: this.element.outerWidth() , height: this.element.outerHeight() };
+	
+		// This is a especially ugly fix for strange blur events happening on mousemove events
+		if (!this.currentHandle)
+			this.focus(this.previousHandle, true); 
 
-			this.offset = this.element.offset();
-			
-			this.handleOffset = this.currentHandle.offset();
-			this.clickOffset = { top: e.pageY - this.handleOffset.top, left: e.pageX - this.handleOffset.left };
-			
-			this.firstValue = this.value();
-			
-			this.propagate('start', e);
-			return true;
-						
-		},
-		stop: function(e) {
-			this.propagate('stop', e);
-			if (this.firstValue != this.value())
-				this.propagate('change', e);
-			// This is a especially ugly fix for strange blur events happening on mousemove events
-			this.focus(this.currentHandle, true);
-			return false;
-		},
-		drag: function(e, handle) {
+		this.offset = this.element.offset();
+		
+		this.handleOffset = this.currentHandle.offset();
+		this.clickOffset = { top: e.pageY - this.handleOffset.top, left: e.pageX - this.handleOffset.left };
+		
+		this.firstValue = this.value();
+		
+		this.propagate('start', e);
+		return true;
+					
+	},
+	stop: function(e) {
+		this.propagate('stop', e);
+		if (this.firstValue != this.value())
+			this.propagate('change', e);
+		// This is a especially ugly fix for strange blur events happening on mousemove events
+		this.focus(this.currentHandle, true);
+		return false;
+	},
+	drag: function(e, handle) {
 
-			var o = this.options;
-			var position = { top: e.pageY - this.offset.top - this.clickOffset.top, left: e.pageX - this.offset.left - this.clickOffset.left};
-			if(!this.currentHandle) this.focus(this.previousHandle, true); //This is a especially ugly fix for strange blur events happening on mousemove events
+		var o = this.options;
+		var position = { top: e.pageY - this.offset.top - this.clickOffset.top, left: e.pageX - this.offset.left - this.clickOffset.left};
+		if(!this.currentHandle) this.focus(this.previousHandle, true); //This is a especially ugly fix for strange blur events happening on mousemove events
 
-			position.left = this.translateLimits(position.left, "x");
-			position.top = this.translateLimits(position.top, "y");
-			
-			if (o.stepping.x) {
-				var value = this.convertValue(position.left, "x");
-				value = Math.round(value / o.stepping.x) * o.stepping.x;
-				position.left = this.translateValue(value, "x");	
-			}
-			if (o.stepping.y) {
-				var value = this.convertValue(position.top, "y");
-				value = Math.round(value / o.stepping.y) * o.stepping.y;
-				position.top = this.translateValue(value, "y");	
-			}
-			
-			position.left = this.translateRange(position.left, "x");
-			position.top = this.translateRange(position.top, "y");
+		position.left = this.translateLimits(position.left, "x");
+		position.top = this.translateLimits(position.top, "y");
+		
+		if (o.stepping.x) {
+			var value = this.convertValue(position.left, "x");
+			value = Math.round(value / o.stepping.x) * o.stepping.x;
+			position.left = this.translateValue(value, "x");	
+		}
+		if (o.stepping.y) {
+			var value = this.convertValue(position.top, "y");
+			value = Math.round(value / o.stepping.y) * o.stepping.y;
+			position.top = this.translateValue(value, "y");	
+		}
+		
+		position.left = this.translateRange(position.left, "x");
+		position.top = this.translateRange(position.top, "y");
 
-			if(o.axis != "vertical") this.currentHandle.css({ left: position.left });
-			if(o.axis != "horizontal") this.currentHandle.css({ top: position.top });
-			
-			//Store the slider's value
-			this.currentHandle.data("mouse").sliderValue = {
-				x: Math.round(this.convertValue(position.left, "x")) || 0,
-				y: Math.round(this.convertValue(position.top, "y")) || 0
-			};
-			
-			if (this.rangeElement)
-				this.updateRange();
-			this.propagate('slide', e);
-			return false;
-		},
+		if(o.axis != "vertical") this.currentHandle.css({ left: position.left });
+		if(o.axis != "horizontal") this.currentHandle.css({ top: position.top });
 		
-		moveTo: function(value, handle, noPropagation) {
+		//Store the slider's value
+		this.currentHandle.data("mouse").sliderValue = {
+			x: Math.round(this.convertValue(position.left, "x")) || 0,
+			y: Math.round(this.convertValue(position.top, "y")) || 0
+		};
+		
+		if (this.rangeElement)
+			this.updateRange();
+		this.propagate('slide', e);
+		return false;
+	},
+	
+	moveTo: function(value, handle, noPropagation) {
 
-			var o = this.options;
+		var o = this.options;
 
-			// Prepare the outer size
-			this.actualSize = { width: this.element.outerWidth() , height: this.element.outerHeight() };
+		// Prepare the outer size
+		this.actualSize = { width: this.element.outerWidth() , height: this.element.outerHeight() };
 
-			//If no handle has been passed, no current handle is available and we have multiple handles, return false
-			if (handle == undefined && !this.currentHandle && this.handle.length != 1)
-				return false; 
-			
-			//If only one handle is available, use it
-			if (handle == undefined && !this.currentHandle)
-				handle = 0;
-			
-			if (handle != undefined)
-				this.currentHandle = this.previousHandle = $(this.handle[handle] || handle);
+		//If no handle has been passed, no current handle is available and we have multiple handles, return false
+		if (handle == undefined && !this.currentHandle && this.handle.length != 1)
+			return false; 
+		
+		//If only one handle is available, use it
+		if (handle == undefined && !this.currentHandle)
+			handle = 0;
+		
+		if (handle != undefined)
+			this.currentHandle = this.previousHandle = $(this.handle[handle] || handle);
 
 
-			if(value.x !== undefined && value.y !== undefined) {
-				var x = value.x, y = value.y;
-			} else {
-				var x = value, y = value;
-			}
+		if(value.x !== undefined && value.y !== undefined) {
+			var x = value.x, y = value.y;
+		} else {
+			var x = value, y = value;
+		}
 
-			if(x !== undefined && x.constructor != Number) {
-				var me = /^\-\=/.test(x), pe = /^\+\=/.test(x);
-				if(me || pe) {
-					x = this.value(null, "x") + parseInt(x.replace(me ? '=' : '+=', ''), 10);
-				} else {
-					x = isNaN(parseInt(x, 10)) ? undefined : parseInt(x, 10);
-				}
+		if(x !== undefined && x.constructor != Number) {
+			var me = /^\-\=/.test(x), pe = /^\+\=/.test(x);
+			if(me || pe) {
+				x = this.value(null, "x") + parseInt(x.replace(me ? '=' : '+=', ''), 10);
+			} else {
+				x = isNaN(parseInt(x, 10)) ? undefined : parseInt(x, 10);
 			}
-			
-			if(y !== undefined && y.constructor != Number) {
-				var me = /^\-\=/.test(y), pe = /^\+\=/.test(y);
-				if(me || pe) {
-					y = this.value(null, "y") + parseInt(y.replace(me ? '=' : '+=', ''), 10);
-				} else {
-					y = isNaN(parseInt(y, 10)) ? undefined : parseInt(y, 10);
-				}
+		}
+		
+		if(y !== undefined && y.constructor != Number) {
+			var me = /^\-\=/.test(y), pe = /^\+\=/.test(y);
+			if(me || pe) {
+				y = this.value(null, "y") + parseInt(y.replace(me ? '=' : '+=', ''), 10);
+			} else {
+				y = isNaN(parseInt(y, 10)) ? undefined : parseInt(y, 10);
 			}
+		}
 
-			if(o.axis != "vertical" && x !== undefined) {
-				if(o.stepping.x) x = Math.round(x / o.stepping.x) * o.stepping.x;
-				x = this.translateValue(x, "x");
-				x = this.translateLimits(x, "x");
-				x = this.translateRange(x, "x");
-				this.currentHandle.css({ left: x });
-			}
+		if(o.axis != "vertical" && x !== undefined) {
+			if(o.stepping.x) x = Math.round(x / o.stepping.x) * o.stepping.x;
+			x = this.translateValue(x, "x");
+			x = this.translateLimits(x, "x");
+			x = this.translateRange(x, "x");
+			this.currentHandle.css({ left: x });
+		}
 
-			if(o.axis != "horizontal" && y !== undefined) {
-				if(o.stepping.y) y = Math.round(y / o.stepping.y) * o.stepping.y;
-				y = this.translateValue(y, "y");
-				y = this.translateLimits(y, "y");
-				y = this.translateRange(y, "y");
-				this.currentHandle.css({ top: y });
-			}
-			
-			if (this.rangeElement)
-				this.updateRange();
-				
-			//Store the slider's value
-			this.currentHandle.data("mouse").sliderValue = {
-				x: Math.round(this.convertValue(x, "x")) || 0,
-				y: Math.round(this.convertValue(y, "y")) || 0
-			};
+		if(o.axis != "horizontal" && y !== undefined) {
+			if(o.stepping.y) y = Math.round(y / o.stepping.y) * o.stepping.y;
+			y = this.translateValue(y, "y");
+			y = this.translateLimits(y, "y");
+			y = this.translateRange(y, "y");
+			this.currentHandle.css({ top: y });
+		}
 		
-			if (!noPropagation) {
-				this.propagate('start', null);
-				this.propagate('stop', null);
-				this.propagate('change', null);
-				this.propagate("slide", null);
-			}
+		if (this.rangeElement)
+			this.updateRange();
+			
+		//Store the slider's value
+		this.currentHandle.data("mouse").sliderValue = {
+			x: Math.round(this.convertValue(x, "x")) || 0,
+			y: Math.round(this.convertValue(y, "y")) || 0
+		};
+	
+		if (!noPropagation) {
+			this.propagate('start', null);
+			this.propagate('stop', null);
+			this.propagate('change', null);
+			this.propagate("slide", null);
 		}
-	});
+	}
+});
 
-	$.ui.slider.getter = "value";
-	
-	$.ui.slider.defaults = {
-		handle: ".ui-slider-handle",
-		distance: 1
-	};
+$.ui.slider.getter = "value";
+
+$.ui.slider.defaults = {
+	handle: ".ui-slider-handle",
+	distance: 1
+};
 
 })(jQuery);
diff --git a/ui/source/ui.sortable.js b/ui/source/ui.sortable.js
index d0eca57b2..81135eff8 100644
--- a/ui/source/ui.sortable.js
+++ b/ui/source/ui.sortable.js
@@ -13,574 +13,573 @@
  * Revision: $Id: ui.sortable.js 5433 2008-05-04 20:07:17Z joern.zaefferer $
  */
 ;(function($) {
+
+function contains(a, b) { 
+    var safari2 = $.browser.safari && $.browser.version < 522; 
+    if (a.contains && !safari2) { 
+        return a.contains(b); 
+    } 
+    if (a.compareDocumentPosition) 
+        return !!(a.compareDocumentPosition(b) & 16); 
+    while (b = b.parentNode) 
+          if (b == a) return true; 
+    return false; 
+};
+
+$.widget("ui.sortable", $.extend($.ui.mouse, {
+	init: function() {
+
+		var o = this.options;
+		this.containerCache = {};
+		this.element.addClass("ui-sortable");
 	
-	function contains(a, b) { 
-	    var safari2 = $.browser.safari && $.browser.version < 522; 
-	    if (a.contains && !safari2) { 
-	        return a.contains(b); 
-	    } 
-	    if (a.compareDocumentPosition) 
-	        return !!(a.compareDocumentPosition(b) & 16); 
-	    while (b = b.parentNode) 
-	          if (b == a) return true; 
-	    return false; 
-	};
-	
-	$.widget("ui.sortable", $.extend($.ui.mouse, {
-		init: function() {
+		//Get the items
+		this.refresh();
 
-			var o = this.options;
-			this.containerCache = {};
-			this.element.addClass("ui-sortable");
+		//Let's determine if the items are floating
+		this.floating = this.items.length ? (/left|right/).test(this.items[0].item.css('float')) : false;
 		
-			//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
-			if(!(/(relative|absolute|fixed)/).test(this.element.css('position'))) this.element.css('position', 'relative');
-			this.offset = this.element.offset();
-	
-			//Initialize mouse events for interaction
-			this.mouseInit();
-			
-		},
-		plugins: {},
-		ui: function(inst) {
-			return {
-				helper: (inst || this)["helper"],
-				placeholder: (inst || this)["placeholder"] || $([]),
-				position: (inst || this)["position"],
-				absolutePosition: (inst || this)["positionAbs"],
-				options: this.options,
-				element: this.element,
-				item: (inst || this)["currentItem"],
-				sender: inst ? inst.element : null
-			};		
-		},
-		propagate: function(n,e,inst, noPropagation) {
-			$.ui.plugin.call(this, n, [e, this.ui(inst)]);
-			if(!noPropagation) this.element.triggerHandler(n == "sort" ? n : "sort"+n, [e, this.ui(inst)], this.options[n]);
-		},
-		serialize: function(o) {
-			
-			
-			
-			var items = ($.isFunction(this.options.items) ? this.options.items.call(this.element) : $(this.options.items, this.element)).not('.ui-sortable-helper'); //Only the items of the sortable itself
-			var str = []; o = o || {};
-			
-			items.each(function() {
-				var res = ($(this).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
-				if(res) str.push((o.key || res[1])+'[]='+(o.key ? res[1] : res[2]));
-			});
-			
-			return str.join('&');
-			
-		},
-		toArray: function(attr) {
-			var items = ($.isFunction(this.options.items) ? this.options.items.call(this.element) : $(this.options.items, this.element)).not('.ui-sortable-helper'); //Only the items of the sortable itself
-			var ret = [];
-
-			items.each(function() { ret.push($(this).attr(attr || 'id')); });
-			return ret;
-		},
-		enable: function() {
-			this.element.removeClass("ui-sortable-disabled");
-			this.options.disabled = false;
-		},
-		disable: function() {
-			this.element.addClass("ui-sortable-disabled");
-			this.options.disabled = true;
-		},
-		/* Be careful with the following core functions */
-		intersectsWith: function(item) {
-			
-			var x1 = this.positionAbs.left, x2 = x1 + this.helperProportions.width,
+		//Let's determine the parent's offset
+		if(!(/(relative|absolute|fixed)/).test(this.element.css('position'))) this.element.css('position', 'relative');
+		this.offset = this.element.offset();
+
+		//Initialize mouse events for interaction
+		this.mouseInit();
+		
+	},
+	plugins: {},
+	ui: function(inst) {
+		return {
+			helper: (inst || this)["helper"],
+			placeholder: (inst || this)["placeholder"] || $([]),
+			position: (inst || this)["position"],
+			absolutePosition: (inst || this)["positionAbs"],
+			options: this.options,
+			element: this.element,
+			item: (inst || this)["currentItem"],
+			sender: inst ? inst.element : null
+		};		
+	},
+	propagate: function(n,e,inst, noPropagation) {
+		$.ui.plugin.call(this, n, [e, this.ui(inst)]);
+		if(!noPropagation) this.element.triggerHandler(n == "sort" ? n : "sort"+n, [e, this.ui(inst)], this.options[n]);
+	},
+	serialize: function(o) {
+		
+		
+		
+		var items = ($.isFunction(this.options.items) ? this.options.items.call(this.element) : $(this.options.items, this.element)).not('.ui-sortable-helper'); //Only the items of the sortable itself
+		var str = []; o = o || {};
+		
+		items.each(function() {
+			var res = ($(this).attr(o.attribute || 'id') || '').match(o.expression || (/(.+)[-=_](.+)/));
+			if(res) str.push((o.key || res[1])+'[]='+(o.key ? res[1] : res[2]));
+		});
+		
+		return str.join('&');
+		
+	},
+	toArray: function(attr) {
+		var items = ($.isFunction(this.options.items) ? this.options.items.call(this.element) : $(this.options.items, this.element)).not('.ui-sortable-helper'); //Only the items of the sortable itself
+		var ret = [];
+
+		items.each(function() { ret.push($(this).attr(attr || 'id')); });
+		return ret;
+	},
+	enable: function() {
+		this.element.removeClass("ui-sortable-disabled");
+		this.options.disabled = false;
+	},
+	disable: function() {
+		this.element.addClass("ui-sortable-disabled");
+		this.options.disabled = true;
+	},
+	/* 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;
+
+		if(this.options.tolerance == "pointer") {
+			return (y1 + this.offset.click.top > t && y1 + this.offset.click.top < b && x1 + this.offset.click.left > l && x1 + this.offset.click.left < r);
+		} 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
+		
+		}
+		
+	},
+	intersectsWithEdge: 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, 
+		var l = item.left, r = l + item.width, 
 			t = item.top, b = t + item.height;
 
-			if(this.options.tolerance == "pointer") {
-				return (y1 + this.offset.click.top > t && y1 + this.offset.click.top < b && x1 + this.offset.click.left > l && x1 + this.offset.click.left < r);
-			} 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
+		if(this.options.tolerance == "pointer" || (this.options.tolerance == "guess" && this.currentItem[0]['offset'+(this.floating ? 'Width' : 'Height')] > item.item[0]['offset'+(this.floating ? 'Width' : 'Height')])) {
+
+			if(!(y1 + this.offset.click.top > t && y1 + this.offset.click.top < b && x1 + this.offset.click.left > l && x1 + this.offset.click.left < r)) return false;
 			
+			if(this.floating) {
+				if(x1 + this.offset.click.left > l && x1 + this.offset.click.left < l + item.width/2) return 2;
+				if(x1 + this.offset.click.left > l+item.width/2 && x1 + this.offset.click.left < r) return 1;
+			} else {
+				if(y1 + this.offset.click.top > t && y1 + this.offset.click.top < t + item.height/2) return 2;
+				if(y1 + this.offset.click.top > t+item.height/2 && y1 + this.offset.click.top < b) return 1;
 			}
-			
-		},
-		intersectsWithEdge: 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;
-
-			if(this.options.tolerance == "pointer" || (this.options.tolerance == "guess" && this.currentItem[0]['offset'+(this.floating ? 'Width' : 'Height')] > item.item[0]['offset'+(this.floating ? 'Width' : 'Height')])) {
-
-				if(!(y1 + this.offset.click.top > t && y1 + this.offset.click.top < b && x1 + this.offset.click.left > l && x1 + this.offset.click.left < r)) return false;
-				
-				if(this.floating) {
-					if(x1 + this.offset.click.left > l && x1 + this.offset.click.left < l + item.width/2) return 2;
-					if(x1 + this.offset.click.left > l+item.width/2 && x1 + this.offset.click.left < r) return 1;
-				} else {
-					if(y1 + this.offset.click.top > t && y1 + this.offset.click.top < t + item.height/2) return 2;
-					if(y1 + this.offset.click.top > t+item.height/2 && y1 + this.offset.click.top < b) return 1;
-				}
 
+		} else {
+		
+			if (!(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 )) return false; // Top Half
+			
+			if(this.floating) {
+				if(x2 > l && x1 < l) return 2; //Crosses left edge
+				if(x1 < r && x2 > r) return 1; //Crosses right edge
 			} else {
-			
-				if (!(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 )) return false; // Top Half
-				
-				if(this.floating) {
-					if(x2 > l && x1 < l) return 2; //Crosses left edge
-					if(x1 < r && x2 > r) return 1; //Crosses right edge
-				} else {
-					if(y2 > t && y1 < t) return 1; //Crosses top edge
-					if(y1 < b && y2 > b) return 2; //Crosses bottom edge
-				}
-			
+				if(y2 > t && y1 < t) return 1; //Crosses top edge
+				if(y1 < b && y2 > b) return 2; //Crosses bottom edge
 			}
-			
-			return false;
-			
-		},
-		refresh: function() {
-			this.refreshItems();
-			this.refreshPositions();
-		},
-		refreshItems: function() {
-			
-			this.items = [];
-			this.containers = [this];
-			var items = this.items;
-			var queries = [$.isFunction(this.options.items) ? this.options.items.call(this.element) : $(this.options.items, this.element)];
-			
-			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.options.disabled) {
-							queries.push($.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element));
-							this.containers.push(inst);
-						}
-					};
+		
+		}
+		
+		return false;
+		
+	},
+	refresh: function() {
+		this.refreshItems();
+		this.refreshPositions();
+	},
+	refreshItems: function() {
+		
+		this.items = [];
+		this.containers = [this];
+		var items = this.items;
+		var queries = [$.isFunction(this.options.items) ? this.options.items.call(this.element) : $(this.options.items, this.element)];
+		
+		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.options.disabled) {
+						queries.push($.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element));
+						this.containers.push(inst);
+					}
 				};
-			}
+			};
+		}
 
-			for (var i = queries.length - 1; i >= 0; i--){
-				queries[i].each(function() {
-					$.data(this, 'sortable-item', true); // Data for target checking (mouse manager)
-					items.push({
-						item: $(this),
-						width: 0, height: 0,
-						left: 0, top: 0
-					});
+		for (var i = queries.length - 1; i >= 0; i--){
+			queries[i].each(function() {
+				$.data(this, 'sortable-item', true); // Data for target checking (mouse manager)
+				items.push({
+					item: $(this),
+					width: 0, height: 0,
+					left: 0, top: 0
 				});
-			};
+			});
+		};
 
-		},
-		refreshPositions: function(fast) {
-			for (var i = this.items.length - 1; i >= 0; i--){
-				var t = this.items[i].item;
-				if(!fast) this.items[i].width = (this.options.toleranceElement ? $(this.options.toleranceElement, t) : t).outerWidth();
-				if(!fast) this.items[i].height = (this.options.toleranceElement ? $(this.options.toleranceElement, t) : t).outerHeight();
-				var p = (this.options.toleranceElement ? $(this.options.toleranceElement, t) : t).offset();
-				this.items[i].left = p.left;
-				this.items[i].top = p.top;
-			};
-			for (var i = this.containers.length - 1; i >= 0; i--){
-				var p =this.containers[i].element.offset();
-				this.containers[i].containerCache.left = p.left;
-				this.containers[i].containerCache.top = p.top;
-				this.containers[i].containerCache.width	= this.containers[i].element.outerWidth();
-				this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
+	},
+	refreshPositions: function(fast) {
+		for (var i = this.items.length - 1; i >= 0; i--){
+			var t = this.items[i].item;
+			if(!fast) this.items[i].width = (this.options.toleranceElement ? $(this.options.toleranceElement, t) : t).outerWidth();
+			if(!fast) this.items[i].height = (this.options.toleranceElement ? $(this.options.toleranceElement, t) : t).outerHeight();
+			var p = (this.options.toleranceElement ? $(this.options.toleranceElement, t) : t).offset();
+			this.items[i].left = p.left;
+			this.items[i].top = p.top;
+		};
+		for (var i = this.containers.length - 1; i >= 0; i--){
+			var p =this.containers[i].element.offset();
+			this.containers[i].containerCache.left = p.left;
+			this.containers[i].containerCache.top = p.top;
+			this.containers[i].containerCache.width	= this.containers[i].element.outerWidth();
+			this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
+		};
+	},
+	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");
+	},
+	createPlaceholder: function(that) {
+		
+		var self = that || this, o = self.options;
+
+		if(o.placeholder.constructor == String) {
+			var className = o.placeholder;
+			o.placeholder = {
+				element: function() {
+					return $('<div></div>').addClass(className)[0];
+				},
+				update: function(i, p) {
+					p.css(i.offset()).css({ width: i.outerWidth(), height: i.outerHeight() });
+				}
 			};
-		},
-		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");
-		},
-		createPlaceholder: function(that) {
-			
-			var self = that || this, o = self.options;
-	
-			if(o.placeholder.constructor == String) {
-				var className = o.placeholder;
-				o.placeholder = {
-					element: function() {
-						return $('<div></div>').addClass(className)[0];
-					},
-					update: function(i, p) {
-						p.css(i.offset()).css({ width: i.outerWidth(), height: i.outerHeight() });
-					}
-				};
-			}
-			
-			self.placeholder = $(o.placeholder.element.call(self.element, self.currentItem)).appendTo('body').css({ position: 'absolute' });
-			o.placeholder.update.call(self.element, self.currentItem, self.placeholder);
-		},
-		contactContainers: function(e) {
-			for (var i = this.containers.length - 1; i >= 0; i--){
+		}
+		
+		self.placeholder = $(o.placeholder.element.call(self.element, self.currentItem)).appendTo('body').css({ position: 'absolute' });
+		o.placeholder.update.call(self.element, self.currentItem, self.placeholder);
+	},
+	contactContainers: function(e) {
+		for (var i = this.containers.length - 1; i >= 0; i--){
 
-				if(this.intersectsWith(this.containers[i].containerCache)) {
-					if(!this.containers[i].containerCache.over) {
-						
+			if(this.intersectsWith(this.containers[i].containerCache)) {
+				if(!this.containers[i].containerCache.over) {
+					
 
-						if(this.currentContainer != this.containers[i]) {
-							
-							//When entering a new container, we will find the item with the least distance and append our item near it
-							var dist = 10000; var itemWithLeastDistance = null; var base = this.positionAbs[this.containers[i].floating ? 'left' : 'top'];
-							for (var j = this.items.length - 1; j >= 0; j--) {
-								if(!contains(this.containers[i].element[0], this.items[j].item[0])) continue;
-								var cur = this.items[j][this.containers[i].floating ? 'left' : 'top'];
-								if(Math.abs(cur - base) < dist) {
-									dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
-								}
-							}
-							
-							if(!itemWithLeastDistance && !this.options.dropOnEmpty) //Check if dropOnEmpty is enabled
-								continue;
-							
-							//We also need to exchange the placeholder
-							if(this.placeholder) this.placeholder.remove();
-							if(this.containers[i].options.placeholder) {
-								this.containers[i].createPlaceholder(this);
-							} else {
-								this.placeholder = null;;
+					if(this.currentContainer != this.containers[i]) {
+						
+						//When entering a new container, we will find the item with the least distance and append our item near it
+						var dist = 10000; var itemWithLeastDistance = null; var base = this.positionAbs[this.containers[i].floating ? 'left' : 'top'];
+						for (var j = this.items.length - 1; j >= 0; j--) {
+							if(!contains(this.containers[i].element[0], this.items[j].item[0])) continue;
+							var cur = this.items[j][this.containers[i].floating ? 'left' : 'top'];
+							if(Math.abs(cur - base) < dist) {
+								dist = Math.abs(cur - base); itemWithLeastDistance = this.items[j];
 							}
-							
-							
-							itemWithLeastDistance ? this.rearrange(e, itemWithLeastDistance) : this.rearrange(e, null, this.containers[i].element);
-							this.propagate("change", e); //Call plugins and callbacks
-							this.containers[i].propagate("change", e, this); //Call plugins and callbacks
-							this.currentContainer = this.containers[i];
-
 						}
 						
-						this.containers[i].propagate("over", e, this);
-						this.containers[i].containerCache.over = 1;
-					}
-				} else {
-					if(this.containers[i].containerCache.over) {
-						this.containers[i].propagate("out", e, this);
-						this.containers[i].containerCache.over = 0;
+						if(!itemWithLeastDistance && !this.options.dropOnEmpty) //Check if dropOnEmpty is enabled
+							continue;
+						
+						//We also need to exchange the placeholder
+						if(this.placeholder) this.placeholder.remove();
+						if(this.containers[i].options.placeholder) {
+							this.containers[i].createPlaceholder(this);
+						} else {
+							this.placeholder = null;;
+						}
+						
+						
+						itemWithLeastDistance ? this.rearrange(e, itemWithLeastDistance) : this.rearrange(e, null, this.containers[i].element);
+						this.propagate("change", e); //Call plugins and callbacks
+						this.containers[i].propagate("change", e, this); //Call plugins and callbacks
+						this.currentContainer = this.containers[i];
+
 					}
+					
+					this.containers[i].propagate("over", e, this);
+					this.containers[i].containerCache.over = 1;
 				}
-				
-			};			
-		},
-		mouseStart: function(e, overrideHandle, noActivation) {
-		
-			var o = this.options;
-			this.currentContainer = this;
-			
-			if(this.options.disabled || this.options.type == 'static') return false;
-
-			//Find out if the clicked node (or one of its parents) is a actual item in this.items
-			var currentItem = null, nodes = $(e.target).parents().each(function() {	
-				if($.data(this, 'sortable-item')) {
-					currentItem = $(this);
-					return false;
+			} else {
+				if(this.containers[i].containerCache.over) {
+					this.containers[i].propagate("out", e, this);
+					this.containers[i].containerCache.over = 0;
 				}
-			});
-			if($.data(e.target, 'sortable-item')) currentItem = $(e.target);
+			}
+			
+		};			
+	},
+	mouseStart: function(e, overrideHandle, noActivation) {
+	
+		var o = this.options;
+		this.currentContainer = this;
 		
-			if(!currentItem) return false;
-			if(this.options.handle && !overrideHandle) {
-				var validHandle = false;
-				$(this.options.handle, currentItem).each(function() { if(this == e.target) validHandle = true; });
-				if(!validHandle) return false;
+		if(this.options.disabled || this.options.type == 'static') return false;
+
+		//Find out if the clicked node (or one of its parents) is a actual item in this.items
+		var currentItem = null, nodes = $(e.target).parents().each(function() {	
+			if($.data(this, 'sortable-item')) {
+				currentItem = $(this);
+				return false;
 			}
-				
-			this.currentItem = currentItem;
+		});
+		if($.data(e.target, 'sortable-item')) currentItem = $(e.target);
+	
+		if(!currentItem) return false;
+		if(this.options.handle && !overrideHandle) {
+			var validHandle = false;
+			$(this.options.handle, currentItem).each(function() { if(this == e.target) validHandle = true; });
+			if(!validHandle) return false;
+		}
+			
+		this.currentItem = currentItem;
 
-			this.refresh();
+		this.refresh();
 
-			//Create and append the visible helper			
-			this.helper = typeof o.helper == 'function' ? $(o.helper.apply(this.element[0], [e, this.currentItem])) : this.currentItem.clone();
-			if(!this.helper.parents('body').length) this.helper.appendTo((o.appendTo != 'parent' ? o.appendTo : this.currentItem[0].parentNode)); //Add the helper to the DOM if that didn't happen already
-			this.helper.css({ position: 'absolute', clear: 'both' }).addClass('ui-sortable-helper'); //Position it absolutely and add a helper class
+		//Create and append the visible helper			
+		this.helper = typeof o.helper == 'function' ? $(o.helper.apply(this.element[0], [e, this.currentItem])) : this.currentItem.clone();
+		if(!this.helper.parents('body').length) this.helper.appendTo((o.appendTo != 'parent' ? o.appendTo : this.currentItem[0].parentNode)); //Add the helper to the DOM if that didn't happen already
+		this.helper.css({ position: 'absolute', clear: 'both' }).addClass('ui-sortable-helper'); //Position it absolutely and add a helper class
 
-			/*
-			 * - Position generation -
-			 * This block generates everything position related - it's the core of draggables.
-			 */
+		/*
+		 * - Position generation -
+		 * This block generates everything position related - it's the core of draggables.
+		 */
 
-			this.margins = {																				//Cache the margins
-				left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
-				top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
-			};		
+		this.margins = {																				//Cache the margins
+			left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
+			top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
+		};		
+	
+		this.offset = this.currentItem.offset();														//The element's absolute position on the page
+		this.offset = {																					//Substract the margins from the element's absolute offset
+			top: this.offset.top - this.margins.top,
+			left: this.offset.left - this.margins.left
+		};
 		
-			this.offset = this.currentItem.offset();														//The element's absolute position on the page
-			this.offset = {																					//Substract the margins from the element's absolute offset
-				top: this.offset.top - this.margins.top,
-				left: this.offset.left - this.margins.left
-			};
-			
-			this.offset.click = {																			//Where the click happened, relative to the element
-				left: e.pageX - this.offset.left,
-				top: e.pageY - this.offset.top
-			};
-			
-			this.offsetParent = this.helper.offsetParent(); var po = this.offsetParent.offset();			//Get the offsetParent and cache its position
+		this.offset.click = {																			//Where the click happened, relative to the element
+			left: e.pageX - this.offset.left,
+			top: e.pageY - this.offset.top
+		};
+		
+		this.offsetParent = this.helper.offsetParent(); var po = this.offsetParent.offset();			//Get the offsetParent and cache its position
 
-			this.offset.parent = {																			//Store its position plus border
-				top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
-				left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
-			};
+		this.offset.parent = {																			//Store its position plus border
+			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
+			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
+		};
+	
+		this.originalPosition = this.generatePosition(e);												//Generate the original position
+		this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() };//Cache the helper size
 		
-			this.originalPosition = this.generatePosition(e);												//Generate the original position
-			this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() };//Cache the helper size
-			
-			if(o.cursorAt) {
-				if(o.cursorAt.left != undefined) this.offset.click.left = o.cursorAt.left;
-				if(o.cursorAt.right != undefined) this.offset.click.left = this.helperProportions.width - o.cursorAt.right;
-				if(o.cursorAt.top != undefined) this.offset.click.top = o.cursorAt.top;
-				if(o.cursorAt.bottom != undefined) this.offset.click.top = this.helperProportions.height - o.cursorAt.bottom;
-			}
+		if(o.cursorAt) {
+			if(o.cursorAt.left != undefined) this.offset.click.left = o.cursorAt.left;
+			if(o.cursorAt.right != undefined) this.offset.click.left = this.helperProportions.width - o.cursorAt.right;
+			if(o.cursorAt.top != undefined) this.offset.click.top = o.cursorAt.top;
+			if(o.cursorAt.bottom != undefined) this.offset.click.top = this.helperProportions.height - o.cursorAt.bottom;
+		}
 
-			this.domPosition = this.currentItem.prev()[0];													//Cache the former DOM position
+		this.domPosition = this.currentItem.prev()[0];													//Cache the former DOM position
 
-			/*
-			 * - Position constraining -
-			 * Here we prepare position constraining like grid and containment.
-			 */	
-			
-			if(o.containment) {
-				if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
-				if(o.containment == 'document') this.containment = [0,0,$(document).width(), ($(document).height() || document.body.parentNode.scrollHeight)];
-				if(!(/^(document|window|parent)$/).test(o.containment)) {
-					var ce = $(o.containment)[0];
-					var co = $(o.containment).offset();
-					
-					this.containment = [
-						co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.parent.left,
-						co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.parent.top,
-						co.left+Math.max(ce.scrollWidth,ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.parent.left - this.helperProportions.width - this.margins.left - (parseInt(this.currentItem.css("marginRight"),10) || 0),
-						co.top+Math.max(ce.scrollHeight,ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.parent.top - this.helperProportions.height - this.margins.top - (parseInt(this.currentItem.css("marginBottom"),10) || 0)
-					];
-				}
-			}
-			
-			//If o.placeholder is used, create a new element at the given position with the class
-			if(o.placeholder) this.createPlaceholder();
-			
-			//Call plugins and callbacks
-			this.propagate("start", e);
-			this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() };//Recache the helper size
-
-			if(this.options.placeholder != 'clone') this.currentItem.css('visibility', 'hidden'); //Set the original element visibility to hidden to still fill out the white space
-			
-			if(!noActivation) {
-				 for (var i = this.containers.length - 1; i >= 0; i--) { this.containers[i].propagate("activate", e, this); } //Post 'activate' events to possible containers
-			}
-			
-			//Prepare possible droppables
-			if($.ui.ddmanager) $.ui.ddmanager.current = this;
-			if ($.ui.ddmanager && !o.dropBehaviour) $.ui.ddmanager.prepareOffsets(this, e);
-
-			this.dragging = true;
-
-			this.mouseDrag(e); //Execute the drag once - this causes the helper not to be visible before getting its correct position
-			return true;
-
-
-		},
-		convertPositionTo: function(d, pos) {
-			if(!pos) pos = this.position;
-			var mod = d == "absolute" ? 1 : -1;
-			return {
-				top: (
-					pos.top																	// the calculated relative position
-					+ this.offset.parent.top * mod											// The offsetParent's offset without borders (offset + border)
-					- (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollTop) * mod	// The offsetParent's scroll position
-					+ this.margins.top * mod												//Add the margin (you don't want the margin counting in intersection methods)
-				),
-				left: (
-					pos.left																// the calculated relative position
-					+ this.offset.parent.left * mod											// The offsetParent's offset without borders (offset + border)
-					- (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft) * mod	// The offsetParent's scroll position
-					+ this.margins.left * mod												//Add the margin (you don't want the margin counting in intersection methods)
-				)
-			};
-		},
-		generatePosition: function(e) {
-			
-			var o = this.options;
-			var position = {
-				top: (
-					e.pageY																	// The absolute mouse position
-					- this.offset.click.top													// Click offset (relative to the element)
-					- this.offset.parent.top												// The offsetParent's offset without borders (offset + border)
-					+ (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollTop)	// The offsetParent's scroll position, not if the element is fixed
-				),
-				left: (
-					e.pageX																	// The absolute mouse position
-					- this.offset.click.left												// Click offset (relative to the element)
-					- this.offset.parent.left												// The offsetParent's offset without borders (offset + border)
-					+ (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft)	// The offsetParent's scroll position, not if the element is fixed
-				)
-			};
-			
-			if(!this.originalPosition) return position;										//If we are not dragging yet, we won't check for options
-			
-			/*
-			 * - Position constraining -
-			 * Constrain the position to a mix of grid, containment.
-			 */
-			if(this.containment) {
-				if(position.left < this.containment[0]) position.left = this.containment[0];
-				if(position.top < this.containment[1]) position.top = this.containment[1];
-				if(position.left > this.containment[2]) position.left = this.containment[2];
-				if(position.top > this.containment[3]) position.top = this.containment[3];
-			}
-			
-			if(o.grid) {
-				var top = this.originalPosition.top + Math.round((position.top - this.originalPosition.top) / o.grid[1]) * o.grid[1];
-				position.top = this.containment ? (!(top < this.containment[1] || top > this.containment[3]) ? top : (!(top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
+		/*
+		 * - Position constraining -
+		 * Here we prepare position constraining like grid and containment.
+		 */	
+		
+		if(o.containment) {
+			if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
+			if(o.containment == 'document') this.containment = [0,0,$(document).width(), ($(document).height() || document.body.parentNode.scrollHeight)];
+			if(!(/^(document|window|parent)$/).test(o.containment)) {
+				var ce = $(o.containment)[0];
+				var co = $(o.containment).offset();
 				
-				var left = this.originalPosition.left + Math.round((position.left - this.originalPosition.left) / o.grid[0]) * o.grid[0];
-				position.left = this.containment ? (!(left < this.containment[0] || left > this.containment[2]) ? left : (!(left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
+				this.containment = [
+					co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.parent.left,
+					co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.parent.top,
+					co.left+Math.max(ce.scrollWidth,ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - this.offset.parent.left - this.helperProportions.width - this.margins.left - (parseInt(this.currentItem.css("marginRight"),10) || 0),
+					co.top+Math.max(ce.scrollHeight,ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - this.offset.parent.top - this.helperProportions.height - this.margins.top - (parseInt(this.currentItem.css("marginBottom"),10) || 0)
+				];
 			}
-			
-			return position;
-		},
-		mouseDrag: function(e) {
+		}
+		
+		//If o.placeholder is used, create a new element at the given position with the class
+		if(o.placeholder) this.createPlaceholder();
+		
+		//Call plugins and callbacks
+		this.propagate("start", e);
+		this.helperProportions = { width: this.helper.outerWidth(), height: this.helper.outerHeight() };//Recache the helper size
 
+		if(this.options.placeholder != 'clone') this.currentItem.css('visibility', 'hidden'); //Set the original element visibility to hidden to still fill out the white space
+		
+		if(!noActivation) {
+			 for (var i = this.containers.length - 1; i >= 0; i--) { this.containers[i].propagate("activate", e, this); } //Post 'activate' events to possible containers
+		}
+		
+		//Prepare possible droppables
+		if($.ui.ddmanager) $.ui.ddmanager.current = this;
+		if ($.ui.ddmanager && !o.dropBehaviour) $.ui.ddmanager.prepareOffsets(this, e);
 
-			//Compute the helpers position
-			this.position = this.generatePosition(e);
-			this.positionAbs = this.convertPositionTo("absolute");
+		this.dragging = true;
 
-			//Rearrange
-			for (var i = this.items.length - 1; i >= 0; i--) {
-				var intersection = this.intersectsWithEdge(this.items[i]);
-				if(!intersection) continue;
-				
-				if(this.items[i].item[0] != this.currentItem[0] //cannot intersect with itself
-					&&	this.currentItem[intersection == 1 ? "next" : "prev"]()[0] != this.items[i].item[0] //no useless actions that have been done before
-					&&	!contains(this.currentItem[0], this.items[i].item[0]) //no action if the item moved is the parent of the item checked
-					&& (this.options.type == 'semi-dynamic' ? !contains(this.element[0], this.items[i].item[0]) : true)
-				) {
-					
-					this.direction = intersection == 1 ? "down" : "up";
-					this.rearrange(e, this.items[i]);
-					this.propagate("change", e); //Call plugins and callbacks
-					break;
-				}
-			}
-			
-			//Post events to containers
-			this.contactContainers(e);
-			
-			 //Call plugins and callbacks
-			this.propagate("sort", e);
+		this.mouseDrag(e); //Execute the drag once - this causes the helper not to be visible before getting its correct position
+		return true;
 
-			if(!this.options.axis || this.options.axis == "x") this.helper[0].style.left = this.position.left+'px';
-			if(!this.options.axis || this.options.axis == "y") this.helper[0].style.top = this.position.top+'px';
-			
-			//Interconnect with droppables
-			if($.ui.ddmanager) $.ui.ddmanager.drag(this, e);
 
-			return false;
+	},
+	convertPositionTo: function(d, pos) {
+		if(!pos) pos = this.position;
+		var mod = d == "absolute" ? 1 : -1;
+		return {
+			top: (
+				pos.top																	// the calculated relative position
+				+ this.offset.parent.top * mod											// The offsetParent's offset without borders (offset + border)
+				- (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollTop) * mod	// The offsetParent's scroll position
+				+ this.margins.top * mod												//Add the margin (you don't want the margin counting in intersection methods)
+			),
+			left: (
+				pos.left																// the calculated relative position
+				+ this.offset.parent.left * mod											// The offsetParent's offset without borders (offset + border)
+				- (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft) * mod	// The offsetParent's scroll position
+				+ this.margins.left * mod												//Add the margin (you don't want the margin counting in intersection methods)
+			)
+		};
+	},
+	generatePosition: function(e) {
+		
+		var o = this.options;
+		var position = {
+			top: (
+				e.pageY																	// The absolute mouse position
+				- this.offset.click.top													// Click offset (relative to the element)
+				- this.offset.parent.top												// The offsetParent's offset without borders (offset + border)
+				+ (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollTop)	// The offsetParent's scroll position, not if the element is fixed
+			),
+			left: (
+				e.pageX																	// The absolute mouse position
+				- this.offset.click.left												// Click offset (relative to the element)
+				- this.offset.parent.left												// The offsetParent's offset without borders (offset + border)
+				+ (this.offsetParent[0] == document.body ? 0 : this.offsetParent[0].scrollLeft)	// The offsetParent's scroll position, not if the element is fixed
+			)
+		};
+		
+		if(!this.originalPosition) return position;										//If we are not dragging yet, we won't check for options
+		
+		/*
+		 * - Position constraining -
+		 * Constrain the position to a mix of grid, containment.
+		 */
+		if(this.containment) {
+			if(position.left < this.containment[0]) position.left = this.containment[0];
+			if(position.top < this.containment[1]) position.top = this.containment[1];
+			if(position.left > this.containment[2]) position.left = this.containment[2];
+			if(position.top > this.containment[3]) position.top = this.containment[3];
+		}
+		
+		if(o.grid) {
+			var top = this.originalPosition.top + Math.round((position.top - this.originalPosition.top) / o.grid[1]) * o.grid[1];
+			position.top = this.containment ? (!(top < this.containment[1] || top > this.containment[3]) ? top : (!(top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
 			
-		},
-		mouseStop: function(e, noPropagation) {
+			var left = this.originalPosition.left + Math.round((position.left - this.originalPosition.left) / o.grid[0]) * o.grid[0];
+			position.left = this.containment ? (!(left < this.containment[0] || left > this.containment[2]) ? left : (!(left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
+		}
+		
+		return position;
+	},
+	mouseDrag: function(e) {
+
+
+		//Compute the helpers position
+		this.position = this.generatePosition(e);
+		this.positionAbs = this.convertPositionTo("absolute");
 
-			//If we are using droppables, inform the manager about the drop
-			if ($.ui.ddmanager && !this.options.dropBehaviour)
-				$.ui.ddmanager.drop(this, e);
+		//Rearrange
+		for (var i = this.items.length - 1; i >= 0; i--) {
+			var intersection = this.intersectsWithEdge(this.items[i]);
+			if(!intersection) continue;
+			
+			if(this.items[i].item[0] != this.currentItem[0] //cannot intersect with itself
+				&&	this.currentItem[intersection == 1 ? "next" : "prev"]()[0] != this.items[i].item[0] //no useless actions that have been done before
+				&&	!contains(this.currentItem[0], this.items[i].item[0]) //no action if the item moved is the parent of the item checked
+				&& (this.options.type == 'semi-dynamic' ? !contains(this.element[0], this.items[i].item[0]) : true)
+			) {
 				
-			if(this.options.revert) {
-				var self = this;
-				var cur = self.currentItem.offset();
-
-				//Also animate the placeholder if we have one
-				if(self.placeholder) self.placeholder.animate({ opacity: 'hide' }, (parseInt(this.options.revert, 10) || 500)-50);
-
-				$(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.propagate("stop", e, null, noPropagation);
-					self.clear(e);
-				});
-			} else {
-				this.propagate("stop", e, null, noPropagation);
-				this.clear(e, noPropagation);
+				this.direction = intersection == 1 ? "down" : "up";
+				this.rearrange(e, this.items[i]);
+				this.propagate("change", e); //Call plugins and callbacks
+				break;
 			}
+		}
+		
+		//Post events to containers
+		this.contactContainers(e);
+		
+		 //Call plugins and callbacks
+		this.propagate("sort", e);
 
-			return false;
-			
-		},
-		clear: function(e, noPropagation) {
-			
-			if(this.domPosition != this.currentItem.prev()[0]) this.propagate("update", e, null, noPropagation); //Trigger update callback if the DOM position has changed
-			if(!contains(this.element[0], this.currentItem[0])) { //Node was moved out of the current element
-				this.propagate("remove", e, null, noPropagation);
-				for (var i = this.containers.length - 1; i >= 0; i--){
-					if(contains(this.containers[i].element[0], this.currentItem[0])) {
-						this.containers[i].propagate("update", e, this, noPropagation);
-						this.containers[i].propagate("receive", e, this, noPropagation);
-					}
-				};
-			};
+		if(!this.options.axis || this.options.axis == "x") this.helper[0].style.left = this.position.left+'px';
+		if(!this.options.axis || this.options.axis == "y") this.helper[0].style.top = this.position.top+'px';
+		
+		//Interconnect with droppables
+		if($.ui.ddmanager) $.ui.ddmanager.drag(this, e);
+
+		return false;
+		
+	},
+	mouseStop: function(e, noPropagation) {
+
+		//If we are using droppables, inform the manager about the drop
+		if ($.ui.ddmanager && !this.options.dropBehaviour)
+			$.ui.ddmanager.drop(this, e);
 			
-			//Post events to containers
+		if(this.options.revert) {
+			var self = this;
+			var cur = self.currentItem.offset();
+
+			//Also animate the placeholder if we have one
+			if(self.placeholder) self.placeholder.animate({ opacity: 'hide' }, (parseInt(this.options.revert, 10) || 500)-50);
+
+			$(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.propagate("stop", e, null, noPropagation);
+				self.clear(e);
+			});
+		} else {
+			this.propagate("stop", e, null, noPropagation);
+			this.clear(e, noPropagation);
+		}
+
+		return false;
+		
+	},
+	clear: function(e, noPropagation) {
+		
+		if(this.domPosition != this.currentItem.prev()[0]) this.propagate("update", e, null, noPropagation); //Trigger update callback if the DOM position has changed
+		if(!contains(this.element[0], this.currentItem[0])) { //Node was moved out of the current element
+			this.propagate("remove", e, null, noPropagation);
 			for (var i = this.containers.length - 1; i >= 0; i--){
-				this.containers[i].propagate("deactivate", e, this, noPropagation);
-				if(this.containers[i].containerCache.over) {
-					this.containers[i].propagate("out", e, this);
-					this.containers[i].containerCache.over = 0;
+				if(contains(this.containers[i].element[0], this.currentItem[0])) {
+					this.containers[i].propagate("update", e, this, noPropagation);
+					this.containers[i].propagate("receive", e, this, noPropagation);
 				}
+			};
+		};
+		
+		//Post events to containers
+		for (var i = this.containers.length - 1; i >= 0; i--){
+			this.containers[i].propagate("deactivate", e, this, noPropagation);
+			if(this.containers[i].containerCache.over) {
+				this.containers[i].propagate("out", e, this);
+				this.containers[i].containerCache.over = 0;
 			}
-			
-			this.dragging = false;
-			if(this.cancelHelperRemoval) return false;
-			$(this.currentItem).css('visibility', '');
-			if(this.placeholder) this.placeholder.remove();
-			this.helper.remove();
-			
-			return true;
-			
-		},
-		rearrange: function(e, i, a) {
-			a ? a.append(this.currentItem) : i.item[this.direction == 'down' ? 'before' : 'after'](this.currentItem);
-			this.refreshPositions(true); //Precompute after each DOM insertion, NOT on mousemove
-			if(this.options.placeholder) this.options.placeholder.update.call(this.element, this.currentItem, this.placeholder);
-		}
-	}));
-	
-	$.extend($.ui.sortable, {
-		getter: "serialize toArray",
-		defaults: {
-			tolerance: "guess",
-			distance: 0,
-			delay: 0,
-			cancel: ":input,button",
-			items: '> *',
-			zIndex: 1000,
-			dropOnEmpty: true,
-			appendTo: "parent"
 		}
-	});
+		
+		this.dragging = false;
+		if(this.cancelHelperRemoval) return false;
+		$(this.currentItem).css('visibility', '');
+		if(this.placeholder) this.placeholder.remove();
+		this.helper.remove();
+		
+		return true;
+		
+	},
+	rearrange: function(e, i, a) {
+		a ? a.append(this.currentItem) : i.item[this.direction == 'down' ? 'before' : 'after'](this.currentItem);
+		this.refreshPositions(true); //Precompute after each DOM insertion, NOT on mousemove
+		if(this.options.placeholder) this.options.placeholder.update.call(this.element, this.currentItem, this.placeholder);
+	}
+}));
+
+$.extend($.ui.sortable, {
+	getter: "serialize toArray",
+	defaults: {
+		tolerance: "guess",
+		distance: 0,
+		delay: 0,
+		cancel: ":input,button",
+		items: '> *',
+		zIndex: 1000,
+		dropOnEmpty: true,
+		appendTo: "parent"
+	}
+});
 
-	
 /*
  * Sortable Extensions
  */
@@ -670,5 +669,4 @@ $.ui.plugin.add("sortable", "scroll", {
 	}
 });
 
-
 })(jQuery);
diff --git a/ui/source/ui.tabs.js b/ui/source/ui.tabs.js
index 605dfab3f..3492848f3 100644
--- a/ui/source/ui.tabs.js
+++ b/ui/source/ui.tabs.js
@@ -13,583 +13,583 @@
  * Revision: $Id: ui.tabs.js 5641 2008-05-20 02:53:23Z scott.gonzalez $
  */
 ;(function($) {
-	
-	$.widget("ui.tabs", {
-		init: function() {
-			this.options.event += '.tabs'; // namespace event
-			
-			// create tabs
-			this.tabify(true);
-		},
-		setData: function(key, value) {
-			if ((/^selected/).test(key))
-				this.select(value);
-			else {
-				this.options[key] = value;
-				this.tabify();
-			}
-		},
-		length: function() {
-			return this.$tabs.length;
-		},
-		tabId: function(a) {
-			return a.title && a.title.replace(/\s/g, '_').replace(/[^A-Za-z0-9\-_:\.]/g, '')
-				|| this.options.idPrefix + $.data(a);
-		},
-		ui: function(tab, panel) {
-			return {
-				instance: this,
-				options: this.options,
-				tab: tab,
-				panel: panel
-			};
-		},
-		tabify: function(init) {
-
-			this.$lis = $('li:has(a[href])', this.element);
-			this.$tabs = this.$lis.map(function() { return $('a', this)[0]; });
-			this.$panels = $([]);
-
-			var self = this, o = this.options;
-
-			this.$tabs.each(function(i, a) {
-				// inline tab
-				if (a.hash && a.hash.replace('#', '')) // Safari 2 reports '#' for an empty hash
-					self.$panels = self.$panels.add(a.hash);
-				// remote tab
-				else if ($(a).attr('href') != '#') { // prevent loading the page itself if href is just "#"
-					$.data(a, 'href.tabs', a.href); // required for restore on destroy
-					$.data(a, 'load.tabs', a.href); // mutable
-					var id = self.tabId(a);
-					a.href = '#' + id;
-					var $panel = $('#' + id);
-					if (!$panel.length) {
-						$panel = $(o.panelTemplate).attr('id', id).addClass(o.panelClass)
-							.insertAfter( self.$panels[i - 1] || self.element );
-						$panel.data('destroy.tabs', true);
-					}
-					self.$panels = self.$panels.add( $panel );
+
+$.widget("ui.tabs", {
+	init: function() {
+		this.options.event += '.tabs'; // namespace event
+		
+		// create tabs
+		this.tabify(true);
+	},
+	setData: function(key, value) {
+		if ((/^selected/).test(key))
+			this.select(value);
+		else {
+			this.options[key] = value;
+			this.tabify();
+		}
+	},
+	length: function() {
+		return this.$tabs.length;
+	},
+	tabId: function(a) {
+		return a.title && a.title.replace(/\s/g, '_').replace(/[^A-Za-z0-9\-_:\.]/g, '')
+			|| this.options.idPrefix + $.data(a);
+	},
+	ui: function(tab, panel) {
+		return {
+			instance: this,
+			options: this.options,
+			tab: tab,
+			panel: panel
+		};
+	},
+	tabify: function(init) {
+
+		this.$lis = $('li:has(a[href])', this.element);
+		this.$tabs = this.$lis.map(function() { return $('a', this)[0]; });
+		this.$panels = $([]);
+
+		var self = this, o = this.options;
+
+		this.$tabs.each(function(i, a) {
+			// inline tab
+			if (a.hash && a.hash.replace('#', '')) // Safari 2 reports '#' for an empty hash
+				self.$panels = self.$panels.add(a.hash);
+			// remote tab
+			else if ($(a).attr('href') != '#') { // prevent loading the page itself if href is just "#"
+				$.data(a, 'href.tabs', a.href); // required for restore on destroy
+				$.data(a, 'load.tabs', a.href); // mutable
+				var id = self.tabId(a);
+				a.href = '#' + id;
+				var $panel = $('#' + id);
+				if (!$panel.length) {
+					$panel = $(o.panelTemplate).attr('id', id).addClass(o.panelClass)
+						.insertAfter( self.$panels[i - 1] || self.element );
+					$panel.data('destroy.tabs', true);
 				}
-				// invalid tab href
-				else
-					o.disabled.push(i + 1);
-			});
+				self.$panels = self.$panels.add( $panel );
+			}
+			// invalid tab href
+			else
+				o.disabled.push(i + 1);
+		});
 
-			if (init) {
+		if (init) {
 
-				// attach necessary classes for styling if not present
-				this.element.addClass(o.navClass);
-				this.$panels.each(function() {
-					var $this = $(this);
-					$this.addClass(o.panelClass);
-				});
+			// attach necessary classes for styling if not present
+			this.element.addClass(o.navClass);
+			this.$panels.each(function() {
+				var $this = $(this);
+				$this.addClass(o.panelClass);
+			});
 
-				// Selected tab
-				// use "selected" option or try to retrieve:
-				// 1. from fragment identifier in url
-				// 2. from cookie
-				// 3. from selected class attribute on <li>
-				if (o.selected === undefined) {
-					if (location.hash) {
-						this.$tabs.each(function(i, a) {
-							if (a.hash == location.hash) {
-								o.selected = i;
-								// prevent page scroll to fragment
-								if ($.browser.msie || $.browser.opera) { // && !o.remote
-									var $toShow = $(location.hash), toShowId = $toShow.attr('id');
-									$toShow.attr('id', '');
-									setTimeout(function() {
-										$toShow.attr('id', toShowId); // restore id
-									}, 500);
-								}
-								scrollTo(0, 0);
-								return false; // break
+			// Selected tab
+			// use "selected" option or try to retrieve:
+			// 1. from fragment identifier in url
+			// 2. from cookie
+			// 3. from selected class attribute on <li>
+			if (o.selected === undefined) {
+				if (location.hash) {
+					this.$tabs.each(function(i, a) {
+						if (a.hash == location.hash) {
+							o.selected = i;
+							// prevent page scroll to fragment
+							if ($.browser.msie || $.browser.opera) { // && !o.remote
+								var $toShow = $(location.hash), toShowId = $toShow.attr('id');
+								$toShow.attr('id', '');
+								setTimeout(function() {
+									$toShow.attr('id', toShowId); // restore id
+								}, 500);
 							}
-						});
-					}
-					else if (o.cookie) {
-						var index = parseInt($.cookie('ui-tabs' + $.data(self.element)),10);
-						if (index && self.$tabs[index])
-							o.selected = index;
-					}
-					else if (self.$lis.filter('.' + o.selectedClass).length)
-						o.selected = self.$lis.index( self.$lis.filter('.' + o.selectedClass)[0] );
+							scrollTo(0, 0);
+							return false; // break
+						}
+					});
 				}
-				o.selected = o.selected === null || o.selected !== undefined ? o.selected : 0; // first tab selected by default
-
-				// Take disabling tabs via class attribute from HTML
-				// into account and update option properly.
-				// A selected tab cannot become disabled.
-				o.disabled = $.unique(o.disabled.concat(
-					$.map(this.$lis.filter('.' + o.disabledClass),
-						function(n, i) { return self.$lis.index(n); } )
-				)).sort();
-				if ($.inArray(o.selected, o.disabled) != -1)
-					o.disabled.splice($.inArray(o.selected, o.disabled), 1);
-				
-				// highlight selected tab
-				this.$panels.addClass(o.hideClass);
-				this.$lis.removeClass(o.selectedClass);
-				if (o.selected !== null) {
-					this.$panels.eq(o.selected).show().removeClass(o.hideClass); // use show and remove class to show in any case no matter how it has been hidden before
-					this.$lis.eq(o.selected).addClass(o.selectedClass);
-					
-					// seems to be expected behavior that the show callback is fired
-					var onShow = function() {
-						$(self.element).triggerHandler('tabsshow',
-							[self.ui(self.$tabs[o.selected], self.$panels[o.selected])], o.show);
-					}; 
-
-					// load if remote tab
-					if ($.data(this.$tabs[o.selected], 'load.tabs'))
-						this.load(o.selected, onShow);
-					// just trigger show event
-					else
-						onShow();
-					
+				else if (o.cookie) {
+					var index = parseInt($.cookie('ui-tabs' + $.data(self.element)),10);
+					if (index && self.$tabs[index])
+						o.selected = index;
 				}
+				else if (self.$lis.filter('.' + o.selectedClass).length)
+					o.selected = self.$lis.index( self.$lis.filter('.' + o.selectedClass)[0] );
+			}
+			o.selected = o.selected === null || o.selected !== undefined ? o.selected : 0; // first tab selected by default
+
+			// Take disabling tabs via class attribute from HTML
+			// into account and update option properly.
+			// A selected tab cannot become disabled.
+			o.disabled = $.unique(o.disabled.concat(
+				$.map(this.$lis.filter('.' + o.disabledClass),
+					function(n, i) { return self.$lis.index(n); } )
+			)).sort();
+			if ($.inArray(o.selected, o.disabled) != -1)
+				o.disabled.splice($.inArray(o.selected, o.disabled), 1);
+			
+			// highlight selected tab
+			this.$panels.addClass(o.hideClass);
+			this.$lis.removeClass(o.selectedClass);
+			if (o.selected !== null) {
+				this.$panels.eq(o.selected).show().removeClass(o.hideClass); // use show and remove class to show in any case no matter how it has been hidden before
+				this.$lis.eq(o.selected).addClass(o.selectedClass);
 				
-				// clean up to avoid memory leaks in certain versions of IE 6
-				$(window).bind('unload', function() {
-					self.$tabs.unbind('.tabs');
-					self.$lis = self.$tabs = self.$panels = null;
-				});
+				// seems to be expected behavior that the show callback is fired
+				var onShow = function() {
+					$(self.element).triggerHandler('tabsshow',
+						[self.ui(self.$tabs[o.selected], self.$panels[o.selected])], o.show);
+				}; 
 
+				// load if remote tab
+				if ($.data(this.$tabs[o.selected], 'load.tabs'))
+					this.load(o.selected, onShow);
+				// just trigger show event
+				else
+					onShow();
+				
 			}
+			
+			// clean up to avoid memory leaks in certain versions of IE 6
+			$(window).bind('unload', function() {
+				self.$tabs.unbind('.tabs');
+				self.$lis = self.$tabs = self.$panels = null;
+			});
 
-			// disable tabs
-			for (var i = 0, li; li = this.$lis[i]; i++)
-				$(li)[$.inArray(i, o.disabled) != -1 && !$(li).hasClass(o.selectedClass) ? 'addClass' : 'removeClass'](o.disabledClass);
+		}
 
-			// reset cache if switching from cached to not cached
-			if (o.cache === false)
-				this.$tabs.removeData('cache.tabs');
-			
-			// set up animations
-			var hideFx, showFx, baseFx = { 'min-width': 0, duration: 1 }, baseDuration = 'normal';
-			if (o.fx && o.fx.constructor == Array)
-				hideFx = o.fx[0] || baseFx, showFx = o.fx[1] || baseFx;
-			else
-				hideFx = showFx = o.fx || baseFx;
-
-			// reset some styles to maintain print style sheets etc.
-			var resetCSS = { display: '', overflow: '', height: '' };
-			if (!$.browser.msie) // not in IE to prevent ClearType font issue
-				resetCSS.opacity = '';
-
-			// Hide a tab, animation prevents browser scrolling to fragment,
-			// $show is optional.
-			function hideTab(clicked, $hide, $show) {
-				$hide.animate(hideFx, hideFx.duration || baseDuration, function() { //
-					$hide.addClass(o.hideClass).css(resetCSS); // maintain flexible height and accessibility in print etc.
-					if ($.browser.msie && hideFx.opacity)
-						$hide[0].style.filter = '';
-					if ($show)
-						showTab(clicked, $show, $hide);
-				});
-			}
+		// disable tabs
+		for (var i = 0, li; li = this.$lis[i]; i++)
+			$(li)[$.inArray(i, o.disabled) != -1 && !$(li).hasClass(o.selectedClass) ? 'addClass' : 'removeClass'](o.disabledClass);
+
+		// reset cache if switching from cached to not cached
+		if (o.cache === false)
+			this.$tabs.removeData('cache.tabs');
+		
+		// set up animations
+		var hideFx, showFx, baseFx = { 'min-width': 0, duration: 1 }, baseDuration = 'normal';
+		if (o.fx && o.fx.constructor == Array)
+			hideFx = o.fx[0] || baseFx, showFx = o.fx[1] || baseFx;
+		else
+			hideFx = showFx = o.fx || baseFx;
+
+		// reset some styles to maintain print style sheets etc.
+		var resetCSS = { display: '', overflow: '', height: '' };
+		if (!$.browser.msie) // not in IE to prevent ClearType font issue
+			resetCSS.opacity = '';
+
+		// Hide a tab, animation prevents browser scrolling to fragment,
+		// $show is optional.
+		function hideTab(clicked, $hide, $show) {
+			$hide.animate(hideFx, hideFx.duration || baseDuration, function() { //
+				$hide.addClass(o.hideClass).css(resetCSS); // maintain flexible height and accessibility in print etc.
+				if ($.browser.msie && hideFx.opacity)
+					$hide[0].style.filter = '';
+				if ($show)
+					showTab(clicked, $show, $hide);
+			});
+		}
 
-			// Show a tab, animation prevents browser scrolling to fragment,
-			// $hide is optional.
-			function showTab(clicked, $show, $hide) {
-				if (showFx === baseFx)
-					$show.css('display', 'block'); // prevent occasionally occuring flicker in Firefox cause by gap between showing and hiding the tab panels
-				$show.animate(showFx, showFx.duration || baseDuration, function() {
-					$show.removeClass(o.hideClass).css(resetCSS); // maintain flexible height and accessibility in print etc.
-					if ($.browser.msie && showFx.opacity)
-						$show[0].style.filter = '';
-
-					// callback
-					$(self.element).triggerHandler('tabsshow',
-						[self.ui(clicked, $show[0])], o.show);
+		// Show a tab, animation prevents browser scrolling to fragment,
+		// $hide is optional.
+		function showTab(clicked, $show, $hide) {
+			if (showFx === baseFx)
+				$show.css('display', 'block'); // prevent occasionally occuring flicker in Firefox cause by gap between showing and hiding the tab panels
+			$show.animate(showFx, showFx.duration || baseDuration, function() {
+				$show.removeClass(o.hideClass).css(resetCSS); // maintain flexible height and accessibility in print etc.
+				if ($.browser.msie && showFx.opacity)
+					$show[0].style.filter = '';
 
-				});
-			}
+				// callback
+				$(self.element).triggerHandler('tabsshow',
+					[self.ui(clicked, $show[0])], o.show);
 
-			// switch a tab
-			function switchTab(clicked, $li, $hide, $show) {
-				/*if (o.bookmarkable && trueClick) { // add to history only if true click occured, not a triggered click
-					$.ajaxHistory.update(clicked.hash);
-				}*/
-				$li.addClass(o.selectedClass)
-					.siblings().removeClass(o.selectedClass);
-				hideTab(clicked, $hide, $show);
+			});
+		}
+
+		// switch a tab
+		function switchTab(clicked, $li, $hide, $show) {
+			/*if (o.bookmarkable && trueClick) { // add to history only if true click occured, not a triggered click
+				$.ajaxHistory.update(clicked.hash);
+			}*/
+			$li.addClass(o.selectedClass)
+				.siblings().removeClass(o.selectedClass);
+			hideTab(clicked, $hide, $show);
+		}
+
+		// attach tab event handler, unbind to avoid duplicates from former tabifying...
+		this.$tabs.unbind('.tabs').bind(o.event, function() {
+
+			//var trueClick = e.clientX; // add to history only if true click occured, not a triggered click
+			var $li = $(this).parents('li:eq(0)'),
+				$hide = self.$panels.filter(':visible'),
+				$show = $(this.hash);
+
+			// If tab is already selected and not unselectable or tab disabled or 
+			// or is already loading or click callback returns false stop here.
+			// Check if click handler returns false last so that it is not executed
+			// for a disabled or loading tab!
+			if (($li.hasClass(o.selectedClass) && !o.unselect)
+				|| $li.hasClass(o.disabledClass) 
+				|| $(this).hasClass(o.loadingClass)
+				|| $(self.element).triggerHandler('tabsselect', [self.ui(this, $show[0])], o.select) === false
+				) {
+				this.blur();
+				return false;
 			}
 
-			// attach tab event handler, unbind to avoid duplicates from former tabifying...
-			this.$tabs.unbind('.tabs').bind(o.event, function() {
-
-				//var trueClick = e.clientX; // add to history only if true click occured, not a triggered click
-				var $li = $(this).parents('li:eq(0)'),
-					$hide = self.$panels.filter(':visible'),
-					$show = $(this.hash);
-
-				// If tab is already selected and not unselectable or tab disabled or 
-				// or is already loading or click callback returns false stop here.
-				// Check if click handler returns false last so that it is not executed
-				// for a disabled or loading tab!
-				if (($li.hasClass(o.selectedClass) && !o.unselect)
-					|| $li.hasClass(o.disabledClass) 
-					|| $(this).hasClass(o.loadingClass)
-					|| $(self.element).triggerHandler('tabsselect', [self.ui(this, $show[0])], o.select) === false
-					) {
+			self.options.selected = self.$tabs.index(this);
+
+			// if tab may be closed
+			if (o.unselect) {
+				if ($li.hasClass(o.selectedClass)) {
+					self.options.selected = null;
+					$li.removeClass(o.selectedClass);
+					self.$panels.stop();
+					hideTab(this, $hide);
+					this.blur();
+					return false;
+				} else if (!$hide.length) {
+					self.$panels.stop();
+					var a = this;
+					self.load(self.$tabs.index(this), function() {
+						$li.addClass(o.selectedClass).addClass(o.unselectClass);
+						showTab(a, $show);
+					});
 					this.blur();
 					return false;
 				}
+			}
 
-				self.options.selected = self.$tabs.index(this);
-
-				// if tab may be closed
-				if (o.unselect) {
-					if ($li.hasClass(o.selectedClass)) {
-						self.options.selected = null;
-						$li.removeClass(o.selectedClass);
-						self.$panels.stop();
-						hideTab(this, $hide);
-						this.blur();
-						return false;
-					} else if (!$hide.length) {
-						self.$panels.stop();
-						var a = this;
-						self.load(self.$tabs.index(this), function() {
-							$li.addClass(o.selectedClass).addClass(o.unselectClass);
-							showTab(a, $show);
-						});
-						this.blur();
-						return false;
-					}
-				}
-
-				if (o.cookie)
-					$.cookie('ui-tabs' + $.data(self.element), self.options.selected, o.cookie);
-
-				// stop possibly running animations
-				self.$panels.stop();
-
-				// show new tab
-				if ($show.length) {
+			if (o.cookie)
+				$.cookie('ui-tabs' + $.data(self.element), self.options.selected, o.cookie);
 
-					// prevent scrollbar scrolling to 0 and than back in IE7, happens only if bookmarking/history is enabled
-					/*if ($.browser.msie && o.bookmarkable) {
-						var showId = this.hash.replace('#', '');
-						$show.attr('id', '');
-						setTimeout(function() {
-							$show.attr('id', showId); // restore id
-						}, 0);
-					}*/
+			// stop possibly running animations
+			self.$panels.stop();
 
-					var a = this;
-					self.load(self.$tabs.index(this), $hide.length ? 
-						function() {
-							switchTab(a, $li, $hide, $show);
-						} :
-						function() {
-							$li.addClass(o.selectedClass);
-							showTab(a, $show);
-						}
-					);
+			// show new tab
+			if ($show.length) {
 
-					// Set scrollbar to saved position - need to use timeout with 0 to prevent browser scroll to target of hash
-					/*var scrollX = window.pageXOffset || document.documentElement && document.documentElement.scrollLeft || document.body.scrollLeft || 0;
-					var scrollY = window.pageYOffset || document.documentElement && document.documentElement.scrollTop || document.body.scrollTop || 0;
+				// prevent scrollbar scrolling to 0 and than back in IE7, happens only if bookmarking/history is enabled
+				/*if ($.browser.msie && o.bookmarkable) {
+					var showId = this.hash.replace('#', '');
+					$show.attr('id', '');
 					setTimeout(function() {
-						scrollTo(scrollX, scrollY);
-					}, 0);*/
+						$show.attr('id', showId); // restore id
+					}, 0);
+				}*/
 
-				} else
-					throw 'jQuery UI Tabs: Mismatching fragment identifier.';
+				var a = this;
+				self.load(self.$tabs.index(this), $hide.length ? 
+					function() {
+						switchTab(a, $li, $hide, $show);
+					} :
+					function() {
+						$li.addClass(o.selectedClass);
+						showTab(a, $show);
+					}
+				);
 
-				// Prevent IE from keeping other link focussed when using the back button
-				// and remove dotted border from clicked link. This is controlled in modern
-				// browsers via CSS, also blur removes focus from address bar in Firefox
-				// which can become a usability and annoying problem with tabsRotate.
-				if ($.browser.msie)
-					this.blur();
+				// Set scrollbar to saved position - need to use timeout with 0 to prevent browser scroll to target of hash
+				/*var scrollX = window.pageXOffset || document.documentElement && document.documentElement.scrollLeft || document.body.scrollLeft || 0;
+				var scrollY = window.pageYOffset || document.documentElement && document.documentElement.scrollTop || document.body.scrollTop || 0;
+				setTimeout(function() {
+					scrollTo(scrollX, scrollY);
+				}, 0);*/
 
-				//return o.bookmarkable && !!trueClick; // convert trueClick == undefined to Boolean required in IE
-				return false;
+			} else
+				throw 'jQuery UI Tabs: Mismatching fragment identifier.';
 
-			});
+			// Prevent IE from keeping other link focussed when using the back button
+			// and remove dotted border from clicked link. This is controlled in modern
+			// browsers via CSS, also blur removes focus from address bar in Firefox
+			// which can become a usability and annoying problem with tabsRotate.
+			if ($.browser.msie)
+				this.blur();
 
-			// disable click if event is configured to something else
-			if (!(/^click/).test(o.event))
-				this.$tabs.bind('click.tabs', function() { return false; });
+			//return o.bookmarkable && !!trueClick; // convert trueClick == undefined to Boolean required in IE
+			return false;
 
-		},
-		add: function(url, label, index) {
-			if (index == undefined) 
-				index = this.$tabs.length; // append by default
+		});
 
-			var o = this.options;
-			var $li = $(o.tabTemplate.replace(/#\{href\}/g, url).replace(/#\{label\}/g, label));
-			$li.data('destroy.tabs', true);
+		// disable click if event is configured to something else
+		if (!(/^click/).test(o.event))
+			this.$tabs.bind('click.tabs', function() { return false; });
 
-			var id = url.indexOf('#') == 0 ? url.replace('#', '') : this.tabId( $('a:first-child', $li)[0] );
+	},
+	add: function(url, label, index) {
+		if (index == undefined) 
+			index = this.$tabs.length; // append by default
 
-			// try to find an existing element before creating a new one
-			var $panel = $('#' + id);
-			if (!$panel.length) {
-				$panel = $(o.panelTemplate).attr('id', id)
-					.addClass(o.hideClass)
-					.data('destroy.tabs', true);
-			}
-			$panel.addClass(o.panelClass);
-			if (index >= this.$lis.length) {
-				$li.appendTo(this.element);
-				$panel.appendTo(this.element[0].parentNode);
-			} else {
-				$li.insertBefore(this.$lis[index]);
-				$panel.insertBefore(this.$panels[index]);
-			}
-			
-			o.disabled = $.map(o.disabled,
-				function(n, i) { return n >= index ? ++n : n });
-				
-			this.tabify();
+		var o = this.options;
+		var $li = $(o.tabTemplate.replace(/#\{href\}/g, url).replace(/#\{label\}/g, label));
+		$li.data('destroy.tabs', true);
 
-			if (this.$tabs.length == 1) {
-				$li.addClass(o.selectedClass);
-				$panel.removeClass(o.hideClass);
-				var href = $.data(this.$tabs[0], 'load.tabs');
-				if (href)
-					this.load(index, href);
-			}
+		var id = url.indexOf('#') == 0 ? url.replace('#', '') : this.tabId( $('a:first-child', $li)[0] );
 
-			// callback
-			this.element.triggerHandler('tabsadd',
-				[this.ui(this.$tabs[index], this.$panels[index])], o.add
-			);
-		},
-		remove: function(index) {
-			var o = this.options, $li = this.$lis.eq(index).remove(),
-				$panel = this.$panels.eq(index).remove();
+		// try to find an existing element before creating a new one
+		var $panel = $('#' + id);
+		if (!$panel.length) {
+			$panel = $(o.panelTemplate).attr('id', id)
+				.addClass(o.hideClass)
+				.data('destroy.tabs', true);
+		}
+		$panel.addClass(o.panelClass);
+		if (index >= this.$lis.length) {
+			$li.appendTo(this.element);
+			$panel.appendTo(this.element[0].parentNode);
+		} else {
+			$li.insertBefore(this.$lis[index]);
+			$panel.insertBefore(this.$panels[index]);
+		}
+		
+		o.disabled = $.map(o.disabled,
+			function(n, i) { return n >= index ? ++n : n });
+			
+		this.tabify();
+
+		if (this.$tabs.length == 1) {
+			$li.addClass(o.selectedClass);
+			$panel.removeClass(o.hideClass);
+			var href = $.data(this.$tabs[0], 'load.tabs');
+			if (href)
+				this.load(index, href);
+		}
 
-			// If selected tab was removed focus tab to the right or
-			// in case the last tab was removed the tab to the left.
-			if ($li.hasClass(o.selectedClass) && this.$tabs.length > 1)
-				this.select(index + (index + 1 < this.$tabs.length ? 1 : -1));
+		// callback
+		this.element.triggerHandler('tabsadd',
+			[this.ui(this.$tabs[index], this.$panels[index])], o.add
+		);
+	},
+	remove: function(index) {
+		var o = this.options, $li = this.$lis.eq(index).remove(),
+			$panel = this.$panels.eq(index).remove();
+
+		// If selected tab was removed focus tab to the right or
+		// in case the last tab was removed the tab to the left.
+		if ($li.hasClass(o.selectedClass) && this.$tabs.length > 1)
+			this.select(index + (index + 1 < this.$tabs.length ? 1 : -1));
+
+		o.disabled = $.map($.grep(o.disabled, function(n, i) { return n != index; }),
+			function(n, i) { return n >= index ? --n : n });
+
+		this.tabify();
+
+		// callback
+		this.element.triggerHandler('tabsremove',
+			[this.ui($li.find('a')[0], $panel[0])], o.remove
+		);
+	},
+	enable: function(index) {
+		var o = this.options;
+		if ($.inArray(index, o.disabled) == -1)
+			return;
+			
+		var $li = this.$lis.eq(index).removeClass(o.disabledClass);
+		if ($.browser.safari) { // fix disappearing tab (that used opacity indicating disabling) after enabling in Safari 2...
+			$li.css('display', 'inline-block');
+			setTimeout(function() {
+				$li.css('display', 'block');
+			}, 0);
+		}
 
-			o.disabled = $.map($.grep(o.disabled, function(n, i) { return n != index; }),
-				function(n, i) { return n >= index ? --n : n });
+		o.disabled = $.grep(o.disabled, function(n, i) { return n != index; });
 
-			this.tabify();
+		// callback
+		this.element.triggerHandler('tabsenable',
+			[this.ui(this.$tabs[index], this.$panels[index])], o.enable
+		);
 
-			// callback
-			this.element.triggerHandler('tabsremove',
-				[this.ui($li.find('a')[0], $panel[0])], o.remove
-			);
-		},
-		enable: function(index) {
-			var o = this.options;
-			if ($.inArray(index, o.disabled) == -1)
-				return;
-				
-			var $li = this.$lis.eq(index).removeClass(o.disabledClass);
-			if ($.browser.safari) { // fix disappearing tab (that used opacity indicating disabling) after enabling in Safari 2...
-				$li.css('display', 'inline-block');
-				setTimeout(function() {
-					$li.css('display', 'block');
-				}, 0);
-			}
+	},
+	disable: function(index) {
+		var self = this, o = this.options;
+		if (index != o.selected) { // cannot disable already selected tab
+			this.$lis.eq(index).addClass(o.disabledClass);
 
-			o.disabled = $.grep(o.disabled, function(n, i) { return n != index; });
+			o.disabled.push(index);
+			o.disabled.sort();
 
 			// callback
-			this.element.triggerHandler('tabsenable',
-				[this.ui(this.$tabs[index], this.$panels[index])], o.enable
+			this.element.triggerHandler('tabsdisable',
+				[this.ui(this.$tabs[index], this.$panels[index])], o.disable
 			);
+		}
+	},
+	select: function(index) {
+		if (typeof index == 'string')
+			index = this.$tabs.index( this.$tabs.filter('[href$=' + index + ']')[0] );
+		this.$tabs.eq(index).trigger(this.options.event);
+	},
+	load: function(index, callback) { // callback is for internal usage only
+		
+		var self = this, o = this.options, $a = this.$tabs.eq(index), a = $a[0],
+				bypassCache = callback == undefined || callback === false, url = $a.data('load.tabs');
+
+		callback = callback || function() {};
+		
+		// no remote or from cache - just finish with callback
+		if (!url || !bypassCache && $.data(a, 'cache.tabs')) {
+			callback();
+			return;
+		}
 
-		},
-		disable: function(index) {
-			var self = this, o = this.options;
-			if (index != o.selected) { // cannot disable already selected tab
-				this.$lis.eq(index).addClass(o.disabledClass);
+		// load remote from here on
+		
+		var inner = function(parent) {
+			var $parent = $(parent), $inner = $parent.find('*:last');
+			return $inner.length && $inner || $parent;
+		};
+		var cleanup = function() {
+			self.$tabs.filter('.' + o.loadingClass).removeClass(o.loadingClass)
+						.each(function() {
+							if (o.spinner)
+								inner(this).parent().html(inner(this).data('label.tabs'));
+						});
+			self.xhr = null;
+		};
+		
+		if (o.spinner) {
+			var label = inner(a).html();
+			inner(a).wrapInner('<em></em>')
+				.find('em').data('label.tabs', label).html(o.spinner);
+		}
 
-				o.disabled.push(index);
-				o.disabled.sort();
+		var ajaxOptions = $.extend({}, o.ajaxOptions, {
+			url: url,
+			success: function(r, s) {
+				$(a.hash).html(r);
+				cleanup();
+				
+				if (o.cache)
+					$.data(a, 'cache.tabs', true); // if loaded once do not load them again
 
-				// callback
-				this.element.triggerHandler('tabsdisable',
-					[this.ui(this.$tabs[index], this.$panels[index])], o.disable
+				// callbacks
+				$(self.element).triggerHandler('tabsload',
+					[self.ui(self.$tabs[index], self.$panels[index])], o.load
 				);
-			}
-		},
-		select: function(index) {
-			if (typeof index == 'string')
-				index = this.$tabs.index( this.$tabs.filter('[href$=' + index + ']')[0] );
-			this.$tabs.eq(index).trigger(this.options.event);
-		},
-		load: function(index, callback) { // callback is for internal usage only
-			
-			var self = this, o = this.options, $a = this.$tabs.eq(index), a = $a[0],
-					bypassCache = callback == undefined || callback === false, url = $a.data('load.tabs');
-
-			callback = callback || function() {};
-			
-			// no remote or from cache - just finish with callback
-			if (!url || !bypassCache && $.data(a, 'cache.tabs')) {
+				o.ajaxOptions.success && o.ajaxOptions.success(r, s);
+				
+				// This callback is required because the switch has to take
+				// place after loading has completed. Call last in order to 
+				// fire load before show callback...
 				callback();
-				return;
-			}
-
-			// load remote from here on
-			
-			var inner = function(parent) {
-				var $parent = $(parent), $inner = $parent.find('*:last');
-				return $inner.length && $inner || $parent;
-			};
-			var cleanup = function() {
-				self.$tabs.filter('.' + o.loadingClass).removeClass(o.loadingClass)
-							.each(function() {
-								if (o.spinner)
-									inner(this).parent().html(inner(this).data('label.tabs'));
-							});
-				self.xhr = null;
-			};
-			
-			if (o.spinner) {
-				var label = inner(a).html();
-				inner(a).wrapInner('<em></em>')
-					.find('em').data('label.tabs', label).html(o.spinner);
 			}
-
-			var ajaxOptions = $.extend({}, o.ajaxOptions, {
-				url: url,
-				success: function(r, s) {
-					$(a.hash).html(r);
-					cleanup();
-					
-					if (o.cache)
-						$.data(a, 'cache.tabs', true); // if loaded once do not load them again
-
-					// callbacks
-					$(self.element).triggerHandler('tabsload',
-						[self.ui(self.$tabs[index], self.$panels[index])], o.load
-					);
-					o.ajaxOptions.success && o.ajaxOptions.success(r, s);
-					
-					// This callback is required because the switch has to take
-					// place after loading has completed. Call last in order to 
-					// fire load before show callback...
-					callback();
-				}
-			});
-			if (this.xhr) {
-				// terminate pending requests from other tabs and restore tab label
-				this.xhr.abort();
-				cleanup();
-			}
-			$a.addClass(o.loadingClass);
-			setTimeout(function() { // timeout is again required in IE, "wait" for id being restored
-				self.xhr = $.ajax(ajaxOptions);
-			}, 0);
-
-		},
-		url: function(index, url) {
-			this.$tabs.eq(index).removeData('cache.tabs').data('load.tabs', url);
-		},
-		destroy: function() {
-			var o = this.options;
-			this.element.unbind('.tabs')
-				.removeClass(o.navClass).removeData('tabs');
-			this.$tabs.each(function() {
-				var href = $.data(this, 'href.tabs');
-				if (href)
-					this.href = href;
-				var $this = $(this).unbind('.tabs');
-				$.each(['href', 'load', 'cache'], function(i, prefix) {
-					$this.removeData(prefix + '.tabs');
-				});
-			});
-			this.$lis.add(this.$panels).each(function() {
-				if ($.data(this, 'destroy.tabs'))
-					$(this).remove();
-				else
-					$(this).removeClass([o.selectedClass, o.unselectClass,
-						o.disabledClass, o.panelClass, o.hideClass].join(' '));
-			});
+		});
+		if (this.xhr) {
+			// terminate pending requests from other tabs and restore tab label
+			this.xhr.abort();
+			cleanup();
 		}
-	});
-	
-	$.ui.tabs.defaults = {
-		// basic setup
-		unselect: false,
-		event: 'click',
-		disabled: [],
-		cookie: null, // e.g. { expires: 7, path: '/', domain: 'jquery.com', secure: true }
-		// TODO history: false,
-
-		// Ajax
-		spinner: 'Loading&#8230;',
-		cache: false,
-		idPrefix: 'ui-tabs-',
-		ajaxOptions: {},
-
-		// animations
-		fx: null, // e.g. { height: 'toggle', opacity: 'toggle', duration: 200 }
-
-		// templates
-		tabTemplate: '<li><a href="#{href}"><span>#{label}</span></a></li>',
-		panelTemplate: '<div></div>',
-
-		// CSS classes
-		navClass: 'ui-tabs-nav',
-		selectedClass: 'ui-tabs-selected',
-		unselectClass: 'ui-tabs-unselect',
-		disabledClass: 'ui-tabs-disabled',
-		panelClass: 'ui-tabs-panel',
-		hideClass: 'ui-tabs-hide',
-		loadingClass: 'ui-tabs-loading'
-	};
-	
-	$.ui.tabs.getter = "length";
+		$a.addClass(o.loadingClass);
+		setTimeout(function() { // timeout is again required in IE, "wait" for id being restored
+			self.xhr = $.ajax(ajaxOptions);
+		}, 0);
+
+	},
+	url: function(index, url) {
+		this.$tabs.eq(index).removeData('cache.tabs').data('load.tabs', url);
+	},
+	destroy: function() {
+		var o = this.options;
+		this.element.unbind('.tabs')
+			.removeClass(o.navClass).removeData('tabs');
+		this.$tabs.each(function() {
+			var href = $.data(this, 'href.tabs');
+			if (href)
+				this.href = href;
+			var $this = $(this).unbind('.tabs');
+			$.each(['href', 'load', 'cache'], function(i, prefix) {
+				$this.removeData(prefix + '.tabs');
+			});
+		});
+		this.$lis.add(this.$panels).each(function() {
+			if ($.data(this, 'destroy.tabs'))
+				$(this).remove();
+			else
+				$(this).removeClass([o.selectedClass, o.unselectClass,
+					o.disabledClass, o.panelClass, o.hideClass].join(' '));
+		});
+	}
+});
+
+$.ui.tabs.defaults = {
+	// basic setup
+	unselect: false,
+	event: 'click',
+	disabled: [],
+	cookie: null, // e.g. { expires: 7, path: '/', domain: 'jquery.com', secure: true }
+	// TODO history: false,
+
+	// Ajax
+	spinner: 'Loading&#8230;',
+	cache: false,
+	idPrefix: 'ui-tabs-',
+	ajaxOptions: {},
+
+	// animations
+	fx: null, // e.g. { height: 'toggle', opacity: 'toggle', duration: 200 }
+
+	// templates
+	tabTemplate: '<li><a href="#{href}"><span>#{label}</span></a></li>',
+	panelTemplate: '<div></div>',
+
+	// CSS classes
+	navClass: 'ui-tabs-nav',
+	selectedClass: 'ui-tabs-selected',
+	unselectClass: 'ui-tabs-unselect',
+	disabledClass: 'ui-tabs-disabled',
+	panelClass: 'ui-tabs-panel',
+	hideClass: 'ui-tabs-hide',
+	loadingClass: 'ui-tabs-loading'
+};
+
+$.ui.tabs.getter = "length";
 
 /*
  * Tabs Extensions
  */
 
-	/*
-	 * Rotate
-	 */
-	$.extend($.ui.tabs.prototype, {
-		rotation: null,
-		rotate: function(ms, continuing) {
-			
-			continuing = continuing || false;
-			
-			var self = this, t = this.options.selected;
-			
-			function start() {
-				self.rotation = setInterval(function() {
-					t = ++t < self.$tabs.length ? t : 0;
-					self.select(t);
-				}, ms); 
-			}
-			
-			function stop(e) {
-				if (!e || e.clientX) { // only in case of a true click
-					clearInterval(self.rotation);
-				}
-			}
-			
-			// start interval
-			if (ms) {
-				start();
-				if (!continuing)
-					this.$tabs.bind(this.options.event, stop);
-				else
-					this.$tabs.bind(this.options.event, function() {
-						stop();
-						t = self.options.selected;
-						start();
-					});
-			}
-			// stop interval
-			else {
-				stop();
-				this.$tabs.unbind(this.options.event, stop);
+/*
+ * Rotate
+ */
+$.extend($.ui.tabs.prototype, {
+	rotation: null,
+	rotate: function(ms, continuing) {
+		
+		continuing = continuing || false;
+		
+		var self = this, t = this.options.selected;
+		
+		function start() {
+			self.rotation = setInterval(function() {
+				t = ++t < self.$tabs.length ? t : 0;
+				self.select(t);
+			}, ms); 
+		}
+		
+		function stop(e) {
+			if (!e || e.clientX) { // only in case of a true click
+				clearInterval(self.rotation);
 			}
 		}
-	});
+		
+		// start interval
+		if (ms) {
+			start();
+			if (!continuing)
+				this.$tabs.bind(this.options.event, stop);
+			else
+				this.$tabs.bind(this.options.event, function() {
+					stop();
+					t = self.options.selected;
+					start();
+				});
+		}
+		// stop interval
+		else {
+			stop();
+			this.$tabs.unbind(this.options.event, stop);
+		}
+	}
+});
 
 })(jQuery);
-- 
2.39.5