/*!
* jQuery UI 1.8.6
*
* Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* http://docs.jquery.com/UI
*/
(function ($, undefined) {

	// prevent duplicate loading
	// this is only a problem because we proxy existing functions
	// and we don't want to double proxy them
	$.ui = $.ui || {};
	if ($.ui.version) {
		return;
	}

	$.extend($.ui, {
		version: "1.8.6",

		keyCode: {
			ALT: 18,
			BACKSPACE: 8,
			CAPS_LOCK: 20,
			COMMA: 188,
			COMMAND: 91,
			COMMAND_LEFT: 91, // COMMAND
			COMMAND_RIGHT: 93,
			CONTROL: 17,
			DELETE: 46,
			DOWN: 40,
			END: 35,
			ENTER: 13,
			ESCAPE: 27,
			HOME: 36,
			INSERT: 45,
			LEFT: 37,
			MENU: 93, // COMMAND_RIGHT
			NUMPAD_ADD: 107,
			NUMPAD_DECIMAL: 110,
			NUMPAD_DIVIDE: 111,
			NUMPAD_ENTER: 108,
			NUMPAD_MULTIPLY: 106,
			NUMPAD_SUBTRACT: 109,
			PAGE_DOWN: 34,
			PAGE_UP: 33,
			PERIOD: 190,
			RIGHT: 39,
			SHIFT: 16,
			SPACE: 32,
			TAB: 9,
			UP: 38,
			WINDOWS: 91 // COMMAND
		}
	});

	// plugins
	$.fn.extend({
		_focus: $.fn.focus,
		focus: function (delay, fn) {
			return typeof delay === "number" ?
			this.each(function () {
				var elem = this;
				setTimeout(function () {
					$(elem).focus();
					if (fn) {
						fn.call(elem);
					}
				}, delay);
			}) :
			this._focus.apply(this, arguments);
		},

		scrollParent: function () {
			var scrollParent;
			if (($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
				scrollParent = this.parents().filter(function () {
					return (/(relative|absolute|fixed)/).test($.curCSS(this, 'position', 1)) && (/(auto|scroll)/).test($.curCSS(this, 'overflow', 1) + $.curCSS(this, 'overflow-y', 1) + $.curCSS(this, 'overflow-x', 1));
				}).eq(0);
			} else {
				scrollParent = this.parents().filter(function () {
					return (/(auto|scroll)/).test($.curCSS(this, 'overflow', 1) + $.curCSS(this, 'overflow-y', 1) + $.curCSS(this, 'overflow-x', 1));
				}).eq(0);
			}

			return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
		},

		zIndex: function (zIndex) {
			if (zIndex !== undefined) {
				return this.css("zIndex", zIndex);
			}

			if (this.length) {
				var elem = $(this[0]), position, value;
				while (elem.length && elem[0] !== document) {
					// Ignore z-index if position is set to a value where z-index is ignored by the browser
					// This makes behavior of this function consistent across browsers
					// WebKit always returns auto if the element is positioned
					position = elem.css("position");
					if (position === "absolute" || position === "relative" || position === "fixed") {
						// IE returns 0 when zIndex is not specified
						// other browsers return a string
						// we ignore the case of nested elements with an explicit value of 0
						// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
						value = parseInt(elem.css("zIndex"), 10);
						if (!isNaN(value) && value !== 0) {
							return value;
						}
					}
					elem = elem.parent();
				}
			}

			return 0;
		},

		disableSelection: function () {
			return this.bind(($.support.selectstart ? "selectstart" : "mousedown") +
			".ui-disableSelection", function (event) {
				event.preventDefault();
			});
		},

		enableSelection: function () {
			return this.unbind(".ui-disableSelection");
		}
	});

	$.each(["Width", "Height"], function (i, name) {
		var side = name === "Width" ? ["Left", "Right"] : ["Top", "Bottom"],
		type = name.toLowerCase(),
		orig = {
			innerWidth: $.fn.innerWidth,
			innerHeight: $.fn.innerHeight,
			outerWidth: $.fn.outerWidth,
			outerHeight: $.fn.outerHeight
		};

		function reduce(elem, size, border, margin) {
			$.each(side, function () {
				size -= parseFloat($.curCSS(elem, "padding" + this, true)) || 0;
				if (border) {
					size -= parseFloat($.curCSS(elem, "border" + this + "Width", true)) || 0;
				}
				if (margin) {
					size -= parseFloat($.curCSS(elem, "margin" + this, true)) || 0;
				}
			});
			return size;
		}

		$.fn["inner" + name] = function (size) {
			if (size === undefined) {
				return orig["inner" + name].call(this);
			}

			return this.each(function () {
				$(this).css(type, reduce(this, size) + "px");
			});
		};

		$.fn["outer" + name] = function (size, margin) {
			if (typeof size !== "number") {
				return orig["outer" + name].call(this, size);
			}

			return this.each(function () {
				$(this).css(type, reduce(this, size, true, margin) + "px");
			});
		};
	});

	// selectors
	function visible(element) {
		return !$(element).parents().andSelf().filter(function () {
			return $.curCSS(this, "visibility") === "hidden" ||
			$.expr.filters.hidden(this);
		}).length;
	}

	$.extend($.expr[":"], {
		data: function (elem, i, match) {
			return !!$.data(elem, match[3]);
		},

		focusable: function (element) {
			var nodeName = element.nodeName.toLowerCase(),
			tabIndex = $.attr(element, "tabindex");
			if ("area" === nodeName) {
				var map = element.parentNode,
				mapName = map.name,
				img;
				if (!element.href || !mapName || map.nodeName.toLowerCase() !== "map") {
					return false;
				}
				img = $("img[usemap=#" + mapName + "]")[0];
				return !!img && visible(img);
			}
			return (/input|select|textarea|button|object/.test(nodeName)
			? !element.disabled
			: "a" == nodeName
				? element.href || !isNaN(tabIndex)
				: !isNaN(tabIndex))
			// the element and all of its ancestors must be visible
			&& visible(element);
		},

		tabbable: function (element) {
			var tabIndex = $.attr(element, "tabindex");
			return (isNaN(tabIndex) || tabIndex >= 0) && $(element).is(":focusable");
		}
	});

	// support
	$(function () {
		var body = document.body,
		div = body.appendChild(div = document.createElement("div"));

		$.extend(div.style, {
			minHeight: "100px",
			height: "auto",
			padding: 0,
			borderWidth: 0
		});

		$.support.minHeight = div.offsetHeight === 100;
		$.support.selectstart = "onselectstart" in div;

		// set display to none to avoid a layout bug in IE
		// http://dev.jquery.com/ticket/4014
		body.removeChild(div).style.display = "none";
	});





	// deprecated
	$.extend($.ui, {
		// $.ui.plugin is deprecated.  Use the proxy pattern instead.
		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 || !instance.element[0].parentNode) {
					return;
				}

				for (var i = 0; i < set.length; i++) {
					if (instance.options[set[i][0]]) {
						set[i][1].apply(instance.element, args);
					}
				}
			}
		},

		// will be deprecated when we switch to jQuery 1.4 - use jQuery.contains()
		contains: function (a, b) {
			return document.compareDocumentPosition ?
			a.compareDocumentPosition(b) & 16 :
			a !== b && a.contains(b);
		},

		// only used by resizable
		hasScroll: function (el, a) {

			//If overflow is hidden, the element might have extra content, but the user wants to hide it
			if ($(el).css("overflow") === "hidden") {
				return false;
			}

			var scroll = (a && a === "left") ? "scrollLeft" : "scrollTop",
			has = false;

			if (el[scroll] > 0) {
				return true;
			}

			// TODO: determine which cases actually cause this to happen
			// if the element doesn't have the scroll set, see if it's possible to
			// set the scroll
			el[scroll] = 1;
			has = (el[scroll] > 0);
			el[scroll] = 0;
			return has;
		},

		// these are odd functions, fix the API or move into individual plugins
		isOverAxis: function (x, reference, size) {
			//Determines when x coordinate is over "b" element axis
			return (x > reference) && (x < (reference + size));
		},
		isOver: function (y, x, top, left, height, width) {
			//Determines when x, y coordinates is over "b" element
			return $.ui.isOverAxis(y, top, height) && $.ui.isOverAxis(x, left, width);
		}
	});

})(jQuery);
/*!
* jQuery UI Widget 1.8.6
*
* Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* http://docs.jquery.com/UI/Widget
*/
(function ($, undefined) {

	// jQuery 1.4+
	if ($.cleanData) {
		var _cleanData = $.cleanData;
		$.cleanData = function (elems) {
			for (var i = 0, elem; (elem = elems[i]) != null; i++) {
				$(elem).triggerHandler("remove");
			}
			_cleanData(elems);
		};
	} else {
		var _remove = $.fn.remove;
		$.fn.remove = function (selector, keepData) {
			return this.each(function () {
				if (!keepData) {
					if (!selector || $.filter(selector, [this]).length) {
						$("*", this).add([this]).each(function () {
							$(this).triggerHandler("remove");
						});
					}
				}
				return _remove.call($(this), selector, keepData);
			});
		};
	}

	$.widget = function (name, base, prototype) {
		var namespace = name.split(".")[0],
		fullName;
		name = name.split(".")[1];
		fullName = namespace + "-" + name;

		if (!prototype) {
			prototype = base;
			base = $.Widget;
		}

		// create selector for plugin
		$.expr[":"][fullName] = function (elem) {
			return !!$.data(elem, name);
		};

		$[namespace] = $[namespace] || {};
		$[namespace][name] = function (options, element) {
			// allow instantiation without initializing for simple inheritance
			if (arguments.length) {
				this._createWidget(options, element);
			}
		};

		var basePrototype = new base();
		// we need to make the options hash a property directly on the new instance
		// otherwise we'll modify the options hash on the prototype that we're
		// inheriting from
		//	$.each( basePrototype, function( key, val ) {
		//		if ( $.isPlainObject(val) ) {
		//			basePrototype[ key ] = $.extend( {}, val );
		//		}
		//	});
		basePrototype.options = $.extend(true, {}, basePrototype.options);
		$[namespace][name].prototype = $.extend(true, basePrototype, {
			namespace: namespace,
			widgetName: name,
			widgetEventPrefix: $[namespace][name].prototype.widgetEventPrefix || name,
			widgetBaseClass: fullName
		}, prototype);

		$.widget.bridge(name, $[namespace][name]);
	};

	$.widget.bridge = function (name, object) {
		$.fn[name] = function (options) {
			var isMethodCall = typeof options === "string",
			args = Array.prototype.slice.call(arguments, 1),
			returnValue = this;

			// allow multiple hashes to be passed on init
			options = !isMethodCall && args.length ?
			$.extend.apply(null, [true, options].concat(args)) :
			options;

			// prevent calls to internal methods
			if (isMethodCall && options.charAt(0) === "_") {
				return returnValue;
			}

			if (isMethodCall) {
				this.each(function () {
					var instance = $.data(this, name),
					methodValue = instance && $.isFunction(instance[options]) ?
						instance[options].apply(instance, args) :
						instance;
					// TODO: add this back in 1.9 and use $.error() (see #5972)
					//				if ( !instance ) {
					//					throw "cannot call methods on " + name + " prior to initialization; " +
					//						"attempted to call method '" + options + "'";
					//				}
					//				if ( !$.isFunction( instance[options] ) ) {
					//					throw "no such method '" + options + "' for " + name + " widget instance";
					//				}
					//				var methodValue = instance[ options ].apply( instance, args );
					if (methodValue !== instance && methodValue !== undefined) {
						returnValue = methodValue;
						return false;
					}
				});
			} else {
				this.each(function () {
					var instance = $.data(this, name);
					if (instance) {
						instance.option(options || {})._init();
					} else {
						$.data(this, name, new object(options, this));
					}
				});
			}

			return returnValue;
		};
	};

	$.Widget = function (options, element) {
		// allow instantiation without initializing for simple inheritance
		if (arguments.length) {
			this._createWidget(options, element);
		}
	};

	$.Widget.prototype = {
		widgetName: "widget",
		widgetEventPrefix: "",
		options: {
			disabled: false
		},
		_createWidget: function (options, element) {
			// $.widget.bridge stores the plugin instance, but we do it anyway
			// so that it's stored even before the _create function runs
			$.data(element, this.widgetName, this);
			this.element = $(element);
			this.options = $.extend(true, {},
			this.options,
			this._getCreateOptions(),
			options);

			var self = this;
			this.element.bind("remove." + this.widgetName, function () {
				self.destroy();
			});

			this._create();
			this._trigger("create");
			this._init();
		},
		_getCreateOptions: function () {
			return $.metadata && $.metadata.get(this.element[0])[this.widgetName];
		},
		_create: function () { },
		_init: function () { },

		destroy: function () {
			this.element
			.unbind("." + this.widgetName)
			.removeData(this.widgetName);
			this.widget()
			.unbind("." + this.widgetName)
			.removeAttr("aria-disabled")
			.removeClass(
				this.widgetBaseClass + "-disabled " +
				"ui-state-disabled");
		},

		widget: function () {
			return this.element;
		},

		option: function (key, value) {
			var options = key;

			if (arguments.length === 0) {
				// don't return a reference to the internal hash
				return $.extend({}, this.options);
			}

			if (typeof key === "string") {
				if (value === undefined) {
					return this.options[key];
				}
				options = {};
				options[key] = value;
			}

			this._setOptions(options);

			return this;
		},
		_setOptions: function (options) {
			var self = this;
			$.each(options, function (key, value) {
				self._setOption(key, value);
			});

			return this;
		},
		_setOption: function (key, value) {
			this.options[key] = value;

			if (key === "disabled") {
				this.widget()
				[value ? "addClass" : "removeClass"](
					this.widgetBaseClass + "-disabled" + " " +
					"ui-state-disabled")
				.attr("aria-disabled", value);
			}

			return this;
		},

		enable: function () {
			return this._setOption("disabled", false);
		},
		disable: function () {
			return this._setOption("disabled", true);
		},

		_trigger: function (type, event, data) {
			var callback = this.options[type];

			event = $.Event(event);
			event.type = (type === this.widgetEventPrefix ?
			type :
			this.widgetEventPrefix + type).toLowerCase();
			data = data || {};

			// copy original event properties over to the new event
			// this would happen if we could call $.event.fix instead of $.Event
			// but we don't have a way to force an event to be fixed multiple times
			if (event.originalEvent) {
				for (var i = $.event.props.length, prop; i; ) {
					prop = $.event.props[--i];
					event[prop] = event.originalEvent[prop];
				}
			}

			this.element.trigger(event, data);

			return !($.isFunction(callback) &&
			callback.call(this.element[0], event, data) === false ||
			event.isDefaultPrevented());
		}
	};

})(jQuery);
/*!
* jQuery UI Mouse 1.8.6
*
* Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* http://docs.jquery.com/UI/Mouse
*
* Depends:
*	jquery.ui.widget.js
*/
(function ($, undefined) {

	$.widget("ui.mouse", {
		options: {
			cancel: ':input,option',
			distance: 1,
			delay: 0
		},
		_mouseInit: function () {
			var self = this;

			this.element
			.bind('mousedown.' + this.widgetName, function (event) {
				return self._mouseDown(event);
			})
			.bind('click.' + this.widgetName, function (event) {
				if (self._preventClickEvent) {
					self._preventClickEvent = false;
					event.stopImmediatePropagation();
					return false;
				}
			});

			this.started = false;
		},

		// TODO: make sure destroying one instance of mouse doesn't mess with
		// other instances of mouse
		_mouseDestroy: function () {
			this.element.unbind('.' + this.widgetName);
		},

		_mouseDown: function (event) {
			// don't let more than one widget handle mouseStart
			// TODO: figure out why we have to use originalEvent
			event.originalEvent = event.originalEvent || {};
			if (event.originalEvent.mouseHandled) { return; }

			// we may have missed mouseup (out of window)
			(this._mouseStarted && this._mouseUp(event));

			this._mouseDownEvent = event;

			var self = this,
			btnIsLeft = (event.which == 1),
			elIsCancel = (typeof this.options.cancel == "string" ? $(event.target).parents().add(event.target).filter(this.options.cancel).length : false);
			if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
				return true;
			}

			this.mouseDelayMet = !this.options.delay;
			if (!this.mouseDelayMet) {
				this._mouseDelayTimer = setTimeout(function () {
					self.mouseDelayMet = true;
				}, this.options.delay);
			}

			if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
				this._mouseStarted = (this._mouseStart(event) !== false);
				if (!this._mouseStarted) {
					event.preventDefault();
					return true;
				}
			}

			// these delegates are required to keep context
			this._mouseMoveDelegate = function (event) {
				return self._mouseMove(event);
			};
			this._mouseUpDelegate = function (event) {
				return self._mouseUp(event);
			};
			$(document)
			.bind('mousemove.' + this.widgetName, this._mouseMoveDelegate)
			.bind('mouseup.' + this.widgetName, this._mouseUpDelegate);

			event.preventDefault();
			event.originalEvent.mouseHandled = true;
			return true;
		},

		_mouseMove: function (event) {
			// IE mouseup check - mouseup happened when mouse was out of window
			if ($.browser.msie && !(document.documentMode >= 9) && !event.button) {
				return this._mouseUp(event);
			}

			if (this._mouseStarted) {
				this._mouseDrag(event);
				return event.preventDefault();
			}

			if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
				this._mouseStarted =
				(this._mouseStart(this._mouseDownEvent, event) !== false);
				(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
			}

			return !this._mouseStarted;
		},

		_mouseUp: function (event) {
			$(document)
			.unbind('mousemove.' + this.widgetName, this._mouseMoveDelegate)
			.unbind('mouseup.' + this.widgetName, this._mouseUpDelegate);

			if (this._mouseStarted) {
				this._mouseStarted = false;
				this._preventClickEvent = (event.target == this._mouseDownEvent.target);
				this._mouseStop(event);
			}

			return false;
		},

		_mouseDistanceMet: function (event) {
			return (Math.max(
				Math.abs(this._mouseDownEvent.pageX - event.pageX),
				Math.abs(this._mouseDownEvent.pageY - event.pageY)
			) >= this.options.distance
		);
		},

		_mouseDelayMet: function (event) {
			return this.mouseDelayMet;
		},

		// These are placeholder methods, to be overriden by extending plugin
		_mouseStart: function (event) { },
		_mouseDrag: function (event) { },
		_mouseStop: function (event) { },
		_mouseCapture: function (event) { return true; }
	});

})(jQuery);
/*
* jQuery UI Position 1.8.6
*
* Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* http://docs.jquery.com/UI/Position
*/
(function ($, undefined) {

	$.ui = $.ui || {};

	var horizontalPositions = /left|center|right/,
	verticalPositions = /top|center|bottom/,
	center = "center",
	_position = $.fn.position,
	_offset = $.fn.offset;

	$.fn.position = function (options) {
		if (!options || !options.of) {
			return _position.apply(this, arguments);
		}

		// make a copy, we don't want to modify arguments
		options = $.extend({}, options);

		var target = $(options.of),
		targetElem = target[0],
		collision = (options.collision || "flip").split(" "),
		offset = options.offset ? options.offset.split(" ") : [0, 0],
		targetWidth,
		targetHeight,
		basePosition;

		if (targetElem.nodeType === 9) {
			targetWidth = target.width();
			targetHeight = target.height();
			basePosition = { top: 0, left: 0 };
			// TODO: use $.isWindow() in 1.9
		} else if (targetElem.setTimeout) {
			targetWidth = target.width();
			targetHeight = target.height();
			basePosition = { top: target.scrollTop(), left: target.scrollLeft() };
		} else if (targetElem.preventDefault) {
			// force left top to allow flipping
			options.at = "left top";
			targetWidth = targetHeight = 0;
			basePosition = { top: options.of.pageY, left: options.of.pageX };
		} else {
			targetWidth = target.outerWidth();
			targetHeight = target.outerHeight();
			basePosition = target.offset();
		}

		// force my and at to have valid horizontal and veritcal positions
		// if a value is missing or invalid, it will be converted to center 
		$.each(["my", "at"], function () {
			var pos = (options[this] || "").split(" ");
			if (pos.length === 1) {
				pos = horizontalPositions.test(pos[0]) ?
				pos.concat([center]) :
				verticalPositions.test(pos[0]) ?
					[center].concat(pos) :
					[center, center];
			}
			pos[0] = horizontalPositions.test(pos[0]) ? pos[0] : center;
			pos[1] = verticalPositions.test(pos[1]) ? pos[1] : center;
			options[this] = pos;
		});

		// normalize collision option
		if (collision.length === 1) {
			collision[1] = collision[0];
		}

		// normalize offset option
		offset[0] = parseInt(offset[0], 10) || 0;
		if (offset.length === 1) {
			offset[1] = offset[0];
		}
		offset[1] = parseInt(offset[1], 10) || 0;

		if (options.at[0] === "right") {
			basePosition.left += targetWidth;
		} else if (options.at[0] === center) {
			basePosition.left += targetWidth / 2;
		}

		if (options.at[1] === "bottom") {
			basePosition.top += targetHeight;
		} else if (options.at[1] === center) {
			basePosition.top += targetHeight / 2;
		}

		basePosition.left += offset[0];
		basePosition.top += offset[1];

		return this.each(function () {
			var elem = $(this),
			elemWidth = elem.outerWidth(),
			elemHeight = elem.outerHeight(),
			marginLeft = parseInt($.curCSS(this, "marginLeft", true)) || 0,
			marginTop = parseInt($.curCSS(this, "marginTop", true)) || 0,
			collisionWidth = elemWidth + marginLeft +
				parseInt($.curCSS(this, "marginRight", true)) || 0,
			collisionHeight = elemHeight + marginTop +
				parseInt($.curCSS(this, "marginBottom", true)) || 0,
			position = $.extend({}, basePosition),
			collisionPosition;

			if (options.my[0] === "right") {
				position.left -= elemWidth;
			} else if (options.my[0] === center) {
				position.left -= elemWidth / 2;
			}

			if (options.my[1] === "bottom") {
				position.top -= elemHeight;
			} else if (options.my[1] === center) {
				position.top -= elemHeight / 2;
			}

			// prevent fractions (see #5280)
			position.left = parseInt(position.left);
			position.top = parseInt(position.top);

			collisionPosition = {
				left: position.left - marginLeft,
				top: position.top - marginTop
			};

			$.each(["left", "top"], function (i, dir) {
				if ($.ui.position[collision[i]]) {
					$.ui.position[collision[i]][dir](position, {
						targetWidth: targetWidth,
						targetHeight: targetHeight,
						elemWidth: elemWidth,
						elemHeight: elemHeight,
						collisionPosition: collisionPosition,
						collisionWidth: collisionWidth,
						collisionHeight: collisionHeight,
						offset: offset,
						my: options.my,
						at: options.at
					});
				}
			});

			if ($.fn.bgiframe) {
				elem.bgiframe();
			}
			elem.offset($.extend(position, { using: options.using }));
		});
	};

	$.ui.position = {
		fit: {
			left: function (position, data) {
				var win = $(window),
				over = data.collisionPosition.left + data.collisionWidth - win.width() - win.scrollLeft();
				position.left = over > 0 ? position.left - over : Math.max(position.left - data.collisionPosition.left, position.left);
			},
			top: function (position, data) {
				var win = $(window),
				over = data.collisionPosition.top + data.collisionHeight - win.height() - win.scrollTop();
				position.top = over > 0 ? position.top - over : Math.max(position.top - data.collisionPosition.top, position.top);
			}
		},

		flip: {
			left: function (position, data) {
				if (data.at[0] === center) {
					return;
				}
				var win = $(window),
				over = data.collisionPosition.left + data.collisionWidth - win.width() - win.scrollLeft(),
				myOffset = data.my[0] === "left" ?
					-data.elemWidth :
					data.my[0] === "right" ?
						data.elemWidth :
						0,
				atOffset = data.at[0] === "left" ?
					data.targetWidth :
					-data.targetWidth,
				offset = -2 * data.offset[0];
				position.left += data.collisionPosition.left < 0 ?
				myOffset + atOffset + offset :
				over > 0 ?
					myOffset + atOffset + offset :
					0;
			},
			top: function (position, data) {
				if (data.at[1] === center) {
					return;
				}
				var win = $(window),
				over = data.collisionPosition.top + data.collisionHeight - win.height() - win.scrollTop(),
				myOffset = data.my[1] === "top" ?
					-data.elemHeight :
					data.my[1] === "bottom" ?
						data.elemHeight :
						0,
				atOffset = data.at[1] === "top" ?
					data.targetHeight :
					-data.targetHeight,
				offset = -2 * data.offset[1];
				position.top += data.collisionPosition.top < 0 ?
				myOffset + atOffset + offset :
				over > 0 ?
					myOffset + atOffset + offset :
					0;
			}
		}
	};

	// offset setter from jQuery 1.4
	if (!$.offset.setOffset) {
		$.offset.setOffset = function (elem, options) {
			// set position first, in-case top/left are set even on static elem
			if (/static/.test($.curCSS(elem, "position"))) {
				elem.style.position = "relative";
			}
			var curElem = $(elem),
			curOffset = curElem.offset(),
			curTop = parseInt($.curCSS(elem, "top", true), 10) || 0,
			curLeft = parseInt($.curCSS(elem, "left", true), 10) || 0,
			props = {
				top: (options.top - curOffset.top) + curTop,
				left: (options.left - curOffset.left) + curLeft
			};

			if ('using' in options) {
				options.using.call(elem, props);
			} else {
				curElem.css(props);
			}
		};

		$.fn.offset = function (options) {
			var elem = this[0];
			if (!elem || !elem.ownerDocument) { return null; }
			if (options) {
				return this.each(function () {
					$.offset.setOffset(this, options);
				});
			}
			return _offset.call(this);
		};
	}

} (jQuery));
/*
* jQuery UI Draggable 1.8.6
*
* Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* http://docs.jquery.com/UI/Draggables
*
* Depends:
*	jquery.ui.core.js
*	jquery.ui.mouse.js
*	jquery.ui.widget.js
*/
(function ($, undefined) {

	$.widget("ui.draggable", $.ui.mouse, {
		widgetEventPrefix: "drag",
		options: {
			addClasses: true,
			appendTo: "parent",
			axis: false,
			connectToSortable: false,
			containment: false,
			cursor: "auto",
			cursorAt: false,
			grid: false,
			handle: false,
			helper: "original",
			iframeFix: false,
			opacity: false,
			refreshPositions: false,
			revert: false,
			revertDuration: 500,
			scope: "default",
			scroll: true,
			scrollSensitivity: 20,
			scrollSpeed: 20,
			snap: false,
			snapMode: "both",
			snapTolerance: 20,
			stack: false,
			zIndex: false
		},
		_create: function () {

			if (this.options.helper == 'original' && !(/^(?:r|a|f)/).test(this.element.css("position")))
				this.element[0].style.position = 'relative';

			(this.options.addClasses && this.element.addClass("ui-draggable"));
			(this.options.disabled && this.element.addClass("ui-draggable-disabled"));

			this._mouseInit();

		},

		destroy: function () {
			if (!this.element.data('draggable')) return;
			this.element
			.removeData("draggable")
			.unbind(".draggable")
			.removeClass("ui-draggable"
				+ " ui-draggable-dragging"
				+ " ui-draggable-disabled");
			this._mouseDestroy();

			return this;
		},

		_mouseCapture: function (event) {

			var o = this.options;

			// among others, prevent a drag on a resizable-handle
			if (this.helper || o.disabled || $(event.target).is('.ui-resizable-handle'))
				return false;

			//Quit if we're not on a valid handle
			this.handle = this._getHandle(event);
			if (!this.handle)
				return false;

			return true;

		},

		_mouseStart: function (event) {

			var o = this.options;

			//Create and append the visible helper
			this.helper = this._createHelper(event);

			//Cache the helper size
			this._cacheHelperProportions();

			//If ddmanager is used for droppables, set the global draggable
			if ($.ui.ddmanager)
				$.ui.ddmanager.current = this;

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

			//Cache the margins of the original element
			this._cacheMargins();

			//Store the helper's css position
			this.cssPosition = this.helper.css("position");
			this.scrollParent = this.helper.scrollParent();

			//The element's absolute position on the page minus margins
			this.offset = this.positionAbs = this.element.offset();
			this.offset = {
				top: this.offset.top - this.margins.top,
				left: this.offset.left - this.margins.left
			};

			$.extend(this.offset, {
				click: { //Where the click happened, relative to the element
					left: event.pageX - this.offset.left,
					top: event.pageY - this.offset.top
				},
				parent: this._getParentOffset(),
				relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
			});

			//Generate the original position
			this.originalPosition = this.position = this._generatePosition(event);
			this.originalPageX = event.pageX;
			this.originalPageY = event.pageY;

			//Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
			(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));

			//Set a containment if given in the options
			if (o.containment)
				this._setContainment();

			//Trigger event + callbacks
			if (this._trigger("start", event) === false) {
				this._clear();
				return false;
			}

			//Recache the helper size
			this._cacheHelperProportions();

			//Prepare the droppable offsets
			if ($.ui.ddmanager && !o.dropBehaviour)
				$.ui.ddmanager.prepareOffsets(this, event);

			this.helper.addClass("ui-draggable-dragging");
			this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
			return true;
		},

		_mouseDrag: function (event, noPropagation) {

			//Compute the helpers position
			this.position = this._generatePosition(event);
			this.positionAbs = this._convertPositionTo("absolute");

			//Call plugins and callbacks and use the resulting position if something is returned
			if (!noPropagation) {
				var ui = this._uiHash();
				if (this._trigger('drag', event, ui) === false) {
					this._mouseUp({});
					return false;
				}
				this.position = ui.position;
			}

			if (!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left + 'px';
			if (!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top + 'px';
			if ($.ui.ddmanager) $.ui.ddmanager.drag(this, event);

			return false;
		},

		_mouseStop: function (event) {

			//If we are using droppables, inform the manager about the drop
			var dropped = false;
			if ($.ui.ddmanager && !this.options.dropBehaviour)
				dropped = $.ui.ddmanager.drop(this, event);

			//if a drop comes from outside (a sortable)
			if (this.dropped) {
				dropped = this.dropped;
				this.dropped = false;
			}

			//if the original element is removed, don't bother to continue
			if (!this.element[0] || !this.element[0].parentNode)
				return false;

			if ((this.options.revert == "invalid" && !dropped) || (this.options.revert == "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
				var self = this;
				$(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function () {
					if (self._trigger("stop", event) !== false) {
						self._clear();
					}
				});
			} else {
				if (this._trigger("stop", event) !== false) {
					this._clear();
				}
			}

			return false;
		},

		cancel: function () {

			if (this.helper.is(".ui-draggable-dragging")) {
				this._mouseUp({});
			} else {
				this._clear();
			}

			return this;

		},

		_getHandle: function (event) {

			var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
			$(this.options.handle, this.element)
			.find("*")
			.andSelf()
			.each(function () {
				if (this == event.target) handle = true;
			});

			return handle;

		},

		_createHelper: function (event) {

			var o = this.options;
			var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper == 'clone' ? this.element.clone() : this.element);

			if (!helper.parents('body').length)
				helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));

			if (helper[0] != this.element[0] && !(/(fixed|absolute)/).test(helper.css("position")))
				helper.css("position", "absolute");

			return helper;

		},

		_adjustOffsetFromHelper: function (obj) {
			if (typeof obj == 'string') {
				obj = obj.split(' ');
			}
			if ($.isArray(obj)) {
				obj = { left: +obj[0], top: +obj[1] || 0 };
			}
			if ('left' in obj) {
				this.offset.click.left = obj.left + this.margins.left;
			}
			if ('right' in obj) {
				this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
			}
			if ('top' in obj) {
				this.offset.click.top = obj.top + this.margins.top;
			}
			if ('bottom' in obj) {
				this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
			}
		},

		_getParentOffset: function () {

			//Get the offsetParent and cache its position
			this.offsetParent = this.helper.offsetParent();
			var po = this.offsetParent.offset();

			// This is a special case where we need to modify a offset calculated on start, since the following happened:
			// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
			// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
			//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
			if (this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) {
				po.left += this.scrollParent.scrollLeft();
				po.top += this.scrollParent.scrollTop();
			}

			if ((this.offsetParent[0] == document.body) //This needs to be actually done for all browsers, since pageX/pageY includes this information
		|| (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix
				po = { top: 0, left: 0 };

			return {
				top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
				left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
			};

		},

		_getRelativeOffset: function () {

			if (this.cssPosition == "relative") {
				var p = this.element.position();
				return {
					top: p.top - (parseInt(this.helper.css("top"), 10) || 0) + this.scrollParent.scrollTop(),
					left: p.left - (parseInt(this.helper.css("left"), 10) || 0) + this.scrollParent.scrollLeft()
				};
			} else {
				return { top: 0, left: 0 };
			}

		},

		_cacheMargins: function () {
			this.margins = {
				left: (parseInt(this.element.css("marginLeft"), 10) || 0),
				top: (parseInt(this.element.css("marginTop"), 10) || 0)
			};
		},

		_cacheHelperProportions: function () {
			this.helperProportions = {
				width: this.helper.outerWidth(),
				height: this.helper.outerHeight()
			};
		},

		_setContainment: function () {

			var o = this.options;
			if (o.containment == 'parent') o.containment = this.helper[0].parentNode;
			if (o.containment == 'document' || o.containment == 'window') this.containment = [
			0 - this.offset.relative.left - this.offset.parent.left,
			0 - this.offset.relative.top - this.offset.parent.top,
			$(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left,
			($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
		];

			if (!(/^(document|window|parent)$/).test(o.containment) && o.containment.constructor != Array) {
				var ce = $(o.containment)[0]; if (!ce) return;
				var co = $(o.containment).offset();
				var over = ($(ce).css("overflow") != 'hidden');

				this.containment = [
				co.left + (parseInt($(ce).css("borderLeftWidth"), 10) || 0) + (parseInt($(ce).css("paddingLeft"), 10) || 0) - this.margins.left,
				co.top + (parseInt($(ce).css("borderTopWidth"), 10) || 0) + (parseInt($(ce).css("paddingTop"), 10) || 0) - this.margins.top,
				co.left + (over ? Math.max(ce.scrollWidth, ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"), 10) || 0) - (parseInt($(ce).css("paddingRight"), 10) || 0) - this.helperProportions.width - this.margins.left,
				co.top + (over ? Math.max(ce.scrollHeight, ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"), 10) || 0) - (parseInt($(ce).css("paddingBottom"), 10) || 0) - this.helperProportions.height - this.margins.top
			];
			} else if (o.containment.constructor == Array) {
				this.containment = o.containment;
			}

		},

		_convertPositionTo: function (d, pos) {

			if (!pos) pos = this.position;
			var mod = d == "absolute" ? 1 : -1;
			var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);

			return {
				top: (
				pos.top																	// The absolute mouse 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)
				- ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : (this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : (scrollIsRootNode ? 0 : scroll.scrollTop())) * mod)
			),
				left: (
				pos.left																// The absolute mouse 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)
				- ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : (this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft()) * mod)
			)
			};

		},

		_generatePosition: function (event) {

			var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
			var pageX = event.pageX;
			var pageY = event.pageY;

			/*
			* - Position constraining -
			* Constrain the position to a mix of grid, containment.
			*/

			if (this.originalPosition) { //If we are not dragging yet, we won't check for options

				if (this.containment) {
					if (event.pageX - this.offset.click.left < this.containment[0]) pageX = this.containment[0] + this.offset.click.left;
					if (event.pageY - this.offset.click.top < this.containment[1]) pageY = this.containment[1] + this.offset.click.top;
					if (event.pageX - this.offset.click.left > this.containment[2]) pageX = this.containment[2] + this.offset.click.left;
					if (event.pageY - this.offset.click.top > this.containment[3]) pageY = this.containment[3] + this.offset.click.top;
				}

				if (o.grid) {
					var top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
					pageY = this.containment ? (!(top - this.offset.click.top < this.containment[1] || top - this.offset.click.top > this.containment[3]) ? top : (!(top - this.offset.click.top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;

					var left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
					pageX = this.containment ? (!(left - this.offset.click.left < this.containment[0] || left - this.offset.click.left > this.containment[2]) ? left : (!(left - this.offset.click.left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
				}

			}

			return {
				top: (
				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)
				+ ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : (this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : (scrollIsRootNode ? 0 : scroll.scrollTop())))
			),
				left: (
				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)
				+ ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : (this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft()))
			)
			};

		},

		_clear: function () {
			this.helper.removeClass("ui-draggable-dragging");
			if (this.helper[0] != this.element[0] && !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

		_trigger: function (type, event, ui) {
			ui = ui || this._uiHash();
			$.ui.plugin.call(this, type, [event, ui]);
			if (type == "drag") this.positionAbs = this._convertPositionTo("absolute"); //The absolute position has to be recalculated after plugins
			return $.Widget.prototype._trigger.call(this, type, event, ui);
		},

		plugins: {},

		_uiHash: function (event) {
			return {
				helper: this.helper,
				position: this.position,
				originalPosition: this.originalPosition,
				offset: this.positionAbs
			};
		}

	});

	$.extend($.ui.draggable, {
		version: "1.8.6"
	});

	$.ui.plugin.add("draggable", "connectToSortable", {
		start: function (event, ui) {

			var inst = $(this).data("draggable"), o = inst.options,
			uiSortable = $.extend({}, ui, { item: inst.element });
			inst.sortables = [];
			$(o.connectToSortable).each(function () {
				var sortable = $.data(this, 'sortable');
				if (sortable && !sortable.options.disabled) {
					inst.sortables.push({
						instance: sortable,
						shouldRevert: sortable.options.revert
					});
					sortable._refreshItems(); //Do a one-time refresh at start to refresh the containerCache
					sortable._trigger("activate", event, uiSortable);
				}
			});

		},
		stop: function (event, 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"),
			uiSortable = $.extend({}, ui, { item: inst.element });

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

					//The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: 'valid/invalid'
					if (this.shouldRevert) this.instance.options.revert = true;

					//Trigger the stop of the sortable
					this.instance._mouseStop(event);

					this.instance.options.helper = this.instance.options._helper;

					//If the helper has been the original item, restore properties in the sortable
					if (inst.options.helper == 'original')
						this.instance.currentItem.css({ top: 'auto', left: 'auto' });

				} else {
					this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
					this.instance._trigger("deactivate", event, uiSortable);
				}

			});

		},
		drag: function (event, ui) {

			var inst = $(this).data("draggable"), self = this;

			var checkPos = function (o) {
				var dyClick = this.offset.click.top, dxClick = this.offset.click.left;
				var helperTop = this.positionAbs.top, helperLeft = this.positionAbs.left;
				var itemHeight = o.height, itemWidth = o.width;
				var itemTop = o.top, itemLeft = o.left;

				return $.ui.isOver(helperTop + dyClick, helperLeft + dxClick, itemTop, itemLeft, itemHeight, itemWidth);
			};

			$.each(inst.sortables, function (i) {

				//Copy over some variables to allow calling the sortable's native _intersectsWith
				this.instance.positionAbs = inst.positionAbs;
				this.instance.helperProportions = inst.helperProportions;
				this.instance.offset.click = inst.offset.click;

				if (this.instance._intersectsWith(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]; };

						event.target = this.instance.currentItem[0];
						this.instance._mouseCapture(event, true);
						this.instance._mouseStart(event, 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._trigger("toSortable", event);
						inst.dropped = this.instance.element; //draggable revert needs that
						//hack so receive/update callbacks work (mostly)
						inst.currentItem = inst.element;
						this.instance.fromOutside = inst;

					}

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

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

						//Prevent reverting on this forced stop
						this.instance.options.revert = false;

						// The out event needs to be triggered independently
						this.instance._trigger('out', event, this.instance._uiHash(this.instance));

						this.instance._mouseStop(event, 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();
						if (this.instance.placeholder) this.instance.placeholder.remove();

						inst._trigger("fromSortable", event);
						inst.dropped = false; //draggable revert needs that
					}

				};

			});

		}
	});

	$.ui.plugin.add("draggable", "cursor", {
		start: function (event, ui) {
			var t = $('body'), o = $(this).data('draggable').options;
			if (t.css("cursor")) o._cursor = t.css("cursor");
			t.css("cursor", o.cursor);
		},
		stop: function (event, ui) {
			var o = $(this).data('draggable').options;
			if (o._cursor) $('body').css("cursor", o._cursor);
		}
	});

	$.ui.plugin.add("draggable", "iframeFix", {
		start: function (event, ui) {
			var o = $(this).data('draggable').options;
			$(o.iframeFix === true ? "iframe" : o.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 (event, ui) {
			$("div.ui-draggable-iframeFix").each(function () { this.parentNode.removeChild(this); }); //Remove frame helpers
		}
	});

	$.ui.plugin.add("draggable", "opacity", {
		start: function (event, ui) {
			var t = $(ui.helper), o = $(this).data('draggable').options;
			if (t.css("opacity")) o._opacity = t.css("opacity");
			t.css('opacity', o.opacity);
		},
		stop: function (event, ui) {
			var o = $(this).data('draggable').options;
			if (o._opacity) $(ui.helper).css('opacity', o._opacity);
		}
	});

	$.ui.plugin.add("draggable", "scroll", {
		start: function (event, ui) {
			var i = $(this).data("draggable");
			if (i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') i.overflowOffset = i.scrollParent.offset();
		},
		drag: function (event, ui) {

			var i = $(this).data("draggable"), o = i.options, scrolled = false;

			if (i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') {

				if (!o.axis || o.axis != 'x') {
					if ((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
						i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
					else if (event.pageY - i.overflowOffset.top < o.scrollSensitivity)
						i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
				}

				if (!o.axis || o.axis != 'y') {
					if ((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
						i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
					else if (event.pageX - i.overflowOffset.left < o.scrollSensitivity)
						i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
				}

			} else {

				if (!o.axis || o.axis != 'x') {
					if (event.pageY - $(document).scrollTop() < o.scrollSensitivity)
						scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
					else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
						scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
				}

				if (!o.axis || o.axis != 'y') {
					if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
						scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
					else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
						scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
				}

			}

			if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
				$.ui.ddmanager.prepareOffsets(i, event);

		}
	});

	$.ui.plugin.add("draggable", "snap", {
		start: function (event, ui) {

			var i = $(this).data("draggable"), o = i.options;
			i.snapElements = [];

			$(o.snap.constructor != String ? (o.snap.items || ':data(draggable)') : o.snap).each(function () {
				var $t = $(this); var $o = $t.offset();
				if (this != i.element[0]) i.snapElements.push({
					item: this,
					width: $t.outerWidth(), height: $t.outerHeight(),
					top: $o.top, left: $o.left
				});
			});

		},
		drag: function (event, ui) {

			var inst = $(this).data("draggable"), o = inst.options;
			var d = o.snapTolerance;

			var x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
			y1 = ui.offset.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))) {
					if (inst.snapElements[i].snapping) (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
					inst.snapElements[i].snapping = false;
					continue;
				}

				if (o.snapMode != 'inner') {
					var ts = Math.abs(t - y2) <= d;
					var bs = Math.abs(b - y1) <= d;
					var ls = Math.abs(l - x2) <= d;
					var rs = Math.abs(r - x1) <= d;
					if (ts) ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
					if (bs) ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
					if (ls) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
					if (rs) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
				}

				var first = (ts || bs || ls || rs);

				if (o.snapMode != 'outer') {
					var ts = Math.abs(t - y1) <= d;
					var bs = Math.abs(b - y2) <= d;
					var ls = Math.abs(l - x1) <= d;
					var rs = Math.abs(r - x2) <= d;
					if (ts) ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
					if (bs) ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
					if (ls) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
					if (rs) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
				}

				if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first))
					(inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
				inst.snapElements[i].snapping = (ts || bs || ls || rs || first);

			};

		}
	});

	$.ui.plugin.add("draggable", "stack", {
		start: function (event, ui) {

			var o = $(this).data("draggable").options;

			var group = $.makeArray($(o.stack)).sort(function (a, b) {
				return (parseInt($(a).css("zIndex"), 10) || 0) - (parseInt($(b).css("zIndex"), 10) || 0);
			});
			if (!group.length) { return; }

			var min = parseInt(group[0].style.zIndex) || 0;
			$(group).each(function (i) {
				this.style.zIndex = min + i;
			});

			this[0].style.zIndex = min + group.length;

		}
	});

	$.ui.plugin.add("draggable", "zIndex", {
		start: function (event, ui) {
			var t = $(ui.helper), o = $(this).data("draggable").options;
			if (t.css("zIndex")) o._zIndex = t.css("zIndex");
			t.css('zIndex', o.zIndex);
		},
		stop: function (event, ui) {
			var o = $(this).data("draggable").options;
			if (o._zIndex) $(ui.helper).css('zIndex', o._zIndex);
		}
	});

})(jQuery);
/*
* jQuery UI Resizable 1.8.6
*
* Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* http://docs.jquery.com/UI/Resizables
*
* Depends:
*	jquery.ui.core.js
*	jquery.ui.mouse.js
*	jquery.ui.widget.js
*/
(function ($, undefined) {

	$.widget("ui.resizable", $.ui.mouse, {
		widgetEventPrefix: "resize",
		options: {
			alsoResize: false,
			animate: false,
			animateDuration: "slow",
			animateEasing: "swing",
			aspectRatio: false,
			autoHide: false,
			containment: false,
			ghost: false,
			grid: false,
			handles: "e,s,se",
			helper: false,
			maxHeight: null,
			maxWidth: null,
			minHeight: 10,
			minWidth: 10,
			zIndex: 1000
		},
		_create: function () {

			var self = this, o = this.options;
			this.element.addClass("ui-resizable");

			$.extend(this, {
				_aspectRatio: !!(o.aspectRatio),
				aspectRatio: o.aspectRatio,
				originalElement: this.element,
				_proportionallyResizeElements: [],
				_helper: o.helper || o.ghost || o.animate ? o.helper || 'ui-resizable-helper' : null
			});

			//Wrap the element if it cannot hold child nodes
			if (this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)) {

				//Opera fix for relative positioning
				if (/relative/.test(this.element.css('position')) && $.browser.opera)
					this.element.css({ position: 'relative', top: 'auto', left: 'auto' });

				//Create a wrapper element and set the wrapper to the new current internal element
				this.element.wrap(
				$('<div class="ui-wrapper" style="overflow: hidden;"></div>').css({
					position: this.element.css('position'),
					width: this.element.outerWidth(),
					height: this.element.outerHeight(),
					top: this.element.css('top'),
					left: this.element.css('left')
				})
			);

				//Overwrite the original this.element
				this.element = this.element.parent().data(
				"resizable", this.element.data('resizable')
			);

				this.elementIsWrapper = true;

				//Move margins to the wrapper
				this.element.css({ marginLeft: this.originalElement.css("marginLeft"), marginTop: this.originalElement.css("marginTop"), marginRight: this.originalElement.css("marginRight"), marginBottom: this.originalElement.css("marginBottom") });
				this.originalElement.css({ marginLeft: 0, marginTop: 0, marginRight: 0, marginBottom: 0 });

				//Prevent Safari textarea resize
				this.originalResizeStyle = this.originalElement.css('resize');
				this.originalElement.css('resize', 'none');

				//Push the actual element to our proportionallyResize internal array
				this._proportionallyResizeElements.push(this.originalElement.css({ position: 'static', zoom: 1, display: 'block' }));

				// avoid IE jump (hard set the margin)
				this.originalElement.css({ margin: this.originalElement.css('margin') });

				// fix handlers offset
				this._proportionallyResize();

			}

			this.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 (this.handles.constructor == String) {

				if (this.handles == 'all') this.handles = 'n,e,s,w,se,sw,ne,nw';
				var n = this.handles.split(","); this.handles = {};

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

					var handle = $.trim(n[i]), hname = 'ui-resizable-' + handle;
					var axis = $('<div class="ui-resizable-handle ' + hname + '"></div>');

					// increase zIndex of sw, se, ne, nw axis
					//TODO : this modifies original option
					if (/sw|se|ne|nw/.test(handle)) axis.css({ zIndex: ++o.zIndex });

					//TODO : What's going on here?
					if ('se' == handle) {
						axis.addClass('ui-icon ui-icon-gripsmall-diagonal-se');
					};

					//Insert into internal handles object and append to element
					this.handles[handle] = '.ui-resizable-' + handle;
					this.element.append(axis);
				}

			}

			this._renderAxis = function (target) {

				target = target || this.element;

				for (var i in this.handles) {

					if (this.handles[i].constructor == String)
						this.handles[i] = $(this.handles[i], this.element).show();

					//Apply pad to wrapper element, needed to fix axis position (textarea, inputs, scrolls)
					if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/textarea|input|select|button/i)) {

						var axis = $(this.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("");

						target.css(padPos, padWrapper);

						this._proportionallyResize();

					}

					//TODO: What's that good for? There's not anything to be executed left
					if (!$(this.handles[i]).length)
						continue;

				}
			};

			//TODO: make renderAxis a prototype function
			this._renderAxis(this.element);

			this._handles = $('.ui-resizable-handle', this.element)
			.disableSelection();

			//Matching axis name
			this._handles.mouseover(function () {
				if (!self.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 = axis && axis[1] ? axis[1] : 'se';
				}
			});

			//If we want to auto hide the elements
			if (o.autoHide) {
				this._handles.hide();
				$(this.element)
				.addClass("ui-resizable-autohide")
				.hover(function () {
					$(this).removeClass("ui-resizable-autohide");
					self._handles.show();
				},
				function () {
					if (!self.resizing) {
						$(this).addClass("ui-resizable-autohide");
						self._handles.hide();
					}
				});
			}

			//Initialize the mouse interaction
			this._mouseInit();

		},

		destroy: function () {

			this._mouseDestroy();

			var _destroy = function (exp) {
				$(exp).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
				.removeData("resizable").unbind(".resizable").find('.ui-resizable-handle').remove();
			};

			//TODO: Unwrap at same DOM position
			if (this.elementIsWrapper) {
				_destroy(this.element);
				var wrapper = this.element;
				wrapper.after(
				this.originalElement.css({
					position: wrapper.css('position'),
					width: wrapper.outerWidth(),
					height: wrapper.outerHeight(),
					top: wrapper.css('top'),
					left: wrapper.css('left')
				})
			).remove();
			}

			this.originalElement.css('resize', this.originalResizeStyle);
			_destroy(this.originalElement);

			return this;
		},

		_mouseCapture: function (event) {
			var handle = false;
			for (var i in this.handles) {
				if ($(this.handles[i])[0] == event.target) {
					handle = true;
				}
			}

			return !this.options.disabled && handle;
		},

		_mouseStart: function (event) {

			var o = this.options, iniPos = this.element.position(), el = this.element;

			this.resizing = true;
			this.documentScroll = { top: $(document).scrollTop(), left: $(document).scrollLeft() };

			// bugfix for http://dev.jquery.com/ticket/1749
			if (el.is('.ui-draggable') || (/absolute/).test(el.css('position'))) {
				el.css({ position: 'absolute', top: iniPos.top, left: iniPos.left });
			}

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

			if (o.containment) {
				curleft += $(o.containment).scrollLeft() || 0;
				curtop += $(o.containment).scrollTop() || 0;
			}

			//Store needed variables
			this.offset = this.helper.offset();
			this.position = { left: curleft, top: curtop };
			this.size = this._helper ? { width: el.outerWidth(), height: el.outerHeight()} : { width: el.width(), height: el.height() };
			this.originalSize = this._helper ? { 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: event.pageX, top: event.pageY };

			//Aspect Ratio
			this.aspectRatio = (typeof o.aspectRatio == 'number') ? o.aspectRatio : ((this.originalSize.width / this.originalSize.height) || 1);

			var cursor = $('.ui-resizable-' + this.axis).css('cursor');
			$('body').css('cursor', cursor == 'auto' ? this.axis + '-resize' : cursor);

			el.addClass("ui-resizable-resizing");
			this._propagate("start", event);
			return true;
		},

		_mouseDrag: function (event) {

			//Increase performance, avoid regex
			var el = this.helper, o = this.options, props = {},
			self = this, smp = this.originalMousePosition, a = this.axis;

			var dx = (event.pageX - smp.left) || 0, dy = (event.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, [event, dx, dy]), ie6 = $.browser.msie && $.browser.version < 7, csdif = this.sizeDiff;

			if (this._aspectRatio || event.shiftKey)
				data = this._updateRatio(data, event);

			data = this._respectSize(data, event);

			// plugins callbacks need to be called first
			this._propagate("resize", event);

			el.css({
				top: this.position.top + "px", left: this.position.left + "px",
				width: this.size.width + "px", height: this.size.height + "px"
			});

			if (!this._helper && this._proportionallyResizeElements.length)
				this._proportionallyResize();

			this._updateCache(data);

			// calling the user callback at the end
			this._trigger('resize', event, this.ui());

			return false;
		},

		_mouseStop: function (event) {

			this.resizing = false;
			var o = this.options, self = this;

			if (this._helper) {
				var pr = this._proportionallyResizeElements, ista = pr.length && (/textarea/i).test(pr[0].nodeName),
						soffseth = ista && $.ui.hasScroll(pr[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 }));

				self.helper.height(self.size.height);
				self.helper.width(self.size.width);

				if (this._helper && !o.animate) this._proportionallyResize();
			}

			$('body').css('cursor', 'auto');

			this.element.removeClass("ui-resizable-resizing");

			this._propagate("stop", event);

			if (this._helper) this.helper.remove();
			return false;

		},

		_updateCache: function (data) {
			var o = this.options;
			this.offset = this.helper.offset();
			if (isNumber(data.left)) this.position.left = data.left;
			if (isNumber(data.top)) this.position.top = data.top;
			if (isNumber(data.height)) this.size.height = data.height;
			if (isNumber(data.width)) this.size.width = data.width;
		},

		_updateRatio: function (data, event) {

			var o = this.options, cpos = this.position, csize = this.size, a = this.axis;

			if (data.height) data.width = (csize.height * this.aspectRatio);
			else if (data.width) data.height = (csize.width / this.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, event) {

			var el = this.helper, o = this.options, pRatio = this._aspectRatio || event.shiftKey, a = this.axis,
				ismaxw = isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width), ismaxh = isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
					isminw = isNumber(data.width) && o.minWidth && (o.minWidth > data.width), isminh = isNumber(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 (!this._proportionallyResizeElements.length) return;
			var element = this.helper || this.element;

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

				var prel = this._proportionallyResizeElements[i];

				if (!this.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')];

					this.borderDif = $.map(b, function (v, i) {
						var border = parseInt(v, 10) || 0, padding = parseInt(p[i], 10) || 0;
						return border + padding;
					});
				}

				if ($.browser.msie && !(!($(element).is(':hidden') || $(element).parents(':hidden').length)))
					continue;

				prel.css({
					height: (element.height() - this.borderDif[0] - this.borderDif[2]) || 0,
					width: (element.width() - this.borderDif[1] - this.borderDif[3]) || 0
				});

			};

		},

		_renderProxy: function () {

			var el = this.element, o = this.options;
			this.elementOffset = el.offset();

			if (this._helper) {

				this.helper = this.helper || $('<div style="overflow:hidden;"></div>');

				// fix ie6 offset TODO: This seems broken
				var ie6 = $.browser.msie && $.browser.version < 7, ie6offset = (ie6 ? 1 : 0),
			pxyoffset = (ie6 ? 2 : -1);

				this.helper.addClass(this._helper).css({
					width: this.element.outerWidth() + pxyoffset,
					height: this.element.outerHeight() + pxyoffset,
					position: 'absolute',
					left: this.elementOffset.left - ie6offset + 'px',
					top: this.elementOffset.top - ie6offset + 'px',
					zIndex: ++o.zIndex //TODO: Don't modify option
				});

				this.helper
				.appendTo("body")
				.disableSelection();

			} else {
				this.helper = this.element;
			}

		},

		_change: {
			e: function (event, dx, dy) {
				return { width: this.originalSize.width + dx };
			},
			w: function (event, dx, dy) {
				var o = this.options, cs = this.originalSize, sp = this.originalPosition;
				return { left: sp.left + dx, width: cs.width - dx };
			},
			n: function (event, dx, dy) {
				var o = this.options, cs = this.originalSize, sp = this.originalPosition;
				return { top: sp.top + dy, height: cs.height - dy };
			},
			s: function (event, dx, dy) {
				return { height: this.originalSize.height + dy };
			},
			se: function (event, dx, dy) {
				return $.extend(this._change.s.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
			},
			sw: function (event, dx, dy) {
				return $.extend(this._change.s.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
			},
			ne: function (event, dx, dy) {
				return $.extend(this._change.n.apply(this, arguments), this._change.e.apply(this, [event, dx, dy]));
			},
			nw: function (event, dx, dy) {
				return $.extend(this._change.n.apply(this, arguments), this._change.w.apply(this, [event, dx, dy]));
			}
		},

		_propagate: function (n, event) {
			$.ui.plugin.call(this, n, [event, this.ui()]);
			(n != "resize" && this._trigger(n, event, this.ui()));
		},

		plugins: {},

		ui: function () {
			return {
				originalElement: this.originalElement,
				element: this.element,
				helper: this.helper,
				position: this.position,
				size: this.size,
				originalSize: this.originalSize,
				originalPosition: this.originalPosition
			};
		}

	});

	$.extend($.ui.resizable, {
		version: "1.8.6"
	});

	/*
	* Resizable Extensions
	*/

	$.ui.plugin.add("resizable", "alsoResize", {

		start: function (event, ui) {
			var self = $(this).data("resizable"), o = self.options;

			var _store = function (exp) {
				$(exp).each(function () {
					var el = $(this);
					el.data("resizable-alsoresize", {
						width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
						left: parseInt(el.css('left'), 10), top: parseInt(el.css('top'), 10),
						position: el.css('position') // to reset Opera on stop()
					});
				});
			};

			if (typeof (o.alsoResize) == 'object' && !o.alsoResize.parentNode) {
				if (o.alsoResize.length) { o.alsoResize = o.alsoResize[0]; _store(o.alsoResize); }
				else { $.each(o.alsoResize, function (exp) { _store(exp); }); }
			} else {
				_store(o.alsoResize);
			}
		},

		resize: function (event, ui) {
			var self = $(this).data("resizable"), o = self.options, 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 el = $(this), start = $(this).data("resizable-alsoresize"), style = {},
					css = c && c.length ? c : el.parents(ui.originalElement[0]).length ? ['width', 'height'] : ['width', 'height', 'top', 'left'];

				$.each(css, function (i, prop) {
					var sum = (start[prop] || 0) + (delta[prop] || 0);
					if (sum && sum >= 0)
						style[prop] = sum || null;
				});

				// Opera fixing relative position
				if ($.browser.opera && /relative/.test(el.css('position'))) {
					self._revertToRelativePosition = true;
					el.css({ position: 'absolute', top: 'auto', left: 'auto' });
				}

				el.css(style);
			});
		};

			if (typeof (o.alsoResize) == 'object' && !o.alsoResize.nodeType) {
				$.each(o.alsoResize, function (exp, c) { _alsoResize(exp, c); });
			} else {
				_alsoResize(o.alsoResize);
			}
		},

		stop: function (event, ui) {
			var self = $(this).data("resizable"), o = self.options;

			var _reset = function (exp) {
				$(exp).each(function () {
					var el = $(this);
					// reset position for Opera - no need to verify it was changed
					el.css({ position: el.data("resizable-alsoresize").position });
				});
			};

			if (self._revertToRelativePosition) {
				self._revertToRelativePosition = false;
				if (typeof (o.alsoResize) == 'object' && !o.alsoResize.nodeType) {
					$.each(o.alsoResize, function (exp) { _reset(exp); });
				} else {
					_reset(o.alsoResize);
				}
			}

			$(this).removeData("resizable-alsoresize");
		}
	});

	$.ui.plugin.add("resizable", "animate", {

		stop: function (event, ui) {
			var self = $(this).data("resizable"), o = self.options;

			var pr = self._proportionallyResizeElements, ista = pr.length && (/textarea/i).test(pr[0].nodeName),
					soffseth = ista && $.ui.hasScroll(pr[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,
				easing: o.animateEasing,
				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.length) $(pr[0]).css({ width: data.width, height: data.height });

					// propagating resize, and updating values for each animation step
					self._updateCache(data);
					self._propagate("resize", event);

				}
			}
		);
		}

	});

	$.ui.plugin.add("resizable", "containment", {

		start: function (event, ui) {
			var self = $(this).data("resizable"), o = self.options, el = self.element;
			var oc = o.containment, ce = (oc instanceof $) ? oc.get(0) : (/parent/.test(oc)) ? el.parent().get(0) : oc;
			if (!ce) return;

			self.containerElement = $(ce);

			if (/document/.test(oc) || oc == document) {
				self.containerOffset = { left: 0, top: 0 };
				self.containerPosition = { 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 {
				var element = $(ce), p = [];
				$(["Top", "Right", "Left", "Bottom"]).each(function (i, name) { p[i] = num(element.css("padding" + name)); });

				self.containerOffset = element.offset();
				self.containerPosition = element.position();
				self.containerSize = { height: (element.innerHeight() - p[3]), width: (element.innerWidth() - p[1]) };

				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
				};
			}
		},

		resize: function (event, ui) {
			var self = $(this).data("resizable"), o = self.options,
				ps = self.containerSize, co = self.containerOffset, cs = self.size, cp = self.position,
				pRatio = self._aspectRatio || event.shiftKey, cop = { top: 0, left: 0 }, ce = self.containerElement;

			if (ce[0] != document && (/static/).test(ce.css('position'))) cop = co;

			if (cp.left < (self._helper ? co.left : 0)) {
				self.size.width = self.size.width + (self._helper ? (self.position.left - co.left) : (self.position.left - cop.left));
				if (pRatio) self.size.height = self.size.width / o.aspectRatio;
				self.position.left = o.helper ? co.left : 0;
			}

			if (cp.top < (self._helper ? co.top : 0)) {
				self.size.height = self.size.height + (self._helper ? (self.position.top - co.top) : self.position.top);
				if (pRatio) self.size.width = self.size.height * o.aspectRatio;
				self.position.top = self._helper ? co.top : 0;
			}

			self.offset.left = self.parentData.left + self.position.left;
			self.offset.top = self.parentData.top + self.position.top;

			var woset = Math.abs((self._helper ? self.offset.left - cop.left : (self.offset.left - cop.left)) + self.sizeDiff.width),
					hoset = Math.abs((self._helper ? self.offset.top - cop.top : (self.offset.top - co.top)) + self.sizeDiff.height);

			var isParent = self.containerElement.get(0) == self.element.parent().get(0),
		    isOffsetRelative = /relative|absolute/.test(self.containerElement.css('position'));

			if (isParent && isOffsetRelative) woset -= self.parentData.left;

			if (woset + self.size.width >= self.parentData.width) {
				self.size.width = self.parentData.width - woset;
				if (pRatio) self.size.height = self.size.width / self.aspectRatio;
			}

			if (hoset + self.size.height >= self.parentData.height) {
				self.size.height = self.parentData.height - hoset;
				if (pRatio) self.size.width = self.size.height * self.aspectRatio;
			}
		},

		stop: function (event, ui) {
			var self = $(this).data("resizable"), o = self.options, cp = self.position,
				co = self.containerOffset, cop = self.containerPosition, ce = self.containerElement;

			var helper = $(self.helper), ho = helper.offset(), w = helper.outerWidth() - self.sizeDiff.width, h = helper.outerHeight() - self.sizeDiff.height;

			if (self._helper && !o.animate && (/relative/).test(ce.css('position')))
				$(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });

			if (self._helper && !o.animate && (/static/).test(ce.css('position')))
				$(this).css({ left: ho.left - cop.left - co.left, width: w, height: h });

		}
	});

	$.ui.plugin.add("resizable", "ghost", {

		start: function (event, ui) {

			var self = $(this).data("resizable"), o = self.options, cs = self.size;

			self.ghost = self.originalElement.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);

		},

		resize: function (event, ui) {
			var self = $(this).data("resizable"), o = self.options;
			if (self.ghost) self.ghost.css({ position: 'relative', height: self.size.height, width: self.size.width });
		},

		stop: function (event, ui) {
			var self = $(this).data("resizable"), o = self.options;
			if (self.ghost && self.helper) self.helper.get(0).removeChild(self.ghost.get(0));
		}

	});

	$.ui.plugin.add("resizable", "grid", {

		resize: function (event, ui) {
			var self = $(this).data("resizable"), o = self.options, cs = self.size, os = self.originalSize, op = self.originalPosition, a = self.axis, ratio = o._aspectRatio || event.shiftKey;
			o.grid = typeof o.grid == "number" ? [o.grid, o.grid] : o.grid;
			var ox = Math.round((cs.width - os.width) / (o.grid[0] || 1)) * (o.grid[0] || 1), oy = Math.round((cs.height - os.height) / (o.grid[1] || 1)) * (o.grid[1] || 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;
			}
		}

	});

	var num = function (v) {
		return parseInt(v, 10) || 0;
	};

	var isNumber = function (value) {
		return !isNaN(parseInt(value, 10));
	};

})(jQuery);
/*
* jQuery UI Dialog 1.8.6
*
* Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* http://docs.jquery.com/UI/Dialog
*
* Depends:
*	jquery.ui.core.js
*	jquery.ui.widget.js
*  jquery.ui.button.js
*	jquery.ui.draggable.js
*	jquery.ui.mouse.js
*	jquery.ui.position.js
*	jquery.ui.resizable.js
*/
(function ($, undefined) {

	var uiDialogClasses =
		'ui-dialog ' +
		'ui-widget ' +
		'ui-widget-content ' +
		'ui-corner-all ',
	sizeRelatedOptions = {
		buttons: true,
		height: true,
		maxHeight: true,
		maxWidth: true,
		minHeight: true,
		minWidth: true,
		width: true
	},
	resizableRelatedOptions = {
		maxHeight: true,
		maxWidth: true,
		minHeight: true,
		minWidth: true
	};

	$.widget("ui.dialog", {
		options: {
			autoOpen: true,
			buttons: {},
			closeOnEscape: true,
			closeOnOverlayClick: false,
			closeText: 'close',
			dialogClass: '',
			draggable: true,
			hide: null,
			height: 'auto',
			maxHeight: false,
			maxWidth: false,
			minHeight: 150,
			minWidth: 150,
			modal: false,
			position: {
				my: 'center',
				at: 'center',
				of: window,
				collision: 'fit',
				// ensure that the titlebar is never outside the document
				using: function (pos) {
					var topOffset = $(this).css(pos).offset().top;
					if (topOffset < 0) {
						$(this).css('top', pos.top - topOffset);
					}
				}
			},
			resizable: true,
			show: null,
			stack: true,
			title: '',
			width: 300,
			zIndex: 1000
		},

		_create: function () {
			this.originalTitle = this.element.attr('title');
			// #5742 - .attr() might return a DOMElement
			if (typeof this.originalTitle !== "string") {
				this.originalTitle = "";
			}

			this.options.title = this.options.title || this.originalTitle;
			var self = this,
			options = self.options,

			title = options.title || '&#160;',
			titleId = $.ui.dialog.getTitleId(self.element),

			uiDialog = (self.uiDialog = $('<div></div>'))
				.appendTo(document.body)
				.hide()
				.addClass(uiDialogClasses + options.dialogClass)
				.css({
					zIndex: options.zIndex
				})
			// setting tabIndex makes the div focusable
			// setting outline to 0 prevents a border on focus in Mozilla
				.attr('tabIndex', -1).css('outline', 0).keydown(function (event) {
					if (options.closeOnEscape && event.keyCode &&
						event.keyCode === $.ui.keyCode.ESCAPE) {

						self.close(event);
						event.preventDefault();
					}
				})
				.attr({
					role: 'dialog',
					'aria-labelledby': titleId
				})
				.mousedown(function (event) {
					self.moveToTop(false, event);
				}),

			uiDialogInner = (self.uiDialogInner = $('<div></div>'))
				.show()
				.removeAttr('title')
				.addClass(
					'ui-dialog-inner ' +
					'ui-widget-inner')
				.appendTo(uiDialog),

			uiDialogContent = self.element
				.show()
				.removeAttr('title')
				.addClass(
					'ui-dialog-content ' +
					'ui-widget-content')
				.appendTo(uiDialogInner),

			uiDialogClose = $('<a href="#"></a>')
				.addClass(
					'ui-dialog-close ' +
					'ui-corner-all'
				)
				.attr('role', 'button')
				.hover(
					function () {
						uiDialogClose.addClass('ui-state-hover');
					},
					function () {
						uiDialogClose.removeClass('ui-state-hover');
					}
				)
				.focus(function () {
					uiDialogClose.addClass('ui-state-focus');
				})
				.blur(function () {
					uiDialogClose.removeClass('ui-state-focus');
				})
				.click(function (event) {
					self.close(event);
					return false;
				})
				.appendTo(uiDialogInner),

			uiDialogCloseText = (self.uiDialogCloseText = $('<span></span>'))
				.addClass(
					'ui-icon ' +
					'ui-icon-closethick'
				)
				.text(options.closeText)
				.appendTo(uiDialogClose);

			//handling of deprecated beforeclose (vs beforeClose) option
			//Ticket #4669 http://dev.jqueryui.com/ticket/4669
			//TODO: remove in 1.9pre
			if ($.isFunction(options.beforeclose) && !$.isFunction(options.beforeClose)) {
				options.beforeClose = options.beforeclose;
			}

			if (options.draggable && $.fn.draggable) {
				self._makeDraggable();
			}
			if (options.resizable && $.fn.resizable) {
				self._makeResizable();
			}

			self._createButtons(options.buttons);
			self._isOpen = false;

			if ($.fn.bgiframe) {
				uiDialog.bgiframe();
			}
		},

		_init: function () {
			if (this.options.autoOpen) {
				this.open();
			}
		},

		destroy: function () {
			var self = this;

			if (self.overlay) {
				self.overlay.destroy();
			}
			self.uiDialog.hide();
			self.element
			.unbind('.dialog')
			.removeData('dialog')
			.removeClass('ui-dialog-content ui-widget-content')
			.hide().appendTo('body');
			self.uiDialog.remove();

			if (self.originalTitle) {
				self.element.attr('title', self.originalTitle);
			}

			return self;
		},

		widget: function () {
			return this.uiDialog;
		},

		close: function (event) {
			var self = this,
			maxZ;

			if (false === self._trigger('beforeClose', event)) {
				return;
			}

			if (self.overlay) {
				self.overlay.destroy();
			}
			self.uiDialog.unbind('keypress.ui-dialog');

			self._isOpen = false;

			if (self.options.hide) {
				self.uiDialog.hide(self.options.hide, function () {
					self._trigger('close', event);
				});
			} else {
				self.uiDialog.hide();
				self._trigger('close', event);
			}

			$.ui.dialog.overlay.resize();

			// adjust the maxZ to allow other modal dialogs to continue to work (see #4309)
			if (self.options.modal) {
				maxZ = 0;
				$('.ui-dialog').each(function () {
					if (this !== self.uiDialog[0]) {
						maxZ = Math.max(maxZ, $(this).css('z-index'));
					}
				});
				$.ui.dialog.maxZ = maxZ;
			}

			return self;
		},

		isOpen: function () {
			return this._isOpen;
		},

		// the force parameter allows us to move modal dialogs to their correct
		// position on open
		moveToTop: function (force, event) {
			var self = this,
			options = self.options,
			saveScroll;

			if ((options.modal && !force) ||
			(!options.stack && !options.modal)) {
				return self._trigger('focus', event);
			}

			if (options.zIndex > $.ui.dialog.maxZ) {
				$.ui.dialog.maxZ = options.zIndex;
			}
			if (self.overlay) {
				$.ui.dialog.maxZ += 1;
				self.overlay.$el.css('z-index', $.ui.dialog.overlay.maxZ = $.ui.dialog.maxZ);
			}

			//Save and then restore scroll since Opera 9.5+ resets when parent z-Index is changed.
			//  http://ui.jquery.com/bugs/ticket/3193
			saveScroll = { scrollTop: self.element.attr('scrollTop'), scrollLeft: self.element.attr('scrollLeft') };
			$.ui.dialog.maxZ += 1;
			self.uiDialog.css('z-index', $.ui.dialog.maxZ);
			self.element.attr(saveScroll);
			self._trigger('focus', event);

			return self;
		},

		open: function () {
			if (this._isOpen) { return; }

			var self = this,
			options = self.options,
			uiDialog = self.uiDialog;

			self.overlay = options.modal ? new $.ui.dialog.overlay(self) : null;
			self._size();
			self._position(options.position);
			uiDialog.show(options.show);
			self.moveToTop(true);

			// prevent tabbing out of modal dialogs
			if (options.modal) {
				uiDialog.bind('keypress.ui-dialog', function (event) {
					if (event.keyCode !== $.ui.keyCode.TAB) {
						return;
					}

					var tabbables = $(':tabbable', this),
					first = tabbables.filter(':first'),
					last = tabbables.filter(':last');

					if (event.target === last[0] && !event.shiftKey) {
						first.focus(1);
						return false;
					} else if (event.target === first[0] && event.shiftKey) {
						last.focus(1);
						return false;
					}
				});
			}

			// set focus to the first tabbable element in the content area or the first button
			// if there are no tabbable elements, set focus on the dialog itself
			$(self.element.find(':tabbable').get().concat(
			uiDialog.find('.ui-dialog-buttonpane :tabbable').get().concat(
				uiDialog.get()))).eq(0).focus();

			self._isOpen = true;
			self._trigger('open');

			return self;
		},

		_createButtons: function (buttons) {
			var self = this,
			hasButtons = false,
			uiDialogButtonPane = $('<div></div>')
				.addClass(
					'ui-dialog-buttonpane ' +
					'ui-widget-content ' +
					'ui-helper-clearfix'
				),
			uiButtonSet = $("<div></div>")
				.addClass("ui-dialog-buttonset")
				.appendTo(uiDialogButtonPane);

			// if we already have a button pane, remove it
			self.uiDialog.find('.ui-dialog-buttonpane').remove();

			if (typeof buttons === 'object' && buttons !== null) {
				$.each(buttons, function () {
					return !(hasButtons = true);
				});
			}
			if (hasButtons) {
				$.each(buttons, function (name, props) {
					props = $.isFunction(props) ?
					{ click: props, text: name} :
					props;
					var button = $('<button type="button"></button>')
					.attr(props, true)
					.unbind('click')
					.click(function () {
						props.click.apply(self.element[0], arguments);
					})
					.appendTo(uiButtonSet);
					if ($.fn.button) {
						button.button();
					}
				});
				uiDialogButtonPane.appendTo(self.uiDialog);
			}
		},

		_makeDraggable: function () {
			var self = this,
			options = self.options,
			doc = $(document),
			heightBeforeDrag;

			function filteredUi(ui) {
				return {
					position: ui.position,
					offset: ui.offset
				};
			}

			self.uiDialog.draggable({
				cancel: '.ui-dialog-content, .ui-dialog-titlebar-close',
				handle: '.ui-dialog-titlebar',
				containment: 'document',
				start: function (event, ui) {
					heightBeforeDrag = options.height === "auto" ? "auto" : $(this).height();
					$(this).height($(this).height()).addClass("ui-dialog-dragging");
					self._trigger('dragStart', event, filteredUi(ui));
				},
				drag: function (event, ui) {
					self._trigger('drag', event, filteredUi(ui));
				},
				stop: function (event, ui) {
					options.position = [ui.position.left - doc.scrollLeft(),
					ui.position.top - doc.scrollTop()];
					$(this).removeClass("ui-dialog-dragging").height(heightBeforeDrag);
					self._trigger('dragStop', event, filteredUi(ui));
					$.ui.dialog.overlay.resize();
				}
			});
		},

		_makeResizable: function (handles) {
			handles = (handles === undefined ? this.options.resizable : handles);
			var self = this,
			options = self.options,
			// .ui-resizable has position: relative defined in the stylesheet
			// but dialogs have to use absolute or fixed positioning
			position = self.uiDialog.css('position'),
			resizeHandles = (typeof handles === 'string' ?
				handles :
				'n,e,s,w,se,sw,ne,nw'
			);

			function filteredUi(ui) {
				return {
					originalPosition: ui.originalPosition,
					originalSize: ui.originalSize,
					position: ui.position,
					size: ui.size
				};
			}

			self.uiDialog.resizable({
				cancel: '.ui-dialog-content',
				containment: 'document',
				alsoResize: self.element,
				maxWidth: options.maxWidth,
				maxHeight: options.maxHeight,
				minWidth: options.minWidth,
				minHeight: self._minHeight(),
				handles: resizeHandles,
				start: function (event, ui) {
					$(this).addClass("ui-dialog-resizing");
					self._trigger('resizeStart', event, filteredUi(ui));
				},
				resize: function (event, ui) {
					self._trigger('resize', event, filteredUi(ui));
				},
				stop: function (event, ui) {
					$(this).removeClass("ui-dialog-resizing");
					options.height = $(this).height();
					options.width = $(this).width();
					self._trigger('resizeStop', event, filteredUi(ui));
					$.ui.dialog.overlay.resize();
				}
			})
		.css('position', position)
		.find('.ui-resizable-se').addClass('ui-icon ui-icon-grip-diagonal-se');
		},

		_minHeight: function () {
			var options = this.options;

			if (options.height === 'auto') {
				return options.minHeight;
			} else {
				return Math.min(options.minHeight, options.height);
			}
		},

		_position: function (position) {
			var myAt = [],
			offset = [0, 0],
			isVisible;

			if (position) {
				// deep extending converts arrays to objects in jQuery <= 1.3.2 :-(
				//		if (typeof position == 'string' || $.isArray(position)) {
				//			myAt = $.isArray(position) ? position : position.split(' ');

				if (typeof position === 'string' || (typeof position === 'object' && '0' in position)) {
					myAt = position.split ? position.split(' ') : [position[0], position[1]];
					if (myAt.length === 1) {
						myAt[1] = myAt[0];
					}

					$.each(['left', 'top'], function (i, offsetPosition) {
						if (+myAt[i] === myAt[i]) {
							offset[i] = myAt[i];
							myAt[i] = offsetPosition;
						}
					});

					position = {
						my: myAt.join(" "),
						at: myAt.join(" "),
						offset: offset.join(" ")
					};
				}

				position = $.extend({}, $.ui.dialog.prototype.options.position, position);
			} else {
				position = $.ui.dialog.prototype.options.position;
			}

			// need to show the dialog to get the actual offset in the position plugin
			isVisible = this.uiDialog.is(':visible');
			if (!isVisible) {
				this.uiDialog.show();
			}
			this.uiDialog
			// workaround for jQuery bug #5781 http://dev.jquery.com/ticket/5781
			.css({ top: 0, left: 0 })
			.position(position);
			if (!isVisible) {
				this.uiDialog.hide();
			}
		},

		_setOptions: function (options) {
			var self = this,
			resizableOptions = {},
			resize = false;

			$.each(options, function (key, value) {
				self._setOption(key, value);

				if (key in sizeRelatedOptions) {
					resize = true;
				}
				if (key in resizableRelatedOptions) {
					resizableOptions[key] = value;
				}
			});

			if (resize) {
				this._size();
			}
			if (this.uiDialog.is(":data(resizable)")) {
				this.uiDialog.resizable("option", resizableOptions);
			}
		},

		_setOption: function (key, value) {
			var self = this,
			uiDialog = self.uiDialog;

			switch (key) {
				//handling of deprecated beforeclose (vs beforeClose) option 
				//Ticket #4669 http://dev.jqueryui.com/ticket/4669 
				//TODO: remove in 1.9pre 
				case "beforeclose":
					key = "beforeClose";
					break;
				case "buttons":
					self._createButtons(value);
					break;
				case "closeText":
					// ensure that we always pass a string
					self.uiDialogCloseText.text("" + value);
					break;
				case "dialogClass":
					uiDialog
					.removeClass(self.options.dialogClass)
					.addClass(uiDialogClasses + value);
					break;
				case "disabled":
					if (value) {
						uiDialog.addClass('ui-dialog-disabled');
					} else {
						uiDialog.removeClass('ui-dialog-disabled');
					}
					break;
				case "draggable":
					var isDraggable = uiDialog.is(":data(draggable)")
					if (isDraggable && !value) {
						uiDialog.draggable("destroy");
					}

					if (!isDraggable && value) {
						self._makeDraggable();
					}
					break;
				case "position":
					self._position(value);
					break;
				case "resizable":
					// currently resizable, becoming non-resizable
					var isResizable = uiDialog.is(":data(resizable)")
					if (isResizable && !value) {
						uiDialog.resizable('destroy');
					}

					// currently resizable, changing handles
					if (isResizable && typeof value === 'string') {
						uiDialog.resizable('option', 'handles', value);
					}

					// currently non-resizable, becoming resizable
					if (!isResizable && value !== false) {
						self._makeResizable(value);
					}
					break;
			}

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

		_size: function () {
			/* If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
			* divs will both have width and height set, so we need to reset them
			*/
			var options = this.options,
			nonContentHeight,
			minContentHeight;

			// reset content sizing
			this.element.show().css({
				width: 'auto',
				minHeight: 0,
				height: 0
			});

			if (options.minWidth > options.width) {
				options.width = options.minWidth;
			}

			// reset wrapper sizing
			// determine the height of all the non-content elements
			nonContentHeight = this.uiDialog.css({
				height: 'auto',
				width: options.width
			})
			.height();
			minContentHeight = Math.max(0, options.minHeight - nonContentHeight);

			if (options.height === "auto") {
				// only needed for IE6 support
				if ($.support.minHeight) {
					this.element.css({
						minHeight: minContentHeight,
						height: "auto"
					});
				} else {
					this.uiDialog.show();
					var autoHeight = this.element.css("height", "auto").height();
					this.uiDialog.hide();
					this.element.height(Math.max(autoHeight, minContentHeight));
				}
			} else {
				this.element.height(Math.max(options.height - nonContentHeight, 0));
			}

			if (this.uiDialog.is(':data(resizable)')) {
				this.uiDialog.resizable('option', 'minHeight', this._minHeight());
			}
		}
	});

	$.extend($.ui.dialog, {
		version: "1.8.6",

		uuid: 0,
		maxZ: 0,

		getTitleId: function ($el) {
			var id = $el.attr('id');
			if (!id) {
				this.uuid += 1;
				id = this.uuid;
			}
			return 'ui-dialog-title-' + id;
		},

		overlay: function (dialog) {
			this.$el = $.ui.dialog.overlay.create(dialog);
		}
	});

	$.extend($.ui.dialog.overlay, {
		instances: [],
		// reuse old instances due to IE memory leak with alpha transparency (see #5185)
		oldInstances: [],
		maxZ: 0,
		events: $.map('focus,mousedown,mouseup,keydown,keypress,click'.split(','),
		function (event) { return event + '.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 () {
					// handle $(el).dialog().dialog('close') (see #4065)
					if ($.ui.dialog.overlay.instances.length) {
						$(document).bind($.ui.dialog.overlay.events, function (event) {
							// stop events if the z-index of the target is < the z-index of the overlay
							// we cannot return true when we don't want to cancel the event (#3523)
							if ($(event.target).zIndex() < $.ui.dialog.overlay.maxZ) {
								return false;
							}
						});
					}
				}, 1);

				// allow closing by pressing the escape key
				$(document).bind('keydown.dialog-overlay', function (event) {
					if (dialog.options.closeOnEscape && event.keyCode &&
					event.keyCode === $.ui.keyCode.ESCAPE) {

						dialog.close(event);
						event.preventDefault();
					}
				});

				if (dialog.options.closeOnOverlayClick) {
					$(document).bind('click.dialog-overlay', function (event) {
						if ($(event.target).zIndex() > $.ui.dialog.overlay.maxZ) {
							return false;
						}
						dialog.close(event);
						event.preventDefault();
					});
				}

				// handle window resize
				$(window).bind('resize.dialog-overlay', $.ui.dialog.overlay.resize);
			}

			var $el = (this.oldInstances.pop() || $('<div></div>').addClass('ui-widget-overlay'))
			.appendTo(document.body)
			.css({
				width: this.width(),
				height: this.height()
			});

			if ($.fn.bgiframe) {
				$el.bgiframe();
			}

			this.instances.push($el);
			return $el;
		},

		destroy: function ($el) {
			this.oldInstances.push(this.instances.splice($.inArray($el, this.instances), 1)[0]);

			if (this.instances.length === 0) {
				$([document, window]).unbind('.dialog-overlay');
			}

			$el.remove();

			// adjust the maxZ to allow other modal dialogs to continue to work (see #4309)
			var maxZ = 0;
			$.each(this.instances, function () {
				maxZ = Math.max(maxZ, this.css('z-index'));
			});
			this.maxZ = maxZ;
		},

		height: function () {
			var scrollHeight,
			offsetHeight;
			// handle IE 6
			if ($.browser.msie && $.browser.version < 7) {
				scrollHeight = Math.max(
				document.documentElement.scrollHeight,
				document.body.scrollHeight
			);
				offsetHeight = Math.max(
				document.documentElement.offsetHeight,
				document.body.offsetHeight
			);

				if (scrollHeight < offsetHeight) {
					return $(window).height() + 'px';
				} else {
					return scrollHeight + 'px';
				}
				// handle "good" browsers
			} else {
				return $(document).height() + 'px';
			}
		},

		width: function () {
			var scrollWidth,
			offsetWidth;
			// handle IE 6
			if ($.browser.msie && $.browser.version < 7) {
				scrollWidth = Math.max(
				document.documentElement.scrollWidth,
				document.body.scrollWidth
			);
				offsetWidth = Math.max(
				document.documentElement.offsetWidth,
				document.body.offsetWidth
			);

				if (scrollWidth < offsetWidth) {
					return $(window).width() + 'px';
				} else {
					return scrollWidth + 'px';
				}
				// handle "good" browsers
			} 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));