+/*! jQuery UI - v1.10.3 - 2013-05-03

+* http://jqueryui.com

+* 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.ui.effect.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.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.position.js, jquery.ui.progressbar.js, jquery.ui.slider.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js

+* Copyright 2013 jQuery Foundation and other contributors; Licensed MIT */

+(function( $, undefined ) {

+

+var uuid = 0,

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

+

+// $.ui might exist from components with no dependencies, e.g., $.ui.position

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

+

+$.extend( $.ui, {

+ version: "1.10.3",

+

+ 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: (function( orig ) {

+ return function( delay, fn ) {

+ return typeof delay === "number" ?

+ this.each(function() {

+ var elem = this;

+ setTimeout(function() {

+ $( elem ).focus();

+ if ( fn ) {

+ fn.call( elem );

+ }

+ }, delay );

+ }) :

+ orig.apply( this, arguments );

+ };

+ })( $.fn.focus ),

+

+ 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 $.widget() extensions 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.3",

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

+

+$.widget("ui.draggable", $.ui.mouse, {

+ version: "1.10.3",

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

+

+ // callbacks

+ drag: null,

+ start: null,

+ stop: null

+ },

+ _create: function() {

+

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

+ this.element[0].style.position = "relative";

+ }

+ if (this.options.addClasses){

+ this.element.addClass("ui-draggable");

+ }

+ if (this.options.disabled){

+ this.element.addClass("ui-draggable-disabled");

+ }

+

+ this._mouseInit();

+

+ },

+

+ _destroy: function() {

+ this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );

+ this._mouseDestroy();

+ },

+

+ _mouseCapture: function(event) {

+

+ var o = this.options;

+

+ // among others, prevent a drag on a resizable-handle

+ if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {

+ return false;

+ }

+

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

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

+ if (!this.handle) {

+ return false;

+ }

+

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

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

+ this.offsetParentCssPosition = this.offsetParent.css( "position" );

+

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

+ };

+

+ //Reset scroll cache

+ this.offset.scroll = false;

+

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

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