1 /*! jQuery UI - v1.11.4 - 2015-03-11

     2 * http://jqueryui.com

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

     4 * Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */

     5 

     6 (function( factory ) {

     7 	if ( typeof define === "function" && define.amd ) {

     8 

     9 		// AMD. Register as an anonymous module.

    10 		define([ "jquery" ], factory );

    11 	} else {

    12 

    13 		// Browser globals

    14 		factory( jQuery );

    15 	}

    16 }(function( $ ) {

    17 /*!

    18  * jQuery UI Core 1.11.4

    19  * http://jqueryui.com

    20  *

    21  * Copyright jQuery Foundation and other contributors

    22  * Released under the MIT license.

    23  * http://jquery.org/license

    24  *

    25  * http://api.jqueryui.com/category/ui-core/

    26  */

    27 

    28 

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

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

    31 

    32 $.extend( $.ui, {

    33 	version: "1.11.4",

    34 

    35 	keyCode: {

    36 		BACKSPACE: 8,

    37 		COMMA: 188,

    38 		DELETE: 46,

    39 		DOWN: 40,

    40 		END: 35,

    41 		ENTER: 13,

    42 		ESCAPE: 27,

    43 		HOME: 36,

    44 		LEFT: 37,

    45 		PAGE_DOWN: 34,

    46 		PAGE_UP: 33,

    47 		PERIOD: 190,

    48 		RIGHT: 39,

    49 		SPACE: 32,

    50 		TAB: 9,

    51 		UP: 38

    52 	}

    53 });

    54 

    55 // plugins

    56 $.fn.extend({

    57 	scrollParent: function( includeHidden ) {

    58 		var position = this.css( "position" ),

    59 			excludeStaticParent = position === "absolute",

    60 			overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,

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

    62 				var parent = $( this );

    63 				if ( excludeStaticParent && parent.css( "position" ) === "static" ) {

    64 					return false;

    65 				}

    66 				return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );

    67 			}).eq( 0 );

    68 

    69 		return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;

    70 	},

    71 

    72 	uniqueId: (function() {

    73 		var uuid = 0;

    74 

    75 		return function() {

    76 			return this.each(function() {

    77 				if ( !this.id ) {

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

    79 				}

    80 			});

    81 		};

    82 	})(),

    83 

    84 	removeUniqueId: function() {

    85 		return this.each(function() {

    86 			if ( /^ui-id-\d+$/.test( this.id ) ) {

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

    88 			}

    89 		});

    90 	}

    91 });

    92 

    93 // selectors

    94 function focusable( element, isTabIndexNotNaN ) {

    95 	var map, mapName, img,

    96 		nodeName = element.nodeName.toLowerCase();

    97 	if ( "area" === nodeName ) {

    98 		map = element.parentNode;

    99 		mapName = map.name;

   100 		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {

   101 			return false;

   102 		}

   103 		img = $( "img[usemap='#" + mapName + "']" )[ 0 ];

   104 		return !!img && visible( img );

   105 	}

   106 	return ( /^(input|select|textarea|button|object)$/.test( nodeName ) ?

   107 		!element.disabled :

   108 		"a" === nodeName ?

   109 			element.href || isTabIndexNotNaN :

   110 			isTabIndexNotNaN) &&

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

   112 		visible( element );

   113 }

   114 

   115 function visible( element ) {

   116 	return $.expr.filters.visible( element ) &&

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

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

   119 		}).length;

   120 }

   121 

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

   123 	data: $.expr.createPseudo ?

   124 		$.expr.createPseudo(function( dataName ) {

   125 			return function( elem ) {

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

   127 			};

   128 		}) :

   129 		// support: jQuery <1.8

   130 		function( elem, i, match ) {

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

   132 		},

   133 

   134 	focusable: function( element ) {

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

   136 	},

   137 

   138 	tabbable: function( element ) {

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

   140 			isTabIndexNaN = isNaN( tabIndex );

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

   142 	}

   143 });

   144 

   145 // support: jQuery <1.8

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

   147 	$.each( [ "Width", "Height" ], function( i, name ) {

   148 		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],

   149 			type = name.toLowerCase(),

   150 			orig = {

   151 				innerWidth: $.fn.innerWidth,

   152 				innerHeight: $.fn.innerHeight,

   153 				outerWidth: $.fn.outerWidth,

   154 				outerHeight: $.fn.outerHeight

   155 			};

   156 

   157 		function reduce( elem, size, border, margin ) {

   158 			$.each( side, function() {

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

   160 				if ( border ) {

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

   162 				}

   163 				if ( margin ) {

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

   165 				}

   166 			});

   167 			return size;

   168 		}

   169 

   170 		$.fn[ "inner" + name ] = function( size ) {

   171 			if ( size === undefined ) {

   172 				return orig[ "inner" + name ].call( this );

   173 			}

   174 

   175 			return this.each(function() {

   176 				$( this ).css( type, reduce( this, size ) + "px" );

   177 			});

   178 		};

   179 

   180 		$.fn[ "outer" + name] = function( size, margin ) {

   181 			if ( typeof size !== "number" ) {

   182 				return orig[ "outer" + name ].call( this, size );

   183 			}

   184 

   185 			return this.each(function() {

   186 				$( this).css( type, reduce( this, size, true, margin ) + "px" );

   187 			});

   188 		};

   189 	});

   190 }

   191 

   192 // support: jQuery <1.8

   193 if ( !$.fn.addBack ) {

   194 	$.fn.addBack = function( selector ) {

   195 		return this.add( selector == null ?

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

   197 		);

   198 	};

   199 }

   200 

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

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

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

   204 		return function( key ) {

   205 			if ( arguments.length ) {

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

   207 			} else {

   208 				return removeData.call( this );

   209 			}

   210 		};

   211 	})( $.fn.removeData );

   212 }

   213 

   214 // deprecated

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

   216 

   217 $.fn.extend({

   218 	focus: (function( orig ) {

   219 		return function( delay, fn ) {

   220 			return typeof delay === "number" ?

   221 				this.each(function() {

   222 					var elem = this;

   223 					setTimeout(function() {

   224 						$( elem ).focus();

   225 						if ( fn ) {

   226 							fn.call( elem );

   227 						}

   228 					}, delay );

   229 				}) :

   230 				orig.apply( this, arguments );

   231 		};

   232 	})( $.fn.focus ),

   233 

   234 	disableSelection: (function() {

   235 		var eventType = "onselectstart" in document.createElement( "div" ) ?

   236 			"selectstart" :

   237 			"mousedown";

   238 

   239 		return function() {

   240 			return this.bind( eventType + ".ui-disableSelection", function( event ) {

   241 				event.preventDefault();

   242 			});

   243 		};

   244 	})(),

   245 

   246 	enableSelection: function() {

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

   248 	},

   249 

   250 	zIndex: function( zIndex ) {

   251 		if ( zIndex !== undefined ) {

   252 			return this.css( "zIndex", zIndex );

   253 		}

   254 

   255 		if ( this.length ) {

   256 			var elem = $( this[ 0 ] ), position, value;

   257 			while ( elem.length && elem[ 0 ] !== document ) {

   258 				// Ignore z-index if position is set to a value where z-index is ignored by the browser

   259 				// This makes behavior of this function consistent across browsers

   260 				// WebKit always returns auto if the element is positioned

   261 				position = elem.css( "position" );

   262 				if ( position === "absolute" || position === "relative" || position === "fixed" ) {

   263 					// IE returns 0 when zIndex is not specified

   264 					// other browsers return a string

   265 					// we ignore the case of nested elements with an explicit value of 0

   266 					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>

   267 					value = parseInt( elem.css( "zIndex" ), 10 );

   268 					if ( !isNaN( value ) && value !== 0 ) {

   269 						return value;

   270 					}

   271 				}

   272 				elem = elem.parent();

   273 			}

   274 		}

   275 

   276 		return 0;

   277 	}

   278 });

   279 

   280 // $.ui.plugin is deprecated. Use $.widget() extensions instead.

   281 $.ui.plugin = {

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

   283 		var i,

   284 			proto = $.ui[ module ].prototype;

   285 		for ( i in set ) {

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

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

   288 		}

   289 	},

   290 	call: function( instance, name, args, allowDisconnected ) {

   291 		var i,

   292 			set = instance.plugins[ name ];

   293 

   294 		if ( !set ) {

   295 			return;

   296 		}

   297 

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

   299 			return;

   300 		}

   301 

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

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

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

   305 			}

   306 		}

   307 	}

   308 };

   309 

   310 

   311 /*!

   312  * jQuery UI Widget 1.11.4

   313  * http://jqueryui.com

   314  *

   315  * Copyright jQuery Foundation and other contributors

   316  * Released under the MIT license.

   317  * http://jquery.org/license

   318  *

   319  * http://api.jqueryui.com/jQuery.widget/

   320  */

   321 

   322 

   323 var widget_uuid = 0,

   324 	widget_slice = Array.prototype.slice;

   325 

   326 $.cleanData = (function( orig ) {

   327 	return function( elems ) {

   328 		var events, elem, i;

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

   330 			try {

   331 

   332 				// Only trigger remove when necessary to save time

   333 				events = $._data( elem, "events" );

   334 				if ( events && events.remove ) {

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

   336 				}

   337 

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

   339 			} catch ( e ) {}

   340 		}

   341 		orig( elems );

   342 	};

   343 })( $.cleanData );

   344 

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

   346 	var fullName, existingConstructor, constructor, basePrototype,

   347 		// proxiedPrototype allows the provided prototype to remain unmodified

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

   349 		proxiedPrototype = {},

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

   351 

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

   353 	fullName = namespace + "-" + name;

   354 

   355 	if ( !prototype ) {

   356 		prototype = base;

   357 		base = $.Widget;

   358 	}

   359 

   360 	// create selector for plugin

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

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

   363 	};

   364 

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

   366 	existingConstructor = $[ namespace ][ name ];

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

   368 		// allow instantiation without "new" keyword

   369 		if ( !this._createWidget ) {

   370 			return new constructor( options, element );

   371 		}

   372 

   373 		// allow instantiation without initializing for simple inheritance

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

   375 		if ( arguments.length ) {

   376 			this._createWidget( options, element );

   377 		}

   378 	};

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

   380 	$.extend( constructor, existingConstructor, {

   381 		version: prototype.version,

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

   383 		// redefine the widget later

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

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

   386 		// redefined after a widget inherits from it

   387 		_childConstructors: []

   388 	});

   389 

   390 	basePrototype = new base();

   391 	// we need to make the options hash a property directly on the new instance

   392 	// otherwise we'll modify the options hash on the prototype that we're

   393 	// inheriting from

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

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

   396 		if ( !$.isFunction( value ) ) {

   397 			proxiedPrototype[ prop ] = value;

   398 			return;

   399 		}

   400 		proxiedPrototype[ prop ] = (function() {

   401 			var _super = function() {

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

   403 				},

   404 				_superApply = function( args ) {

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

   406 				};

   407 			return function() {

   408 				var __super = this._super,

   409 					__superApply = this._superApply,

   410 					returnValue;

   411 

   412 				this._super = _super;

   413 				this._superApply = _superApply;

   414 

   415 				returnValue = value.apply( this, arguments );

   416 

   417 				this._super = __super;

   418 				this._superApply = __superApply;

   419 

   420 				return returnValue;

   421 			};

   422 		})();

   423 	});

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

   425 		// TODO: remove support for widgetEventPrefix

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

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

   428 		widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name

   429 	}, proxiedPrototype, {

   430 		constructor: constructor,

   431 		namespace: namespace,

   432 		widgetName: name,

   433 		widgetFullName: fullName

   434 	});

   435 

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

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

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

   439 	// level in the prototype chain.

   440 	if ( existingConstructor ) {

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

   442 			var childPrototype = child.prototype;

   443 

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

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

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

   447 		});

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

   449 		// so the old child constructors can be garbage collected

   450 		delete existingConstructor._childConstructors;

   451 	} else {

   452 		base._childConstructors.push( constructor );

   453 	}

   454 

   455 	$.widget.bridge( name, constructor );

   456 

   457 	return constructor;

   458 };

   459 

   460 $.widget.extend = function( target ) {

   461 	var input = widget_slice.call( arguments, 1 ),

   462 		inputIndex = 0,

   463 		inputLength = input.length,

   464 		key,

   465 		value;

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

   467 		for ( key in input[ inputIndex ] ) {

   468 			value = input[ inputIndex ][ key ];

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

   470 				// Clone objects

   471 				if ( $.isPlainObject( value ) ) {

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

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

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

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

   476 				// Copy everything else by reference

   477 				} else {

   478 					target[ key ] = value;

   479 				}

   480 			}

   481 		}

   482 	}

   483 	return target;

   484 };

   485 

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

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

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

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

   490 			args = widget_slice.call( arguments, 1 ),

   491 			returnValue = this;

   492 

   493 		if ( isMethodCall ) {

   494 			this.each(function() {

   495 				var methodValue,

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

   497 				if ( options === "instance" ) {

   498 					returnValue = instance;

   499 					return false;

   500 				}

   501 				if ( !instance ) {

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

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

   504 				}

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

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

   507 				}

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

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

   510 					returnValue = methodValue && methodValue.jquery ?

   511 						returnValue.pushStack( methodValue.get() ) :

   512 						methodValue;

   513 					return false;

   514 				}

   515 			});

   516 		} else {

   517 

   518 			// Allow multiple hashes to be passed on init

   519 			if ( args.length ) {

   520 				options = $.widget.extend.apply( null, [ options ].concat(args) );

   521 			}

   522 

   523 			this.each(function() {

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

   525 				if ( instance ) {

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

   527 					if ( instance._init ) {

   528 						instance._init();

   529 					}

   530 				} else {

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

   532 				}

   533 			});

   534 		}

   535 

   536 		return returnValue;

   537 	};

   538 };

   539 

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

   541 $.Widget._childConstructors = [];

   542 

   543 $.Widget.prototype = {

   544 	widgetName: "widget",

   545 	widgetEventPrefix: "",

   546 	defaultElement: "<div>",

   547 	options: {

   548 		disabled: false,

   549 

   550 		// callbacks

   551 		create: null

   552 	},

   553 	_createWidget: function( options, element ) {

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

   555 		this.element = $( element );

   556 		this.uuid = widget_uuid++;

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

   558 

   559 		this.bindings = $();

   560 		this.hoverable = $();

   561 		this.focusable = $();

   562 

   563 		if ( element !== this ) {

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

   565 			this._on( true, this.element, {

   566 				remove: function( event ) {

   567 					if ( event.target === element ) {

   568 						this.destroy();

   569 					}

   570 				}

   571 			});

   572 			this.document = $( element.style ?

   573 				// element within the document

   574 				element.ownerDocument :

   575 				// element is window or document

   576 				element.document || element );

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

   578 		}

   579 

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

   581 			this.options,

   582 			this._getCreateOptions(),

   583 			options );

   584 

   585 		this._create();

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

   587 		this._init();

   588 	},

   589 	_getCreateOptions: $.noop,

   590 	_getCreateEventData: $.noop,

   591 	_create: $.noop,

   592 	_init: $.noop,

   593 

   594 	destroy: function() {

   595 		this._destroy();

   596 		// we can probably remove the unbind calls in 2.0

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

   598 		this.element

   599 			.unbind( this.eventNamespace )

   600 			.removeData( this.widgetFullName )

   601 			// support: jquery <1.6.3

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

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

   604 		this.widget()

   605 			.unbind( this.eventNamespace )

   606 			.removeAttr( "aria-disabled" )

   607 			.removeClass(

   608 				this.widgetFullName + "-disabled " +

   609 				"ui-state-disabled" );

   610 

   611 		// clean up events and states

   612 		this.bindings.unbind( this.eventNamespace );

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

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

   615 	},

   616 	_destroy: $.noop,

   617 

   618 	widget: function() {

   619 		return this.element;

   620 	},

   621 

   622 	option: function( key, value ) {

   623 		var options = key,

   624 			parts,

   625 			curOption,

   626 			i;

   627 

   628 		if ( arguments.length === 0 ) {

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

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

   631 		}

   632 

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

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

   635 			options = {};

   636 			parts = key.split( "." );

   637 			key = parts.shift();

   638 			if ( parts.length ) {

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

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

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

   642 					curOption = curOption[ parts[ i ] ];

   643 				}

   644 				key = parts.pop();

   645 				if ( arguments.length === 1 ) {

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

   647 				}

   648 				curOption[ key ] = value;

   649 			} else {

   650 				if ( arguments.length === 1 ) {

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

   652 				}

   653 				options[ key ] = value;

   654 			}

   655 		}

   656 

   657 		this._setOptions( options );

   658 

   659 		return this;

   660 	},

   661 	_setOptions: function( options ) {

   662 		var key;

   663 

   664 		for ( key in options ) {

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

   666 		}

   667 

   668 		return this;

   669 	},

   670 	_setOption: function( key, value ) {

   671 		this.options[ key ] = value;

   672 

   673 		if ( key === "disabled" ) {

   674 			this.widget()

   675 				.toggleClass( this.widgetFullName + "-disabled", !!value );

   676 

   677 			// If the widget is becoming disabled, then nothing is interactive

   678 			if ( value ) {

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

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

   681 			}

   682 		}

   683 

   684 		return this;

   685 	},

   686 

   687 	enable: function() {

   688 		return this._setOptions({ disabled: false });

   689 	},

   690 	disable: function() {

   691 		return this._setOptions({ disabled: true });

   692 	},

   693 

   694 	_on: function( suppressDisabledCheck, element, handlers ) {

   695 		var delegateElement,

   696 			instance = this;

   697 

   698 		// no suppressDisabledCheck flag, shuffle arguments

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

   700 			handlers = element;

   701 			element = suppressDisabledCheck;

   702 			suppressDisabledCheck = false;

   703 		}

   704 

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

   706 		if ( !handlers ) {

   707 			handlers = element;

   708 			element = this.element;

   709 			delegateElement = this.widget();

   710 		} else {

   711 			element = delegateElement = $( element );

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

   713 		}

   714 

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

   716 			function handlerProxy() {

   717 				// allow widgets to customize the disabled handling

   718 				// - disabled as an array instead of boolean

   719 				// - disabled class as method for disabling individual parts

   720 				if ( !suppressDisabledCheck &&

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

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

   723 					return;

   724 				}

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

   726 					.apply( instance, arguments );

   727 			}

   728 

   729 			// copy the guid so direct unbinding works

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

   731 				handlerProxy.guid = handler.guid =

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

   733 			}

   734 

   735 			var match = event.match( /^([\w:-]*)\s*(.*)$/ ),

   736 				eventName = match[1] + instance.eventNamespace,

   737 				selector = match[2];

   738 			if ( selector ) {

   739 				delegateElement.delegate( selector, eventName, handlerProxy );

   740 			} else {

   741 				element.bind( eventName, handlerProxy );

   742 			}

   743 		});

   744 	},

   745 

   746 	_off: function( element, eventName ) {

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

   748 			this.eventNamespace;

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

   750 

   751 		// Clear the stack to avoid memory leaks (#10056)

   752 		this.bindings = $( this.bindings.not( element ).get() );

   753 		this.focusable = $( this.focusable.not( element ).get() );

   754 		this.hoverable = $( this.hoverable.not( element ).get() );

   755 	},

   756 

   757 	_delay: function( handler, delay ) {

   758 		function handlerProxy() {

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

   760 				.apply( instance, arguments );

   761 		}

   762 		var instance = this;

   763 		return setTimeout( handlerProxy, delay || 0 );

   764 	},

   765 

   766 	_hoverable: function( element ) {

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

   768 		this._on( element, {

   769 			mouseenter: function( event ) {

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

   771 			},

   772 			mouseleave: function( event ) {

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

   774 			}

   775 		});

   776 	},

   777 

   778 	_focusable: function( element ) {

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

   780 		this._on( element, {

   781 			focusin: function( event ) {

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

   783 			},

   784 			focusout: function( event ) {

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

   786 			}

   787 		});

   788 	},

   789 

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

   791 		var prop, orig,

   792 			callback = this.options[ type ];

   793 

   794 		data = data || {};

   795 		event = $.Event( event );

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

   797 			type :

   798 			this.widgetEventPrefix + type ).toLowerCase();

   799 		// the original event may come from any element

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

   801 		event.target = this.element[ 0 ];

   802 

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

   804 		orig = event.originalEvent;

   805 		if ( orig ) {

   806 			for ( prop in orig ) {

   807 				if ( !( prop in event ) ) {

   808 					event[ prop ] = orig[ prop ];

   809 				}

   810 			}

   811 		}

   812 

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

   814 		return !( $.isFunction( callback ) &&

   815 			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||

   816 			event.isDefaultPrevented() );

   817 	}

   818 };

   819 

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

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

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

   823 			options = { effect: options };

   824 		}

   825 		var hasOptions,

   826 			effectName = !options ?

   827 				method :

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

   829 					defaultEffect :

   830 					options.effect || defaultEffect;

   831 		options = options || {};

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

   833 			options = { duration: options };

   834 		}

   835 		hasOptions = !$.isEmptyObject( options );

   836 		options.complete = callback;

   837 		if ( options.delay ) {

   838 			element.delay( options.delay );

   839 		}

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

   841 			element[ method ]( options );

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

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

   844 		} else {

   845 			element.queue(function( next ) {

   846 				$( this )[ method ]();

   847 				if ( callback ) {

   848 					callback.call( element[ 0 ] );

   849 				}

   850 				next();

   851 			});

   852 		}

   853 	};

   854 });

   855 

   856 var widget = $.widget;

   857 

   858 

   859 /*!

   860  * jQuery UI Mouse 1.11.4

   861  * http://jqueryui.com

   862  *

   863  * Copyright jQuery Foundation and other contributors

   864  * Released under the MIT license.

   865  * http://jquery.org/license

   866  *

   867  * http://api.jqueryui.com/mouse/

   868  */

   869 

   870 

   871 var mouseHandled = false;

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

   873 	mouseHandled = false;

   874 });

   875 

   876 var mouse = $.widget("ui.mouse", {

   877 	version: "1.11.4",

   878 	options: {

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

   880 		distance: 1,

   881 		delay: 0

   882 	},

   883 	_mouseInit: function() {

   884 		var that = this;

   885 

   886 		this.element

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

   888 				return that._mouseDown(event);

   889 			})

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

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

   892 					$.removeData(event.target, that.widgetName + ".preventClickEvent");

   893 					event.stopImmediatePropagation();

   894 					return false;

   895 				}

   896 			});

   897 

   898 		this.started = false;

   899 	},

   900 

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

   902 	// other instances of mouse

   903 	_mouseDestroy: function() {

   904 		this.element.unbind("." + this.widgetName);

   905 		if ( this._mouseMoveDelegate ) {

   906 			this.document

   907 				.unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)

   908 				.unbind("mouseup." + this.widgetName, this._mouseUpDelegate);

   909 		}

   910 	},

   911 

   912 	_mouseDown: function(event) {

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

   914 		if ( mouseHandled ) {

   915 			return;

   916 		}

   917 

   918 		this._mouseMoved = false;

   919 

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

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

   922 

   923 		this._mouseDownEvent = event;

   924 

   925 		var that = this,

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

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

   928 			// disabled inputs (#7620)

   929 			elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);

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

   931 			return true;

   932 		}

   933 

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

   935 		if (!this.mouseDelayMet) {

   936 			this._mouseDelayTimer = setTimeout(function() {

   937 				that.mouseDelayMet = true;

   938 			}, this.options.delay);

   939 		}

   940 

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

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

   943 			if (!this._mouseStarted) {

   944 				event.preventDefault();

   945 				return true;

   946 			}

   947 		}

   948 

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

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

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

   952 		}

   953 

   954 		// these delegates are required to keep context

   955 		this._mouseMoveDelegate = function(event) {

   956 			return that._mouseMove(event);

   957 		};

   958 		this._mouseUpDelegate = function(event) {

   959 			return that._mouseUp(event);

   960 		};

   961 

   962 		this.document

   963 			.bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )

   964 			.bind( "mouseup." + this.widgetName, this._mouseUpDelegate );

   965 

   966 		event.preventDefault();

   967 

   968 		mouseHandled = true;

   969 		return true;

   970 	},

   971 

   972 	_mouseMove: function(event) {

   973 		// Only check for mouseups outside the document if you've moved inside the document

   974 		// at least once. This prevents the firing of mouseup in the case of IE<9, which will

   975 		// fire a mousemove event if content is placed under the cursor. See #7778

   976 		// Support: IE <9

   977 		if ( this._mouseMoved ) {

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

   979 			if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {

   980 				return this._mouseUp(event);

   981 

   982 			// Iframe mouseup check - mouseup occurred in another document

   983 			} else if ( !event.which ) {

   984 				return this._mouseUp( event );

   985 			}

   986 		}

   987 

   988 		if ( event.which || event.button ) {

   989 			this._mouseMoved = true;

   990 		}

   991 

   992 		if (this._mouseStarted) {

   993 			this._mouseDrag(event);

   994 			return event.preventDefault();

   995 		}

   996 

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

   998 			this._mouseStarted =

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

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

  1001 		}

  1002 

  1003 		return !this._mouseStarted;

  1004 	},

  1005 

  1006 	_mouseUp: function(event) {

  1007 		this.document

  1008 			.unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )

  1009 			.unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );

  1010 

  1011 		if (this._mouseStarted) {

  1012 			this._mouseStarted = false;

  1013 

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

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

  1016 			}

  1017 

  1018 			this._mouseStop(event);

  1019 		}

  1020 

  1021 		mouseHandled = false;

  1022 		return false;

  1023 	},

  1024 

  1025 	_mouseDistanceMet: function(event) {

  1026 		return (Math.max(

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

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

  1029 			) >= this.options.distance

  1030 		);

  1031 	},

  1032 

  1033 	_mouseDelayMet: function(/* event */) {

  1034 		return this.mouseDelayMet;

  1035 	},

  1036 

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

  1038 	_mouseStart: function(/* event */) {},

  1039 	_mouseDrag: function(/* event */) {},

  1040 	_mouseStop: function(/* event */) {},

  1041 	_mouseCapture: function(/* event */) { return true; }

  1042 });

  1043 

  1044 

  1045 /*!

  1046  * jQuery UI Position 1.11.4

  1047  * http://jqueryui.com

  1048  *

  1049  * Copyright jQuery Foundation and other contributors

  1050  * Released under the MIT license.

  1051  * http://jquery.org/license

  1052  *

  1053  * http://api.jqueryui.com/position/

  1054  */

  1055 

  1056 (function() {

  1057 

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

  1059 

  1060 var cachedScrollbarWidth, supportsOffsetFractions,

  1061 	max = Math.max,

  1062 	abs = Math.abs,

  1063 	round = Math.round,

  1064 	rhorizontal = /left|center|right/,

  1065 	rvertical = /top|center|bottom/,

  1066 	roffset = /[\+\-]\d+(\.[\d]+)?%?/,

  1067 	rposition = /^\w+/,

  1068 	rpercent = /%$/,

  1069 	_position = $.fn.position;

  1070 

  1071 function getOffsets( offsets, width, height ) {

  1072 	return [

  1073 		parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),

  1074 		parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )

  1075 	];

  1076 }

  1077 

  1078 function parseCss( element, property ) {

  1079 	return parseInt( $.css( element, property ), 10 ) || 0;

  1080 }

  1081 

  1082 function getDimensions( elem ) {

  1083 	var raw = elem[0];

  1084 	if ( raw.nodeType === 9 ) {

  1085 		return {

  1086 			width: elem.width(),

  1087 			height: elem.height(),

  1088 			offset: { top: 0, left: 0 }

  1089 		};

  1090 	}

  1091 	if ( $.isWindow( raw ) ) {

  1092 		return {

  1093 			width: elem.width(),

  1094 			height: elem.height(),

  1095 			offset: { top: elem.scrollTop(), left: elem.scrollLeft() }

  1096 		};

  1097 	}

  1098 	if ( raw.preventDefault ) {

  1099 		return {

  1100 			width: 0,

  1101 			height: 0,

  1102 			offset: { top: raw.pageY, left: raw.pageX }

  1103 		};

  1104 	}

  1105 	return {

  1106 		width: elem.outerWidth(),

  1107 		height: elem.outerHeight(),

  1108 		offset: elem.offset()

  1109 	};

  1110 }

  1111 

  1112 $.position = {

  1113 	scrollbarWidth: function() {

  1114 		if ( cachedScrollbarWidth !== undefined ) {

  1115 			return cachedScrollbarWidth;

  1116 		}

  1117 		var w1, w2,

  1118 			div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),

  1119 			innerDiv = div.children()[0];

  1120 

  1121 		$( "body" ).append( div );

  1122 		w1 = innerDiv.offsetWidth;

  1123 		div.css( "overflow", "scroll" );

  1124 

  1125 		w2 = innerDiv.offsetWidth;

  1126 

  1127 		if ( w1 === w2 ) {

  1128 			w2 = div[0].clientWidth;

  1129 		}

  1130 

  1131 		div.remove();

  1132 

  1133 		return (cachedScrollbarWidth = w1 - w2);

  1134 	},

  1135 	getScrollInfo: function( within ) {