/*! jQuery UI - v1.10.0 - 2013-01-17

* http://jqueryui.com

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

* Copyright (c) 2013 jQuery Foundation and other contributors Licensed MIT */

(function( $, undefined ) {

var uuid = 0,

runiqueId = /^ui-id-\d+$/;

// 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.10.0",

keyCode: {

BACKSPACE: 8,

COMMA: 188,

DELETE: 46,

DOWN: 40,

END: 35,

ENTER: 13,

ESCAPE: 27,

HOME: 36,

LEFT: 37,

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,

SPACE: 32,

TAB: 9,

UP: 38

}

});

// 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 (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {

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

return (/(relative|absolute|fixed)/).test($.css(this,"position")) && (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));

}).eq(0);

} else {

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

return (/(auto|scroll)/).test($.css(this,"overflow")+$.css(this,"overflow-y")+$.css(this,"overflow-x"));

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

},

uniqueId: function() {

return this.each(function() {

if ( !this.id ) {

this.id = "ui-id-" + (++uuid);

}

});

},

removeUniqueId: function() {

return this.each(function() {

if ( runiqueId.test( this.id ) ) {

$( this ).removeAttr( "id" );

}

});

}

});

// selectors

function focusable( element, isTabIndexNotNaN ) {

var map, mapName, img,

nodeName = element.nodeName.toLowerCase();

if ( "area" === nodeName ) {

map = element.parentNode;

mapName = map.name;

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 $.expr.filters.visible( element ) &&

!$( element ).parents().addBack().filter(function() {

return $.css( this, "visibility" ) === "hidden";

}).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: 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( $.css( elem, "padding" + this ) ) || 0;

if ( border ) {

size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;

}

if ( margin ) {

size -= parseFloat( $.css( elem, "margin" + this ) ) || 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" );

});

};

});

}

// support: jQuery <1.8

if ( !$.fn.addBack ) {

$.fn.addBack = function( selector ) {

return this.add( selector == null ?

this.prevObject : this.prevObject.filter( selector )

);

};

}

// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)

if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {

$.fn.removeData = (function( removeData ) {

return function( key ) {

if ( arguments.length ) {

return removeData.call( this, $.camelCase( key ) );

} else {

return removeData.call( this );

}

};

})( $.fn.removeData );

}

// deprecated

$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );

$.support.selectstart = "onselectstart" in document.createElement( "div" );

$.fn.extend({

disableSelection: function() {

return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +

".ui-disableSelection", function( event ) {

event.preventDefault();

});

},

enableSelection: function() {

return this.unbind( ".ui-disableSelection" );

}

});

$.extend( $.ui, {

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

plugin: {

add: function( module, option, set ) {

var i,

proto = $.ui[ module ].prototype;

for ( i in set ) {

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

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

}

},

call: function( instance, name, args ) {

var i,

set = instance.plugins[ name ];

if ( !set || !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) {

return;

}

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

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

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

}

}

}

},

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

}

});

})( jQuery );

(function( $, undefined ) {

var uuid = 0,

slice = Array.prototype.slice,

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

};

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

var fullName, existingConstructor, constructor, basePrototype,

// proxiedPrototype allows the provided prototype to remain unmodified

// so that it can be used as a mixin for multiple widgets (#8876)

proxiedPrototype = {},

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

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

fullName = namespace + "-" + name;

if ( !prototype ) {

prototype = base;

base = $.Widget;

}

// create selector for plugin

$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {

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

};

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

existingConstructor = $[ namespace ][ name ];

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

// allow instantiation without "new" keyword

if ( !this._createWidget ) {

return new constructor( options, element );

}

// allow instantiation without initializing for simple inheritance

// must use "new" keyword (the code above always passes args)

if ( arguments.length ) {

this._createWidget( options, element );

}

};

// extend with the existing constructor to carry over any static properties

$.extend( constructor, existingConstructor, {

version: prototype.version,

// copy the object used to create the prototype in case we need to

// redefine the widget later

_proto: $.extend( {}, prototype ),

// track widgets that inherit from this widget in case this widget is

// redefined after a widget inherits from it

_childConstructors: []

});

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

basePrototype.options = $.widget.extend( {}, basePrototype.options );

$.each( prototype, function( prop, value ) {

if ( !$.isFunction( value ) ) {

proxiedPrototype[ prop ] = value;

return;

}

proxiedPrototype[ prop ] = (function() {

var _super = function() {

return base.prototype[ prop ].apply( this, arguments );

},

_superApply = function( args ) {

return base.prototype[ prop ].apply( this, args );

};

return function() {

var __super = this._super,

__superApply = this._superApply,

returnValue;

this._super = _super;

this._superApply = _superApply;

returnValue = value.apply( this, arguments );

this._super = __super;

this._superApply = __superApply;

return returnValue;

};

})();

});

constructor.prototype = $.widget.extend( basePrototype, {

// TODO: remove support for widgetEventPrefix

// always use the name + a colon as the prefix, e.g., draggable:start

// don't prefix for widgets that aren't DOM-based

widgetEventPrefix: existingConstructor ? basePrototype.widgetEventPrefix : name

}, proxiedPrototype, {

constructor: constructor,

namespace: namespace,

widgetName: name,

widgetFullName: fullName

});

// If this widget is being redefined then we need to find all widgets that

// are inheriting from it and redefine all of them so that they inherit from

// the new version of this widget. We're essentially trying to replace one

// level in the prototype chain.

if ( existingConstructor ) {

$.each( existingConstructor._childConstructors, function( i, child ) {

var childPrototype = child.prototype;

// redefine the child widget using the same prototype that was

// originally used, but inherit from the new version of the base

$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );

});

// remove the list of existing child constructors from the old constructor

// so the old child constructors can be garbage collected

delete existingConstructor._childConstructors;

} else {

base._childConstructors.push( constructor );

}

$.widget.bridge( name, constructor );

};

$.widget.extend = function( target ) {

var input = slice.call( arguments, 1 ),

inputIndex = 0,

inputLength = input.length,

key,

value;

for ( ; inputIndex < inputLength; inputIndex++ ) {

for ( key in input[ inputIndex ] ) {

value = input[ inputIndex ][ key ];

if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {

// Clone objects

if ( $.isPlainObject( value ) ) {

target[ key ] = $.isPlainObject( target[ key ] ) ?

$.widget.extend( {}, target[ key ], value ) :

// Don't extend strings, arrays, etc. with objects

$.widget.extend( {}, value );

// Copy everything else by reference

} else {

target[ key ] = value;

}

}

}

}

return target;

};

$.widget.bridge = function( name, object ) {

var fullName = object.prototype.widgetFullName || name;

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

var isMethodCall = typeof options === "string",

args = slice.call( arguments, 1 ),

returnValue = this;

// allow multiple hashes to be passed on init

options = !isMethodCall && args.length ?

$.widget.extend.apply( null, [ options ].concat(args) ) :

options;

if ( isMethodCall ) {

this.each(function() {

var methodValue,

instance = $.data( this, fullName );

if ( !instance ) {

return $.error( "cannot call methods on " + name + " prior to initialization; " +

"attempted to call method '" + options + "'" );

}

if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {

return $.error( "no such method '" + options + "' for " + name + " widget instance" );

}

methodValue = instance[ options ].apply( instance, args );

if ( methodValue !== instance && methodValue !== undefined ) {

returnValue = methodValue && methodValue.jquery ?

returnValue.pushStack( methodValue.get() ) :

methodValue;

return false;

}

});

} else {

this.each(function() {

var instance = $.data( this, fullName );

if ( instance ) {

instance.option( options || {} )._init();

} else {

$.data( this, fullName, new object( options, this ) );

}

});

}

return returnValue;

};

};

$.Widget = function( /* options, element */ ) {};

$.Widget._childConstructors = [];

$.Widget.prototype = {

widgetName: "widget",

widgetEventPrefix: "",

defaultElement: "<div>",

options: {

disabled: false,

// callbacks

create: null

},

_createWidget: function( options, element ) {

element = $( element || this.defaultElement || this )[ 0 ];

this.element = $( element );

this.uuid = uuid++;

this.eventNamespace = "." + this.widgetName + this.uuid;

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

this.options,

this._getCreateOptions(),

options );

this.bindings = $();

this.hoverable = $();

this.focusable = $();

if ( element !== this ) {

$.data( element, this.widgetFullName, this );

this._on( true, this.element, {

remove: function( event ) {

if ( event.target === element ) {

this.destroy();

}

}

});

this.document = $( element.style ?

// element within the document

element.ownerDocument :

// element is window or document

element.document || element );

this.window = $( this.document[0].defaultView || this.document[0].parentWindow );

}

this._create();

this._trigger( "create", null, this._getCreateEventData() );

this._init();

},

_getCreateOptions: $.noop,

_getCreateEventData: $.noop,

_create: $.noop,

_init: $.noop,

destroy: function() {

this._destroy();

// we can probably remove the unbind calls in 2.0

// all event bindings should go through this._on()

this.element

.unbind( this.eventNamespace )

// 1.9 BC for #7810

// TODO remove dual storage

.removeData( this.widgetName )

.removeData( this.widgetFullName )

// support: jquery <1.6.3

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

.removeData( $.camelCase( this.widgetFullName ) );

this.widget()

.unbind( this.eventNamespace )

.removeAttr( "aria-disabled" )

.removeClass(

this.widgetFullName + "-disabled " +

"ui-state-disabled" );

// clean up events and states

this.bindings.unbind( this.eventNamespace );

this.hoverable.removeClass( "ui-state-hover" );

this.focusable.removeClass( "ui-state-focus" );

},

_destroy: $.noop,

widget: function() {

return this.element;

},

option: function( key, value ) {

var options = key,

parts,

curOption,

i;

if ( arguments.length === 0 ) {

// don't return a reference to the internal hash

return $.widget.extend( {}, this.options );

}

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

// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }

options = {};

parts = key.split( "." );

key = parts.shift();

if ( parts.length ) {

curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );

for ( i = 0; i < parts.length - 1; i++ ) {

curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};

curOption = curOption[ parts[ i ] ];

}

key = parts.pop();

if ( value === undefined ) {

return curOption[ key ] === undefined ? null : curOption[ key ];

}

curOption[ key ] = value;

} else {

if ( value === undefined ) {

return this.options[ key ] === undefined ? null : this.options[ key ];

}

options[ key ] = value;

}

}

this._setOptions( options );

return this;

},

_setOptions: function( options ) {

var key;

for ( key in options ) {

this._setOption( key, options[ key ] );

}

return this;

},

_setOption: function( key, value ) {

this.options[ key ] = value;

if ( key === "disabled" ) {

this.widget()

.toggleClass( this.widgetFullName + "-disabled ui-state-disabled", !!value )

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

this.hoverable.removeClass( "ui-state-hover" );

this.focusable.removeClass( "ui-state-focus" );

}

return this;

},

enable: function() {

return this._setOption( "disabled", false );

},

disable: function() {

return this._setOption( "disabled", true );

},

_on: function( suppressDisabledCheck, element, handlers ) {

var delegateElement,

instance = this;

// no suppressDisabledCheck flag, shuffle arguments

if ( typeof suppressDisabledCheck !== "boolean" ) {

handlers = element;

element = suppressDisabledCheck;

suppressDisabledCheck = false;

}

// no element argument, shuffle and use this.element

if ( !handlers ) {

handlers = element;

element = this.element;

delegateElement = this.widget();

} else {

// accept selectors, DOM elements

element = delegateElement = $( element );

this.bindings = this.bindings.add( element );

}

$.each( handlers, function( event, handler ) {

function handlerProxy() {

// allow widgets to customize the disabled handling

// - disabled as an array instead of boolean

// - disabled class as method for disabling individual parts

if ( !suppressDisabledCheck &&

( instance.options.disabled === true ||

$( this ).hasClass( "ui-state-disabled" ) ) ) {

return;

}

return ( typeof handler === "string" ? instance[ handler ] : handler )

.apply( instance, arguments );

}

// copy the guid so direct unbinding works

if ( typeof handler !== "string" ) {

handlerProxy.guid = handler.guid =

handler.guid || handlerProxy.guid || $.guid++;

}

var match = event.match( /^(\w+)\s*(.*)$/ ),

eventName = match[1] + instance.eventNamespace,

selector = match[2];

if ( selector ) {

delegateElement.delegate( selector, eventName, handlerProxy );

} else {

element.bind( eventName, handlerProxy );

}

});

},

_off: function( element, eventName ) {

eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;

element.unbind( eventName ).undelegate( eventName );

},

_delay: function( handler, delay ) {

function handlerProxy() {

return ( typeof handler === "string" ? instance[ handler ] : handler )

.apply( instance, arguments );

}

var instance = this;

return setTimeout( handlerProxy, delay || 0 );

},

_hoverable: function( element ) {

this.hoverable = this.hoverable.add( element );

this._on( element, {

mouseenter: function( event ) {

$( event.currentTarget ).addClass( "ui-state-hover" );

},

mouseleave: function( event ) {

$( event.currentTarget ).removeClass( "ui-state-hover" );

}

});

},

_focusable: function( element ) {

this.focusable = this.focusable.add( element );

this._on( element, {

focusin: function( event ) {

$( event.currentTarget ).addClass( "ui-state-focus" );

},

focusout: function( event ) {

$( event.currentTarget ).removeClass( "ui-state-focus" );

}

});

},

_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.apply( this.element[0], [ event ].concat( data ) ) === false ||

event.isDefaultPrevented() );

}

};

$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {

$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {

if ( typeof options === "string" ) {

options = { effect: options };

}

var hasOptions,

effectName = !options ?

method :

options === true || typeof options === "number" ?

defaultEffect :

options.effect || defaultEffect;

options = options || {};

if ( typeof options === "number" ) {

options = { duration: options };

}

hasOptions = !$.isEmptyObject( options );

options.complete = callback;

if ( options.delay ) {

element.delay( options.delay );

}

if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {

element[ method ]( options );

} else if ( effectName !== method && element[ effectName ] ) {

element[ effectName ]( options.duration, options.easing, callback );

} else {

element.queue(function( next ) {

$( this )[ method ]();

if ( callback ) {

callback.call( element[ 0 ] );

}

next();

});

}

};

});

})( jQuery );

(function( $, undefined ) {

var mouseHandled = false;

$( document ).mouseup( function() {

mouseHandled = false;

});

$.widget("ui.mouse", {

version: "1.10.0",

options: {

cancel: "input,textarea,button,select,option",

distance: 1,

delay: 0

},

_mouseInit: function() {

var that = this;

this.element

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

return that._mouseDown(event);

})

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

if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {

$.removeData(event.target, that.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 that = 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() {

that.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 that._mouseMove(event);

};

this._mouseUpDelegate = function(event) {

return that._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 ($.ui.ie && ( !document.documentMode || 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 ) {

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

var cachedScrollbarWidth,

max = Math.max,

abs = Math.abs,

round = Math.round,

rhorizontal = /left|center|right/,

rvertical = /top|center|bottom/,

roffset = /[\+\-]\d+%?/,

rposition = /^\w+/,

rpercent = /%$/,

_position = $.fn.position;