809 lines
24 KiB
JavaScript
809 lines
24 KiB
JavaScript
/*! jQuery UI - v1.12.1+0b7246b6eeadfa9e2696e22f3230f6452f8129dc - 2020-02-20
|
|
* http://jqueryui.com
|
|
* Includes: widget.js
|
|
* Copyright jQuery Foundation and other contributors; Licensed MIT */
|
|
|
|
/* 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') {
|
|
// Node/CommonJS
|
|
factory(require('jquery'));
|
|
} else {
|
|
// Browser globals
|
|
factory(window.jQuery);
|
|
}
|
|
})(function ($) {
|
|
('use strict');
|
|
|
|
$.ui = $.ui || {};
|
|
|
|
$.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/
|
|
|
|
// 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) {
|
|
var events, elem, i;
|
|
// 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);
|
|
};
|
|
})($.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.pseudos[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 (
|
|
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);
|
|
|
|
// 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 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) {
|
|
var current, i;
|
|
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());
|
|
}
|
|
that.classesElementLookup[classes[i]] = current;
|
|
full.push(classes[i]);
|
|
if (checkOption && options.classes[classes[i]]) {
|
|
full.push(options.classes[classes[i]]);
|
|
}
|
|
}
|
|
}
|
|
|
|
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());
|
|
}
|
|
});
|
|
|
|
this._off($(event.target));
|
|
},
|
|
|
|
_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);
|
|
|
|
// 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) {
|
|
var instance = this;
|
|
function handlerProxy() {
|
|
return (typeof handler === 'string'
|
|
? instance[handler]
|
|
: handler
|
|
).apply(instance, arguments);
|
|
}
|
|
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();
|
|
});
|
|
}
|
|
};
|
|
});
|
|
});
|