1 /*

     2  * jQuery UI 1.6rc6

     3  *

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

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

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

     7  *

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

     9  */

    10 ;(function($) {

    11 

    12 var _remove = $.fn.remove,

    13 	isFF2 = $.browser.mozilla && (parseFloat($.browser.version) < 1.9);

    14 

    15 //Helper functions and ui object

    16 $.ui = {

    17 	version: "1.6rc6",

    18 

    19 	// $.ui.plugin is deprecated.  Use the proxy pattern instead.

    20 	plugin: {

    21 		add: function(module, option, set) {

    22 			var proto = $.ui[module].prototype;

    23 			for(var i in set) {

    24 				proto.plugins[i] = proto.plugins[i] || [];

    25 				proto.plugins[i].push([option, set[i]]);

    26 			}

    27 		},

    28 		call: function(instance, name, args) {

    29 			var set = instance.plugins[name];

    30 			if(!set) { return; }

    31 

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

    33 				if (instance.options[set[i][0]]) {

    34 					set[i][1].apply(instance.element, args);

    35 				}

    36 			}

    37 		}

    38 	},

    39 

    40 	contains: function(a, b) {

    41 		return document.compareDocumentPosition

    42 			? a.compareDocumentPosition(b) & 16

    43 			: a !== b && a.contains(b);

    44 	},

    45 

    46 	cssCache: {},

    47 	css: function(name) {

    48 		if ($.ui.cssCache[name]) { return $.ui.cssCache[name]; }

    49 		var tmp = $('<div class="ui-gen"></div>').addClass(name).css({position:'absolute', top:'-5000px', left:'-5000px', display:'block'}).appendTo('body');

    50 

    51 		//if (!$.browser.safari)

    52 			//tmp.appendTo('body');

    53 

    54 		//Opera and Safari set width and height to 0px instead of auto

    55 		//Safari returns rgba(0,0,0,0) when bgcolor is not set

    56 		$.ui.cssCache[name] = !!(

    57 			(!(/auto|default/).test(tmp.css('cursor')) || (/^[1-9]/).test(tmp.css('height')) || (/^[1-9]/).test(tmp.css('width')) ||

    58 			!(/none/).test(tmp.css('backgroundImage')) || !(/transparent|rgba\(0, 0, 0, 0\)/).test(tmp.css('backgroundColor')))

    59 		);

    60 		try { $('body').get(0).removeChild(tmp.get(0));	} catch(e){}

    61 		return $.ui.cssCache[name];

    62 	},

    63 

    64 	hasScroll: function(el, a) {

    65 

    66 		//If overflow is hidden, the element might have extra content, but the user wants to hide it

    67 		if ($(el).css('overflow') == 'hidden') { return false; }

    68 

    69 		var scroll = (a && a == 'left') ? 'scrollLeft' : 'scrollTop',

    70 			has = false;

    71 

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

    73 

    74 		// TODO: determine which cases actually cause this to happen

    75 		// if the element doesn't have the scroll set, see if it's possible to

    76 		// set the scroll

    77 		el[scroll] = 1;

    78 		has = (el[scroll] > 0);

    79 		el[scroll] = 0;

    80 		return has;

    81 	},

    82 

    83 	isOverAxis: function(x, reference, size) {

    84 		//Determines when x coordinate is over "b" element axis

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

    86 	},

    87 

    88 	isOver: function(y, x, top, left, height, width) {

    89 		//Determines when x, y coordinates is over "b" element

    90 		return $.ui.isOverAxis(y, top, height) && $.ui.isOverAxis(x, left, width);

    91 	},

    92 

    93 	keyCode: {

    94 		BACKSPACE: 8,

    95 		CAPS_LOCK: 20,

    96 		COMMA: 188,

    97 		CONTROL: 17,

    98 		DELETE: 46,

    99 		DOWN: 40,

   100 		END: 35,

   101 		ENTER: 13,

   102 		ESCAPE: 27,

   103 		HOME: 36,

   104 		INSERT: 45,

   105 		LEFT: 37,

   106 		NUMPAD_ADD: 107,

   107 		NUMPAD_DECIMAL: 110,

   108 		NUMPAD_DIVIDE: 111,

   109 		NUMPAD_ENTER: 108,

   110 		NUMPAD_MULTIPLY: 106,

   111 		NUMPAD_SUBTRACT: 109,

   112 		PAGE_DOWN: 34,

   113 		PAGE_UP: 33,

   114 		PERIOD: 190,

   115 		RIGHT: 39,

   116 		SHIFT: 16,

   117 		SPACE: 32,

   118 		TAB: 9,

   119 		UP: 38

   120 	}

   121 };

   122 

   123 // WAI-ARIA normalization

   124 if (isFF2) {

   125 	var attr = $.attr,

   126 		removeAttr = $.fn.removeAttr,

   127 		ariaNS = "http://www.w3.org/2005/07/aaa",

   128 		ariaState = /^aria-/,

   129 		ariaRole = /^wairole:/;

   130 

   131 	$.attr = function(elem, name, value) {

   132 		var set = value !== undefined;

   133 

   134 		return (name == 'role'

   135 			? (set

   136 				? attr.call(this, elem, name, "wairole:" + value)

   137 				: (attr.apply(this, arguments) || "").replace(ariaRole, ""))

   138 			: (ariaState.test(name)

   139 				? (set

   140 					? elem.setAttributeNS(ariaNS,

   141 						name.replace(ariaState, "aaa:"), value)

   142 					: attr.call(this, elem, name.replace(ariaState, "aaa:")))

   143 				: attr.apply(this, arguments)));

   144 	};

   145 

   146 	$.fn.removeAttr = function(name) {

   147 		return (ariaState.test(name)

   148 			? this.each(function() {

   149 				this.removeAttributeNS(ariaNS, name.replace(ariaState, ""));

   150 			}) : removeAttr.call(this, name));

   151 	};

   152 }

   153 

   154 //jQuery plugins

   155 $.fn.extend({

   156 	remove: function() {

   157 		// Safari has a native remove event which actually removes DOM elements,

   158 		// so we have to use triggerHandler instead of trigger (#3037).

   159 		$("*", this).add(this).each(function() {

   160 			$(this).triggerHandler("remove");

   161 		});

   162 		return _remove.apply(this, arguments );

   163 	},

   164 

   165 	enableSelection: function() {

   166 		return this

   167 			.attr('unselectable', 'off')

   168 			.css('MozUserSelect', '')

   169 			.unbind('selectstart.ui');

   170 	},

   171 

   172 	disableSelection: function() {

   173 		return this

   174 			.attr('unselectable', 'on')

   175 			.css('MozUserSelect', 'none')

   176 			.bind('selectstart.ui', function() { return false; });

   177 	},

   178 

   179 	scrollParent: function() {

   180 		var scrollParent;

   181 		if(($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {

   182 			scrollParent = this.parents().filter(function() {

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

   184 			}).eq(0);

   185 		} else {

   186 			scrollParent = this.parents().filter(function() {

   187 				return (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));

   188 			}).eq(0);

   189 		}

   190 

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

   192 	}

   193 });

   194 

   195 

   196 //Additional selectors

   197 $.extend($.expr[':'], {

   198 	data: function(elem, i, match) {

   199 		return !!$.data(elem, match[3]);

   200 	},

   201 

   202 	focusable: function(element) {

   203 		var nodeName = element.nodeName.toLowerCase(),

   204 			tabIndex = $.attr(element, 'tabindex');

   205 		return (/input|select|textarea|button|object/.test(nodeName)

   206 			? !element.disabled

   207 			: 'a' == nodeName || 'area' == nodeName

   208 				? element.href || !isNaN(tabIndex)

   209 				: !isNaN(tabIndex))

   210 			// the element and all of its ancestors must be visible

   211 			// the browser may report that the area is hidden

   212 			&& !$(element)['area' == nodeName ? 'parents' : 'closest'](':hidden').length;

   213 	},

   214 

   215 	tabbable: function(element) {

   216 		var tabIndex = $.attr(element, 'tabindex');

   217 		return (isNaN(tabIndex) || tabIndex >= 0) && $(element).is(':focusable');

   218 	}

   219 });

   220 

   221 

   222 // $.widget is a factory to create jQuery plugins

   223 // taking some boilerplate code out of the plugin code

   224 function getter(namespace, plugin, method, args) {

   225 	function getMethods(type) {

   226 		var methods = $[namespace][plugin][type] || [];

   227 		return (typeof methods == 'string' ? methods.split(/,?\s+/) : methods);

   228 	}

   229 

   230 	var methods = getMethods('getter');

   231 	if (args.length == 1 && typeof args[0] == 'string') {

   232 		methods = methods.concat(getMethods('getterSetter'));

   233 	}

   234 	return ($.inArray(method, methods) != -1);

   235 }

   236 

   237 $.widget = function(name, prototype) {

   238 	var namespace = name.split(".")[0];

   239 	name = name.split(".")[1];

   240 

   241 	// create plugin method

   242 	$.fn[name] = function(options) {

   243 		var isMethodCall = (typeof options == 'string'),

   244 			args = Array.prototype.slice.call(arguments, 1);

   245 

   246 		// prevent calls to internal methods

   247 		if (isMethodCall && options.substring(0, 1) == '_') {

   248 			return this;

   249 		}

   250 

   251 		// handle getter methods

   252 		if (isMethodCall && getter(namespace, name, options, args)) {

   253 			var instance = $.data(this[0], name);

   254 			return (instance ? instance[options].apply(instance, args)

   255 				: undefined);

   256 		}

   257 

   258 		// handle initialization and non-getter methods

   259 		return this.each(function() {

   260 			var instance = $.data(this, name);

   261 

   262 			// constructor

   263 			(!instance && !isMethodCall &&

   264 				$.data(this, name, new $[namespace][name](this, options))._init());

   265 

   266 			// method call

   267 			(instance && isMethodCall && $.isFunction(instance[options]) &&

   268 				instance[options].apply(instance, args));

   269 		});

   270 	};

   271 

   272 	// create widget constructor

   273 	$[namespace] = $[namespace] || {};

   274 	$[namespace][name] = function(element, options) {

   275 		var self = this;

   276 

   277 		this.namespace = namespace;

   278 		this.widgetName = name;

   279 		this.widgetEventPrefix = $[namespace][name].eventPrefix || name;

   280 		this.widgetBaseClass = namespace + '-' + name;

   281 

   282 		this.options = $.extend({},

   283 			$.widget.defaults,

   284 			$[namespace][name].defaults,

   285 			$.metadata && $.metadata.get(element)[name],

   286 			options);

   287 

   288 		this.element = $(element)

   289 			.bind('setData.' + name, function(event, key, value) {

   290 				if (event.target == element) {

   291 					return self._setData(key, value);

   292 				}

   293 			})

   294 			.bind('getData.' + name, function(event, key) {

   295 				if (event.target == element) {

   296 					return self._getData(key);

   297 				}

   298 			})

   299 			.bind('remove', function() {

   300 				return self.destroy();

   301 			});

   302 	};

   303 

   304 	// add widget prototype

   305 	$[namespace][name].prototype = $.extend({}, $.widget.prototype, prototype);

   306 

   307 	// TODO: merge getter and getterSetter properties from widget prototype

   308 	// and plugin prototype

   309 	$[namespace][name].getterSetter = 'option';

   310 };

   311 

   312 $.widget.prototype = {

   313 	_init: function() {},

   314 	destroy: function() {

   315 		this.element.removeData(this.widgetName)

   316 			.removeClass(this.widgetBaseClass + '-disabled' + ' ' + this.namespace + '-state-disabled')

   317 			.removeAttr('aria-disabled');

   318 	},

   319 

   320 	option: function(key, value) {

   321 		var options = key,

   322 			self = this;

   323 

   324 		if (typeof key == "string") {

   325 			if (value === undefined) {

   326 				return this._getData(key);

   327 			}

   328 			options = {};

   329 			options[key] = value;

   330 		}

   331 

   332 		$.each(options, function(key, value) {

   333 			self._setData(key, value);

   334 		});

   335 	},

   336 	_getData: function(key) {

   337 		return this.options[key];

   338 	},

   339 	_setData: function(key, value) {

   340 		this.options[key] = value;

   341 

   342 		if (key == 'disabled') {

   343 			this.element

   344 				[value ? 'addClass' : 'removeClass'](

   345 					this.widgetBaseClass + '-disabled' + ' ' +

   346 					this.namespace + '-state-disabled')

   347 				.attr("aria-disabled", value);

   348 		}

   349 	},

   350 

   351 	enable: function() {

   352 		this._setData('disabled', false);

   353 	},

   354 	disable: function() {

   355 		this._setData('disabled', true);

   356 	},

   357 

   358 	_trigger: function(type, event, data) {

   359 		var callback = this.options[type],

   360 			eventName = (type == this.widgetEventPrefix

   361 				? type : this.widgetEventPrefix + type);

   362 

   363 		event = $.Event(event);

   364 		event.type = eventName;

   365 

   366 		// copy original event properties over to the new event

   367 		// this would happen if we could call $.event.fix instead of $.Event

   368 		// but we don't have a way to force an event to be fixed multiple times

   369 		if (event.originalEvent) {

   370 			for (var i = $.event.props.length, prop; i;) {

   371 				prop = $.event.props[--i];

   372 				event[prop] = event.originalEvent[prop];

   373 			}

   374 		}

   375 

   376 		this.element.trigger(event, data);

   377 

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

   379 			|| event.isDefaultPrevented());

   380 	}

   381 };

   382 

   383 $.widget.defaults = {

   384 	disabled: false

   385 };

   386 

   387 

   388 /** Mouse Interaction Plugin **/

   389 

   390 $.ui.mouse = {

   391 	_mouseInit: function() {

   392 		var self = this;

   393 

   394 		this.element

   395 			.bind('mousedown.'+this.widgetName, function(event) {

   396 				return self._mouseDown(event);

   397 			})

   398 			.bind('click.'+this.widgetName, function(event) {

   399 				if(self._preventClickEvent) {

   400 					self._preventClickEvent = false;

   401 					return false;

   402 				}

   403 			});

   404 

   405 		// Prevent text selection in IE

   406 		if ($.browser.msie) {

   407 			this._mouseUnselectable = this.element.attr('unselectable');

   408 			this.element.attr('unselectable', 'on');

   409 		}

   410 

   411 		this.started = false;

   412 	},

   413 

   414 	// TODO: make sure destroying one instance of mouse doesn't mess with

   415 	// other instances of mouse

   416 	_mouseDestroy: function() {

   417 		this.element.unbind('.'+this.widgetName);

   418 

   419 		// Restore text selection in IE

   420 		($.browser.msie

   421 			&& this.element.attr('unselectable', this._mouseUnselectable));

   422 	},

   423 

   424 	_mouseDown: function(event) {

   425 		// don't let more than one widget handle mouseStart

   426 		if (event.originalEvent.mouseHandled) { return; }

   427 

   428 		// we may have missed mouseup (out of window)

   429 		(this._mouseStarted && this._mouseUp(event));

   430 

   431 		this._mouseDownEvent = event;

   432 

   433 		var self = this,

   434 			btnIsLeft = (event.which == 1),

   435 			elIsCancel = (typeof this.options.cancel == "string" ? $(event.target).parents().add(event.target).filter(this.options.cancel).length : false);

   436 		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {

   437 			return true;

   438 		}

   439 

   440 		this.mouseDelayMet = !this.options.delay;

   441 		if (!this.mouseDelayMet) {

   442 			this._mouseDelayTimer = setTimeout(function() {

   443 				self.mouseDelayMet = true;

   444 			}, this.options.delay);

   445 		}

   446 

   447 		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {

   448 			this._mouseStarted = (this._mouseStart(event) !== false);

   449 			if (!this._mouseStarted) {

   450 				event.preventDefault();

   451 				return true;

   452 			}

   453 		}

   454 

   455 		// these delegates are required to keep context

   456 		this._mouseMoveDelegate = function(event) {

   457 			return self._mouseMove(event);

   458 		};

   459 		this._mouseUpDelegate = function(event) {

   460 			return self._mouseUp(event);

   461 		};

   462 		$(document)

   463 			.bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)

   464 			.bind('mouseup.'+this.widgetName, this._mouseUpDelegate);

   465 

   466 		// preventDefault() is used to prevent the selection of text here -

   467 		// however, in Safari, this causes select boxes not to be selectable

   468 		// anymore, so this fix is needed

   469 		($.browser.safari || event.preventDefault());

   470 

   471 		event.originalEvent.mouseHandled = true;

   472 		return true;

   473 	},

   474 

   475 	_mouseMove: function(event) {

   476 		// IE mouseup check - mouseup happened when mouse was out of window

   477 		if ($.browser.msie && !event.button) {

   478 			return this._mouseUp(event);

   479 		}

   480 

   481 		if (this._mouseStarted) {

   482 			this._mouseDrag(event);

   483 			return event.preventDefault();

   484 		}

   485 

   486 		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {

   487 			this._mouseStarted =

   488 				(this._mouseStart(this._mouseDownEvent, event) !== false);

   489 			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));

   490 		}

   491 

   492 		return !this._mouseStarted;

   493 	},

   494 

   495 	_mouseUp: function(event) {

   496 		$(document)

   497 			.unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)

   498 			.unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);

   499 

   500 		if (this._mouseStarted) {

   501 			this._mouseStarted = false;

   502 			this._preventClickEvent = true;

   503 			this._mouseStop(event);

   504 		}

   505 

   506 		return false;

   507 	},

   508 

   509 	_mouseDistanceMet: function(event) {

   510 		return (Math.max(

   511 				Math.abs(this._mouseDownEvent.pageX - event.pageX),

   512 				Math.abs(this._mouseDownEvent.pageY - event.pageY)

   513 			) >= this.options.distance

   514 		);

   515 	},

   516 

   517 	_mouseDelayMet: function(event) {

   518 		return this.mouseDelayMet;

   519 	},

   520 

   521 	// These are placeholder methods, to be overriden by extending plugin

   522 	_mouseStart: function(event) {},

   523 	_mouseDrag: function(event) {},

   524 	_mouseStop: function(event) {},

   525 	_mouseCapture: function(event) { return true; }

   526 };

   527 

   528 $.ui.mouse.defaults = {

   529 	cancel: null,

   530 	distance: 1,

   531 	delay: 0

   532 };

   533 

   534 })(jQuery);

   535 /*

   536  * jQuery UI Draggable 1.6rc6

   537  *

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

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

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

   541  *

   542  * http://docs.jquery.com/UI/Draggables

   543  *

   544  * Depends:

   545  *	ui.core.js

   546  */

   547 (function($) {

   548 

   549 $.widget("ui.draggable", $.extend({}, $.ui.mouse, {

   550 

   551 	_init: function() {

   552 

   553 		if (this.options.helper == 'original' && !(/^(?:r|a|f)/).test(this.element.css("position")))

   554 			this.element[0].style.position = 'relative';

   555 

   556 		(this.options.cssNamespace && this.element.addClass(this.options.cssNamespace+"-draggable"));

   557 		(this.options.disabled && this.element.addClass(this.options.cssNamespace+'-draggable-disabled'));

   558 

   559 		this._mouseInit();

   560 

   561 	},

   562 

   563 	destroy: function() {

   564 		if(!this.element.data('draggable')) return;

   565 		this.element.removeData("draggable").unbind(".draggable").removeClass(this.options.cssNamespace+'-draggable '+this.options.cssNamespace+'-draggable-dragging '+this.options.cssNamespace+'-draggable-disabled');

   566 		this._mouseDestroy();

   567 	},

   568 

   569 	_mouseCapture: function(event) {

   570 

   571 		var o = this.options;

   572 

   573 		if (this.helper || o.disabled || $(event.target).is('.'+this.options.cssNamespace+'-resizable-handle'))

   574 			return false;

   575 

   576 		//Quit if we're not on a valid handle

   577 		this.handle = this._getHandle(event);

   578 		if (!this.handle)

   579 			return false;

   580 

   581 		return true;

   582 

   583 	},

   584 

   585 	_mouseStart: function(event) {

   586 

   587 		var o = this.options;

   588 

   589 		//Create and append the visible helper

   590 		this.helper = this._createHelper(event);

   591 

   592 		//Cache the helper size

   593 		this._cacheHelperProportions();

   594 

   595 		//If ddmanager is used for droppables, set the global draggable

   596 		if($.ui.ddmanager)

   597 			$.ui.ddmanager.current = this;

   598 

   599 		/*

   600 		 * - Position generation -

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

   602 		 */

   603 

   604 		//Cache the margins of the original element

   605 		this._cacheMargins();

   606 

   607 		//Store the helper's css position

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

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

   610 

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

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

   613 		this.offset = {

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

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

   616 		};

   617 

   618 		$.extend(this.offset, {

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

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

   621 				top: event.pageY - this.offset.top

   622 			},

   623 			parent: this._getParentOffset(),

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

   625 		});

   626 

   627 		//Generate the original position

   628 		this.originalPosition = this._generatePosition(event);

   629 		this.originalPageX = event.pageX;

   630 		this.originalPageY = event.pageY;

   631 

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

   633 		if(o.cursorAt)

   634 			this._adjustOffsetFromHelper(o.cursorAt);

   635 

   636 		//Set a containment if given in the options

   637 		if(o.containment)

   638 			this._setContainment();

   639 

   640 		//Call plugins and callbacks

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

   642 

   643 		//Recache the helper size

   644 		this._cacheHelperProportions();

   645 

   646 		//Prepare the droppable offsets

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

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

   649 

   650 		this.helper.addClass(o.cssNamespace+"-draggable-dragging");

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

   652 		return true;

   653 	},

   654 

   655 	_mouseDrag: function(event, noPropagation) {

   656 

   657 		//Compute the helpers position

   658 		this.position = this._generatePosition(event);

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

   660 

   661 		//Call plugins and callbacks and use the resulting position if something is returned

   662 		if (!noPropagation) {

   663 			var ui = this._uiHash();

   664 			this._trigger('drag', event, ui);

   665 			this.position = ui.position;

   666 		}

   667 

   668 		if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px';

   669 		if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px';

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

   671 

   672 		return false;

   673 	},

   674 

   675 	_mouseStop: function(event) {

   676 

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

   678 		var dropped = false;

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

   680 			dropped = $.ui.ddmanager.drop(this, event);

   681 

   682 		//if a drop comes from outside (a sortable)

   683 		if(this.dropped) {

   684 			dropped = this.dropped;

   685 			this.dropped = false;

   686 		}

   687 

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

   689 			var self = this;

   690 			$(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {

   691 				self._trigger("stop", event);

   692 				self._clear();

   693 			});

   694 		} else {

   695 			this._trigger("stop", event);

   696 			this._clear();

   697 		}

   698 

   699 		return false;

   700 	},

   701 

   702 	_getHandle: function(event) {

   703 

   704 		var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;

   705 		$(this.options.handle, this.element)

   706 			.find("*")

   707 			.andSelf()

   708 			.each(function() {

   709 				if(this == event.target) handle = true;

   710 			});

   711 

   712 		return handle;

   713 

   714 	},

   715 

   716 	_createHelper: function(event) {

   717 

   718 		var o = this.options;

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

   720 

   721 		if(!helper.parents('body').length)

   722 			helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));

   723 

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

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

   726 

   727 		return helper;

   728 

   729 	},

   730 

   731 	_adjustOffsetFromHelper: function(obj) {

   732 		if(obj.left != undefined) this.offset.click.left = obj.left + this.margins.left;

   733 		if(obj.right != undefined) this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;

   734 		if(obj.top != undefined) this.offset.click.top = obj.top + this.margins.top;

   735 		if(obj.bottom != undefined) this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;

   736 	},

   737 

   738 	_getParentOffset: function() {

   739 

   740 		//Get the offsetParent and cache its position

   741 		this.offsetParent = this.helper.offsetParent();

   742 		var po = this.offsetParent.offset();

   743 

   744 		// This is a special case where we need to modify a offset calculated on start, since the following happened:

   745 		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent

   746 		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that

   747 		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag

   748 		if(this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) {

   749 			po.left += this.scrollParent.scrollLeft();

   750 			po.top += this.scrollParent.scrollTop();

   751 		}

   752 

   753 		if((this.offsetParent[0] == document.body && $.browser.mozilla)	//Ugly FF3 fix

   754 		|| (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix

   755 			po = { top: 0, left: 0 };

   756 

   757 		return {

   758 			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),

   759 			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)

   760 		};

   761 

   762 	},

   763 

   764 	_getRelativeOffset: function() {

   765 

   766 		if(this.cssPosition == "relative") {

   767 			var p = this.element.position();

   768 			return {

   769 				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),

   770 				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()

   771 			};

   772 		} else {

   773 			return { top: 0, left: 0 };

   774 		}

   775 

   776 	},

   777 

   778 	_cacheMargins: function() {

   779 		this.margins = {

   780 			left: (parseInt(this.element.css("marginLeft"),10) || 0),

   781 			top: (parseInt(this.element.css("marginTop"),10) || 0)

   782 		};

   783 	},

   784 

   785 	_cacheHelperProportions: function() {

   786 		this.helperProportions = {

   787 			width: this.helper.outerWidth(),

   788 			height: this.helper.outerHeight()

   789 		};

   790 	},

   791 

   792 	_setContainment: function() {

   793 

   794 		var o = this.options;

   795 		if(o.containment == 'parent') o.containment = this.helper[0].parentNode;

   796 		if(o.containment == 'document' || o.containment == 'window') this.containment = [

   797 			0 - this.offset.relative.left - this.offset.parent.left,

   798 			0 - this.offset.relative.top - this.offset.parent.top,

   799 			$(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left,

   800 			($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top

   801 		];

   802 

   803 		if(!(/^(document|window|parent)$/).test(o.containment) && o.containment.constructor != Array) {

   804 			var ce = $(o.containment)[0]; if(!ce) return;

   805 			var co = $(o.containment).offset();

   806 			var over = ($(ce).css("overflow") != 'hidden');

   807 

   808 			this.containment = [

   809 				co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,

   810 				co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,

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

   812 				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

   813 			];

   814 		} else if(o.containment.constructor == Array) {

   815 			this.containment = o.containment;

   816 		}

   817 

   818 	},

   819 

   820 	_convertPositionTo: function(d, pos) {

   821 

   822 		if(!pos) pos = this.position;

   823 		var mod = d == "absolute" ? 1 : -1;

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

   825 

   826 		return {

   827 			top: (

   828 				pos.top																	// The absolute mouse position

   829 				+ this.offset.relative.top * mod										// Only for relative positioned nodes: Relative offset from element to offset parent

   830 				+ this.offset.parent.top * mod											// The offsetParent's offset without borders (offset + border)

   831 				- ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod

   832 			),

   833 			left: (

   834 				pos.left																// The absolute mouse position

   835 				+ this.offset.relative.left * mod										// Only for relative positioned nodes: Relative offset from element to offset parent

   836 				+ this.offset.parent.left * mod											// The offsetParent's offset without borders (offset + border)

   837 				- ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod

   838 			)

   839 		};

   840 

   841 	},

   842 

   843 	_generatePosition: function(event) {

   844 

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

   846 

   847 		// This is another very weird special case that only happens for relative elements:

   848 		// 1. If the css position is relative

   849 		// 2. and the scroll parent is the document or similar to the offset parent

   850 		// we have to refresh the relative offset during the scroll so there are no jumps

   851 		if(this.cssPosition == 'relative' && !(this.scrollParent[0] != document && this.scrollParent[0] != this.offsetParent[0])) {

   852 			this.offset.relative = this._getRelativeOffset();

   853 		}

   854 

   855 		var pageX = event.pageX;

   856 		var pageY = event.pageY;

   857 

   858 		/*

   859 		 * - Position constraining -

   860 		 * Constrain the position to a mix of grid, containment.

   861 		 */

   862 

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

   864 

   865 			if(this.containment) {

   866 				if(event.pageX - this.offset.click.left < this.containment[0]) pageX = this.containment[0] + this.offset.click.left;

   867 				if(event.pageY - this.offset.click.top < this.containment[1]) pageY = this.containment[1] + this.offset.click.top;

   868 				if(event.pageX - this.offset.click.left > this.containment[2]) pageX = this.containment[2] + this.offset.click.left;

   869 				if(event.pageY - this.offset.click.top > this.containment[3]) pageY = this.containment[3] + this.offset.click.top;

   870 			}

   871 

   872 			if(o.grid) {

   873 				var top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];

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

   875 

   876 				var left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];

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

   878 			}

   879 

   880 		}

   881 

   882 		return {

   883 			top: (

   884 				pageY																// The absolute mouse position

   885 				- this.offset.click.top													// Click offset (relative to the element)

   886 				- this.offset.relative.top												// Only for relative positioned nodes: Relative offset from element to offset parent

   887 				- this.offset.parent.top												// The offsetParent's offset without borders (offset + border)

   888 				+ ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) )

   889 			),

   890 			left: (

   891 				pageX																// The absolute mouse position

   892 				- this.offset.click.left												// Click offset (relative to the element)

   893 				- this.offset.relative.left												// Only for relative positioned nodes: Relative offset from element to offset parent

   894 				- this.offset.parent.left												// The offsetParent's offset without borders (offset + border)

   895 				+ ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() )

   896 			)

   897 		};

   898 

   899 	},

   900 

   901 	_clear: function() {

   902 		this.helper.removeClass(this.options.cssNamespace+"-draggable-dragging");

   903 		if(this.helper[0] != this.element[0] && !this.cancelHelperRemoval) this.helper.remove();

   904 		//if($.ui.ddmanager) $.ui.ddmanager.current = null;

   905 		this.helper = null;

   906 		this.cancelHelperRemoval = false;

   907 	},

   908 

   909 	// From now on bulk stuff - mainly helpers

   910 

   911 	_trigger: function(type, event, ui) {

   912 		ui = ui || this._uiHash();

   913 		$.ui.plugin.call(this, type, [event, ui]);

   914 		if(type == "drag") this.positionAbs = this._convertPositionTo("absolute"); //The absolute position has to be recalculated after plugins

   915 		return $.widget.prototype._trigger.call(this, type, event, ui);

   916 	},

   917 

   918 	plugins: {},

   919 

   920 	_uiHash: function(event) {

   921 		return {

   922 			helper: this.helper,

   923 			position: this.position,

   924 			absolutePosition: this.positionAbs, //deprecated

   925 			offset: this.positionAbs

   926 		};

   927 	}

   928 

   929 }));

   930 

   931 $.extend($.ui.draggable, {

   932 	version: "1.6rc6",

   933 	eventPrefix: "drag",

   934 	defaults: {

   935 		appendTo: "parent",

   936 		axis: false,

   937 		cancel: ":input,option",

   938 		connectToSortable: false,

   939 		containment: false,

   940 		cssNamespace: "ui",

   941 		cursor: "default",

   942 		cursorAt: false,

   943 		delay: 0,

   944 		distance: 1,

   945 		grid: false,

   946 		handle: false,

   947 		helper: "original",

   948 		iframeFix: false,

   949 		opacity: false,

   950 		refreshPositions: false,

   951 		revert: false,

   952 		revertDuration: 500,

   953 		scope: "default",

   954 		scroll: true,

   955 		scrollSensitivity: 20,

   956 		scrollSpeed: 20,

   957 		snap: false,

   958 		snapMode: "both",

   959 		snapTolerance: 20,

   960 		stack: false,

   961 		zIndex: false

   962 	}

   963 });

   964 

   965 $.ui.plugin.add("draggable", "connectToSortable", {

   966 	start: function(event, ui) {

   967 

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

   969 		inst.sortables = [];

   970 		$(o.connectToSortable).each(function() {

   971 			// 'this' points to a string, and should therefore resolved as query, but instead, if the string is assigned to a variable, it loops through the strings properties,

   972 			// so we have to append '' to make it anonymous again

   973 			$(typeof this == 'string' ? this+'': this).each(function() {

   974 				if($.data(this, 'sortable')) {

   975 					var sortable = $.data(this, 'sortable');

   976 					inst.sortables.push({

   977 						instance: sortable,

   978 						shouldRevert: sortable.options.revert

   979 					});

   980 					sortable._refreshItems();	//Do a one-time refresh at start to refresh the containerCache

   981 					sortable._trigger("activate", event, inst);

   982 				}

   983 			});

   984 		});

   985 

   986 	},

   987 	stop: function(event, ui) {

   988 

   989 		//If we are still over the sortable, we fake the stop event of the sortable, but also remove helper

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

   991 

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

   993 			if(this.instance.isOver) {

   994 

   995 				this.instance.isOver = 0;

   996 

   997 				inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance

   998 				this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)

   999 

  1000 				//The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: 'valid/invalid'

  1001 				if(this.shouldRevert) this.instance.options.revert = true;

  1002 

  1003 				//Trigger the stop of the sortable

  1004 				this.instance._mouseStop(event);

  1005 

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

  1007 

  1008 				//If the helper has been the original item, restore properties in the sortable

  1009 				if(inst.options.helper == 'original')

  1010 					this.instance.currentItem.css({ top: 'auto', left: 'auto' });

  1011 

  1012 			} else {

  1013 				this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance

  1014 				this.instance._trigger("deactivate", event, inst);

  1015 			}

  1016 

  1017 		});

  1018 

  1019 	},

  1020 	drag: function(event, ui) {

  1021 

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

  1023 

  1024 		var checkPos = function(o) {

  1025 			var dyClick = this.offset.click.top, dxClick = this.offset.click.left;

  1026 			var helperTop = this.positionAbs.top, helperLeft = this.positionAbs.left;

  1027 			var itemHeight = o.height, itemWidth = o.width;

  1028 			var itemTop = o.top, itemLeft = o.left;

  1029 

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

  1031 		};

  1032 

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

  1034 

  1035 			if(checkPos.call(inst, this.instance.containerCache)) {

  1036 

  1037 				//If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once

  1038 				if(!this.instance.isOver) {

  1039 					this.instance.isOver = 1;

  1040 					//Now we fake the start of dragging for the sortable instance,

  1041 					//by cloning the list group item, appending it to the sortable and using it as inst.currentItem

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

  1043 					this.instance.currentItem = $(self).clone().appendTo(this.instance.element).data("sortable-item", true);

  1044 					this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it

  1045 					this.instance.options.helper = function() { return ui.helper[0]; };

  1046 

  1047 					event.target = this.instance.currentItem[0];

  1048 					this.instance._mouseCapture(event, true);

  1049 					this.instance._mouseStart(event, true, true);

  1050 

  1051 					//Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes

  1052 					this.instance.offset.click.top = inst.offset.click.top;

  1053 					this.instance.offset.click.left = inst.offset.click.left;

  1054 					this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;

  1055 					this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;

  1056 

  1057 					inst._trigger("toSortable", event);

  1058 					inst.dropped = this.instance.element; //draggable revert needs that

  1059 					this.instance.fromOutside = inst; //Little hack so receive/update callbacks work

  1060 

  1061 				}

  1062 

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

  1064 				if(this.instance.currentItem) this.instance._mouseDrag(event);

  1065 

  1066 			} else {

  1067 

  1068 				//If it doesn't intersect with the sortable, and it intersected before,

  1069 				//we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval

  1070 				if(this.instance.isOver) {

  1071 					this.instance.isOver = 0;

  1072 					this.instance.cancelHelperRemoval = true;

  1073 					this.instance.options.revert = false; //No revert here

  1074 					this.instance._mouseStop(event, true);

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

  1076 

  1077 					//Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size

  1078 					this.instance.currentItem.remove();

  1079 					if(this.instance.placeholder) this.instance.placeholder.remove();

  1080 

  1081 					inst._trigger("fromSortable", event);

  1082 					inst.dropped = false; //draggable revert needs that

  1083 				}

  1084 

  1085 			};

  1086 

  1087 		});

  1088 

  1089 	}

  1090 });

  1091 

  1092 $.ui.plugin.add("draggable", "cursor", {

  1093 	start: function(event, ui) {

  1094 		var t = $('body'), o = $(this).data('draggable').options;

  1095 		if (t.css("cursor")) o._cursor = t.css("cursor");

  1096 		t.css("cursor", o.cursor);

  1097 	},

  1098 	stop: function(event, ui) {

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

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

  1101 	}

  1102 });

  1103 

  1104 $.ui.plugin.add("draggable", "iframeFix", {

  1105 	start: function(event, ui) {

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

  1107 		$(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {

  1108 			$('<div class="ui-draggable-iframeFix" style="background: #fff;"></div>')

  1109 			.css({

  1110 				width: this.offsetWidth+"px", height: this.offsetHeight+"px",

  1111 				position: "absolute", opacity: "0.001", zIndex: 1000

  1112 			})

  1113 			.css($(this).offset())

  1114 			.appendTo("body");

  1115 		});

  1116 	},

  1117 	stop: function(event, ui) {

  1118 		$("div.ui-draggable-iframeFix").each(function() { this.parentNode.removeChild(this); }); //Remove frame helpers

  1119 	}

  1120 });

  1121 

  1122 $.ui.plugin.add("draggable", "opacity", {

  1123 	start: function(event, ui) {

  1124 		var t = $(ui.helper), o = $(this).data('draggable').options;

  1125 		if(t.css("opacity")) o._opacity = t.css("opacity");

  1126 		t.css('opacity', o.opacity);

  1127 	},

  1128 	stop: function(event, ui) {

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

  1130 		if(o._opacity) $(ui.helper).css('opacity', o._opacity);

  1131 	}

  1132 });

  1133 

  1134 $.ui.plugin.add("draggable", "scroll", {

  1135 	start: function(event, ui) {

  1136 		var i = $(this).data("draggable");