|
|
@@ -0,0 +1,1419 @@
|
|
|
+/*! jQuery UI - v1.12.1 - 2021-06-01
|
|
|
+* http://jqueryui.com
|
|
|
+* Includes: widget.js, keycode.js, unique-id.js, widgets/accordion.js
|
|
|
+* Copyright jQuery Foundation and other contributors; Licensed MIT */
|
|
|
+
|
|
|
+(function( factory ) {
|
|
|
+ if ( typeof define === "function" && define.amd ) {
|
|
|
+
|
|
|
+ // AMD. Register as an anonymous module.
|
|
|
+ define([ "jquery" ], factory );
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // Browser globals
|
|
|
+ factory( jQuery );
|
|
|
+ }
|
|
|
+}(function( $ ) {
|
|
|
+
|
|
|
+$.ui = $.ui || {};
|
|
|
+
|
|
|
+var version = $.ui.version = "1.12.1";
|
|
|
+
|
|
|
+
|
|
|
+/*!
|
|
|
+ * jQuery UI Widget 1.12.1
|
|
|
+ * http://jqueryui.com
|
|
|
+ *
|
|
|
+ * Copyright jQuery Foundation and other contributors
|
|
|
+ * Released under the MIT license.
|
|
|
+ * http://jquery.org/license
|
|
|
+ */
|
|
|
+
|
|
|
+//>>label: Widget
|
|
|
+//>>group: Core
|
|
|
+//>>description: Provides a factory for creating stateful widgets with a common API.
|
|
|
+//>>docs: http://api.jqueryui.com/jQuery.widget/
|
|
|
+//>>demos: http://jqueryui.com/widget/
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+var widgetUuid = 0;
|
|
|
+var widgetSlice = Array.prototype.slice;
|
|
|
+
|
|
|
+$.cleanData = ( function( orig ) {
|
|
|
+ return function( elems ) {
|
|
|
+ var events, elem, i;
|
|
|
+ for ( i = 0; ( elem = elems[ i ] ) != null; i++ ) {
|
|
|
+ try {
|
|
|
+
|
|
|
+ // Only trigger remove when necessary to save time
|
|
|
+ events = $._data( elem, "events" );
|
|
|
+ if ( events && events.remove ) {
|
|
|
+ $( elem ).triggerHandler( "remove" );
|
|
|
+ }
|
|
|
+
|
|
|
+ // Http://bugs.jquery.com/ticket/8235
|
|
|
+ } catch ( e ) {}
|
|
|
+ }
|
|
|
+ orig( elems );
|
|
|
+ };
|
|
|
+} )( $.cleanData );
|
|
|
+
|
|
|
+$.widget = function( name, base, prototype ) {
|
|
|
+ var existingConstructor, constructor, basePrototype;
|
|
|
+
|
|
|
+ // ProxiedPrototype allows the provided prototype to remain unmodified
|
|
|
+ // so that it can be used as a mixin for multiple widgets (#8876)
|
|
|
+ var proxiedPrototype = {};
|
|
|
+
|
|
|
+ var namespace = name.split( "." )[ 0 ];
|
|
|
+ name = name.split( "." )[ 1 ];
|
|
|
+ var fullName = namespace + "-" + name;
|
|
|
+
|
|
|
+ if ( !prototype ) {
|
|
|
+ prototype = base;
|
|
|
+ base = $.Widget;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( $.isArray( prototype ) ) {
|
|
|
+ prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
|
|
|
+ }
|
|
|
+
|
|
|
+ // Create selector for plugin
|
|
|
+ $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
|
|
|
+ return !!$.data( elem, fullName );
|
|
|
+ };
|
|
|
+
|
|
|
+ $[ namespace ] = $[ namespace ] || {};
|
|
|
+ existingConstructor = $[ namespace ][ name ];
|
|
|
+ constructor = $[ namespace ][ name ] = function( options, element ) {
|
|
|
+
|
|
|
+ // Allow instantiation without "new" keyword
|
|
|
+ if ( !this._createWidget ) {
|
|
|
+ return new constructor( options, element );
|
|
|
+ }
|
|
|
+
|
|
|
+ // Allow instantiation without initializing for simple inheritance
|
|
|
+ // must use "new" keyword (the code above always passes args)
|
|
|
+ if ( arguments.length ) {
|
|
|
+ this._createWidget( options, element );
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ // Extend with the existing constructor to carry over any static properties
|
|
|
+ $.extend( constructor, existingConstructor, {
|
|
|
+ version: prototype.version,
|
|
|
+
|
|
|
+ // Copy the object used to create the prototype in case we need to
|
|
|
+ // redefine the widget later
|
|
|
+ _proto: $.extend( {}, prototype ),
|
|
|
+
|
|
|
+ // Track widgets that inherit from this widget in case this widget is
|
|
|
+ // redefined after a widget inherits from it
|
|
|
+ _childConstructors: []
|
|
|
+ } );
|
|
|
+
|
|
|
+ basePrototype = new base();
|
|
|
+
|
|
|
+ // We need to make the options hash a property directly on the new instance
|
|
|
+ // otherwise we'll modify the options hash on the prototype that we're
|
|
|
+ // inheriting from
|
|
|
+ basePrototype.options = $.widget.extend( {}, basePrototype.options );
|
|
|
+ $.each( prototype, function( prop, value ) {
|
|
|
+ if ( !$.isFunction( value ) ) {
|
|
|
+ proxiedPrototype[ prop ] = value;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ proxiedPrototype[ prop ] = ( function() {
|
|
|
+ function _super() {
|
|
|
+ return base.prototype[ prop ].apply( this, arguments );
|
|
|
+ }
|
|
|
+
|
|
|
+ function _superApply( args ) {
|
|
|
+ return base.prototype[ prop ].apply( this, args );
|
|
|
+ }
|
|
|
+
|
|
|
+ return function() {
|
|
|
+ var __super = this._super;
|
|
|
+ var __superApply = this._superApply;
|
|
|
+ var returnValue;
|
|
|
+
|
|
|
+ this._super = _super;
|
|
|
+ this._superApply = _superApply;
|
|
|
+
|
|
|
+ returnValue = value.apply( this, arguments );
|
|
|
+
|
|
|
+ this._super = __super;
|
|
|
+ this._superApply = __superApply;
|
|
|
+
|
|
|
+ return returnValue;
|
|
|
+ };
|
|
|
+ } )();
|
|
|
+ } );
|
|
|
+ constructor.prototype = $.widget.extend( basePrototype, {
|
|
|
+
|
|
|
+ // TODO: remove support for widgetEventPrefix
|
|
|
+ // always use the name + a colon as the prefix, e.g., draggable:start
|
|
|
+ // don't prefix for widgets that aren't DOM-based
|
|
|
+ widgetEventPrefix: existingConstructor ? ( basePrototype.widgetEventPrefix || name ) : name
|
|
|
+ }, proxiedPrototype, {
|
|
|
+ constructor: constructor,
|
|
|
+ namespace: namespace,
|
|
|
+ widgetName: name,
|
|
|
+ widgetFullName: fullName
|
|
|
+ } );
|
|
|
+
|
|
|
+ // If this widget is being redefined then we need to find all widgets that
|
|
|
+ // are inheriting from it and redefine all of them so that they inherit from
|
|
|
+ // the new version of this widget. We're essentially trying to replace one
|
|
|
+ // level in the prototype chain.
|
|
|
+ if ( existingConstructor ) {
|
|
|
+ $.each( existingConstructor._childConstructors, function( i, child ) {
|
|
|
+ var childPrototype = child.prototype;
|
|
|
+
|
|
|
+ // Redefine the child widget using the same prototype that was
|
|
|
+ // originally used, but inherit from the new version of the base
|
|
|
+ $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor,
|
|
|
+ child._proto );
|
|
|
+ } );
|
|
|
+
|
|
|
+ // Remove the list of existing child constructors from the old constructor
|
|
|
+ // so the old child constructors can be garbage collected
|
|
|
+ delete existingConstructor._childConstructors;
|
|
|
+ } else {
|
|
|
+ base._childConstructors.push( constructor );
|
|
|
+ }
|
|
|
+
|
|
|
+ $.widget.bridge( name, constructor );
|
|
|
+
|
|
|
+ return constructor;
|
|
|
+};
|
|
|
+
|
|
|
+$.widget.extend = function( target ) {
|
|
|
+ var input = widgetSlice.call( arguments, 1 );
|
|
|
+ var inputIndex = 0;
|
|
|
+ var inputLength = input.length;
|
|
|
+ var key;
|
|
|
+ var value;
|
|
|
+
|
|
|
+ for ( ; inputIndex < inputLength; inputIndex++ ) {
|
|
|
+ for ( key in input[ inputIndex ] ) {
|
|
|
+ value = input[ inputIndex ][ key ];
|
|
|
+ if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
|
|
|
+
|
|
|
+ // Clone objects
|
|
|
+ if ( $.isPlainObject( value ) ) {
|
|
|
+ target[ key ] = $.isPlainObject( target[ key ] ) ?
|
|
|
+ $.widget.extend( {}, target[ key ], value ) :
|
|
|
+
|
|
|
+ // Don't extend strings, arrays, etc. with objects
|
|
|
+ $.widget.extend( {}, value );
|
|
|
+
|
|
|
+ // Copy everything else by reference
|
|
|
+ } else {
|
|
|
+ target[ key ] = value;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return target;
|
|
|
+};
|
|
|
+
|
|
|
+$.widget.bridge = function( name, object ) {
|
|
|
+ var fullName = object.prototype.widgetFullName || name;
|
|
|
+ $.fn[ name ] = function( options ) {
|
|
|
+ var isMethodCall = typeof options === "string";
|
|
|
+ var args = widgetSlice.call( arguments, 1 );
|
|
|
+ var returnValue = this;
|
|
|
+
|
|
|
+ if ( isMethodCall ) {
|
|
|
+
|
|
|
+ // If this is an empty collection, we need to have the instance method
|
|
|
+ // return undefined instead of the jQuery instance
|
|
|
+ if ( !this.length && options === "instance" ) {
|
|
|
+ returnValue = undefined;
|
|
|
+ } else {
|
|
|
+ this.each( function() {
|
|
|
+ var methodValue;
|
|
|
+ var instance = $.data( this, fullName );
|
|
|
+
|
|
|
+ if ( options === "instance" ) {
|
|
|
+ returnValue = instance;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( !instance ) {
|
|
|
+ return $.error( "cannot call methods on " + name +
|
|
|
+ " prior to initialization; " +
|
|
|
+ "attempted to call method '" + options + "'" );
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( !$.isFunction( instance[ options ] ) || options.charAt( 0 ) === "_" ) {
|
|
|
+ return $.error( "no such method '" + options + "' for " + name +
|
|
|
+ " widget instance" );
|
|
|
+ }
|
|
|
+
|
|
|
+ methodValue = instance[ options ].apply( instance, args );
|
|
|
+
|
|
|
+ if ( methodValue !== instance && methodValue !== undefined ) {
|
|
|
+ returnValue = methodValue && methodValue.jquery ?
|
|
|
+ returnValue.pushStack( methodValue.get() ) :
|
|
|
+ methodValue;
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // Allow multiple hashes to be passed on init
|
|
|
+ if ( args.length ) {
|
|
|
+ options = $.widget.extend.apply( null, [ options ].concat( args ) );
|
|
|
+ }
|
|
|
+
|
|
|
+ this.each( function() {
|
|
|
+ var instance = $.data( this, fullName );
|
|
|
+ if ( instance ) {
|
|
|
+ instance.option( options || {} );
|
|
|
+ if ( instance._init ) {
|
|
|
+ instance._init();
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ $.data( this, fullName, new object( options, this ) );
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ }
|
|
|
+
|
|
|
+ return returnValue;
|
|
|
+ };
|
|
|
+};
|
|
|
+
|
|
|
+$.Widget = function( /* options, element */ ) {};
|
|
|
+$.Widget._childConstructors = [];
|
|
|
+
|
|
|
+$.Widget.prototype = {
|
|
|
+ widgetName: "widget",
|
|
|
+ widgetEventPrefix: "",
|
|
|
+ defaultElement: "<div>",
|
|
|
+
|
|
|
+ options: {
|
|
|
+ classes: {},
|
|
|
+ disabled: false,
|
|
|
+
|
|
|
+ // Callbacks
|
|
|
+ create: null
|
|
|
+ },
|
|
|
+
|
|
|
+ _createWidget: function( options, element ) {
|
|
|
+ element = $( element || this.defaultElement || this )[ 0 ];
|
|
|
+ this.element = $( element );
|
|
|
+ this.uuid = widgetUuid++;
|
|
|
+ this.eventNamespace = "." + this.widgetName + this.uuid;
|
|
|
+
|
|
|
+ this.bindings = $();
|
|
|
+ this.hoverable = $();
|
|
|
+ this.focusable = $();
|
|
|
+ this.classesElementLookup = {};
|
|
|
+
|
|
|
+ if ( element !== this ) {
|
|
|
+ $.data( element, this.widgetFullName, this );
|
|
|
+ this._on( true, this.element, {
|
|
|
+ remove: function( event ) {
|
|
|
+ if ( event.target === element ) {
|
|
|
+ this.destroy();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ this.document = $( element.style ?
|
|
|
+
|
|
|
+ // Element within the document
|
|
|
+ element.ownerDocument :
|
|
|
+
|
|
|
+ // Element is window or document
|
|
|
+ element.document || element );
|
|
|
+ this.window = $( this.document[ 0 ].defaultView || this.document[ 0 ].parentWindow );
|
|
|
+ }
|
|
|
+
|
|
|
+ this.options = $.widget.extend( {},
|
|
|
+ this.options,
|
|
|
+ this._getCreateOptions(),
|
|
|
+ options );
|
|
|
+
|
|
|
+ this._create();
|
|
|
+
|
|
|
+ if ( this.options.disabled ) {
|
|
|
+ this._setOptionDisabled( this.options.disabled );
|
|
|
+ }
|
|
|
+
|
|
|
+ this._trigger( "create", null, this._getCreateEventData() );
|
|
|
+ this._init();
|
|
|
+ },
|
|
|
+
|
|
|
+ _getCreateOptions: function() {
|
|
|
+ return {};
|
|
|
+ },
|
|
|
+
|
|
|
+ _getCreateEventData: $.noop,
|
|
|
+
|
|
|
+ _create: $.noop,
|
|
|
+
|
|
|
+ _init: $.noop,
|
|
|
+
|
|
|
+ destroy: function() {
|
|
|
+ var that = this;
|
|
|
+
|
|
|
+ this._destroy();
|
|
|
+ $.each( this.classesElementLookup, function( key, value ) {
|
|
|
+ that._removeClass( value, key );
|
|
|
+ } );
|
|
|
+
|
|
|
+ // We can probably remove the unbind calls in 2.0
|
|
|
+ // all event bindings should go through this._on()
|
|
|
+ this.element
|
|
|
+ .off( this.eventNamespace )
|
|
|
+ .removeData( this.widgetFullName );
|
|
|
+ this.widget()
|
|
|
+ .off( this.eventNamespace )
|
|
|
+ .removeAttr( "aria-disabled" );
|
|
|
+
|
|
|
+ // Clean up events and states
|
|
|
+ this.bindings.off( this.eventNamespace );
|
|
|
+ },
|
|
|
+
|
|
|
+ _destroy: $.noop,
|
|
|
+
|
|
|
+ widget: function() {
|
|
|
+ return this.element;
|
|
|
+ },
|
|
|
+
|
|
|
+ option: function( key, value ) {
|
|
|
+ var options = key;
|
|
|
+ var parts;
|
|
|
+ var curOption;
|
|
|
+ var i;
|
|
|
+
|
|
|
+ if ( arguments.length === 0 ) {
|
|
|
+
|
|
|
+ // Don't return a reference to the internal hash
|
|
|
+ return $.widget.extend( {}, this.options );
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( typeof key === "string" ) {
|
|
|
+
|
|
|
+ // Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
|
|
|
+ options = {};
|
|
|
+ parts = key.split( "." );
|
|
|
+ key = parts.shift();
|
|
|
+ if ( parts.length ) {
|
|
|
+ curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
|
|
|
+ for ( i = 0; i < parts.length - 1; i++ ) {
|
|
|
+ curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
|
|
|
+ curOption = curOption[ parts[ i ] ];
|
|
|
+ }
|
|
|
+ key = parts.pop();
|
|
|
+ if ( arguments.length === 1 ) {
|
|
|
+ return curOption[ key ] === undefined ? null : curOption[ key ];
|
|
|
+ }
|
|
|
+ curOption[ key ] = value;
|
|
|
+ } else {
|
|
|
+ if ( arguments.length === 1 ) {
|
|
|
+ return this.options[ key ] === undefined ? null : this.options[ key ];
|
|
|
+ }
|
|
|
+ options[ key ] = value;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ this._setOptions( options );
|
|
|
+
|
|
|
+ return this;
|
|
|
+ },
|
|
|
+
|
|
|
+ _setOptions: function( options ) {
|
|
|
+ var key;
|
|
|
+
|
|
|
+ for ( key in options ) {
|
|
|
+ this._setOption( key, options[ key ] );
|
|
|
+ }
|
|
|
+
|
|
|
+ return this;
|
|
|
+ },
|
|
|
+
|
|
|
+ _setOption: function( key, value ) {
|
|
|
+ if ( key === "classes" ) {
|
|
|
+ this._setOptionClasses( value );
|
|
|
+ }
|
|
|
+
|
|
|
+ this.options[ key ] = value;
|
|
|
+
|
|
|
+ if ( key === "disabled" ) {
|
|
|
+ this._setOptionDisabled( value );
|
|
|
+ }
|
|
|
+
|
|
|
+ return this;
|
|
|
+ },
|
|
|
+
|
|
|
+ _setOptionClasses: function( value ) {
|
|
|
+ var classKey, elements, currentElements;
|
|
|
+
|
|
|
+ for ( classKey in value ) {
|
|
|
+ currentElements = this.classesElementLookup[ classKey ];
|
|
|
+ if ( value[ classKey ] === this.options.classes[ classKey ] ||
|
|
|
+ !currentElements ||
|
|
|
+ !currentElements.length ) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // We are doing this to create a new jQuery object because the _removeClass() call
|
|
|
+ // on the next line is going to destroy the reference to the current elements being
|
|
|
+ // tracked. We need to save a copy of this collection so that we can add the new classes
|
|
|
+ // below.
|
|
|
+ elements = $( currentElements.get() );
|
|
|
+ this._removeClass( currentElements, classKey );
|
|
|
+
|
|
|
+ // We don't use _addClass() here, because that uses this.options.classes
|
|
|
+ // for generating the string of classes. We want to use the value passed in from
|
|
|
+ // _setOption(), this is the new value of the classes option which was passed to
|
|
|
+ // _setOption(). We pass this value directly to _classes().
|
|
|
+ elements.addClass( this._classes( {
|
|
|
+ element: elements,
|
|
|
+ keys: classKey,
|
|
|
+ classes: value,
|
|
|
+ add: true
|
|
|
+ } ) );
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ _setOptionDisabled: function( value ) {
|
|
|
+ this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );
|
|
|
+
|
|
|
+ // If the widget is becoming disabled, then nothing is interactive
|
|
|
+ if ( value ) {
|
|
|
+ this._removeClass( this.hoverable, null, "ui-state-hover" );
|
|
|
+ this._removeClass( this.focusable, null, "ui-state-focus" );
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ enable: function() {
|
|
|
+ return this._setOptions( { disabled: false } );
|
|
|
+ },
|
|
|
+
|
|
|
+ disable: function() {
|
|
|
+ return this._setOptions( { disabled: true } );
|
|
|
+ },
|
|
|
+
|
|
|
+ _classes: function( options ) {
|
|
|
+ var full = [];
|
|
|
+ var that = this;
|
|
|
+
|
|
|
+ options = $.extend( {
|
|
|
+ element: this.element,
|
|
|
+ classes: this.options.classes || {}
|
|
|
+ }, options );
|
|
|
+
|
|
|
+ function processClassString( classes, checkOption ) {
|
|
|
+ var current, i;
|
|
|
+ for ( i = 0; i < classes.length; i++ ) {
|
|
|
+ current = that.classesElementLookup[ classes[ i ] ] || $();
|
|
|
+ if ( options.add ) {
|
|
|
+ current = $( $.unique( current.get().concat( options.element.get() ) ) );
|
|
|
+ } else {
|
|
|
+ current = $( current.not( options.element ).get() );
|
|
|
+ }
|
|
|
+ that.classesElementLookup[ classes[ i ] ] = current;
|
|
|
+ full.push( classes[ i ] );
|
|
|
+ if ( checkOption && options.classes[ classes[ i ] ] ) {
|
|
|
+ full.push( options.classes[ classes[ i ] ] );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ this._on( options.element, {
|
|
|
+ "remove": "_untrackClassesElement"
|
|
|
+ } );
|
|
|
+
|
|
|
+ if ( options.keys ) {
|
|
|
+ processClassString( options.keys.match( /\S+/g ) || [], true );
|
|
|
+ }
|
|
|
+ if ( options.extra ) {
|
|
|
+ processClassString( options.extra.match( /\S+/g ) || [] );
|
|
|
+ }
|
|
|
+
|
|
|
+ return full.join( " " );
|
|
|
+ },
|
|
|
+
|
|
|
+ _untrackClassesElement: function( event ) {
|
|
|
+ var that = this;
|
|
|
+ $.each( that.classesElementLookup, function( key, value ) {
|
|
|
+ if ( $.inArray( event.target, value ) !== -1 ) {
|
|
|
+ that.classesElementLookup[ key ] = $( value.not( event.target ).get() );
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ },
|
|
|
+
|
|
|
+ _removeClass: function( element, keys, extra ) {
|
|
|
+ return this._toggleClass( element, keys, extra, false );
|
|
|
+ },
|
|
|
+
|
|
|
+ _addClass: function( element, keys, extra ) {
|
|
|
+ return this._toggleClass( element, keys, extra, true );
|
|
|
+ },
|
|
|
+
|
|
|
+ _toggleClass: function( element, keys, extra, add ) {
|
|
|
+ add = ( typeof add === "boolean" ) ? add : extra;
|
|
|
+ var shift = ( typeof element === "string" || element === null ),
|
|
|
+ options = {
|
|
|
+ extra: shift ? keys : extra,
|
|
|
+ keys: shift ? element : keys,
|
|
|
+ element: shift ? this.element : element,
|
|
|
+ add: add
|
|
|
+ };
|
|
|
+ options.element.toggleClass( this._classes( options ), add );
|
|
|
+ return this;
|
|
|
+ },
|
|
|
+
|
|
|
+ _on: function( suppressDisabledCheck, element, handlers ) {
|
|
|
+ var delegateElement;
|
|
|
+ var instance = this;
|
|
|
+
|
|
|
+ // No suppressDisabledCheck flag, shuffle arguments
|
|
|
+ if ( typeof suppressDisabledCheck !== "boolean" ) {
|
|
|
+ handlers = element;
|
|
|
+ element = suppressDisabledCheck;
|
|
|
+ suppressDisabledCheck = false;
|
|
|
+ }
|
|
|
+
|
|
|
+ // No element argument, shuffle and use this.element
|
|
|
+ if ( !handlers ) {
|
|
|
+ handlers = element;
|
|
|
+ element = this.element;
|
|
|
+ delegateElement = this.widget();
|
|
|
+ } else {
|
|
|
+ element = delegateElement = $( element );
|
|
|
+ this.bindings = this.bindings.add( element );
|
|
|
+ }
|
|
|
+
|
|
|
+ $.each( handlers, function( event, handler ) {
|
|
|
+ function handlerProxy() {
|
|
|
+
|
|
|
+ // Allow widgets to customize the disabled handling
|
|
|
+ // - disabled as an array instead of boolean
|
|
|
+ // - disabled class as method for disabling individual parts
|
|
|
+ if ( !suppressDisabledCheck &&
|
|
|
+ ( instance.options.disabled === true ||
|
|
|
+ $( this ).hasClass( "ui-state-disabled" ) ) ) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ return ( typeof handler === "string" ? instance[ handler ] : handler )
|
|
|
+ .apply( instance, arguments );
|
|
|
+ }
|
|
|
+
|
|
|
+ // Copy the guid so direct unbinding works
|
|
|
+ if ( typeof handler !== "string" ) {
|
|
|
+ handlerProxy.guid = handler.guid =
|
|
|
+ handler.guid || handlerProxy.guid || $.guid++;
|
|
|
+ }
|
|
|
+
|
|
|
+ var match = event.match( /^([\w:-]*)\s*(.*)$/ );
|
|
|
+ var eventName = match[ 1 ] + instance.eventNamespace;
|
|
|
+ var selector = match[ 2 ];
|
|
|
+
|
|
|
+ if ( selector ) {
|
|
|
+ delegateElement.on( eventName, selector, handlerProxy );
|
|
|
+ } else {
|
|
|
+ element.on( eventName, handlerProxy );
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ },
|
|
|
+
|
|
|
+ _off: function( element, eventName ) {
|
|
|
+ eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
|
|
|
+ this.eventNamespace;
|
|
|
+ element.off( eventName ).off( eventName );
|
|
|
+
|
|
|
+ // Clear the stack to avoid memory leaks (#10056)
|
|
|
+ this.bindings = $( this.bindings.not( element ).get() );
|
|
|
+ this.focusable = $( this.focusable.not( element ).get() );
|
|
|
+ this.hoverable = $( this.hoverable.not( element ).get() );
|
|
|
+ },
|
|
|
+
|
|
|
+ _delay: function( handler, delay ) {
|
|
|
+ function handlerProxy() {
|
|
|
+ return ( typeof handler === "string" ? instance[ handler ] : handler )
|
|
|
+ .apply( instance, arguments );
|
|
|
+ }
|
|
|
+ var instance = this;
|
|
|
+ return setTimeout( handlerProxy, delay || 0 );
|
|
|
+ },
|
|
|
+
|
|
|
+ _hoverable: function( element ) {
|
|
|
+ this.hoverable = this.hoverable.add( element );
|
|
|
+ this._on( element, {
|
|
|
+ mouseenter: function( event ) {
|
|
|
+ this._addClass( $( event.currentTarget ), null, "ui-state-hover" );
|
|
|
+ },
|
|
|
+ mouseleave: function( event ) {
|
|
|
+ this._removeClass( $( event.currentTarget ), null, "ui-state-hover" );
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ },
|
|
|
+
|
|
|
+ _focusable: function( element ) {
|
|
|
+ this.focusable = this.focusable.add( element );
|
|
|
+ this._on( element, {
|
|
|
+ focusin: function( event ) {
|
|
|
+ this._addClass( $( event.currentTarget ), null, "ui-state-focus" );
|
|
|
+ },
|
|
|
+ focusout: function( event ) {
|
|
|
+ this._removeClass( $( event.currentTarget ), null, "ui-state-focus" );
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ },
|
|
|
+
|
|
|
+ _trigger: function( type, event, data ) {
|
|
|
+ var prop, orig;
|
|
|
+ var callback = this.options[ type ];
|
|
|
+
|
|
|
+ data = data || {};
|
|
|
+ event = $.Event( event );
|
|
|
+ event.type = ( type === this.widgetEventPrefix ?
|
|
|
+ type :
|
|
|
+ this.widgetEventPrefix + type ).toLowerCase();
|
|
|
+
|
|
|
+ // The original event may come from any element
|
|
|
+ // so we need to reset the target on the new event
|
|
|
+ event.target = this.element[ 0 ];
|
|
|
+
|
|
|
+ // Copy original event properties over to the new event
|
|
|
+ orig = event.originalEvent;
|
|
|
+ if ( orig ) {
|
|
|
+ for ( prop in orig ) {
|
|
|
+ if ( !( prop in event ) ) {
|
|
|
+ event[ prop ] = orig[ prop ];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ this.element.trigger( event, data );
|
|
|
+ return !( $.isFunction( callback ) &&
|
|
|
+ callback.apply( this.element[ 0 ], [ event ].concat( data ) ) === false ||
|
|
|
+ event.isDefaultPrevented() );
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+$.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
|
|
|
+ $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
|
|
|
+ if ( typeof options === "string" ) {
|
|
|
+ options = { effect: options };
|
|
|
+ }
|
|
|
+
|
|
|
+ var hasOptions;
|
|
|
+ var effectName = !options ?
|
|
|
+ method :
|
|
|
+ options === true || typeof options === "number" ?
|
|
|
+ defaultEffect :
|
|
|
+ options.effect || defaultEffect;
|
|
|
+
|
|
|
+ options = options || {};
|
|
|
+ if ( typeof options === "number" ) {
|
|
|
+ options = { duration: options };
|
|
|
+ }
|
|
|
+
|
|
|
+ hasOptions = !$.isEmptyObject( options );
|
|
|
+ options.complete = callback;
|
|
|
+
|
|
|
+ if ( options.delay ) {
|
|
|
+ element.delay( options.delay );
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
|
|
|
+ element[ method ]( options );
|
|
|
+ } else if ( effectName !== method && element[ effectName ] ) {
|
|
|
+ element[ effectName ]( options.duration, options.easing, callback );
|
|
|
+ } else {
|
|
|
+ element.queue( function( next ) {
|
|
|
+ $( this )[ method ]();
|
|
|
+ if ( callback ) {
|
|
|
+ callback.call( element[ 0 ] );
|
|
|
+ }
|
|
|
+ next();
|
|
|
+ } );
|
|
|
+ }
|
|
|
+ };
|
|
|
+} );
|
|
|
+
|
|
|
+var widget = $.widget;
|
|
|
+
|
|
|
+
|
|
|
+/*!
|
|
|
+ * jQuery UI Keycode 1.12.1
|
|
|
+ * http://jqueryui.com
|
|
|
+ *
|
|
|
+ * Copyright jQuery Foundation and other contributors
|
|
|
+ * Released under the MIT license.
|
|
|
+ * http://jquery.org/license
|
|
|
+ */
|
|
|
+
|
|
|
+//>>label: Keycode
|
|
|
+//>>group: Core
|
|
|
+//>>description: Provide keycodes as keynames
|
|
|
+//>>docs: http://api.jqueryui.com/jQuery.ui.keyCode/
|
|
|
+
|
|
|
+
|
|
|
+var keycode = $.ui.keyCode = {
|
|
|
+ BACKSPACE: 8,
|
|
|
+ COMMA: 188,
|
|
|
+ DELETE: 46,
|
|
|
+ DOWN: 40,
|
|
|
+ END: 35,
|
|
|
+ ENTER: 13,
|
|
|
+ ESCAPE: 27,
|
|
|
+ HOME: 36,
|
|
|
+ LEFT: 37,
|
|
|
+ PAGE_DOWN: 34,
|
|
|
+ PAGE_UP: 33,
|
|
|
+ PERIOD: 190,
|
|
|
+ RIGHT: 39,
|
|
|
+ SPACE: 32,
|
|
|
+ TAB: 9,
|
|
|
+ UP: 38
|
|
|
+};
|
|
|
+
|
|
|
+
|
|
|
+/*!
|
|
|
+ * jQuery UI Unique ID 1.12.1
|
|
|
+ * http://jqueryui.com
|
|
|
+ *
|
|
|
+ * Copyright jQuery Foundation and other contributors
|
|
|
+ * Released under the MIT license.
|
|
|
+ * http://jquery.org/license
|
|
|
+ */
|
|
|
+
|
|
|
+//>>label: uniqueId
|
|
|
+//>>group: Core
|
|
|
+//>>description: Functions to generate and remove uniqueId's
|
|
|
+//>>docs: http://api.jqueryui.com/uniqueId/
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+var uniqueId = $.fn.extend( {
|
|
|
+ uniqueId: ( function() {
|
|
|
+ var uuid = 0;
|
|
|
+
|
|
|
+ return function() {
|
|
|
+ return this.each( function() {
|
|
|
+ if ( !this.id ) {
|
|
|
+ this.id = "ui-id-" + ( ++uuid );
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ };
|
|
|
+ } )(),
|
|
|
+
|
|
|
+ removeUniqueId: function() {
|
|
|
+ return this.each( function() {
|
|
|
+ if ( /^ui-id-\d+$/.test( this.id ) ) {
|
|
|
+ $( this ).removeAttr( "id" );
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ }
|
|
|
+} );
|
|
|
+
|
|
|
+
|
|
|
+/*!
|
|
|
+ * jQuery UI Accordion 1.12.1
|
|
|
+ * http://jqueryui.com
|
|
|
+ *
|
|
|
+ * Copyright jQuery Foundation and other contributors
|
|
|
+ * Released under the MIT license.
|
|
|
+ * http://jquery.org/license
|
|
|
+ */
|
|
|
+
|
|
|
+//>>label: Accordion
|
|
|
+//>>group: Widgets
|
|
|
+// jscs:disable maximumLineLength
|
|
|
+//>>description: Displays collapsible content panels for presenting information in a limited amount of space.
|
|
|
+// jscs:enable maximumLineLength
|
|
|
+//>>docs: http://api.jqueryui.com/accordion/
|
|
|
+//>>demos: http://jqueryui.com/accordion/
|
|
|
+//>>css.structure: ../../themes/base/core.css
|
|
|
+//>>css.structure: ../../themes/base/accordion.css
|
|
|
+//>>css.theme: ../../themes/base/theme.css
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+var widgetsAccordion = $.widget( "ui.accordion", {
|
|
|
+ version: "1.12.1",
|
|
|
+ options: {
|
|
|
+ active: 0,
|
|
|
+ animate: {},
|
|
|
+ classes: {
|
|
|
+ "ui-accordion-header": "ui-corner-top",
|
|
|
+ "ui-accordion-header-collapsed": "ui-corner-all",
|
|
|
+ "ui-accordion-content": "ui-corner-bottom"
|
|
|
+ },
|
|
|
+ collapsible: false,
|
|
|
+ event: "click",
|
|
|
+ header: "> li > :first-child, > :not(li):even",
|
|
|
+ heightStyle: "auto",
|
|
|
+ icons: {
|
|
|
+ activeHeader: "ui-icon-triangle-1-s",
|
|
|
+ header: "ui-icon-triangle-1-e"
|
|
|
+ },
|
|
|
+
|
|
|
+ // Callbacks
|
|
|
+ activate: null,
|
|
|
+ beforeActivate: null
|
|
|
+ },
|
|
|
+
|
|
|
+ hideProps: {
|
|
|
+ borderTopWidth: "hide",
|
|
|
+ borderBottomWidth: "hide",
|
|
|
+ paddingTop: "hide",
|
|
|
+ paddingBottom: "hide",
|
|
|
+ height: "hide"
|
|
|
+ },
|
|
|
+
|
|
|
+ showProps: {
|
|
|
+ borderTopWidth: "show",
|
|
|
+ borderBottomWidth: "show",
|
|
|
+ paddingTop: "show",
|
|
|
+ paddingBottom: "show",
|
|
|
+ height: "show"
|
|
|
+ },
|
|
|
+
|
|
|
+ _create: function() {
|
|
|
+ var options = this.options;
|
|
|
+
|
|
|
+ this.prevShow = this.prevHide = $();
|
|
|
+ this._addClass( "ui-accordion", "ui-widget ui-helper-reset" );
|
|
|
+ this.element.attr( "role", "tablist" );
|
|
|
+
|
|
|
+ // Don't allow collapsible: false and active: false / null
|
|
|
+ if ( !options.collapsible && ( options.active === false || options.active == null ) ) {
|
|
|
+ options.active = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ this._processPanels();
|
|
|
+
|
|
|
+ // handle negative values
|
|
|
+ if ( options.active < 0 ) {
|
|
|
+ options.active += this.headers.length;
|
|
|
+ }
|
|
|
+ this._refresh();
|
|
|
+ },
|
|
|
+
|
|
|
+ _getCreateEventData: function() {
|
|
|
+ return {
|
|
|
+ header: this.active,
|
|
|
+ panel: !this.active.length ? $() : this.active.next()
|
|
|
+ };
|
|
|
+ },
|
|
|
+
|
|
|
+ _createIcons: function() {
|
|
|
+ var icon, children,
|
|
|
+ icons = this.options.icons;
|
|
|
+
|
|
|
+ if ( icons ) {
|
|
|
+ icon = $( "<span>" );
|
|
|
+ this._addClass( icon, "ui-accordion-header-icon", "ui-icon " + icons.header );
|
|
|
+ icon.prependTo( this.headers );
|
|
|
+ children = this.active.children( ".ui-accordion-header-icon" );
|
|
|
+ this._removeClass( children, icons.header )
|
|
|
+ ._addClass( children, null, icons.activeHeader )
|
|
|
+ ._addClass( this.headers, "ui-accordion-icons" );
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ _destroyIcons: function() {
|
|
|
+ this._removeClass( this.headers, "ui-accordion-icons" );
|
|
|
+ this.headers.children( ".ui-accordion-header-icon" ).remove();
|
|
|
+ },
|
|
|
+
|
|
|
+ _destroy: function() {
|
|
|
+ var contents;
|
|
|
+
|
|
|
+ // Clean up main element
|
|
|
+ this.element.removeAttr( "role" );
|
|
|
+
|
|
|
+ // Clean up headers
|
|
|
+ this.headers
|
|
|
+ .removeAttr( "role aria-expanded aria-selected aria-controls tabIndex" )
|
|
|
+ .removeUniqueId();
|
|
|
+
|
|
|
+ this._destroyIcons();
|
|
|
+
|
|
|
+ // Clean up content panels
|
|
|
+ contents = this.headers.next()
|
|
|
+ .css( "display", "" )
|
|
|
+ .removeAttr( "role aria-hidden aria-labelledby" )
|
|
|
+ .removeUniqueId();
|
|
|
+
|
|
|
+ if ( this.options.heightStyle !== "content" ) {
|
|
|
+ contents.css( "height", "" );
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ _setOption: function( key, value ) {
|
|
|
+ if ( key === "active" ) {
|
|
|
+
|
|
|
+ // _activate() will handle invalid values and update this.options
|
|
|
+ this._activate( value );
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( key === "event" ) {
|
|
|
+ if ( this.options.event ) {
|
|
|
+ this._off( this.headers, this.options.event );
|
|
|
+ }
|
|
|
+ this._setupEvents( value );
|
|
|
+ }
|
|
|
+
|
|
|
+ this._super( key, value );
|
|
|
+
|
|
|
+ // Setting collapsible: false while collapsed; open first panel
|
|
|
+ if ( key === "collapsible" && !value && this.options.active === false ) {
|
|
|
+ this._activate( 0 );
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( key === "icons" ) {
|
|
|
+ this._destroyIcons();
|
|
|
+ if ( value ) {
|
|
|
+ this._createIcons();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ _setOptionDisabled: function( value ) {
|
|
|
+ this._super( value );
|
|
|
+
|
|
|
+ this.element.attr( "aria-disabled", value );
|
|
|
+
|
|
|
+ // Support: IE8 Only
|
|
|
+ // #5332 / #6059 - opacity doesn't cascade to positioned elements in IE
|
|
|
+ // so we need to add the disabled class to the headers and panels
|
|
|
+ this._toggleClass( null, "ui-state-disabled", !!value );
|
|
|
+ this._toggleClass( this.headers.add( this.headers.next() ), null, "ui-state-disabled",
|
|
|
+ !!value );
|
|
|
+ },
|
|
|
+
|
|
|
+ _keydown: function( event ) {
|
|
|
+ if ( event.altKey || event.ctrlKey ) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var keyCode = $.ui.keyCode,
|
|
|
+ length = this.headers.length,
|
|
|
+ currentIndex = this.headers.index( event.target ),
|
|
|
+ toFocus = false;
|
|
|
+
|
|
|
+ switch ( event.keyCode ) {
|
|
|
+ case keyCode.RIGHT:
|
|
|
+ case keyCode.DOWN:
|
|
|
+ toFocus = this.headers[ ( currentIndex + 1 ) % length ];
|
|
|
+ break;
|
|
|
+ case keyCode.LEFT:
|
|
|
+ case keyCode.UP:
|
|
|
+ toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
|
|
|
+ break;
|
|
|
+ case keyCode.SPACE:
|
|
|
+ case keyCode.ENTER:
|
|
|
+ this._eventHandler( event );
|
|
|
+ break;
|
|
|
+ case keyCode.HOME:
|
|
|
+ toFocus = this.headers[ 0 ];
|
|
|
+ break;
|
|
|
+ case keyCode.END:
|
|
|
+ toFocus = this.headers[ length - 1 ];
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( toFocus ) {
|
|
|
+ $( event.target ).attr( "tabIndex", -1 );
|
|
|
+ $( toFocus ).attr( "tabIndex", 0 );
|
|
|
+ $( toFocus ).trigger( "focus" );
|
|
|
+ event.preventDefault();
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ _panelKeyDown: function( event ) {
|
|
|
+ if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
|
|
|
+ $( event.currentTarget ).prev().trigger( "focus" );
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ refresh: function() {
|
|
|
+ var options = this.options;
|
|
|
+ this._processPanels();
|
|
|
+
|
|
|
+ // Was collapsed or no panel
|
|
|
+ if ( ( options.active === false && options.collapsible === true ) ||
|
|
|
+ !this.headers.length ) {
|
|
|
+ options.active = false;
|
|
|
+ this.active = $();
|
|
|
+
|
|
|
+ // active false only when collapsible is true
|
|
|
+ } else if ( options.active === false ) {
|
|
|
+ this._activate( 0 );
|
|
|
+
|
|
|
+ // was active, but active panel is gone
|
|
|
+ } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
|
|
|
+
|
|
|
+ // all remaining panel are disabled
|
|
|
+ if ( this.headers.length === this.headers.find( ".ui-state-disabled" ).length ) {
|
|
|
+ options.active = false;
|
|
|
+ this.active = $();
|
|
|
+
|
|
|
+ // activate previous panel
|
|
|
+ } else {
|
|
|
+ this._activate( Math.max( 0, options.active - 1 ) );
|
|
|
+ }
|
|
|
+
|
|
|
+ // was active, active panel still exists
|
|
|
+ } else {
|
|
|
+
|
|
|
+ // make sure active index is correct
|
|
|
+ options.active = this.headers.index( this.active );
|
|
|
+ }
|
|
|
+
|
|
|
+ this._destroyIcons();
|
|
|
+
|
|
|
+ this._refresh();
|
|
|
+ },
|
|
|
+
|
|
|
+ _processPanels: function() {
|
|
|
+ var prevHeaders = this.headers,
|
|
|
+ prevPanels = this.panels;
|
|
|
+
|
|
|
+ this.headers = this.element.find( this.options.header );
|
|
|
+ this._addClass( this.headers, "ui-accordion-header ui-accordion-header-collapsed",
|
|
|
+ "ui-state-default" );
|
|
|
+
|
|
|
+ this.panels = this.headers.next().filter( ":not(.ui-accordion-content-active)" ).hide();
|
|
|
+ this._addClass( this.panels, "ui-accordion-content", "ui-helper-reset ui-widget-content" );
|
|
|
+
|
|
|
+ // Avoid memory leaks (#10056)
|
|
|
+ if ( prevPanels ) {
|
|
|
+ this._off( prevHeaders.not( this.headers ) );
|
|
|
+ this._off( prevPanels.not( this.panels ) );
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ _refresh: function() {
|
|
|
+ var maxHeight,
|
|
|
+ options = this.options,
|
|
|
+ heightStyle = options.heightStyle,
|
|
|
+ parent = this.element.parent();
|
|
|
+
|
|
|
+ this.active = this._findActive( options.active );
|
|
|
+ this._addClass( this.active, "ui-accordion-header-active", "ui-state-active" )
|
|
|
+ ._removeClass( this.active, "ui-accordion-header-collapsed" );
|
|
|
+ this._addClass( this.active.next(), "ui-accordion-content-active" );
|
|
|
+ this.active.next().show();
|
|
|
+
|
|
|
+ this.headers
|
|
|
+ .attr( "role", "tab" )
|
|
|
+ .each( function() {
|
|
|
+ var header = $( this ),
|
|
|
+ headerId = header.uniqueId().attr( "id" ),
|
|
|
+ panel = header.next(),
|
|
|
+ panelId = panel.uniqueId().attr( "id" );
|
|
|
+ header.attr( "aria-controls", panelId );
|
|
|
+ panel.attr( "aria-labelledby", headerId );
|
|
|
+ } )
|
|
|
+ .next()
|
|
|
+ .attr( "role", "tabpanel" );
|
|
|
+
|
|
|
+ this.headers
|
|
|
+ .not( this.active )
|
|
|
+ .attr( {
|
|
|
+ "aria-selected": "false",
|
|
|
+ "aria-expanded": "false",
|
|
|
+ tabIndex: -1
|
|
|
+ } )
|
|
|
+ .next()
|
|
|
+ .attr( {
|
|
|
+ "aria-hidden": "true"
|
|
|
+ } )
|
|
|
+ .hide();
|
|
|
+
|
|
|
+ // Make sure at least one header is in the tab order
|
|
|
+ if ( !this.active.length ) {
|
|
|
+ this.headers.eq( 0 ).attr( "tabIndex", 0 );
|
|
|
+ } else {
|
|
|
+ this.active.attr( {
|
|
|
+ "aria-selected": "true",
|
|
|
+ "aria-expanded": "true",
|
|
|
+ tabIndex: 0
|
|
|
+ } )
|
|
|
+ .next()
|
|
|
+ .attr( {
|
|
|
+ "aria-hidden": "false"
|
|
|
+ } );
|
|
|
+ }
|
|
|
+
|
|
|
+ this._createIcons();
|
|
|
+
|
|
|
+ this._setupEvents( options.event );
|
|
|
+
|
|
|
+ if ( heightStyle === "fill" ) {
|
|
|
+ maxHeight = parent.height();
|
|
|
+ this.element.siblings( ":visible" ).each( function() {
|
|
|
+ var elem = $( this ),
|
|
|
+ position = elem.css( "position" );
|
|
|
+
|
|
|
+ if ( position === "absolute" || position === "fixed" ) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ maxHeight -= elem.outerHeight( true );
|
|
|
+ } );
|
|
|
+
|
|
|
+ this.headers.each( function() {
|
|
|
+ maxHeight -= $( this ).outerHeight( true );
|
|
|
+ } );
|
|
|
+
|
|
|
+ this.headers.next()
|
|
|
+ .each( function() {
|
|
|
+ $( this ).height( Math.max( 0, maxHeight -
|
|
|
+ $( this ).innerHeight() + $( this ).height() ) );
|
|
|
+ } )
|
|
|
+ .css( "overflow", "auto" );
|
|
|
+ } else if ( heightStyle === "auto" ) {
|
|
|
+ maxHeight = 0;
|
|
|
+ this.headers.next()
|
|
|
+ .each( function() {
|
|
|
+ var isVisible = $( this ).is( ":visible" );
|
|
|
+ if ( !isVisible ) {
|
|
|
+ $( this ).show();
|
|
|
+ }
|
|
|
+ maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
|
|
|
+ if ( !isVisible ) {
|
|
|
+ $( this ).hide();
|
|
|
+ }
|
|
|
+ } )
|
|
|
+ .height( maxHeight );
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ _activate: function( index ) {
|
|
|
+ var active = this._findActive( index )[ 0 ];
|
|
|
+
|
|
|
+ // Trying to activate the already active panel
|
|
|
+ if ( active === this.active[ 0 ] ) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Trying to collapse, simulate a click on the currently active header
|
|
|
+ active = active || this.active[ 0 ];
|
|
|
+
|
|
|
+ this._eventHandler( {
|
|
|
+ target: active,
|
|
|
+ currentTarget: active,
|
|
|
+ preventDefault: $.noop
|
|
|
+ } );
|
|
|
+ },
|
|
|
+
|
|
|
+ _findActive: function( selector ) {
|
|
|
+ return typeof selector === "number" ? this.headers.eq( selector ) : $();
|
|
|
+ },
|
|
|
+
|
|
|
+ _setupEvents: function( event ) {
|
|
|
+ var events = {
|
|
|
+ keydown: "_keydown"
|
|
|
+ };
|
|
|
+ if ( event ) {
|
|
|
+ $.each( event.split( " " ), function( index, eventName ) {
|
|
|
+ events[ eventName ] = "_eventHandler";
|
|
|
+ } );
|
|
|
+ }
|
|
|
+
|
|
|
+ this._off( this.headers.add( this.headers.next() ) );
|
|
|
+ this._on( this.headers, events );
|
|
|
+ this._on( this.headers.next(), { keydown: "_panelKeyDown" } );
|
|
|
+ this._hoverable( this.headers );
|
|
|
+ this._focusable( this.headers );
|
|
|
+ },
|
|
|
+
|
|
|
+ _eventHandler: function( event ) {
|
|
|
+ var activeChildren, clickedChildren,
|
|
|
+ options = this.options,
|
|
|
+ active = this.active,
|
|
|
+ clicked = $( event.currentTarget ),
|
|
|
+ clickedIsActive = clicked[ 0 ] === active[ 0 ],
|
|
|
+ collapsing = clickedIsActive && options.collapsible,
|
|
|
+ toShow = collapsing ? $() : clicked.next(),
|
|
|
+ toHide = active.next(),
|
|
|
+ eventData = {
|
|
|
+ oldHeader: active,
|
|
|
+ oldPanel: toHide,
|
|
|
+ newHeader: collapsing ? $() : clicked,
|
|
|
+ newPanel: toShow
|
|
|
+ };
|
|
|
+
|
|
|
+ event.preventDefault();
|
|
|
+
|
|
|
+ if (
|
|
|
+
|
|
|
+ // click on active header, but not collapsible
|
|
|
+ ( clickedIsActive && !options.collapsible ) ||
|
|
|
+
|
|
|
+ // allow canceling activation
|
|
|
+ ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ options.active = collapsing ? false : this.headers.index( clicked );
|
|
|
+
|
|
|
+ // When the call to ._toggle() comes after the class changes
|
|
|
+ // it causes a very odd bug in IE 8 (see #6720)
|
|
|
+ this.active = clickedIsActive ? $() : clicked;
|
|
|
+ this._toggle( eventData );
|
|
|
+
|
|
|
+ // Switch classes
|
|
|
+ // corner classes on the previously active header stay after the animation
|
|
|
+ this._removeClass( active, "ui-accordion-header-active", "ui-state-active" );
|
|
|
+ if ( options.icons ) {
|
|
|
+ activeChildren = active.children( ".ui-accordion-header-icon" );
|
|
|
+ this._removeClass( activeChildren, null, options.icons.activeHeader )
|
|
|
+ ._addClass( activeChildren, null, options.icons.header );
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( !clickedIsActive ) {
|
|
|
+ this._removeClass( clicked, "ui-accordion-header-collapsed" )
|
|
|
+ ._addClass( clicked, "ui-accordion-header-active", "ui-state-active" );
|
|
|
+ if ( options.icons ) {
|
|
|
+ clickedChildren = clicked.children( ".ui-accordion-header-icon" );
|
|
|
+ this._removeClass( clickedChildren, null, options.icons.header )
|
|
|
+ ._addClass( clickedChildren, null, options.icons.activeHeader );
|
|
|
+ }
|
|
|
+
|
|
|
+ this._addClass( clicked.next(), "ui-accordion-content-active" );
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ _toggle: function( data ) {
|
|
|
+ var toShow = data.newPanel,
|
|
|
+ toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
|
|
|
+
|
|
|
+ // Handle activating a panel during the animation for another activation
|
|
|
+ this.prevShow.add( this.prevHide ).stop( true, true );
|
|
|
+ this.prevShow = toShow;
|
|
|
+ this.prevHide = toHide;
|
|
|
+
|
|
|
+ if ( this.options.animate ) {
|
|
|
+ this._animate( toShow, toHide, data );
|
|
|
+ } else {
|
|
|
+ toHide.hide();
|
|
|
+ toShow.show();
|
|
|
+ this._toggleComplete( data );
|
|
|
+ }
|
|
|
+
|
|
|
+ toHide.attr( {
|
|
|
+ "aria-hidden": "true"
|
|
|
+ } );
|
|
|
+ toHide.prev().attr( {
|
|
|
+ "aria-selected": "false",
|
|
|
+ "aria-expanded": "false"
|
|
|
+ } );
|
|
|
+
|
|
|
+ // if we're switching panels, remove the old header from the tab order
|
|
|
+ // if we're opening from collapsed state, remove the previous header from the tab order
|
|
|
+ // if we're collapsing, then keep the collapsing header in the tab order
|
|
|
+ if ( toShow.length && toHide.length ) {
|
|
|
+ toHide.prev().attr( {
|
|
|
+ "tabIndex": -1,
|
|
|
+ "aria-expanded": "false"
|
|
|
+ } );
|
|
|
+ } else if ( toShow.length ) {
|
|
|
+ this.headers.filter( function() {
|
|
|
+ return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0;
|
|
|
+ } )
|
|
|
+ .attr( "tabIndex", -1 );
|
|
|
+ }
|
|
|
+
|
|
|
+ toShow
|
|
|
+ .attr( "aria-hidden", "false" )
|
|
|
+ .prev()
|
|
|
+ .attr( {
|
|
|
+ "aria-selected": "true",
|
|
|
+ "aria-expanded": "true",
|
|
|
+ tabIndex: 0
|
|
|
+ } );
|
|
|
+ },
|
|
|
+
|
|
|
+ _animate: function( toShow, toHide, data ) {
|
|
|
+ var total, easing, duration,
|
|
|
+ that = this,
|
|
|
+ adjust = 0,
|
|
|
+ boxSizing = toShow.css( "box-sizing" ),
|
|
|
+ down = toShow.length &&
|
|
|
+ ( !toHide.length || ( toShow.index() < toHide.index() ) ),
|
|
|
+ animate = this.options.animate || {},
|
|
|
+ options = down && animate.down || animate,
|
|
|
+ complete = function() {
|
|
|
+ that._toggleComplete( data );
|
|
|
+ };
|
|
|
+
|
|
|
+ if ( typeof options === "number" ) {
|
|
|
+ duration = options;
|
|
|
+ }
|
|
|
+ if ( typeof options === "string" ) {
|
|
|
+ easing = options;
|
|
|
+ }
|
|
|
+
|
|
|
+ // fall back from options to animation in case of partial down settings
|
|
|
+ easing = easing || options.easing || animate.easing;
|
|
|
+ duration = duration || options.duration || animate.duration;
|
|
|
+
|
|
|
+ if ( !toHide.length ) {
|
|
|
+ return toShow.animate( this.showProps, duration, easing, complete );
|
|
|
+ }
|
|
|
+ if ( !toShow.length ) {
|
|
|
+ return toHide.animate( this.hideProps, duration, easing, complete );
|
|
|
+ }
|
|
|
+
|
|
|
+ total = toShow.show().outerHeight();
|
|
|
+ toHide.animate( this.hideProps, {
|
|
|
+ duration: duration,
|
|
|
+ easing: easing,
|
|
|
+ step: function( now, fx ) {
|
|
|
+ fx.now = Math.round( now );
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ toShow
|
|
|
+ .hide()
|
|
|
+ .animate( this.showProps, {
|
|
|
+ duration: duration,
|
|
|
+ easing: easing,
|
|
|
+ complete: complete,
|
|
|
+ step: function( now, fx ) {
|
|
|
+ fx.now = Math.round( now );
|
|
|
+ if ( fx.prop !== "height" ) {
|
|
|
+ if ( boxSizing === "content-box" ) {
|
|
|
+ adjust += fx.now;
|
|
|
+ }
|
|
|
+ } else if ( that.options.heightStyle !== "content" ) {
|
|
|
+ fx.now = Math.round( total - toHide.outerHeight() - adjust );
|
|
|
+ adjust = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } );
|
|
|
+ },
|
|
|
+
|
|
|
+ _toggleComplete: function( data ) {
|
|
|
+ var toHide = data.oldPanel,
|
|
|
+ prev = toHide.prev();
|
|
|
+
|
|
|
+ this._removeClass( toHide, "ui-accordion-content-active" );
|
|
|
+ this._removeClass( prev, "ui-accordion-header-active" )
|
|
|
+ ._addClass( prev, "ui-accordion-header-collapsed" );
|
|
|
+
|
|
|
+ // Work around for rendering bug in IE (#5421)
|
|
|
+ if ( toHide.length ) {
|
|
|
+ toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
|
|
|
+ }
|
|
|
+ this._trigger( "activate", null, data );
|
|
|
+ }
|
|
|
+} );
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+}));
|
Reynold Tan
