https://carlocaiado.com.br/wp-includes/js/jquery/ui/tabs.js?ver=1.13.3

1/*!
2 * jQuery UI Tabs 1.13.3
3 * https://jqueryui.com
4 *
5 * Copyright OpenJS Foundation and other contributors
6 * Released under the MIT license.
7 * https://jquery.org/license
8 */
9
10//>>label: Tabs
11//>>group: Widgets
12//>>description: Transforms a set of container elements into a tab structure.
13//>>docs: https://api.jqueryui.com/tabs/
14//>>demos: https://jqueryui.com/tabs/
15//>>css.structure: ../../themes/base/core.css
16//>>css.structure: ../../themes/base/tabs.css
17//>>css.theme: ../../themes/base/theme.css
18
19( function( factory ) {
20	"use strict";
21
22	if ( typeof define === "function" && define.amd ) {
23
24		// AMD. Register as an anonymous module.
25		define( [
26			"jquery",
27			"../keycode",
28			"../safe-active-element",
29			"../unique-id",
30			"../version",
31			"../widget"
32		], factory );
33	} else {
34
35		// Browser globals
36		factory( jQuery );
37	}
38} )( function( $ ) {
39"use strict";
40
41$.widget( "ui.tabs", {
42	version: "1.13.3",
43	delay: 300,
44	options: {
45		active: null,
46		classes: {
47			"ui-tabs": "ui-corner-all",
48			"ui-tabs-nav": "ui-corner-all",
49			"ui-tabs-panel": "ui-corner-bottom",
50			"ui-tabs-tab": "ui-corner-top"
51		},
52		collapsible: false,
53		event: "click",
54		heightStyle: "content",
55		hide: null,
56		show: null,
57
58		// Callbacks
59		activate: null,
60		beforeActivate: null,
61		beforeLoad: null,
62		load: null
63	},
64
65	_isLocal: ( function() {
66		var rhash = /#.*$/;
67
68		return function( anchor ) {
69			var anchorUrl, locationUrl;
70
71			anchorUrl = anchor.href.replace( rhash, "" );
72			locationUrl = location.href.replace( rhash, "" );
73
74			// Decoding may throw an error if the URL isn't UTF-8 (#9518)
75			try {
76				anchorUrl = decodeURIComponent( anchorUrl );
77			} catch ( error ) {}
78			try {
79				locationUrl = decodeURIComponent( locationUrl );
80			} catch ( error ) {}
81
82			return anchor.hash.length > 1 && anchorUrl === locationUrl;
83		};
84	} )(),
85
86	_create: function() {
87		var that = this,
88			options = this.options;
89
90		this.running = false;
91
92		this._addClass( "ui-tabs", "ui-widget ui-widget-content" );
93		this._toggleClass( "ui-tabs-collapsible", null, options.collapsible );
94
95		this._processTabs();
96		options.active = this._initialActive();
97
98		// Take disabling tabs via class attribute from HTML
99		// into account and update option properly.
100		if ( Array.isArray( options.disabled ) ) {
101			options.disabled = $.uniqueSort( options.disabled.concat(
102				$.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
103					return that.tabs.index( li );
104				} )
105			) ).sort();
106		}
107
108		// Check for length avoids error when initializing empty list
109		if ( this.options.active !== false && this.anchors.length ) {
110			this.active = this._findActive( options.active );
111		} else {
112			this.active = $();
113		}
114
115		this._refresh();
116
117		if ( this.active.length ) {
118			this.load( options.active );
119		}
120	},
121
122	_initialActive: function() {
123		var active = this.options.active,
124			collapsible = this.options.collapsible,
125			locationHash = location.hash.substring( 1 );
126
127		if ( active === null ) {
128
129			// check the fragment identifier in the URL
130			if ( locationHash ) {
131				this.tabs.each( function( i, tab ) {
132					if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
133						active = i;
134						return false;
135					}
136				} );
137			}
138
139			// Check for a tab marked active via a class
140			if ( active === null ) {
141				active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
142			}
143
144			// No active tab, set to false
145			if ( active === null || active === -1 ) {
146				active = this.tabs.length ? 0 : false;
147			}
148		}
149
150		// Handle numbers: negative, out of range
151		if ( active !== false ) {
152			active = this.tabs.index( this.tabs.eq( active ) );
153			if ( active === -1 ) {
154				active = collapsible ? false : 0;
155			}
156		}
157
158		// Don't allow collapsible: false and active: false
159		if ( !collapsible && active === false && this.anchors.length ) {
160			active = 0;
161		}
162
163		return active;
164	},
165
166	_getCreateEventData: function() {
167		return {
168			tab: this.active,
169			panel: !this.active.length ? $() : this._getPanelForTab( this.active )
170		};
171	},
172
173	_tabKeydown: function( event ) {
174		var focusedTab = $( $.ui.safeActiveElement( this.document[ 0 ] ) ).closest( "li" ),
175			selectedIndex = this.tabs.index( focusedTab ),
176			goingForward = true;
177
178		if ( this._handlePageNav( event ) ) {
179			return;
180		}
181
182		switch ( event.keyCode ) {
183		case $.ui.keyCode.RIGHT:
184		case $.ui.keyCode.DOWN:
185			selectedIndex++;
186			break;
187		case $.ui.keyCode.UP:
188		case $.ui.keyCode.LEFT:
189			goingForward = false;
190			selectedIndex--;
191			break;
192		case $.ui.keyCode.END:
193			selectedIndex = this.anchors.length - 1;
194			break;
195		case $.ui.keyCode.HOME:
196			selectedIndex = 0;
197			break;
198		case $.ui.keyCode.SPACE:
199
200			// Activate only, no collapsing
201			event.preventDefault();
202			clearTimeout( this.activating );
203			this._activate( selectedIndex );
204			return;
205		case $.ui.keyCode.ENTER:
206
207			// Toggle (cancel delayed activation, allow collapsing)
208			event.preventDefault();
209			clearTimeout( this.activating );
210
211			// Determine if we should collapse or activate
212			this._activate( selectedIndex === this.options.active ? false : selectedIndex );
213			return;
214		default:
215			return;
216		}
217
218		// Focus the appropriate tab, based on which key was pressed
219		event.preventDefault();
220		clearTimeout( this.activating );
221		selectedIndex = this._focusNextTab( selectedIndex, goingForward );
222
223		// Navigating with control/command key will prevent automatic activation
224		if ( !event.ctrlKey && !event.metaKey ) {
225
226			// Update aria-selected immediately so that AT think the tab is already selected.
227			// Otherwise AT may confuse the user by stating that they need to activate the tab,
228			// but the tab will already be activated by the time the announcement finishes.
229			focusedTab.attr( "aria-selected", "false" );
230			this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
231
232			this.activating = this._delay( function() {
233				this.option( "active", selectedIndex );
234			}, this.delay );
235		}
236	},
237
238	_panelKeydown: function( event ) {
239		if ( this._handlePageNav( event ) ) {
240			return;
241		}
242
243		// Ctrl+up moves focus to the current tab
244		if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
245			event.preventDefault();
246			this.active.trigger( "focus" );
247		}
248	},
249
250	// Alt+page up/down moves focus to the previous/next tab (and activates)
251	_handlePageNav: function( event ) {
252		if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
253			this._activate( this._focusNextTab( this.options.active - 1, false ) );
254			return true;
255		}
256		if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
257			this._activate( this._focusNextTab( this.options.active + 1, true ) );
258			return true;
259		}
260	},
261
262	_findNextTab: function( index, goingForward ) {
263		var lastTabIndex = this.tabs.length - 1;
264
265		function constrain() {
266			if ( index > lastTabIndex ) {
267				index = 0;
268			}
269			if ( index < 0 ) {
270				index = lastTabIndex;
271			}
272			return index;
273		}
274
275		while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
276			index = goingForward ? index + 1 : index - 1;
277		}
278
279		return index;
280	},
281
282	_focusNextTab: function( index, goingForward ) {
283		index = this._findNextTab( index, goingForward );
284		this.tabs.eq( index ).trigger( "focus" );
285		return index;
286	},
287
288	_setOption: function( key, value ) {
289		if ( key === "active" ) {
290
291			// _activate() will handle invalid values and update this.options
292			this._activate( value );
293			return;
294		}
295
296		this._super( key, value );
297
298		if ( key === "collapsible" ) {
299			this._toggleClass( "ui-tabs-collapsible", null, value );
300
301			// Setting collapsible: false while collapsed; open first panel
302			if ( !value && this.options.active === false ) {
303				this._activate( 0 );
304			}
305		}
306
307		if ( key === "event" ) {
308			this._setupEvents( value );
309		}
310
311		if ( key === "heightStyle" ) {
312			this._setupHeightStyle( value );
313		}
314	},
315
316	_sanitizeSelector: function( hash ) {
317		return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
318	},
319
320	refresh: function() {
321		var options = this.options,
322			lis = this.tablist.children( ":has(a[href])" );
323
324		// Get disabled tabs from class attribute from HTML
325		// this will get converted to a boolean if needed in _refresh()
326		options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
327			return lis.index( tab );
328		} );
329
330		this._processTabs();
331
332		// Was collapsed or no tabs
333		if ( options.active === false || !this.anchors.length ) {
334			options.active = false;
335			this.active = $();
336
337		// was active, but active tab is gone
338		} else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
339
340			// all remaining tabs are disabled
341			if ( this.tabs.length === options.disabled.length ) {
342				options.active = false;
343				this.active = $();
344
345			// activate previous tab
346			} else {
347				this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
348			}
349
350		// was active, active tab still exists
351		} else {
352
353			// make sure active index is correct
354			options.active = this.tabs.index( this.active );
355		}
356
357		this._refresh();
358	},
359
360	_refresh: function() {
361		this._setOptionDisabled( this.options.disabled );
362		this._setupEvents( this.options.event );
363		this._setupHeightStyle( this.options.heightStyle );
364
365		this.tabs.not( this.active ).attr( {
366			"aria-selected": "false",
367			"aria-expanded": "false",
368			tabIndex: -1
369		} );
370		this.panels.not( this._getPanelForTab( this.active ) )
371			.hide()
372			.attr( {
373				"aria-hidden": "true"
374			} );
375
376		// Make sure one tab is in the tab order
377		if ( !this.active.length ) {
378			this.tabs.eq( 0 ).attr( "tabIndex", 0 );
379		} else {
380			this.active
381				.attr( {
382					"aria-selected": "true",
383					"aria-expanded": "true",
384					tabIndex: 0
385				} );
386			this._addClass( this.active, "ui-tabs-active", "ui-state-active" );
387			this._getPanelForTab( this.active )
388				.show()
389				.attr( {
390					"aria-hidden": "false"
391				} );
392		}
393	},
394
395	_processTabs: function() {
396		var that = this,
397			prevTabs = this.tabs,
398			prevAnchors = this.anchors,
399			prevPanels = this.panels;
400
401		this.tablist = this._getList().attr( "role", "tablist" );
402		this._addClass( this.tablist, "ui-tabs-nav",
403			"ui-helper-reset ui-helper-clearfix ui-widget-header" );
404
405		// Prevent users from focusing disabled tabs via click
406		this.tablist
407			.on( "mousedown" + this.eventNamespace, "> li", function( event ) {
408				if ( $( this ).is( ".ui-state-disabled" ) ) {
409					event.preventDefault();
410				}
411			} )
412
413			// Support: IE <9
414			// Preventing the default action in mousedown doesn't prevent IE
415			// from focusing the element, so if the anchor gets focused, blur.
416			// We don't have to worry about focusing the previously focused
417			// element since clicking on a non-focusable element should focus
418			// the body anyway.
419			.on( "focus" + this.eventNamespace, ".ui-tabs-anchor", function() {
420				if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
421					this.blur();
422				}
423			} );
424
425		this.tabs = this.tablist.find( "> li:has(a[href])" )
426			.attr( {
427				role: "tab",
428				tabIndex: -1
429			} );
430		this._addClass( this.tabs, "ui-tabs-tab", "ui-state-default" );
431
432		this.anchors = this.tabs.map( function() {
433			return $( "a", this )[ 0 ];
434		} )
435			.attr( {
436				tabIndex: -1
437			} );
438		this._addClass( this.anchors, "ui-tabs-anchor" );
439
440		this.panels = $();
441
442		this.anchors.each( function( i, anchor ) {
443			var selector, panel, panelId,
444				anchorId = $( anchor ).uniqueId().attr( "id" ),
445				tab = $( anchor ).closest( "li" ),
446				originalAriaControls = tab.attr( "aria-controls" );
447
448			// Inline tab
449			if ( that._isLocal( anchor ) ) {
450				selector = anchor.hash;
451				panelId = selector.substring( 1 );
452				panel = that.element.find( that._sanitizeSelector( selector ) );
453
454			// remote tab
455			} else {
456
457				// If the tab doesn't already have aria-controls,
458				// generate an id by using a throw-away element
459				panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
460				selector = "#" + panelId;
461				panel = that.element.find( selector );
462				if ( !panel.length ) {
463					panel = that._createPanel( panelId );
464					panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
465				}
466				panel.attr( "aria-live", "polite" );
467			}
468
469			if ( panel.length ) {
470				that.panels = that.panels.add( panel );
471			}
472			if ( originalAriaControls ) {
473				tab.data( "ui-tabs-aria-controls", originalAriaControls );
474			}
475			tab.attr( {
476				"aria-controls": panelId,
477				"aria-labelledby": anchorId
478			} );
479			panel.attr( "aria-labelledby", anchorId );
480		} );
481
482		this.panels.attr( "role", "tabpanel" );
483		this._addClass( this.panels, "ui-tabs-panel", "ui-widget-content" );
484
485		// Avoid memory leaks (#10056)
486		if ( prevTabs ) {
487			this._off( prevTabs.not( this.tabs ) );
488			this._off( prevAnchors.not( this.anchors ) );
489			this._off( prevPanels.not( this.panels ) );
490		}
491	},
492
493	// Allow overriding how to find the list for rare usage scenarios (#7715)
494	_getList: function() {
495		return this.tablist || this.element.find( "ol, ul" ).eq( 0 );
496	},
497
498	_createPanel: function( id ) {
499		return $( "<div>" )
500			.attr( "id", id )
501			.data( "ui-tabs-destroy", true );
502	},
503
504	_setOptionDisabled: function( disabled ) {
505		var currentItem, li, i;
506
507		if ( Array

507.isArray( disabled ) ) {
508			if ( !disabled.length ) {
509				disabled = false;
510			} else if ( disabled.length === this.anchors.length ) {
511				disabled = true;
512			}
513		}
514
515		// Disable tabs
516		for ( i = 0; ( li = this.tabs[ i ] ); i++ ) {
517			currentItem = $( li );
518			if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
519				currentItem.attr( "aria-disabled", "true" );
520				this._addClass( currentItem, null, "ui-state-disabled" );
521			} else {
522				currentItem.removeAttr( "aria-disabled" );
523				this._removeClass( currentItem, null, "ui-state-disabled" );
524			}
525		}
526
527		this.options.disabled = disabled;
528
529		this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null,
530			disabled === true );
531	},
532
533	_setupEvents: function( event ) {
534		var events = {};
535		if ( event ) {
536			$.each( event.split( " " ), function( index, eventName ) {
537				events[ eventName ] = "_eventHandler";
538			} );
539		}
540
541		this._off( this.anchors.add( this.tabs ).add( this.panels ) );
542
543		// Always prevent the default action, even when disabled
544		this._on( true, this.anchors, {
545			click: function( event ) {
546				event.preventDefault();
547			}
548		} );
549		this._on( this.anchors, events );
550		this._on( this.tabs, { keydown: "_tabKeydown" } );
551		this._on( this.panels, { keydown: "_panelKeydown" } );
552
553		this._focusable( this.tabs );
554		this._hoverable( this.tabs );
555	},
556
557	_setupHeightStyle: function( heightStyle ) {
558		var maxHeight,
559			parent = this.element.parent();
560
561		if ( heightStyle === "fill" ) {
562			maxHeight = parent.height();
563			maxHeight -= this.element.outerHeight() - this.element.height();
564
565			this.element.siblings( ":visible" ).each( function() {
566				var elem = $( this ),
567					position = elem.css( "position" );
568
569				if ( position === "absolute" || position === "fixed" ) {
570					return;
571				}
572				maxHeight -= elem.outerHeight( true );
573			} );
574
575			this.element.children().not( this.panels ).each( function() {
576				maxHeight -= $( this ).outerHeight( true );
577			} );
578
579			this.panels.each( function() {
580				$( this ).height( Math.max( 0, maxHeight -
581					$( this ).innerHeight() + $( this ).height() ) );
582			} )
583				.css( "overflow", "auto" );
584		} else if ( heightStyle === "auto" ) {
585			maxHeight = 0;
586			this.panels.each( function() {
587				maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
588			} ).height( maxHeight );
589		}
590	},
591
592	_eventHandler: function( event ) {
593		var options = this.options,
594			active = this.active,
595			anchor = $( event.currentTarget ),
596			tab = anchor.closest( "li" ),
597			clickedIsActive = tab[ 0 ] === active[ 0 ],
598			collapsing = clickedIsActive && options.collapsible,
599			toShow = collapsing ? $() : this._getPanelForTab( tab ),
600			toHide = !active.length ? $() : this._getPanelForTab( active ),
601			eventData = {
602				oldTab: active,
603				oldPanel: toHide,
604				newTab: collapsing ? $() : tab,
605				newPanel: toShow
606			};
607
608		event.preventDefault();
609
610		if ( tab.hasClass( "ui-state-disabled" ) ||
611
612				// tab is already loading
613				tab.hasClass( "ui-tabs-loading" ) ||
614
615				// can't switch durning an animation
616				this.running ||
617
618				// click on active header, but not collapsible
619				( clickedIsActive && !options.collapsible ) ||
620
621				// allow canceling activation
622				( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
623			return;
624		}
625
626		options.active = collapsing ? false : this.tabs.index( tab );
627
628		this.active = clickedIsActive ? $() : tab;
629		if ( this.xhr ) {
630			this.xhr.abort();
631		}
632
633		if ( !toHide.length && !toShow.length ) {
634			$.error( "jQuery UI Tabs: Mismatching fragment identifier." );
635		}
636
637		if ( toShow.length ) {
638			this.load( this.tabs.index( tab ), event );
639		}
640		this._toggle( event, eventData );
641	},
642
643	// Handles show/hide for selecting tabs
644	_toggle: function( event, eventData ) {
645		var that = this,
646			toShow = eventData.newPanel,
647			toHide = eventData.oldPanel;
648
649		this.running = true;
650
651		function complete() {
652			that.running = false;
653			that._trigger( "activate", event, eventData );
654		}
655
656		function show() {
657			that._addClass( eventData.newTab.closest( "li" ), "ui-tabs-active", "ui-state-active" );
658
659			if ( toShow.length && that.options.show ) {
660				that._show( toShow, that.options.show, complete );
661			} else {
662				toShow.show();
663				complete();
664			}
665		}
666
667		// Start out by hiding, then showing, then completing
668		if ( toHide.length && this.options.hide ) {
669			this._hide( toHide, this.options.hide, function() {
670				that._removeClass( eventData.oldTab.closest( "li" ),
671					"ui-tabs-active", "ui-state-active" );
672				show();
673			} );
674		} else {
675			this._removeClass( eventData.oldTab.closest( "li" ),
676				"ui-tabs-active", "ui-state-active" );
677			toHide.hide();
678			show();
679		}
680
681		toHide.attr( "aria-hidden", "true" );
682		eventData.oldTab.attr( {
683			"aria-selected": "false",
684			"aria-expanded": "false"
685		} );
686
687		// If we're switching tabs, remove the old tab from the tab order.

688		// If we're opening from collapsed state, remove the previous tab from the tab order.
689		// If we're collapsing, then keep the collapsing tab in the tab order.
690		if ( toShow.length && toHide.length ) {
691			eventData.oldTab.attr( "tabIndex", -1 );
692		} else if ( toShow.length ) {
693			this.tabs.filter( function() {
694				return $( this ).attr( "tabIndex" ) === 0;
695			} )
696				.attr( "tabIndex", -1 );
697		}
698
699		toShow.attr( "aria-hidden", "false" );
700		eventData.newTab.attr( {
701			"aria-selected": "true",
702			"aria-expanded": "true",
703			tabIndex: 0
704		} );
705	},
706
707	_activate: function( index ) {
708		var anchor,
709			active = this._findActive( index );
710
711		// Trying to activate the already active panel
712		if ( active[ 0 ] === this.active[ 0 ] ) {
713			return;
714		}
715
716		// Trying to collapse, simulate a click on the current active header
717		if ( !active.length ) {
718			active = this.active;
719		}
720
721		anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
722		this._eventHandler( {
723			target: anchor,
724			currentTarget: anchor,
725			preventDefault: $.noop
726		} );
727	},
728
729	_findActive: function( index ) {
730		return index === false ? $() : this.tabs.eq( index );
731	},
732
733	_getIndex: function( index ) {
734
735		// meta-function to give users option to provide a href string instead of a numerical index.
736		if ( typeof index === "string" ) {
737			index = this.anchors.index( this.anchors.filter( "[href$='" +
738				$.escapeSelector( index ) + "']" ) );
739		}
740
741		return index;
742	},
743
744	_destroy: function() {
745		if ( this.xhr ) {
746			this.xhr.abort();
747		}
748
749		this.tablist
750			.removeAttr( "role" )
751			.off( this.eventNamespace );
752
753		this.anchors
754			.removeAttr( "role tabIndex" )
755			.removeUniqueId();
756
757		this.tabs.add( this.panels ).each( function() {
758			if ( $.data( this, "ui-tabs-destroy" ) ) {
759				$( this ).remove();
760			} else {
761				$( this ).removeAttr( "role tabIndex " +
762					"aria-live aria-busy aria-selected aria-labelledby aria-hidden aria-expanded" );
763			}
764		} );
765
766		this.tabs.each( function() {
767			var li = $( this ),
768				prev = li.data( "ui-tabs-aria-controls" );
769			if ( prev ) {
770				li
771					.attr( "aria-controls", prev )
772					.removeData( "ui-tabs-aria-controls" );
773			} else {
774				li.removeAttr( "aria-controls" );
775			}
776		} );
777
778		this.panels.show();
779
780		if ( this.options.heightStyle !== "content" ) {
781			this.panels.css( "height", "" );
782		}
783	},
784
785	enable: function( index ) {
786		var disabled = this.options.disabled;
787		if ( disabled === false ) {
788			return;
789		}
790
791		if ( index === undefined ) {
792			disabled = false;
793		} else {
794			index = this._getIndex( index );
795			if ( Array.isArray( disabled ) ) {
796				disabled = $.map( disabled, function( num ) {
797					return num !== index ? num : null;
798				} );
799			} else {
800				disabled = $.map( this.tabs, function( li, num ) {
801					return num !== index ? num : null;
802				} );
803			}
804		}
805		this._setOptionDisabled( disabled );
806	},
807
808	disable: function( index ) {
809		var disabled = this.options.disabled;
810		if ( disabled === true ) {
811			return;
812		}
813
814		if ( index === undefined ) {
815			disabled = true;
816		} else {
817			index = this._getIndex( index );
818			if ( $.inArray( index, disabled ) !== -1 ) {
819				return;
820			}
821			if ( Array.isArray( disabled ) ) {
822				disabled = $.merge( [ index ], disabled ).sort();
823			} else {
824				disabled = [ index ];
825			}
826		}
827		this._setOptionDisabled( disabled );
828	},
829
830	load: function( index, event ) {
831		index = this._getIndex( index );
832		var that = this,
833			tab = this.tabs.eq( index ),
834			anchor = tab.find( ".ui-tabs-anchor" ),
835			panel = this._getPanelForTab( tab ),
836			eventData = {
837				tab: tab,
838				panel: panel
839			},
840			complete = function( jqXHR, status ) {
841				if ( status === "abort" ) {
842					that.panels.stop( false, true );
843				}
844
845				that._removeClass( tab, "ui-tabs-loading" );
846				panel.removeAttr( "aria-busy" );
847
848				if ( jqXHR === that.xhr ) {
849					delete that.xhr;
850				}
851			};
852
853		// Not remote
854		if ( this._isLocal( anchor[ 0 ] ) ) {
855			return;
856		}
857
858		this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
859
860		// Support: jQuery <1.8
861		// jQuery <1.8 returns false if the request is canceled in beforeSend,
862		// but as of 1.8, $.ajax() always returns a jqXHR object.
863		if ( this.xhr && this.xhr.statusText !== "canceled" ) {
864			this._addClass( tab, "ui-tabs-loading" );
865			panel.attr( "aria-busy", "true" );
866
867			this.xhr
868				.done( function( response, status, jqXHR ) {
869
870					// support: jQuery <1.8
871					// https://bugs.jquery.com/ticket/11778
872					setTimeout( function() {
873						panel.html( response );
874						that._trigger( "load", event, eventData );
875
876						complete( jqXHR, status );
877					}, 1 );
878				} )
879				.fail( function( jqXHR, status ) {
880
881					// support: jQuery <1.8
882					// https://bugs.jquery.com/ticket/11778
883					setTimeout( function() {
884						complete( jqXHR, status );
885					}, 1 );
886				} );
887		}
888	},
889
890	_ajaxSettings: function( anchor, event, eventData ) {
891		var that = this;
892		return {
893
894			// Support: IE <11 only
895			// Strip any hash that exists to prevent errors with the Ajax request
896			url: anchor.attr( "href" ).replace( /#.*$/, "" ),
897			beforeSend: function( jqXHR, settings ) {
898				return that._trigger( "beforeLoad", event,
899					$.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
900			}
901		};
902	},
903
904	_getPanelForTab: function( tab ) {
905		var id = $( tab ).attr( "aria-controls" );
906		return this.element.find( this._sanitizeSelector( "#" + id ) );
907	}
908} );
909
910// DEPRECATED
911// TODO: Switch return back to widget declaration at top of file when this is removed
912if ( $.uiBackCompat !== false ) {
913
914	// Backcompat for ui-tab class (now ui-tabs-tab)
915	$.widget( "ui.tabs", $.ui.tabs, {
916		_processTabs: function() {
917			this._superApply( arguments );
918			this._addClass( this.tabs, "ui-tab" );
919		}
920	} );
921}
922