aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/blueimp/jquery-file-upload/js/vendor/jquery.ui.widget.js
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/blueimp/jquery-file-upload/js/vendor/jquery.ui.widget.js')
-rw-r--r--vendor/blueimp/jquery-file-upload/js/vendor/jquery.ui.widget.js742
1 files changed, 399 insertions, 343 deletions
diff --git a/vendor/blueimp/jquery-file-upload/js/vendor/jquery.ui.widget.js b/vendor/blueimp/jquery-file-upload/js/vendor/jquery.ui.widget.js
index 914b8ffb8..69096aaa3 100644
--- a/vendor/blueimp/jquery-file-upload/js/vendor/jquery.ui.widget.js
+++ b/vendor/blueimp/jquery-file-upload/js/vendor/jquery.ui.widget.js
@@ -1,28 +1,29 @@
-/*! jQuery UI - v1.12.1+CommonJS - 2018-02-10
+/*! jQuery UI - v1.12.1+0b7246b6eeadfa9e2696e22f3230f6452f8129dc - 2020-02-20
* http://jqueryui.com
* Includes: widget.js
* Copyright jQuery Foundation and other contributors; Licensed MIT */
-(function( factory ) {
- if ( typeof define === "function" && define.amd ) {
+/* global define, require */
+/* eslint-disable no-param-reassign, new-cap, jsdoc/require-jsdoc */
+(function (factory) {
+ 'use strict';
+ if (typeof define === 'function' && define.amd) {
// AMD. Register as an anonymous module.
- define([ "jquery" ], factory );
- } else if ( typeof exports === "object" ) {
-
+ define(['jquery'], factory);
+ } else if (typeof exports === 'object') {
// Node/CommonJS
- factory( require( "jquery" ) );
+ factory(require('jquery'));
} else {
-
// Browser globals
- factory( jQuery );
+ factory(window.jQuery);
}
-}(function( $ ) {
+})(function ($) {
+ ('use strict');
$.ui = $.ui || {};
- var version = $.ui.version = "1.12.1";
-
+ $.ui.version = '1.12.1';
/*!
* jQuery UI Widget 1.12.1
@@ -39,105 +40,111 @@
//>>docs: http://api.jqueryui.com/jQuery.widget/
//>>demos: http://jqueryui.com/widget/
+ // Support: jQuery 1.9.x or older
+ // $.expr[ ":" ] is deprecated.
+ if (!$.expr.pseudos) {
+ $.expr.pseudos = $.expr[':'];
+ }
+ // Support: jQuery 1.11.x or older
+ // $.unique has been renamed to $.uniqueSort
+ if (!$.uniqueSort) {
+ $.uniqueSort = $.unique;
+ }
var widgetUuid = 0;
+ var widgetHasOwnProperty = Array.prototype.hasOwnProperty;
var widgetSlice = Array.prototype.slice;
- $.cleanData = ( function( orig ) {
- return function( elems ) {
+ $.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 ) {}
+ // eslint-disable-next-line eqeqeq
+ for (i = 0; (elem = elems[i]) != null; i++) {
+ // Only trigger remove when necessary to save time
+ events = $._data(elem, 'events');
+ if (events && events.remove) {
+ $(elem).triggerHandler('remove');
+ }
}
- orig( elems );
+ orig(elems);
};
- } )( $.cleanData );
+ })($.cleanData);
- $.widget = function( name, base, prototype ) {
+ $.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;
+ var namespace = name.split('.')[0];
+ name = name.split('.')[1];
+ var fullName = namespace + '-' + name;
- if ( !prototype ) {
+ if (!prototype) {
prototype = base;
base = $.Widget;
}
- if ( $.isArray( prototype ) ) {
- prototype = $.extend.apply( null, [ {} ].concat( prototype ) );
+ if ($.isArray(prototype)) {
+ prototype = $.extend.apply(null, [{}].concat(prototype));
}
// Create selector for plugin
- $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
- return !!$.data( elem, fullName );
+ $.expr.pseudos[fullName.toLowerCase()] = function (elem) {
+ return !!$.data(elem, fullName);
};
- $[ namespace ] = $[ namespace ] || {};
- existingConstructor = $[ namespace ][ name ];
- constructor = $[ namespace ][ name ] = function( options, element ) {
-
+ $[namespace] = $[namespace] || {};
+ existingConstructor = $[namespace][name];
+ constructor = $[namespace][name] = function (options, element) {
// Allow instantiation without "new" keyword
- if ( !this._createWidget ) {
- return new constructor( options, element );
+ 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 );
+ if (arguments.length) {
+ this._createWidget(options, element);
}
};
// Extend with the existing constructor to carry over any static properties
- $.extend( constructor, existingConstructor, {
+ $.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 ),
+ _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;
+ basePrototype.options = $.widget.extend({}, basePrototype.options);
+ $.each(prototype, function (prop, value) {
+ if (!$.isFunction(value)) {
+ proxiedPrototype[prop] = value;
return;
}
- proxiedPrototype[ prop ] = ( function() {
+ proxiedPrototype[prop] = (function () {
function _super() {
- return base.prototype[ prop ].apply( this, arguments );
+ return base.prototype[prop].apply(this, arguments);
}
- function _superApply( args ) {
- return base.prototype[ prop ].apply( this, args );
+ function _superApply(args) {
+ return base.prototype[prop].apply(this, args);
}
- return function() {
+ return function () {
var __super = this._super;
var __superApply = this._superApply;
var returnValue;
@@ -145,77 +152,87 @@
this._super = _super;
this._superApply = _superApply;
- returnValue = value.apply( this, arguments );
+ 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
- } );
+ })();
+ });
+ 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 ) {
+ 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 );
- } );
+ $.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 );
+ base._childConstructors.push(constructor);
}
- $.widget.bridge( name, constructor );
+ $.widget.bridge(name, constructor);
return constructor;
};
- $.widget.extend = function( target ) {
- var input = widgetSlice.call( arguments, 1 );
+ $.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 ) {
-
+ for (; inputIndex < inputLength; inputIndex++) {
+ for (key in input[inputIndex]) {
+ value = input[inputIndex][key];
+ if (
+ widgetHasOwnProperty.call(input[inputIndex], 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 );
+ 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;
+ target[key] = value;
}
}
}
@@ -223,81 +240,90 @@
return target;
};
- $.widget.bridge = function( name, object ) {
+ $.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 );
+ $.fn[name] = function (options) {
+ var isMethodCall = typeof options === 'string';
+ var args = widgetSlice.call(arguments, 1);
var returnValue = this;
- if ( isMethodCall ) {
-
+ 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" ) {
+ if (!this.length && options === 'instance') {
returnValue = undefined;
} else {
- this.each( function() {
+ this.each(function () {
var methodValue;
- var instance = $.data( this, fullName );
+ var instance = $.data(this, fullName);
- if ( options === "instance" ) {
+ 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 (!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" );
+ if (!$.isFunction(instance[options]) || options.charAt(0) === '_') {
+ return $.error(
+ "no such method '" +
+ options +
+ "' for " +
+ name +
+ ' widget instance'
+ );
}
- methodValue = instance[ options ].apply( instance, args );
+ methodValue = instance[options].apply(instance, args);
- if ( methodValue !== instance && methodValue !== undefined ) {
- returnValue = methodValue && methodValue.jquery ?
- returnValue.pushStack( methodValue.get() ) :
- methodValue;
+ 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 ) );
+ 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 ) {
+ 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 ) );
+ $.data(this, fullName, new object(options, this));
}
- } );
+ });
}
return returnValue;
};
};
- $.Widget = function( /* options, element */ ) {};
+ $.Widget = function (/* options, element */) {};
$.Widget._childConstructors = [];
$.Widget.prototype = {
- widgetName: "widget",
- widgetEventPrefix: "",
- defaultElement: "<div>",
+ widgetName: 'widget',
+ widgetEventPrefix: '',
+ defaultElement: '<div>',
options: {
classes: {},
@@ -307,52 +333,56 @@
create: null
},
- _createWidget: function( options, element ) {
- element = $( element || this.defaultElement || this )[ 0 ];
- this.element = $( element );
+ _createWidget: function (options, element) {
+ element = $(element || this.defaultElement || this)[0];
+ this.element = $(element);
this.uuid = widgetUuid++;
- this.eventNamespace = "." + this.widgetName + this.uuid;
+ 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 ) {
+ 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.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 = $.widget.extend(
+ {},
this.options,
this._getCreateOptions(),
- options );
+ options
+ );
this._create();
- if ( this.options.disabled ) {
- this._setOptionDisabled( this.options.disabled );
+ if (this.options.disabled) {
+ this._setOptionDisabled(this.options.disabled);
}
- this._trigger( "create", null, this._getCreateEventData() );
+ this._trigger('create', null, this._getCreateEventData());
this._init();
},
- _getCreateOptions: function() {
+ _getCreateOptions: function () {
return {};
},
@@ -362,107 +392,103 @@
_init: $.noop,
- destroy: function() {
+ destroy: function () {
var that = this;
this._destroy();
- $.each( this.classesElementLookup, function( key, value ) {
- that._removeClass( value, key );
- } );
+ $.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" );
+ 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 );
+ this.bindings.off(this.eventNamespace);
},
_destroy: $.noop,
- widget: function() {
+ widget: function () {
return this.element;
},
- option: function( key, value ) {
+ option: function (key, value) {
var options = key;
var parts;
var curOption;
var i;
- if ( arguments.length === 0 ) {
-
+ if (arguments.length === 0) {
// Don't return a reference to the internal hash
- return $.widget.extend( {}, this.options );
+ return $.widget.extend({}, this.options);
}
- if ( typeof key === "string" ) {
-
+ if (typeof key === 'string') {
// Handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
options = {};
- parts = key.split( "." );
+ 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 ] ];
+ 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 ];
+ if (arguments.length === 1) {
+ return curOption[key] === undefined ? null : curOption[key];
}
- curOption[ key ] = value;
+ curOption[key] = value;
} else {
- if ( arguments.length === 1 ) {
- return this.options[ key ] === undefined ? null : this.options[ key ];
+ if (arguments.length === 1) {
+ return this.options[key] === undefined ? null : this.options[key];
}
- options[ key ] = value;
+ options[key] = value;
}
}
- this._setOptions( options );
+ this._setOptions(options);
return this;
},
- _setOptions: function( options ) {
+ _setOptions: function (options) {
var key;
- for ( key in options ) {
- this._setOption( key, options[ key ] );
+ for (key in options) {
+ this._setOption(key, options[key]);
}
return this;
},
- _setOption: function( key, value ) {
- if ( key === "classes" ) {
- this._setOptionClasses( value );
+ _setOption: function (key, value) {
+ if (key === 'classes') {
+ this._setOptionClasses(value);
}
- this.options[ key ] = value;
+ this.options[key] = value;
- if ( key === "disabled" ) {
- this._setOptionDisabled( value );
+ if (key === 'disabled') {
+ this._setOptionDisabled(value);
}
return this;
},
- _setOptionClasses: function( value ) {
+ _setOptionClasses: function (value) {
var classKey, elements, currentElements;
- for ( classKey in value ) {
- currentElements = this.classesElementLookup[ classKey ];
- if ( value[ classKey ] === this.options.classes[ classKey ] ||
+ for (classKey in value) {
+ currentElements = this.classesElementLookup[classKey];
+ if (
+ value[classKey] === this.options.classes[classKey] ||
!currentElements ||
- !currentElements.length ) {
+ !currentElements.length
+ ) {
continue;
}
@@ -470,283 +496,313 @@
// 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 );
+ 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
- } ) );
+ elements.addClass(
+ this._classes({
+ element: elements,
+ keys: classKey,
+ classes: value,
+ add: true
+ })
+ );
}
},
- _setOptionDisabled: function( value ) {
- this._toggleClass( this.widget(), this.widgetFullName + "-disabled", null, !!value );
+ _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" );
+ 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 } );
+ enable: function () {
+ return this._setOptions({ disabled: false });
},
- disable: function() {
- return this._setOptions( { disabled: true } );
+ disable: function () {
+ return this._setOptions({ disabled: true });
},
- _classes: function( options ) {
+ _classes: function (options) {
var full = [];
var that = this;
- options = $.extend( {
- element: this.element,
- classes: this.options.classes || {}
- }, options );
+ options = $.extend(
+ {
+ element: this.element,
+ classes: this.options.classes || {}
+ },
+ options
+ );
+
+ function bindRemoveEvent() {
+ options.element.each(function (_, element) {
+ var isTracked = $.map(that.classesElementLookup, function (elements) {
+ return elements;
+ }).some(function (elements) {
+ return elements.is(element);
+ });
+
+ if (!isTracked) {
+ that._on($(element), {
+ remove: '_untrackClassesElement'
+ });
+ }
+ });
+ }
- function processClassString( classes, checkOption ) {
+ 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() ) ) );
+ for (i = 0; i < classes.length; i++) {
+ current = that.classesElementLookup[classes[i]] || $();
+ if (options.add) {
+ bindRemoveEvent();
+ current = $(
+ $.uniqueSort(current.get().concat(options.element.get()))
+ );
} else {
- current = $( current.not( options.element ).get() );
+ 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 ] ] );
+ 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.keys) {
+ processClassString(options.keys.match(/\S+/g) || [], true);
}
- if ( options.extra ) {
- processClassString( options.extra.match( /\S+/g ) || [] );
+ if (options.extra) {
+ processClassString(options.extra.match(/\S+/g) || []);
}
- return full.join( " " );
+ return full.join(' ');
},
- _untrackClassesElement: function( event ) {
+ _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() );
+ $.each(that.classesElementLookup, function (key, value) {
+ if ($.inArray(event.target, value) !== -1) {
+ that.classesElementLookup[key] = $(value.not(event.target).get());
}
- } );
+ });
+
+ this._off($(event.target));
},
- _removeClass: function( element, keys, extra ) {
- return this._toggleClass( element, keys, extra, false );
+ _removeClass: function (element, keys, extra) {
+ return this._toggleClass(element, keys, extra, false);
},
- _addClass: function( element, keys, extra ) {
- return this._toggleClass( element, keys, extra, true );
+ _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 ),
+ _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 );
+ options.element.toggleClass(this._classes(options), add);
return this;
},
- _on: function( suppressDisabledCheck, element, handlers ) {
+ _on: function (suppressDisabledCheck, element, handlers) {
var delegateElement;
var instance = this;
// No suppressDisabledCheck flag, shuffle arguments
- if ( typeof suppressDisabledCheck !== "boolean" ) {
+ if (typeof suppressDisabledCheck !== 'boolean') {
handlers = element;
element = suppressDisabledCheck;
suppressDisabledCheck = false;
}
// No element argument, shuffle and use this.element
- if ( !handlers ) {
+ if (!handlers) {
handlers = element;
element = this.element;
delegateElement = this.widget();
} else {
- element = delegateElement = $( element );
- this.bindings = this.bindings.add( element );
+ element = delegateElement = $(element);
+ this.bindings = this.bindings.add(element);
}
- $.each( handlers, function( event, handler ) {
+ $.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" ) ) ) {
+ if (
+ !suppressDisabledCheck &&
+ (instance.options.disabled === true ||
+ $(this).hasClass('ui-state-disabled'))
+ ) {
return;
}
- return ( typeof handler === "string" ? instance[ handler ] : handler )
- .apply( instance, arguments );
+ return (typeof handler === 'string'
+ ? instance[handler]
+ : handler
+ ).apply(instance, arguments);
}
// Copy the guid so direct unbinding works
- if ( typeof handler !== "string" ) {
+ 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 ];
+ var match = event.match(/^([\w:-]*)\s*(.*)$/);
+ var eventName = match[1] + instance.eventNamespace;
+ var selector = match[2];
- if ( selector ) {
- delegateElement.on( eventName, selector, handlerProxy );
+ if (selector) {
+ delegateElement.on(eventName, selector, handlerProxy);
} else {
- element.on( eventName, handlerProxy );
+ element.on(eventName, handlerProxy);
}
- } );
+ });
},
- _off: function( element, eventName ) {
- eventName = ( eventName || "" ).split( " " ).join( this.eventNamespace + " " ) +
+ _off: function (element, eventName) {
+ eventName =
+ (eventName || '').split(' ').join(this.eventNamespace + ' ') +
this.eventNamespace;
- element.off( eventName ).off( eventName );
+ element.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() );
+ 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 ) {
+ _delay: function (handler, delay) {
+ var instance = this;
function handlerProxy() {
- return ( typeof handler === "string" ? instance[ handler ] : handler )
- .apply( instance, arguments );
+ return (typeof handler === 'string'
+ ? instance[handler]
+ : handler
+ ).apply(instance, arguments);
}
- var instance = this;
- return setTimeout( handlerProxy, delay || 0 );
+ 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" );
+ _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" );
+ 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" );
+ _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" );
+ focusout: function (event) {
+ this._removeClass($(event.currentTarget), null, 'ui-state-focus');
}
- } );
+ });
},
- _trigger: function( type, event, data ) {
+ _trigger: function (type, event, data) {
var prop, orig;
- var callback = this.options[ type ];
+ var callback = this.options[type];
data = data || {};
- event = $.Event( event );
- event.type = ( type === this.widgetEventPrefix ?
- type :
- this.widgetEventPrefix + type ).toLowerCase();
+ 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 ];
+ 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 ];
+ 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() );
+ 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" ) {
+ $.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;
+ var effectName = !options
+ ? method
+ : options === true || typeof options === 'number'
+ ? defaultEffect
+ : options.effect || defaultEffect;
options = options || {};
- if ( typeof options === "number" ) {
+ if (typeof options === 'number') {
options = { duration: options };
}
- hasOptions = !$.isEmptyObject( options );
+ hasOptions = !$.isEmptyObject(options);
options.complete = callback;
- if ( options.delay ) {
- element.delay( options.delay );
+ 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 );
+ 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 ] );
+ element.queue(function (next) {
+ $(this)[method]();
+ if (callback) {
+ callback.call(element[0]);
}
next();
- } );
+ });
}
};
- } );
-
- var widget = $.widget;
-
-
-
-
-}));
+ });
+});
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-27 15:09:20 +0000