1 /*! jQuery UI - v1.10.4 - 2014-02-09

     2 * http://jqueryui.com

     3 * Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.position.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.sortable.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.js, jquery.ui.menu.js, jquery.ui.progressbar.js, jquery.ui.slider.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.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

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

     5 

     6 (function( $, undefined ) {

     7 

     8 var uuid = 0,

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

    10 

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

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

    13 

    14 $.extend( $.ui, {

    15 	version: "1.10.4",

    16 

    17 	keyCode: {

    18 		BACKSPACE: 8,

    19 		COMMA: 188,

    20 		DELETE: 46,

    21 		DOWN: 40,

    22 		END: 35,

    23 		ENTER: 13,

    24 		ESCAPE: 27,

    25 		HOME: 36,

    26 		LEFT: 37,

    27 		NUMPAD_ADD: 107,

    28 		NUMPAD_DECIMAL: 110,

    29 		NUMPAD_DIVIDE: 111,

    30 		NUMPAD_ENTER: 108,

    31 		NUMPAD_MULTIPLY: 106,

    32 		NUMPAD_SUBTRACT: 109,

    33 		PAGE_DOWN: 34,

    34 		PAGE_UP: 33,

    35 		PERIOD: 190,

    36 		RIGHT: 39,

    37 		SPACE: 32,

    38 		TAB: 9,

    39 		UP: 38

    40 	}

    41 });

    42 

    43 // plugins

    44 $.fn.extend({

    45 	focus: (function( orig ) {

    46 		return function( delay, fn ) {

    47 			return typeof delay === "number" ?

    48 				this.each(function() {

    49 					var elem = this;

    50 					setTimeout(function() {

    51 						$( elem ).focus();

    52 						if ( fn ) {

    53 							fn.call( elem );

    54 						}

    55 					}, delay );

    56 				}) :

    57 				orig.apply( this, arguments );

    58 		};

    59 	})( $.fn.focus ),

    60 

    61 	scrollParent: function() {

    62 		var scrollParent;

    63 		if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {

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

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

    66 			}).eq(0);

    67 		} else {

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

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

    70 			}).eq(0);

    71 		}

    72 

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

    74 	},

    75 

    76 	zIndex: function( zIndex ) {

    77 		if ( zIndex !== undefined ) {

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

    79 		}

    80 

    81 		if ( this.length ) {

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

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

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

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

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

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

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

    89 					// IE returns 0 when zIndex is not specified

    90 					// other browsers return a string

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

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

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

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

    95 						return value;

    96 					}

    97 				}

    98 				elem = elem.parent();

    99 			}

   100 		}

   101 

   102 		return 0;

   103 	},

   104 

   105 	uniqueId: function() {

   106 		return this.each(function() {

   107 			if ( !this.id ) {

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

   109 			}

   110 		});

   111 	},

   112 

   113 	removeUniqueId: function() {

   114 		return this.each(function() {

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

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

   117 			}

   118 		});

   119 	}

   120 });

   121 

   122 // selectors

   123 function focusable( element, isTabIndexNotNaN ) {

   124 	var map, mapName, img,

   125 		nodeName = element.nodeName.toLowerCase();

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

   127 		map = element.parentNode;

   128 		mapName = map.name;

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

   130 			return false;

   131 		}

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

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

   134 	}

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

   136 		!element.disabled :

   137 		"a" === nodeName ?

   138 			element.href || isTabIndexNotNaN :

   139 			isTabIndexNotNaN) &&

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

   141 		visible( element );

   142 }

   143 

   144 function visible( element ) {

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

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

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

   148 		}).length;

   149 }

   150 

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

   152 	data: $.expr.createPseudo ?

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

   154 			return function( elem ) {

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

   156 			};

   157 		}) :

   158 		// support: jQuery <1.8

   159 		function( elem, i, match ) {

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

   161 		},

   162 

   163 	focusable: function( element ) {

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

   165 	},

   166 

   167 	tabbable: function( element ) {

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

   169 			isTabIndexNaN = isNaN( tabIndex );

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

   171 	}

   172 });

   173 

   174 // support: jQuery <1.8

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

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

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

   178 			type = name.toLowerCase(),

   179 			orig = {

   180 				innerWidth: $.fn.innerWidth,

   181 				innerHeight: $.fn.innerHeight,

   182 				outerWidth: $.fn.outerWidth,

   183 				outerHeight: $.fn.outerHeight

   184 			};

   185 

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

   187 			$.each( side, function() {

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

   189 				if ( border ) {

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

   191 				}

   192 				if ( margin ) {

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

   194 				}

   195 			});

   196 			return size;

   197 		}

   198 

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

   200 			if ( size === undefined ) {

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

   202 			}

   203 

   204 			return this.each(function() {

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

   206 			});

   207 		};

   208 

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

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

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

   212 			}

   213 

   214 			return this.each(function() {

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

   216 			});

   217 		};

   218 	});

   219 }

   220 

   221 // support: jQuery <1.8

   222 if ( !$.fn.addBack ) {

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

   224 		return this.add( selector == null ?

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

   226 		);

   227 	};

   228 }

   229 

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

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

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

   233 		return function( key ) {

   234 			if ( arguments.length ) {

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

   236 			} else {

   237 				return removeData.call( this );

   238 			}

   239 		};

   240 	})( $.fn.removeData );

   241 }

   242 

   243 

   244 

   245 

   246 

   247 // deprecated

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

   249 

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

   251 $.fn.extend({

   252 	disableSelection: function() {

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

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

   255 				event.preventDefault();

   256 			});

   257 	},

   258 

   259 	enableSelection: function() {

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

   261 	}

   262 });

   263 

   264 $.extend( $.ui, {

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

   266 	plugin: {

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

   268 			var i,

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

   270 			for ( i in set ) {

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

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

   273 			}

   274 		},

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

   276 			var i,

   277 				set = instance.plugins[ name ];

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

   279 				return;

   280 			}

   281 

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

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

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

   285 				}

   286 			}

   287 		}

   288 	},

   289 

   290 	// only used by resizable

   291 	hasScroll: function( el, a ) {

   292 

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

   294 		if ( $( el ).css( "overflow" ) === "hidden") {

   295 			return false;

   296 		}

   297 

   298 		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",

   299 			has = false;

   300 

   301 		if ( el[ scroll ] > 0 ) {

   302 			return true;

   303 		}

   304 

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

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

   307 		// set the scroll

   308 		el[ scroll ] = 1;

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

   310 		el[ scroll ] = 0;

   311 		return has;

   312 	}

   313 });

   314 

   315 })( jQuery );

   316 (function( $, undefined ) {

   317 

   318 var uuid = 0,

   319 	slice = Array.prototype.slice,

   320 	_cleanData = $.cleanData;

   321 $.cleanData = function( elems ) {

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

   323 		try {

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

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

   326 		} catch( e ) {}

   327 	}

   328 	_cleanData( elems );

   329 };

   330 

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

   332 	var fullName, existingConstructor, constructor, basePrototype,

   333 		// proxiedPrototype allows the provided prototype to remain unmodified

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

   335 		proxiedPrototype = {},

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

   337 

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

   339 	fullName = namespace + "-" + name;

   340 

   341 	if ( !prototype ) {

   342 		prototype = base;

   343 		base = $.Widget;

   344 	}

   345 

   346 	// create selector for plugin

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

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

   349 	};

   350 

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

   352 	existingConstructor = $[ namespace ][ name ];

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

   354 		// allow instantiation without "new" keyword

   355 		if ( !this._createWidget ) {

   356 			return new constructor( options, element );

   357 		}

   358 

   359 		// allow instantiation without initializing for simple inheritance

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

   361 		if ( arguments.length ) {

   362 			this._createWidget( options, element );

   363 		}

   364 	};

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

   366 	$.extend( constructor, existingConstructor, {

   367 		version: prototype.version,

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

   369 		// redefine the widget later

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

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

   372 		// redefined after a widget inherits from it

   373 		_childConstructors: []

   374 	});

   375 

   376 	basePrototype = new base();

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

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

   379 	// inheriting from

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

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

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

   383 			proxiedPrototype[ prop ] = value;

   384 			return;

   385 		}

   386 		proxiedPrototype[ prop ] = (function() {

   387 			var _super = function() {

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

   389 				},

   390 				_superApply = function( args ) {

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

   392 				};

   393 			return function() {

   394 				var __super = this._super,

   395 					__superApply = this._superApply,

   396 					returnValue;

   397 

   398 				this._super = _super;

   399 				this._superApply = _superApply;

   400 

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

   402 

   403 				this._super = __super;

   404 				this._superApply = __superApply;

   405 

   406 				return returnValue;

   407 			};

   408 		})();

   409 	});

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

   411 		// TODO: remove support for widgetEventPrefix

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

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

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

   415 	}, proxiedPrototype, {

   416 		constructor: constructor,

   417 		namespace: namespace,

   418 		widgetName: name,

   419 		widgetFullName: fullName

   420 	});

   421 

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

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

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

   425 	// level in the prototype chain.

   426 	if ( existingConstructor ) {

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

   428 			var childPrototype = child.prototype;

   429 

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

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

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

   433 		});

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

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

   436 		delete existingConstructor._childConstructors;

   437 	} else {

   438 		base._childConstructors.push( constructor );

   439 	}

   440 

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

   442 };

   443 

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

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

   446 		inputIndex = 0,

   447 		inputLength = input.length,

   448 		key,

   449 		value;

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

   451 		for ( key in input[ inputIndex ] ) {

   452 			value = input[ inputIndex ][ key ];

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

   454 				// Clone objects

   455 				if ( $.isPlainObject( value ) ) {

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

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

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

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

   460 				// Copy everything else by reference

   461 				} else {

   462 					target[ key ] = value;

   463 				}

   464 			}

   465 		}

   466 	}

   467 	return target;

   468 };

   469 

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

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

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

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

   474 			args = slice.call( arguments, 1 ),

   475 			returnValue = this;

   476 

   477 		// allow multiple hashes to be passed on init

   478 		options = !isMethodCall && args.length ?

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

   480 			options;

   481 

   482 		if ( isMethodCall ) {

   483 			this.each(function() {

   484 				var methodValue,

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

   486 				if ( !instance ) {

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

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

   489 				}

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

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

   492 				}

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

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

   495 					returnValue = methodValue && methodValue.jquery ?

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

   497 						methodValue;

   498 					return false;

   499 				}

   500 			});

   501 		} else {

   502 			this.each(function() {

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

   504 				if ( instance ) {

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

   506 				} else {

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

   508 				}

   509 			});

   510 		}

   511 

   512 		return returnValue;

   513 	};

   514 };

   515 

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

   517 $.Widget._childConstructors = [];

   518 

   519 $.Widget.prototype = {

   520 	widgetName: "widget",

   521 	widgetEventPrefix: "",

   522 	defaultElement: "<div>",

   523 	options: {

   524 		disabled: false,

   525 

   526 		// callbacks

   527 		create: null

   528 	},

   529 	_createWidget: function( options, element ) {

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

   531 		this.element = $( element );

   532 		this.uuid = uuid++;

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

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

   535 			this.options,

   536 			this._getCreateOptions(),

   537 			options );

   538 

   539 		this.bindings = $();

   540 		this.hoverable = $();

   541 		this.focusable = $();

   542 

   543 		if ( element !== this ) {

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

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

   546 				remove: function( event ) {

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

   548 						this.destroy();

   549 					}

   550 				}

   551 			});

   552 			this.document = $( element.style ?

   553 				// element within the document

   554 				element.ownerDocument :

   555 				// element is window or document

   556 				element.document || element );

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

   558 		}

   559 

   560 		this._create();

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

   562 		this._init();

   563 	},

   564 	_getCreateOptions: $.noop,

   565 	_getCreateEventData: $.noop,

   566 	_create: $.noop,

   567 	_init: $.noop,

   568 

   569 	destroy: function() {

   570 		this._destroy();

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

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

   573 		this.element

   574 			.unbind( this.eventNamespace )

   575 			// 1.9 BC for #7810

   576 			// TODO remove dual storage

   577 			.removeData( this.widgetName )

   578 			.removeData( this.widgetFullName )

   579 			// support: jquery <1.6.3

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

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

   582 		this.widget()

   583 			.unbind( this.eventNamespace )

   584 			.removeAttr( "aria-disabled" )

   585 			.removeClass(

   586 				this.widgetFullName + "-disabled " +

   587 				"ui-state-disabled" );

   588 

   589 		// clean up events and states

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

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

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

   593 	},

   594 	_destroy: $.noop,

   595 

   596 	widget: function() {

   597 		return this.element;

   598 	},

   599 

   600 	option: function( key, value ) {

   601 		var options = key,

   602 			parts,

   603 			curOption,

   604 			i;

   605 

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

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

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

   609 		}

   610 

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

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

   613 			options = {};

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

   615 			key = parts.shift();

   616 			if ( parts.length ) {

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

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

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

   620 					curOption = curOption[ parts[ i ] ];

   621 				}

   622 				key = parts.pop();

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

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

   625 				}

   626 				curOption[ key ] = value;

   627 			} else {

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

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

   630 				}

   631 				options[ key ] = value;

   632 			}

   633 		}

   634 

   635 		this._setOptions( options );

   636 

   637 		return this;

   638 	},

   639 	_setOptions: function( options ) {

   640 		var key;

   641 

   642 		for ( key in options ) {

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

   644 		}

   645 

   646 		return this;

   647 	},

   648 	_setOption: function( key, value ) {

   649 		this.options[ key ] = value;

   650 

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

   652 			this.widget()

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

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

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

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

   657 		}

   658 

   659 		return this;

   660 	},

   661 

   662 	enable: function() {

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

   664 	},

   665 	disable: function() {

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

   667 	},

   668 

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

   670 		var delegateElement,

   671 			instance = this;

   672 

   673 		// no suppressDisabledCheck flag, shuffle arguments

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

   675 			handlers = element;

   676 			element = suppressDisabledCheck;

   677 			suppressDisabledCheck = false;

   678 		}

   679 

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

   681 		if ( !handlers ) {

   682 			handlers = element;

   683 			element = this.element;

   684 			delegateElement = this.widget();

   685 		} else {

   686 			// accept selectors, DOM elements

   687 			element = delegateElement = $( element );

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

   689 		}

   690 

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

   692 			function handlerProxy() {

   693 				// allow widgets to customize the disabled handling

   694 				// - disabled as an array instead of boolean

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

   696 				if ( !suppressDisabledCheck &&

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

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

   699 					return;

   700 				}

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

   702 					.apply( instance, arguments );

   703 			}

   704 

   705 			// copy the guid so direct unbinding works

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

   707 				handlerProxy.guid = handler.guid =

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

   709 			}

   710 

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

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

   713 				selector = match[2];

   714 			if ( selector ) {

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

   716 			} else {

   717 				element.bind( eventName, handlerProxy );

   718 			}

   719 		});

   720 	},

   721 

   722 	_off: function( element, eventName ) {

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

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

   725 	},

   726 

   727 	_delay: function( handler, delay ) {

   728 		function handlerProxy() {

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

   730 				.apply( instance, arguments );

   731 		}

   732 		var instance = this;

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

   734 	},

   735 

   736 	_hoverable: function( element ) {

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

   738 		this._on( element, {

   739 			mouseenter: function( event ) {

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

   741 			},

   742 			mouseleave: function( event ) {

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

   744 			}

   745 		});

   746 	},

   747 

   748 	_focusable: function( element ) {

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

   750 		this._on( element, {

   751 			focusin: function( event ) {

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

   753 			},

   754 			focusout: function( event ) {

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

   756 			}

   757 		});

   758 	},

   759 

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

   761 		var prop, orig,

   762 			callback = this.options[ type ];

   763 

   764 		data = data || {};

   765 		event = $.Event( event );

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

   767 			type :

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

   769 		// the original event may come from any element

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

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

   772 

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

   774 		orig = event.originalEvent;

   775 		if ( orig ) {

   776 			for ( prop in orig ) {

   777 				if ( !( prop in event ) ) {

   778 					event[ prop ] = orig[ prop ];

   779 				}

   780 			}

   781 		}

   782 

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

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

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

   786 			event.isDefaultPrevented() );

   787 	}

   788 };

   789 

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

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

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

   793 			options = { effect: options };

   794 		}

   795 		var hasOptions,

   796 			effectName = !options ?

   797 				method :

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

   799 					defaultEffect :

   800 					options.effect || defaultEffect;

   801 		options = options || {};

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

   803 			options = { duration: options };

   804 		}

   805 		hasOptions = !$.isEmptyObject( options );

   806 		options.complete = callback;

   807 		if ( options.delay ) {

   808 			element.delay( options.delay );

   809 		}

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

   811 			element[ method ]( options );

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

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

   814 		} else {

   815 			element.queue(function( next ) {

   816 				$( this )[ method ]();

   817 				if ( callback ) {

   818 					callback.call( element[ 0 ] );

   819 				}

   820 				next();

   821 			});

   822 		}

   823 	};

   824 });

   825 

   826 })( jQuery );

   827 (function( $, undefined ) {

   828 

   829 var mouseHandled = false;

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

   831 	mouseHandled = false;

   832 });

   833 

   834 $.widget("ui.mouse", {

   835 	version: "1.10.4",

   836 	options: {

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

   838 		distance: 1,

   839 		delay: 0

   840 	},

   841 	_mouseInit: function() {

   842 		var that = this;

   843 

   844 		this.element

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

   846 				return that._mouseDown(event);

   847 			})

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

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

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

   851 					event.stopImmediatePropagation();

   852 					return false;

   853 				}

   854 			});

   855 

   856 		this.started = false;

   857 	},

   858 

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

   860 	// other instances of mouse

   861 	_mouseDestroy: function() {

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

   863 		if ( this._mouseMoveDelegate ) {

   864 			$(document)

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

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

   867 		}

   868 	},

   869 

   870 	_mouseDown: function(event) {

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

   872 		if( mouseHandled ) { return; }

   873 

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

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

   876 

   877 		this._mouseDownEvent = event;

   878 

   879 		var that = this,

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

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

   882 			// disabled inputs (#7620)

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

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

   885 			return true;

   886 		}

   887 

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

   889 		if (!this.mouseDelayMet) {

   890 			this._mouseDelayTimer = setTimeout(function() {

   891 				that.mouseDelayMet = true;

   892 			}, this.options.delay);

   893 		}

   894 

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

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

   897 			if (!this._mouseStarted) {

   898 				event.preventDefault();

   899 				return true;

   900 			}

   901 		}

   902 

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

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

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

   906 		}

   907 

   908 		// these delegates are required to keep context

   909 		this._mouseMoveDelegate = function(event) {

   910 			return that._mouseMove(event);

   911 		};

   912 		this._mouseUpDelegate = function(event) {

   913 			return that._mouseUp(event);

   914 		};

   915 		$(document)

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

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

   918 

   919 		event.preventDefault();

   920 

   921 		mouseHandled = true;

   922 		return true;

   923 	},

   924 

   925 	_mouseMove: function(event) {

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

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

   928 			return this._mouseUp(event);

   929 		}

   930 

   931 		if (this._mouseStarted) {

   932 			this._mouseDrag(event);

   933 			return event.preventDefault();

   934 		}

   935 

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

   937 			this._mouseStarted =

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

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

   940 		}

   941 

   942 		return !this._mouseStarted;

   943 	},

   944 

   945 	_mouseUp: function(event) {

   946 		$(document)

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

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

   949 

   950 		if (this._mouseStarted) {

   951 			this._mouseStarted = false;

   952 

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

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

   955 			}

   956 

   957 			this._mouseStop(event);

   958 		}

   959 

   960 		return false;

   961 	},

   962 

   963 	_mouseDistanceMet: function(event) {

   964 		return (Math.max(

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

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

   967 			) >= this.options.distance

   968 		);

   969 	},

   970 

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

   972 		return this.mouseDelayMet;

   973 	},

   974 

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

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

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

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

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

   980 });

   981 

   982 })(jQuery);

   983 (function( $, undefined ) {

   984 

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

   986 

   987 var cachedScrollbarWidth,

   988 	max = Math.max,

   989 	abs = Math.abs,

   990 	round = Math.round,

   991 	rhorizontal = /left|center|right/,

   992 	rvertical = /top|center|bottom/,

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

   994 	rposition = /^\w+/,

   995 	rpercent = /%$/,

   996 	_position = $.fn.position;

   997 

   998 function getOffsets( offsets, width, height ) {

   999 	return [

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

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

  1002 	];

  1003 }

  1004 

  1005 function parseCss( element, property ) {

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

  1007 }

  1008 

  1009 function getDimensions( elem ) {

  1010 	var raw = elem[0];

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

  1012 		return {

  1013 			width: elem.width(),

  1014 			height: elem.height(),

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

  1016 		};

  1017 	}

  1018 	if ( $.isWindow( raw ) ) {

  1019 		return {

  1020 			width: elem.width(),

  1021 			height: elem.height(),

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

  1023 		};

  1024 	}

  1025 	if ( raw.preventDefault ) {

  1026 		return {

  1027 			width: 0,

  1028 			height: 0,

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

  1030 		};

  1031 	}

  1032 	return {

  1033 		width: elem.outerWidth(),

  1034 		height: elem.outerHeight(),

  1035 		offset: elem.offset()

  1036 	};

  1037 }

  1038 

  1039 $.position = {

  1040 	scrollbarWidth: function() {

  1041 		if ( cachedScrollbarWidth !== undefined ) {

  1042 			return cachedScrollbarWidth;

  1043 		}

  1044 		var w1, w2,

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

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

  1047 

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

  1049 		w1 = innerDiv.offsetWidth;

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

  1051 

  1052 		w2 = innerDiv.offsetWidth;

  1053 

  1054 		if ( w1 === w2 ) {

  1055 			w2 = div[0].clientWidth;

  1056 		}

  1057 

  1058 		div.remove();

  1059 

  1060 		return (cachedScrollbarWidth = w1 - w2);

  1061 	},

  1062 	getScrollInfo: function( within ) {

  1063 		var overflowX = within.isWindow || within.isDocument ? "" :

  1064 				within.element.css( "overflow-x" ),

  1065 			overflowY = within.isWindow || within.isDocument ? "" :

  1066 				within.element.css( "overflow-y" ),

  1067 			hasOverflowX = overflowX === "scroll" ||

  1068 				( overflowX === "auto" && within.width < within.element[0].scrollWidth ),

  1069 			hasOverflowY = overflowY === "scroll" ||

  1070 				( overflowY === "auto" && within.height < within.element[0].scrollHeight );

  1071 		return {

  1072 			width: hasOverflowY ? $.position.scrollbarWidth() : 0,

  1073 			height: hasOverflowX ? $.position.scrollbarWidth() : 0

  1074 		};

  1075 	},

  1076 	getWithinInfo: function( element ) {

  1077 		var withinElement = $( element || window ),

  1078 			isWindow = $.isWindow( withinElement[0] ),

  1079 			isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;

  1080 		return {

  1081 			element: withinElement,

  1082 			isWindow: isWindow,

  1083 			isDocument: isDocument,

  1084 			offset: withinElement.offset() || { left: 0, top: 0 },

  1085 			scrollLeft: withinElement.scrollLeft(),

  1086 			scrollTop: withinElement.scrollTop(),

  1087 			width: isWindow ? withinElement.width() : withinElement.outerWidth(),

  1088 			height: isWindow ? withinElement.height() : withinElement.outerHeight()

  1089 		};

  1090 	}

  1091 };

  1092 

  1093 $.fn.position = function( options ) {

  1094 	if ( !options || !options.of ) {

  1095 		return _position.apply( this, arguments );

  1096 	}

  1097 

  1098 	// make a copy, we don't want to modify arguments

  1099 	options = $.extend( {}, options );

  1100 

  1101 	var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,

  1102 		target = $( options.of ),

  1103 		within = $.position.getWithinInfo( options.within ),

  1104 		scrollInfo = $.position.getScrollInfo( within ),

  1105 		collision = ( options.collision || "flip" ).split( " " ),

  1106 		offsets = {};

  1107 

  1108 	dimensions = getDimensions( target );

  1109 	if ( target[0].preventDefault ) {

  1110 		// force left top to allow flipping

  1111 		options.at = "left top";

  1112 	}

  1113 	targetWidth = dimensions.width;

  1114 	targetHeight = dimensions.height;

  1115 	targetOffset = dimensions.offset;

  1116 	// clone to reuse original targetOffset later

  1117 	basePosition = $.extend( {}, targetOffset );

  1118 

  1119 	// force my and at to have valid horizontal and vertical positions

  1120 	// if a value is missing or invalid, it will be converted to center

  1121 	$.each( [ "my", "at" ], function() {

  1122 		var pos = ( options[ this ] || "" ).split( " " ),

  1123 			horizontalOffset,

  1124 			verticalOffset;

  1125 

  1126 		if ( pos.length === 1) {

  1127 			pos = rhorizontal.test( pos[ 0 ] ) ?

  1128 				pos.concat( [ "center" ] ) :

  1129 				rvertical.test( pos[ 0 ] ) ?

  1130 					[ "center" ].concat( pos ) :

  1131 					[ "center", "center" ];

  1132 		}

  1133 		pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";

  1134 		pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";

  1135