/* NUGET: BEGIN LICENSE TEXT

*

* Microsoft grants you the right to use these script files for the sole

* purpose of either: (i) interacting through your browser with the Microsoft

* website or online service, subject to the applicable licensing or use

* terms; or (ii) using the files as included with a Microsoft product subject

* to that product's license terms. Microsoft reserves all other rights to the

* files not expressly granted by Microsoft, whether by implication, estoppel

* or otherwise. Insofar as a script file is dual licensed under GPL,

* Microsoft neither took the code under GPL nor distributes it thereunder but

* under the terms set out in this paragraph. All notices and licenses

* below are for informational purposes only.

*

* jQuery UI; Copyright (c) 2012 Paul Bakaus; http://opensource.org/licenses/MIT

*

* Includes jQuery Easing v1.3; Copyright 2008 George McGinley Smith; http://opensource.org/licenses/BSD-3-Clause

*

* NUGET: END LICENSE TEXT */

/*! jQuery UI - v1.8.24 - 2012-09-28

* https://github.com/jquery/jquery-ui

* Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.effects.core.js, jquery.effects.blind.js, jquery.effects.bounce.js, jquery.effects.clip.js, jquery.effects.drop.js, jquery.effects.explode.js, jquery.effects.fade.js, jquery.effects.fold.js, jquery.effects.highlight.js, jquery.effects.pulsate.js, jquery.effects.scale.js, jquery.effects.shake.js, jquery.effects.slide.js, jquery.effects.transfer.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.js, jquery.ui.position.js, jquery.ui.progressbar.js, jquery.ui.slider.js, jquery.ui.tabs.js

* Copyright (c) 2012 AUTHORS.txt; Licensed MIT */

(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.24",

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({

propAttr: $.fn.prop || $.fn.attr,

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

}

});

// support: jQuery <1.8

if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {

$.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 focusable( element, isTabIndexNotNaN ) {

var nodeName = element.nodeName.toLowerCase();

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 || isTabIndexNotNaN

: isTabIndexNotNaN)

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

&& visible( element );

}

function visible( element ) {

return !$( element ).parents().andSelf().filter(function() {

return $.curCSS( this, "visibility" ) === "hidden" ||

$.expr.filters.hidden( this );

}).length;

}

$.extend( $.expr[ ":" ], {

data: $.expr.createPseudo ?

$.expr.createPseudo(function( dataName ) {

return function( elem ) {

return !!$.data( elem, dataName );

};

}) :

// support: jQuery <1.8

function( elem, i, match ) {

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

},

focusable: function( element ) {

return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );

},

tabbable: function( element ) {

var tabIndex = $.attr( element, "tabindex" ),

isTabIndexNaN = isNaN( tabIndex );

return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );

}

});

// support

$(function() {

var body = document.body,

div = body.appendChild( div = document.createElement( "div" ) );

// access offsetHeight before setting the style to prevent a layout bug

// in IE 9 which causes the elemnt to continue to take up space even

// after it is removed from the DOM (#8026)

div.offsetHeight;

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

});

// jQuery <1.4.3 uses curCSS, in 1.4.3 - 1.7.2 curCSS = css, 1.8+ only has css

if ( !$.curCSS ) {

$.curCSS = $.css;

}

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

(function( $, undefined ) {

// jQuery 1.4+

if ( $.cleanData ) {

var _cleanData = $.cleanData;

$.cleanData = function( elems ) {

for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {

try {

$( elem ).triggerHandler( "remove" );

// http://bugs.jquery.com/ticket/8235

} catch( e ) {}

}

_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() {

try {

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

// http://bugs.jquery.com/ticket/8235

} catch( e ) {}

});

}

}

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 prop, orig,

callback = this.options[ type ];

data = data || {};

event = $.Event( event );

event.type = ( type === this.widgetEventPrefix ?

type :

this.widgetEventPrefix + type ).toLowerCase();

// the original event may come from any element

// so we need to reset the target on the new event

event.target = this.element[ 0 ];

// copy original event properties over to the new event

orig = event.originalEvent;

if ( orig ) {

for ( prop in orig ) {

if ( !( prop in event ) ) {

event[ prop ] = orig[ prop ];

}

}

}

this.element.trigger( event, data );

return !( $.isFunction(callback) &&

callback.call( this.element[0], event, data ) === false ||

event.isDefaultPrevented() );

}

};

})( jQuery );

(function( $, undefined ) {

var mouseHandled = false;

$( document ).mouseup( function( e ) {

mouseHandled = false;

});

$.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 (true === $.data(event.target, self.widgetName + '.preventClickEvent')) {

$.removeData(event.target, self.widgetName + '.preventClickEvent');

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

if ( this._mouseMoveDelegate ) {

$(document)

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

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

}

},

_mouseDown: function(event) {

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

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

// event.target.nodeName works around a bug in IE 8 with

// disabled inputs (#7620)

elIsCancel = (typeof this.options.cancel == "string" && event.target.nodeName ? $(event.target).closest(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;

}

}

// Click event may never have fired (Gecko & Opera)

if (true === $.data(event.target, this.widgetName + '.preventClickEvent')) {

$.removeData(event.target, this.widgetName + '.preventClickEvent');

}

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

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;

if (event.target == this._mouseDownEvent.target) {

$.data(event.target, this.widgetName + '.preventClickEvent', true);

}

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

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

if ( o.iframeFix ) {

$(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");

});

}

return true;

},

_mouseStart: function(event) {

var o = this.options;

//Create and append the visible helper

this.helper = this._createHelper(event);

this.helper.addClass("ui-draggable-dragging");

//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._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position

//If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)

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

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 no longer in the DOM don't bother to continue (see #8269)

var element = this.element[0], elementInDom = false;

while ( element && (element = element.parentNode) ) {

if (element == document ) {

elementInDom = true;

}

}

if ( !elementInDom && this.options.helper === "original" )

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;

},

_mouseUp: function(event) {

//Remove frame helpers

$("div.ui-draggable-iframeFix").each(function() {

this.parentNode.removeChild(this);

});

//If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)