https://www.abateb42late.com/scripts/PatternSeven/jquery-ui.js

1/*! jQuery UI - v1.11.0 - 2014-08-03
2* http://jqueryui.com
3* Includes: core.js, widget.js, tabs.js
4* Copyright 2014 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.0
19 * http://jqueryui.com
20 *
21 * Copyright 2014 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.0",
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() {
58		var position = this.css( "position" ),
59			excludeStaticParent = position === "absolute",
60			scrollParent = this.parents().filter( function() {
61				var parent = $( this );
62				if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
63					return false;
64				}
65				return (/(auto|scroll)/).test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );
66			}).eq( 0 );
67
68		return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
69	},
70
71	uniqueId: (function() {
72		var uuid = 0;
73
74		return function() {
75			return this.each(function() {
76				if ( !this.id ) {
77					this.id = "ui-id-" + ( ++uuid );
78				}
79			});
80		};
81	})(),
82
83	removeUniqueId: function() {
84		return this.each(function() {
85			if ( /^ui-id-\d+$/.test( this.id ) ) {
86				$( this ).removeAttr( "id" );
87			}
88		});
89	}
90});
91
92// selectors
93function focusable( element, isTabIndexNotNaN ) {
94	var map, mapName, img,
95		nodeName = element.nodeName.toLowerCase();
96	if ( "area" === nodeName ) {
97		map = element.parentNode;
98		mapName = map.name;
99		if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
100			return false;
101		}
102		img = $( "img[usemap=#" + mapName + "]" )[0];
103		return !!img && visible( img );
104	}
105	return ( /input|select|textarea|button|object/.test( nodeName ) ?
106		!element.disabled :
107		"a" === nodeName ?
108			element.href || isTabIndexNotNaN :
109			isTabIndexNotNaN) &&
110		// the element and all of its ancestors must be visible
111		visible( element );
112}
113
114function visible( element ) {
115	return $.expr.filters.visible( element ) &&
116		!$( element ).parents().addBack().filter(function() {
117			return $.css( this, "visibility" ) === "hidden";
118		}).length;
119}
120
121$.extend( $.expr[ ":" ], {
122	data: $.expr.createPseudo ?
123		$.expr.createPseudo(function( dataName ) {
124			return function( elem ) {
125				return !!$.data( elem, dataName );
126			};
127		}) :
128		// support: jQuery <1.8
129		function( elem, i, match ) {
130			return !!$.data( elem, match[ 3 ] );
131		},
132
133	focusable: function( element ) {
134		return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
135	},
136
137	tabbable: function( element ) {
138		var tabIndex = $.attr( element, "tabindex" ),
139			isTabIndexNaN = isNaN( tabIndex );
140		return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
141	}
142});
143
144// support: jQuery <1.8
145if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
146	$.each( [ "Width", "Height" ], function( i, name ) {
147		var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
148			type = name.toLowerCase(),
149			orig = {
150				innerWidth: $.fn.innerWidth,
151				innerHeight: $.fn.innerHeight,
152				outerWidth: $.fn.outerWidth,
153				outerHeight: $.fn.outerHeight
154			};
155
156		function reduce( elem, size, border, margin ) {
157			$.each( side, function() {
158				size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
159				if ( border ) {
160					size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
161				}
162				if ( margin ) {
163					size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
164				}
165			});
166			return size;
167		}
168
169		$.fn[ "inner" + name ] = function( size ) {
170			if ( size === undefined ) {
171				return orig[ "inner" + name ].call( this );
172			}
173
174			return this.each(function() {
175				$( this ).css( type, reduce( this, size ) + "px" );
176			});
177		};
178
179		$.fn[ "outer" + name] = function( size, margin ) {
180			if ( typeof size !== "number" ) {
181				return orig[ "outer" + name ].call( this, size );
182			}
183
184			return this.each(function() {
185				$( this).css( type, reduce( this, size, true, margin ) + "px" );
186			});
187		};
188	});
189}
190
191// support: jQuery <1.8
192if ( !$.fn.addBack ) {
193	$.fn.addBack = function( selector ) {
194		return this.add( selector == null ?
195			this.prevObject : this.prevObject.filter( selector )
196		);
197	};
198}
199
200// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
201if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
202	$.fn.removeData = (function( removeData ) {
203		return function( key ) {
204			if ( arguments.length ) {
205				return removeData.call( this, $.camelCase( key ) );
206			} else {
207				return removeData.call( this );
208			}
209		};
210	})( $.fn.removeData );
211}
212
213// deprecated
214$.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
215
216$.fn.extend({
217	focus: (function( orig ) {
218		return function( delay, fn ) {
219			return typeof delay === "number" ?
220				this.each(function() {
221					var elem = this;
222					setTimeout(function() {
223						$( elem ).focus();
224						if ( fn ) {
225							fn.call( elem );
226						}
227					}, delay );
228				}) :
229				orig.apply( this, arguments );
230		};
231	})( $.fn.focus ),
232
233	disableSelection: (function() {
234		var eventType = "onselectstart" in document.createElement( "div" ) ?
235			"selectstart" :
236			"mousedown";
237
238		return function() {
239			return this.bind( eventType + ".ui-disableSelection", function( event ) {
240				event.preventDefault();
241			});
242		};
243	})(),
244
245	enableSelection: function() {
246		return this.unbind( ".ui-disableSelection" );
247	},
248
249	zIndex: function( zIndex ) {
250		if ( zIndex !== undefined ) {
251			return this.css( "zIndex", zIndex );
252		}
253
254		if ( this.length ) {
255			var elem = $( this[ 0 ] ), position, value;
256			while ( elem.length && elem[ 0 ] !== document ) {
257				// Ignore z-index if position is set to a value where z-index is ignored by the browser
258				// This makes behavior of this function consistent across browsers
259				// WebKit always returns auto if the element is positioned
260				position = elem.css( "position" );
261				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
262					// IE returns 0 when zIndex is not specified
263					// other browsers return a string
264					// we ignore the case of nested elements with an explicit value of 0
265					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
266					value = parseInt( elem.css( "zIndex" ), 10 );
267					if ( !isNaN( value ) && value !== 0 ) {
268						return value;
269					}
270				}
271				elem = elem.parent();
272			}
273		}
274
275		return 0;
276	}
277});
278
279// $.ui.plugin is deprecated. Use $.widget() extensions instead.
280$.ui.plugin = {
281	add: function( module, option, set ) {
282		var i,
283			proto = $.ui[ module ].prototype;
284		for ( i in set ) {
285			proto.plugins[ i ] = proto.plugins[ i ] || [];
286			proto.plugins[ i ].push( [ option, set[ i ] ] );
287		}
288	},
289	call: function( instance, name, args, allowDisconnected ) {
290		var i,
291			set = instance.plugins[ name ];
292
293		if ( !set ) {
294			return;
295		}
296
297		if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
298			return;
299		}
300
301		for ( i = 0; i < set.length; i++ ) {
302			if ( instance.options[ set[ i ][ 0 ] ] ) {
303				set[ i ][ 1 ].apply( instance.element, args );
304			}
305		}
306	}
307};
308
309
310/*!
311 * jQuery UI Widget 1.11.0
312 * http://jqueryui.com
313 *
314 * Copyright 2014 jQuery Foundation and other contributors
315 * Released under the MIT license.
316 * http://jquery.org/license
317 *
318 * http://api.jqueryui.com/jQuery.widget/
319 */
320
321
322var widget_uuid = 0,
323	widget_slice = Array.prototype.slice;
324
325$.cleanData = (function( orig ) {
326	return function( elems ) {
327		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
328			try {
329				$( elem ).triggerHandler( "remove" );
330			// http://bugs.jquery.com/ticket/8235
331			} catch( e ) {}
332		}
333		orig( elems );
334	};
335})( $.cleanData );
336
337$.widget = function( name, base, prototype ) {
338	var fullName, existingConstructor, constructor, basePrototype,
339		// proxiedPrototype allows the provided prototype to remain unmodified
340		// so that it can be used as a mixin for multiple widgets (#8876)
341		proxiedPrototype = {},
342		namespace = name.split( "." )[ 0 ];
343
344	name = name.split( "." )[ 1 ];
345	fullName = namespace + "-" + name;
346
347	if ( !prototype ) {
348		prototype = base;
349		base = $.Widget;
350	}
351
352	// create selector for plugin
353	$.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
354		return !!$.data( elem, fullName );
355	};
356
357	$[ namespace ] = $[ namespace ] || {};
358	existingConstructor = $[ namespace ][ name ];
359	constructor = $[ namespace ][ name ] = function( options, element ) {
360		// allow instantiation without "new" keyword
361		if ( !this._createWidget ) {
362			return new constructor( options, element );
363		}
364
365		// allow instantiation without initializing for simple inheritance
366		// must use "new" keyword (the code above always passes args)
367		if ( arguments.length ) {
368			this._createWidget( options, element );
369		}
370	};
371	// extend with the existing constructor to carry over any static properties
372	$.extend( constructor, existingConstructor, {
373		version: prototype.version,
374		// copy the object used to create the prototype in case we need to
375		// redefine the widget later
376		_proto: $.extend( {}, prototype ),
377		// track widgets that inherit from this widget in case this widget is
378		// redefined after a widget inherits from it
379		_childConstructors: []
380	});
381
382	basePrototype = new base();
383	// we need to make the options hash a property directly on the new instance
384	// otherwise we'll modify the options hash on the prototype that we're
385	// inheriting from
386	basePrototype.options = $.widget.extend( {}, basePrototype.options );
387	$.each( prototype, function( prop, value ) {
388		if ( !$.isFunction( value ) ) {
389			proxiedPrototype[ prop ] = value;
390			return;
391		}
392		proxiedPrototype[ prop ] = (function() {
393			var _super = function() {
394					return base.prototype[ prop ].apply( this, arguments );
395				},
396				_superApply = function( args ) {
397					return base.prototype[ prop ].apply( this, args );
398				};
399			return function() {
400				var __super = this._super,
401					__superApply = this._superApply,
402					returnValue;
403
404				this._super = _super;
405				this._superApply = _superApply;
406
407				returnValue = value.apply( this, arguments );
408
409				this._super = __super;
410				this._superApply = __superApply;
411
412				return returnValue;
413			};
414		})();
415	});
416	constructor.prototype = $.widget.extend( basePrototype, {
417		// TODO: remove support for widgetEventPrefix
418		// always use the name + a colon as the prefix, e.g., draggable:start
419		// don't prefix for widgets that aren't DOM-based
420		widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
421	}, proxiedPrototype, {
422		constructor: constructor,
423		namespace: namespace,
424		widgetName: name,
425		widgetFullName: fullName
426	});
427
428	// If this widget is being redefined then we need to find all widgets that
429	// are inheriting from it and redefine all of them so that they inherit from
430	// the new version of this widget. We're essentially trying to replace one
431	// level in the prototype chain.
432	if ( existingConstructor ) {
433		$.each( existingConstructor._childConstructors, function( i, child ) {
434			var childPrototype = child.prototype;
435
436			// redefine the child widget using the same prototype that was
437			// originally used, but inherit from the new version of the base
438			$.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
439		});
440		// remove the list of existing child constructors from the old constructor
441		// so the old child constructors can be garbage collected
442		delete existingConstructor._childConstructors;
443	} else {
444		base._childConstructors.push( constructor );
445	}
446
447	$.widget.bridge( name, constructor );
448
449	return constructor;
450};
451
452$.widget.extend = function( target ) {
453	var input = widget_slice.call( arguments, 1 ),
454		inputIndex = 0,
455		inputLength = input.length,
456		key,
457		value;
458	for ( ; inputIndex < inputLength; inputIndex++ ) {
459		for ( key in input[ inputIndex ] ) {
460			value = input[ inputIndex ][ key ];
461			if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
462				// Clone objects
463				if ( $.isPlainObject( value ) ) {
464					target[ key ] = $.isPlainObject( target[ key ] ) ?
465						$.widget.extend( {}, target[ key ], value ) :
466						// Don't extend strings, arrays, etc. with objects
467						$.widget.extend( {}, value );
468				// Copy everything else by reference
469				} else {
470					target[ key ] = value;
471				}
472			}
473		}
474	}
475	return target;
476};
477
478$.widget.bridge = function( name, object ) {
479	var fullName = object.prototype.widgetFullName || name;
480	$.fn[ name ] = function( options ) {
481		var isMethodCall = typeof options === "string",
482			args = widget_slice.call( arguments, 1 ),
483			returnValue = this;
484
485		// allow multiple hashes to be passed on init
486		options = !isMethodCall && args.length ?
487			$.widget.extend.apply( null, [ options ].concat(args) ) :
488			options;
489
490		if ( isMethodCall ) {
491			this.each(function() {
492				var methodValue,
493					instance = $.data( this, fullName );
494				if ( options === "instance" ) {
495					returnValue = instance;
496					return false;
497				}
498				if ( !instance ) {
499					return $.error( "cannot call methods on " + name + " prior to initialization; " +
500						"attempted to call method '" + options + "'" );
501				}
502				if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
503					return $.error( "no such method '" + options + "' for " + name + " widget instance" );
504				}
505				methodValue = instance[ options ].apply( instance, args );
506				if ( methodValue !== instance && methodValue !== undefined ) {
507					returnValue = methodValue && methodValue.jquery ?
508						returnValue.pushStack( methodValue.get() ) :
509						methodValue;
510					return false;
511				}
512			});
513		} else {
514			this.each(function() {
515				var instance = $.data( this, fullName );
516				if ( instance ) {
517					instance.option( options || {} );
518					if ( instance._init ) {
519						instance._init();
520					}
521				} else {
522					$.data( this, fullName, new object( options, this ) );
523				}
524			});
525		}
526
527		return returnValue;
528	};
529};
530
531$.Widget = function( /* options, element */ ) {};
532$.Widget._childConstructors = [];
533
534$.Widget.prototype = {
535	widgetName: "widget",
536	widgetEventPrefix: "",
537	defaultElement: "<div>",
538	options: {
539		disabled: false,
540
541		// callbacks
542		create: null
543	},
544	_createWidget: function( options, element ) {
545		element = $( element || this.defaultElement || this )[ 0 ];
546		this.element = $( element );
547		this.uuid = widget_uuid++;
548		this.eventNamespace = "." + this.widgetName + this.uuid;
549		this.options = $.widget.extend( {},
550			this.options,
551			this._getCreateOptions(),
552			options );
553
554		this.bindings = $();
555		this.hoverable = $();
556		this.focusable = $();
557
558		if ( element !== this ) {
559			$.data( element, this.widgetFullName, this );
560			this._on( true, this.element, {
561				remove: function( event ) {
562					if ( event.target === element ) {
563						this.destroy();
564					}
565				}
566			});
567			this.document = $( element.style ?
568				// element within the document
569				element.ownerDocument :
570				// element is window or document
571				element.document || element );
572			this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
573		}
574
575		this._create();
576		this._trigger( "create", null, this._getCreateEventData() );
577		this._init();
578	},
579	_getCreateOptions: $.noop,
580	_getCreateEventData: $.noop,
581	_create: $.noop,
582	_init: $.noop,
583
584	destroy: function() {
585		this._destroy();
586		// we can probably remove the unbind calls in 2.0
587		// all event bindings should go through this._on()
588		this.element
589			.unbind( this.eventNamespace )
590			.removeData( this.widgetFullName )
591			// support: jquery <1.6.3
592			// http://bugs.jquery.com/ticket/9413
593			.removeData( $.camelCase( this.widgetFullName ) );
594		this.widget()
595			.unbind( this.eventNamespace )
596			.removeAttr( "aria-disabled" )
597			.removeClass(
598				this.widgetFullName + "-disabled " +
599				"ui-state-disabled" );
600
601		// clean up events and states
602		this.bindings.unbind( this.eventNamespace );
603		this.hoverable.removeClass( "ui-state-hover" );
604		this.focusable.removeClass( "ui-state-focus" );
605	},
606	_destroy: $.noop,
607
608	widget: function() {
609		return this.element;
610	},
611
612	option: function( key, value ) {
613		var options = key,
614			parts,
615			curOption,
616			i;
617
618		if ( arguments.length === 0 ) {
619			// don't return a reference to the internal hash
620			return $.widget.extend( {}, this.options );
621		}
622
623		if ( typeof key === "string" ) {
624			// handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
625			options = {};
626			parts = key.split( "." );
627			key = parts.shift();
628			if ( parts.length ) {
629				curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
630				for ( i = 0; i < parts.length - 1; i++ ) {
631					curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
632					curOption = curOption[ parts[ i ] ];
633				}
634				key = parts.pop();
635				if ( arguments.length === 1 ) {
636					return curOption[ key ] === undefined ? null : curOption[ key ];
637				}
638				curOption[ key ] = value;
639			} else {
640				if ( arguments.length === 1 ) {
641					return this.options[ key ] === undefined ? null : this.options[ key ];
642				}
643				options[ key ] = value;
644			}
645		}
646
647		this._setOptions( options );
648
649		return this;
650	},
651	_setOptions: function( options ) {
652		var key;
653
654		for ( key in options ) {
655			this._setOption( key, options[ key ] );
656		}
657
658		return this;
659	},
660	_setOption: function( key, value ) {
661		this.options[ key ] = value;
662
663		if ( key === "disabled" ) {
664			this.widget()
665				.toggleClass( this.widgetFullName + "-disabled", !!value );
666
667			// If the widget is becoming disabled, then nothing is interactive
668			if ( value ) {
669				this.hoverable.removeClass( "ui-state-hover" );
670				this.focusable.removeClass( "ui-state-focus" );
671			}
672		}
673
674		return this;
675	},
676
677	enable: function() {
678		return this._setOptions({ disabled: false });
679	},
680	disable: function() {
681		return this._setOptions({ disabled: true });
682	},
683
684	_on: function( suppressDisabledCheck, element, handlers ) {
685		var delegateElement,
686			instance = this;
687
688		// no suppressDisabledCheck flag, shuffle arguments
689		if ( typeof suppressDisabledCheck !== "boolean" ) {
690			handlers = element;
691			element = suppressDisabledCheck;
692			suppressDisabledCheck = false;
693		}
694
695		// no element argument, shuffle and use this.element
696		if ( !handlers ) {
697			handlers = element;
698			element = this.element;
699			delegateElement = this.widget();
700		} else {
701			element = delegateElement = $( element );
702			this.bindings = this.bindings.add( element );
703		}
704
705		$.each( handlers, function( event, handler ) {
706			function handlerProxy() {
707				// allow widgets to customize the disabled handling
708				// - disabled as an array instead of boolean
709				// - disabled class as method for disabling individual parts
710				if ( !suppressDisabledCheck &&
711						( instance.options.disabled === true ||
712							$( this ).hasClass( "ui-state-disabled" ) ) ) {
713					return;
714				}
715				return ( typeof handler === "string" ? instance[ handler ] : handler )
716					.apply( instance, arguments );
717			}
718
719			// copy the guid so direct unbinding works
720			if ( typeof handler !== "string" ) {
721				handlerProxy.guid = handler.guid =
722					handler.guid || handlerProxy.guid || $.guid++;
723			}
724
725			var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
726				eventName = match[1] + instance.eventNamespace,
727				selector = match[2];
728			if ( selector ) {
729				delegateElement.delegate( selector, eventName, handlerProxy );
730			} else {
731				element.bind( eventName, handlerProxy );
732			}
733		});
734	},
735
736	_off: function( element, eventName ) {
737		eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) + this.eventNamespace;
738		element.unbind( eventName ).undelegate( eventName );
739	},
740
741	_delay: function( handler, delay ) {
742		function handlerProxy() {
743			return ( typeof handler === "string" ? instance[ handler ] : handler )
744				.apply( instance, arguments );
745		}
746		var instance = this;
747		return setTimeout( handlerProxy, delay || 0 );
748	},
749
750	_hoverable: function( element ) {
751		this.hoverable = this.hoverable.add( element );
752		this._on( element, {
753			mouseenter: function( event ) {
754				$( event.currentTarget ).addClass( "ui-state-hover" );
755			},
756			mouseleave: function( event ) {
757				$( event.currentTarget ).removeClass( "ui-state-hover" );
758			}
759		});
760	},
761
762	_focusable: function( element ) {
763		this.focusable = this.focusable.add( element );
764		this._on( element, {
765			focusin: function( event ) {
766				$( event.currentTarget ).addClass( "ui-state-focus" );
767			},
768			focusout: function( event ) {
769				$( event.currentTarget ).removeClass( "ui-state-focus" );
770			}
771		});
772	},
773
774	_trigger: function( type, event, data ) {
775		var prop, orig,
776			callback = this.options[ type ];
777
778		data = data || {};
779		event = $.Event( event );
780		event.type = ( type === this.widgetEventPrefix ?
781			type :
782			this.widgetEventPrefix + type ).toLowerCase();
783		// the original event may come from any element
784		// so we need to reset the target on the new event
785		event.target = this.element[ 0 ];
786
787		// copy original event properties over to the new event
788		orig = event.originalEvent;
789		if ( orig ) {
790			for ( prop in orig ) {
791				if ( !( prop in event ) ) {
792					event[ prop ] = orig[ prop ];
793				}
794			}
795		}
796
797		this.element.trigger( event, data );
798		return !( $.isFunction( callback ) &&
799			callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
800			event.isDefaultPrevented() );
801	}
802};
803
804$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
805	$.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
806		if ( typeof options === "string" ) {
807			options = { effect: options };
808		}
809		var hasOptions,
810			effectName = !options ?
811				method :
812				options === true || typeof options === "number" ?
813					defaultEffect :
814					options.effect || defaultEffect;
815		options = options || {};
816		if ( typeof options === "number" ) {
817			options = { duration: options };
818		}
819		hasOptions = !$.isEmptyObject( options );
820		options.complete = callback;
821		if ( options.delay ) {
822			element.delay( options.delay );
823		}
824		if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
825			element[ method ]( options );
826		} else if ( effectName !== method && element[ effectName ] ) {
827			element[ effectName ]( options.duration, options.easing, callback );
828		} else {
829			element.queue(function( next ) {
830				$( this )[ method ]();
831				if ( callback ) {
832					callback.call( element[ 0 ] );
833				}
834				next();
835			});
836		}
837	};
838});
839
840var widget = $.widget;
841
842
843/*!
844 * jQuery UI Tabs 1.11.0
845 * http://jqueryui.com
846 *
847 * Copyright 2014 jQuery Foundation and other contributors
848 * Released under the MIT license.
849 * http://jquery.org/license
850 *
851 * http://api.jqueryui.com/tabs/
852 */
853
854
855var tabs = $.widget( "ui.tabs", {
856	version: "1.11.0",
857	delay: 300,
858	options: {
859		active: null,
860		collapsible: false,
861		event: "click",
862		heightStyle: "content",
863		hide: null,
864		show: null,
865
866		// callbacks
867		activate: null,
868		beforeActivate: null,
869		beforeLoad: null,
870		load: null
871	},
872
873	_isLocal: (function() {
874		var rhash = /#.*$/;
875
876		return function( anchor ) {
877			var anchorUrl, locationUrl;
878
879			// support: IE7
880			// IE7 doesn't normalize the href property when set via script (#9317)
881			anchor = anchor.cloneNode( false );
882
883			anchorUrl = anchor.href.replace( rhash, "" );
884			locationUrl = location.href.replace( rhash, "" );
885
886			// decoding may throw an error if the URL isn't UTF-8 (#9518)
887			try {
888				anchorUrl = decodeURIComponent( anchorUrl );
889			} catch ( error ) {}
890			try {
891				locationUrl = decodeURIComponent( locationUrl );
892			} catch ( error ) {}
893
894			return anchor.hash.length > 1 && anchorUrl === locationUrl;
895		};
896	})(),
897
898	_create: function() {
899		var that = this,
900			options = this.options;
901
902		this.running = false;
903
904		this.element
905			.addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
906			.toggleClass( "ui-tabs-collapsible", options.collapsible )
907			// Prevent users from focusing disabled tabs via click
908			.delegate( ".ui-tabs-nav > li", "mousedown" + this.eventNamespace, function( event ) {
909				if ( $( this ).is( ".ui-state-disabled" ) ) {
910					event.preventDefault();
911				}
912			})
913			// support: IE <9
914			// Preventing the default action in mousedown doesn't prevent IE
915			// from focusing the element, so if the anchor gets focused, blur.
916			// We don't have to worry about focusing the previously focused
917			// element since clicking on a non-focusable element should focus
918			// the body anyway.
919			.delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
920				if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
921					this.blur();
922				}
923			});
924
925		this._processTabs();
926		options.active = this._initialActive();
927
928		// Take disabling tabs via class attribute from HTML
929		// into account and update option properly.
930		if ( $.isArray( options.disabled ) ) {
931			options.disabled = $.unique( options.disabled.concat(
932				$.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
933					return that.tabs.index( li );
934				})
935			) ).sort();
936		}
937
938		// check for length avoids error when initializing empty list
939		if ( this.options.active !== false && this.anchors.length ) {
940			this.active = this._findActive( options.active );
941		} else {
942			this.active = $();
943		}
944
945		this._refresh();
946
947		if ( this.active.length ) {
948			this.load( options.active );
949		}
950	},
951
952	_initialActive: function() {
953		var active = this.options.active,
954			collapsible = this.options.collapsible,
955			locationHash = location.hash.substring( 1 );
956
957		if ( active === null ) {
958			// check the fragment identifier in the URL
959			if ( locationHash ) {
960				this.tabs.each(function( i, tab ) {
961					if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
962						active = i;
963						return false;
964					}
965				});
966			}
967
968			// check for a tab marked active via a class
969			if ( active === null ) {
970				active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
971			}
972
973			// no active tab, set to false
974			if ( active === null || active === -1 ) {
975				active = this.tabs.length ? 0 : false;
976			}
977		}
978
979		// handle numbers: negative, out of range
980		if ( active !== false ) {
981			active = this.tabs.index( this.tabs.eq( active ) );
982			if ( active === -1 ) {
983				active = collapsible ? false : 0;
984			}
985		}
986
987		// don't allow collapsible: false and active: false
988		if ( !collapsible && active === false && this.anchors.length ) {
989			active = 0;
990		}
991
992		return active;
993	},
994
995	_getCreateEventData: function() {
996		return {
997			tab: this.active,
998			panel: !this.active.length ? $() : this._getPanelForTab( this.active )
999		};
1000	},
1001
1002	_tabKeydown: function( event ) {
1003		var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
1004			selectedIndex = this.tabs.index( focusedTab ),
1005			goingForward = true;
1006
1007		if ( this._handlePageNav( event ) ) {
1008			return;
1009		}
1010
1011		switch ( event.keyCode ) {
1012			case $.ui.keyCode.RIGHT:
1013			case $.ui.keyCode.DOWN:
1014				selectedIndex++;
1015				break;
1016			case $.ui.keyCode.UP:
1017			case $.ui.keyCode.LEFT:
1018				goingForward = false;
1019				selectedIndex--;
1020				break;
1021			case $.ui.keyCode.END:
1022				selectedIndex = this.anchors.length - 1;
1023				break;
1024			case $.ui.keyCode.HOME:
1025				selectedIndex = 0;
1026				break;
1027			case $.ui.keyCode.SPACE:
1028				// Activate only, no collapsing
1029				event.preventDefault();
1030				clearTimeout( this.activating );
1031				this._activate( selectedIndex );
1032				return;
1033			case $.ui.keyCode.ENTER:
1034				// Toggle (cancel delayed activation, allow collapsing)
1035				event.preventDefault();
1036				clearTimeout( this.activating );
1037				// Determine if we should collapse or activate
1038				this._activate( selectedIndex === this.options.active ? false : selectedIndex );
1039				return;
1040			default:
1041				return;
1042		}
1043
1044		// Focus the appropriate tab, based on which key was pressed
1045		event.preventDefault();
1046		clearTimeout( this.activating );
1047		selectedIndex = this._focusNextTab( selectedIndex, goingForward );
1048
1049		// Navigating with control key will prevent automatic activation
1050		if ( !event.ctrlKey ) {
1051			// Update aria-selected immediately so that AT think the tab is already selected.
1052			// Otherwise AT may confuse the user by stating that they need to activate the tab,
1053			// but the tab will already be activated by the time the announcement finishes.
1054			focusedTab.attr( "aria-selected", "false" );
1055			this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
1056
1057			this.activating = this._delay(function() {
1058				this.option( "active", selectedIndex );
1059			}, this.delay );
1060		}
1061	},
1062
1063	_panelKeydown: function( event ) {
1064		if ( this._handlePageNav( event ) ) {
1065			return;
1066		}
1067
1068		// Ctrl+up moves focus to the current tab
1069		if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
1070			event.preventDefault();
1071			this.active.focus();
1072		}
1073	},
1074
1075	// Alt+page up/down moves focus to the previous/next tab (and activates)
1076	_handlePageNav: function( event ) {
1077		if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
1078			this._activate( this._focusNextTab( this.options.active - 1, false ) );
1079			return true;
1080		}
1081		if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
1082			this._activate( this._focusNextTab( this.options.active + 1, true ) );
1083			return true;
1084		}
1085	},
1086
1087	_findNextTab: function( index, goingForward ) {
1088		var lastTabIndex = this.tabs.length - 1;
1089
1090		function constrain() {
1091			if ( index > lastTabIndex ) {
1092				index = 0;
1093			}
1094			if ( index < 0 ) {
1095				index = lastTabIndex;
1096			}
1097			return index;
1098		}
1099
1100		while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
1101			index = goingForward ? index + 1 : index - 1;
1102		}
1103
1104		return index;
1105	},
1106
1107	_focusNextTab: function( index, goingForward ) {
1108		index = this._findNextTab( index, goingForward );
1109		this.tabs.eq( index ).focus();
1110		return index;
1111	},
1112
1113	_setOption: function( key, value ) {
1114		if ( key === "active" ) {
1115			// _activate() will handle invalid values and update this.options
1116			this._activate( value );
1117			return;
1118		}
1119
1120		if ( key === "disabled" ) {
1121			// don't use the widget factory's disabled handling
1122			this._setupDisabled( value );
1123			return;
1124		}
1125
1126		this._super( key, value);
1127
1128		if ( key === "collapsible" ) {
1129			this.element.toggleClass( "ui-tabs-collapsible", value );
1130			// Setting collapsible: false while collapsed; open first panel
1131			if ( !value && this.options.active === false ) {
1132				this._activate( 0 );
1133			}
1134		}
1135
1136		if ( key === "event" ) {
1137			this._setupEvents( value );
1138		}
1139
1140		if ( key === "heightStyle" ) {
1141			this._setupHeightStyle( value );
1142		}
1143	},
1144
1145	_sanitizeSelector: function( hash ) {
1146		return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
1147	},
1148
1149	refresh: function() {
1150		var options = this.options,
1151			lis = this.tablist.children( ":has(a[href])" );
1152
1153		// get disabled tabs from class attribute from HTML
1154		// this will get converted to a boolean if needed in _refresh()
1155		options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
1156			return lis.index( tab );
1157		});
1158
1159		this._processTabs();
1160
1161		// was collapsed or no tabs
1162		if ( options.active === false || !this.anchors.length ) {
1163			options.active = false;
1164			this.active = $();
1165		// was active, but active tab is gone
1166		} else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
1167			// all remaining tabs are disabled
1168			if ( this.tabs.length === options.disabled.length ) {
1169				options.active = false;
1170				this.active = $();
1171			// activate previous tab
1172			} else {
1173				this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
1174			}
1175		// was active, active tab still exists
1176		} else {
1177			// make sure active index is correct
1178			options.active = this.tabs.index( this.active );
1179		}
1180
1181		this._refresh();
1182	},
1183
1184	_refresh: function() {
1185		this._setupDisabled( this.options.disabled );
1186		this._setupEvents( this.options.event );
1187		this._setupHeightStyle( this.options.heightStyle );
1188
1189		this.tabs.not( this.active ).attr({
1190			"aria-selected": "false",
1191			"aria-expanded": "false",
1192			tabIndex: -1
1193		});
1194		this.panels.not( this._getPanelForTab( this.active ) )
1195			.hide()
1196			.attr({
1197				"aria-hidden": "true"
1198			});
1199
1200		// Make sure one tab is in the tab order
1201		if ( !this.active.length ) {
1202			this.tabs.eq( 0 ).attr( "tabIndex", 0 );
1203		} else {
1204			this.active
1205				.addClass( "ui-tabs-active ui-state-active" )
1206				.attr({
1207					"aria-selected": "true",
1208					"aria-expanded": "true",
1209					tabIndex: 0
1210				});
1211			this._getPanelForTab( this.active )
1212				.show()
1213				.attr({
1214					"aria-hidden": "false"
1215				});
1216		}
1217	},
1218
1219	_processTabs: function() {
1220		var that = this;
1221
1222		this.tablist = this._getList()
1223			.addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
1224			.attr( "role", "tablist" );
1225
1226		this.tabs = this.tablist.find( "> li:has(a[href])" )
1227			.addClass( "ui-state-default ui-corner-top" )
1228			.attr({
1229				role: "tab",
1230				tabIndex: -1
1231			});
1232
1233		this.anchors = this.tabs.map(function() {
1234				return $( "a", this )[ 0 ];
1235			})
1236			.addClass( "ui-tabs-anchor" )
1237			.attr({
1238				role: "presentation",
1239				tabIndex: -1
1240			});
1241
1242		this.panels = $();
1243
1244		this.anchors.each(function( i, anchor ) {
1245			var selector, panel, panelId,
1246				anchorId = $( anchor ).uniqueId().attr( "id" ),
1247				tab = $( anchor ).closest( "li" ),
1248				originalAriaControls = tab.attr( "aria-controls" );
1249
1250			// inline tab
1251			if ( that._isLocal( anchor ) ) {
1252				selector = anchor.hash;
1253				panelId = selector.substring( 1 );
1254				panel = that.element.find( that._sanitizeSelector( selector ) );
1255			// remote tab
1256			} else {
1257				// If the tab doesn't already have aria-controls,
1258				// generate an id by using a throw-away element
1259				panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
1260				selector = "#" + panelId;
1261				panel = that.element.find( selector );
1262				if ( !panel.length ) {
1263					panel = that._createPanel( panelId );
1264					panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
1265				}
1266				panel.attr( "aria-live", "polite" );
1267			}
1268
1269			if ( panel.length) {
1270				that.panels = that.panels.add( panel );
1271			}
1272			if ( originalAriaControls ) {
1273				tab.data( "ui-tabs-aria-controls", originalAriaControls );
1274			}
1275			tab.attr({
1276				"aria-controls": panelId,
1277				"aria-labelledby": anchorId
1278			});
1279			panel.attr( "aria-labelledby", anchorId );
1280		});
1281
1282		this.panels
1283			.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
1284			.attr( "role", "tabpanel" );
1285	},
1286
1287	// allow overriding how to find the list for rare usage scenarios (#7715)
1288	_getList: function() {
1289		return this.tablist || this.element.find( "ol,ul" ).eq( 0 );
1290	},
1291
1292	_createPanel: function( id ) {
1293		return $( "<div>" )
1294			.attr( "id", id )
1295			.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
1296			.data( "ui-tabs-destroy", true );
1297	},
1298
1299	_setupDisabled: function( disabled ) {
1300		if ( $.isArray( disabled ) ) {
1301			if ( !disabled.length ) {
1302				disabled = false;
1303			} else if ( disabled.length === this.anchors.length ) {
1304				disabled = true;
1305			}
1306		}
1307
1308		// disable tabs
1309		for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
1310			if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
1311				$( li )
1312					.addClass( "ui-state-disabled" )
1313					.attr( "aria-disabled", "true" );
1314			} else {
1315				$( li )
1316					.removeClass( "ui-state-disabled" )
1317					.removeAttr( "aria-disabled" );
1318			}
1319		}
1320
1321		this.options.disabled = disabled;
1322	},
1323
1324	_setupEvents: function( event ) {
1325		var events = {};
1326		if ( event ) {
1327			$.each( event.split(" "), function( index, eventName ) {
1328				events[ eventName ] = "_eventHandler";
1329			});
1330		}
1331
1332		this._off( this.anchors.add( this.tabs ).add( this.panels ) );
1333		// Always prevent the default action, even when disabled
1334		this._on( true, this.anchors, {
1335			click: function( event ) {
1336				event.preventDefault();
1337			}
1338		});
1339		this._on( this.anchors, events );
1340		this._on( this.tabs, { keydown: "_tabKeydown" } );
1341		this._on( this.panels, { keydown: "_panelKeydown" } );
1342
1343		this._focusable( this.tabs );
1344		this._hoverable( this.tabs );
1345	},
1346
1347	_setupHeightStyle: function( heightStyle ) {
1348		var maxHeight,
1349			parent = this.element.parent();
1350
1351		if ( heightStyle === "fill" ) {
1352			maxHeight = parent.height();
1353			maxHeight -= this.element.outerHeight() - this.element.height();
1354
1355			this.element.siblings( ":visible" ).each(function() {
1356				var elem = $( this ),
1357					position = elem.css( "position" );
1358
1359				if ( position === "absolute" || position === "fixed" ) {
1360					return;
1361				}
1362				maxHeight -= elem.outerHeight( true );
1363			});
1364
1365			this.element.children().not( this.panels ).each(function() {
1366				maxHeight -= $( this ).outerHeight( true );
1367			});
1368
1369			this.panels.each(function() {
1370				$( this ).height( Math.max( 0, maxHeight -
1371					$( this ).innerHeight() + $( this ).height() ) );
1372			})
1373			.css( "overflow", "auto" );
1374		} else if ( heightStyle === "auto" ) {
1375			maxHeight = 0;
1376			this.panels.each(function() {
1377				maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
1378			}).height( maxHeight );
1379		}
1380	},
1381
1382	_eventHandler: function( event ) {
1383		var options = this.options,
1384			active = this.active,
1385			anchor = $( event.currentTarget ),
1386			tab = anchor.closest( "li" ),
1387			clickedIsActive = tab[ 0 ] === active[ 0 ],
1388			collapsing = clickedIsActive && options.collapsible,
1389			toShow = collapsing ? $() : this._getPanelForTab( tab ),
1390			toHide = !active.length ? $() : this._getPanelForTab( active ),
1391			eventData = {
1392				oldTab: active,
1393				oldPanel: toHide,
1394				newTab: collapsing ? $() : tab,
1395				newPanel: toShow
1396			};
1397
1398		event.preventDefault();
1399
1400		if ( tab.hasClass( "ui-state-disabled" ) ||
1401				// tab is already loading
1402				tab.hasClass( "ui-tabs-loading" ) ||
1403				// can't switch durning an animation
1404				this.running ||
1405				// click on active header, but not collapsible
1406				( clickedIsActive && !options.collapsible ) ||
1407				// allow canceling activation
1408				( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
1409			return;
1410		}
1411
1412		options.active = collapsing ? false : this.tabs.index( tab );
1413
1414		this.active = clickedIsActive ? $() : tab;
1415		if ( this.xhr ) {
1416			this.xhr.abort();
1417		}
1418
1419		if ( !toHide.length && !toShow.length ) {
1420			$.error( "jQuery UI Tabs: Mismatching fragment identifier." );
1421		}
1422
1423		if ( toShow.length ) {
1424			this.load( this.tabs.index( tab ), event );
1425		}
1426		this._toggle( event, eventData );
1427	},
1428
1429	// handles show/hide for selecting tabs
1430	_toggle: function( event, eventData ) {
1431		var that = this,
1432			toShow = eventData.newPanel,
1433			toHide = eventData.oldPanel;
1434
1435		this.running = true;
1436
1437		function complete() {
1438			that.running = false;
1439			that._trigger( "activate", event, eventData );
1440		}
1441
1442		function show() {
1443			eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
1444
1445			if ( toShow.length && that.options.show ) {
1446				that._show( toShow, that.options.show, complete );
1447			} else {
1448				toShow.show();
1449				complete();
1450			}
1451		}
1452
1453		// start out by hiding, then showing, then completing
1454		if ( toHide.length && this.options.hide ) {
1455			this._hide( toHide, this.options.hide, function() {
1456				eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
1457				show();
1458			});
1459		} else {
1460			eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
1461			toHide.hide();
1462			show();
1463		}
1464
1465		toHide.attr( "aria-hidden", "true" );
1466		eventData.oldTab.attr({
1467			"aria-selected": "false",
1468			"aria-expanded": "false"
1469		});
1470		// If we're switching tabs, remove the old tab from the tab order.
1471		// If we're opening from collapsed state, remove the previous tab from the tab order.
1472		// If we're collapsing, then keep the collapsing tab in the tab order.
1473		if ( toShow.length && toHide.length ) {
1474			eventData.oldTab.attr( "tabIndex", -1 );
1475		} else if ( toShow.length ) {
1476			this.tabs.filter(function() {
1477				return $( this ).attr( "tabIndex" ) === 0;
1478			})
1479			.attr( "tabIndex", -1 );
1480		}
1481
1482		toShow.attr( "aria-hidden", "false" );
1483		eventData.newTab.attr({
1484			"aria-selected": "true",
1485			"aria-expanded": "true",
1486			tabIndex: 0
1487		});
1488	},
1489
1490	_activate: function( index ) {
1491		var anchor,
1492			active = this._findActive( index );
1493
1494		// trying to activate the already active panel
1495		if ( active[ 0 ] === this.active[ 0 ] ) {
1496			return;
1497		}
1498
1499		// trying to collapse, simulate a click on the current active header
1500		if ( !active.length ) {
1501			active = this.active;
1502		}
1503
1504		anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
1505		this._eventHandler({
1506			target: anchor,
1507			currentTarget: anchor,
1508			preventDefault: $.noop
1509		});
1510	},
1511
1512	_findActive: function( index ) {
1513		return index === false ? $() : this.tabs.eq( index );
1514	},
1515
1516	_getIndex: function( index ) {
1517		// meta-function to give users option to provide a href string instead of a numerical index.
1518		if ( typeof index === "string" ) {
1519			index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
1520		}
1521
1522		return index;
1523	},
1524
1525	_destroy: function() {
1526		if ( this.xhr ) {
1527			this.xhr.abort();
1528		}
1529
1530		this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
1531
1532		this.tablist
1533			.removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
1534			.removeAttr( "role" );
1535
1536		this.anchors
1537			.removeClass( "ui-tabs-anchor" )
1538			.removeAttr( "role" )
1539			.removeAttr( "tabIndex" )
1540			.removeUniqueId();
1541
1542		this.tabs.add( this.panels ).each(function() {
1543			if ( $.data( this, "ui-tabs-destroy" ) ) {
1544				$( this ).remove();
1545			} else {
1546				$( this )
1547					.removeClass( "ui-state-default ui-state-active ui-state-disabled " +
1548						"ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
1549					.removeAttr( "tabIndex" )
1550					.removeAttr( "aria-live" )
1551					.removeAttr( "aria-busy" )
1552					.removeAttr( "aria-selected" )
1553					.removeAttr( "aria-labelledby" )
1554					.removeAttr( "aria-hidden" )
1555					.removeAttr( "aria-expanded" )
1556					.removeAttr( "role" );
1557			}
1558		});
1559
1560		this.tabs.each(function() {
1561			var li = $( this ),
1562				prev = li.data( "ui-tabs-aria-controls" );
1563			if ( prev ) {
1564				li
1565					.attr( "aria-controls", prev )
1566					.removeData( "ui-tabs-aria-controls" );
1567			} else {
1568				li.removeAttr( "aria-controls" );
1569			}
1570		});
1571
1572		this.panels.show();
1573
1574		if ( this.options.heightStyle !== "content" ) {
1575			this.panels.css( "height", "" );
1576		}
1577	},
1578
1579	enable: function( index ) {
1580		var disabled = this.options.disabled;
1581		if ( disabled === false ) {
1582			return;
1583		}
1584
1585		if ( index === undefined ) {
1586			disabled = false;
1587		} else {
1588			index = this._getIndex( index );
1589			if ( $.isArray( disabled ) ) {
1590				disabled = $.map( disabled, function( num ) {
1591					return num !== index ? num : null;
1592				});
1593			} else {
1594				disabled = $.map( this.tabs, function( li, num ) {
1595					return num !== index ? num : null;
1596				});
1597			}
1598		}
1599		this._setupDisabled( disabled );
1600	},
1601
1602	disable: function( index ) {
1603		var disabled = this.options.disabled;
1604		if ( disabled === true ) {
1605			return;
1606		}
1607
1608		if ( index === undefined ) {
1609			disabled = true;
1610		} else {
1611			index = this._getIndex( index );
1612			if ( $.inArray( index, disabled ) !== -1 ) {
1613				return;
1614			}
1615			if ( $.isArray( disabled ) ) {
1616				disabled = $.merge( [ index ], disabled ).sort();
1617			} else {
1618				disabled = [ index ];
1619			}
1620		}
1621		this._setupDisabled( disabled );
1622	},
1623
1624	load: function( index, event ) {
1625		index = this._getIndex( index );
1626		var that = this,
1627			tab = this.tabs.eq( index ),
1628			anchor = tab.find( ".ui-tabs-anchor" ),
1629			panel = this._getPanelForTab( tab ),
1630			eventData = {
1631				tab: tab,
1632				panel: panel
1633			};
1634
1635		// not remote
1636		if ( this._isLocal( anchor[ 0 ] ) ) {
1637			return;
1638		}
1639
1640		this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
1641
1642		// support: jQuery <1.8
1643		// jQuery <1.8 returns false if the request is canceled in beforeSend,
1644		// but as of 1.8, $.ajax() always returns a jqXHR object.
1645		if ( this.xhr && this.xhr.statusText !== "canceled" ) {
1646			tab.addClass( "ui-tabs-loading" );
1647			panel.attr( "aria-busy", "true" );
1648
1649			this.xhr
1650				.success(function( response ) {
1651					// support: jQuery <1.8
1652					// http://bugs.jquery.com/ticket/11778
1653					setTimeout(function() {
1654						panel.html( response );
1655						that._trigger( "load", event, eventData );
1656					}, 1 );
1657				})
1658				.complete(function( jqXHR, status ) {
1659					// support: jQuery <1.8
1660					// http://bugs.jquery.com/ticket/11778
1661					setTimeout(function() {
1662						if ( status === "abort" ) {
1663							that.panels.stop( false, true );
1664						}
1665
1666						tab.removeClass( "ui-tabs-loading" );
1667						panel.removeAttr( "aria-busy" );
1668
1669						if ( jqXHR === that.xhr ) {
1670							delete that.xhr;
1671						}
1672					}, 1 );
1673				});
1674		}
1675	},
1676
1677	_ajaxSettings: function( anchor, event, eventData ) {
1678		var that = this;
1679		return {
1680			url: anchor.attr( "href" ),
1681			beforeSend: function( jqXHR, settings ) {
1682				return that._trigger( "beforeLoad", event,
1683					$.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
1684			}
1685		};
1686	},
1687
1688	_getPanelForTab: function( tab ) {
1689		var id = $( tab ).attr( "aria-controls" );
1690		return this.element.find( this._sanitizeSelector( "#" + id ) );
1691	}
1692});
1693
1694
1695
1696}));