http://git-wip-us.apache.org/repos/asf/stratos/blob/c795440d/extensions/das/modules/artifacts/metering-dashboard/capps/stratos-metering-service/GadgetApplicationSignUpsFilter/Application_Signups_Filter/js/jquery-ui.js ---------------------------------------------------------------------- diff --git a/extensions/das/modules/artifacts/metering-dashboard/capps/stratos-metering-service/GadgetApplicationSignUpsFilter/Application_Signups_Filter/js/jquery-ui.js b/extensions/das/modules/artifacts/metering-dashboard/capps/stratos-metering-service/GadgetApplicationSignUpsFilter/Application_Signups_Filter/js/jquery-ui.js new file mode 100644 index 0000000..b651adc --- /dev/null +++ b/extensions/das/modules/artifacts/metering-dashboard/capps/stratos-metering-service/GadgetApplicationSignUpsFilter/Application_Signups_Filter/js/jquery-ui.js @@ -0,0 +1,16753 @@ +/*! jQuery UI - v1.11.4 - 2015-03-11 + * http://jqueryui.com + * Includes: core.js, widget.js, mouse.js, position.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, draggable.js, droppable.js, effect.js, effect-blind.js, effect-bounce.js, effect-clip.js, effect-drop.js, effect-explode.js, effect-fade.js, effect-fold.js, effect-highlight.js, effect-puff.js, effect-pulsate.js, effect-scale.js, effect-shake.js, effect-size.js, effect-slide.js, effect-transfer.js, menu.js, progressbar.js, resizable.js, selectable.js, selectmenu.js, slider.js, sortable.js, spinner.js, tabs.js, tooltip.js + * Copyright 2015 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 ($) { + /*! + * jQuery UI Core 1.11.4 + * http://jqueryui.com + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license. + * http://jquery.org/license + * + * http://api.jqueryui.com/category/ui-core/ + */ + + +// $.ui might exist from components with no dependencies, e.g., $.ui.position + $.ui = $.ui || {}; + + $.extend($.ui, { + version: "1.11.4", + + 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 + } + }); + +// plugins + $.fn.extend({ + scrollParent: function (includeHidden) { + var position = this.css("position"), + excludeStaticParent = position === "absolute", + overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/, + scrollParent = this.parents().filter(function () { + var parent = $(this); + if (excludeStaticParent && parent.css("position") === "static") { + return false; + } + return overflowRegex.test(parent.css("overflow") + parent.css("overflow-y") + parent.css("overflow-x")); + }).eq(0); + + return position === "fixed" || !scrollParent.length ? $(this[0].ownerDocument || document) : scrollParent; + }, + + 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"); + } + }); + } + }); + +// selectors + function focusable(element, isTabIndexNotNaN) { + var map, mapName, img, + nodeName = element.nodeName.toLowerCase(); + if ("area" === nodeName) { + map = element.parentNode; + mapName = map.name; + if (!element.href || !mapName || map.nodeName.toLowerCase() !== "map") { + return false; + } + img = $("img[usemap='#" + mapName + "']")[0]; + return !!img && visible(img); + } + return ( /^(input|select|textarea|button|object)$/.test(nodeName) ? + !element.disabled : + "a" === nodeName ? + element.href || isTabIndexNotNaN : + isTabIndexNotNaN) && + // the element and all of its ancestors must be visible + visible(element); + } + + function visible(element) { + return $.expr.filters.visible(element) && !$(element).parents().addBack().filter(function () { + return $.css(this, "visibility") === "hidden"; + }).length; + } + + $.extend($.expr[":"], { + data: $.expr.createPseudo ? + $.expr.createPseudo(function (dataName) { + return function (elem) { + return !!$.data(elem, dataName); + }; + }) : + // support: jQuery <1.8 + function (elem, i, match) { + return !!$.data(elem, match[3]); + }, + + focusable: function (element) { + return focusable(element, !isNaN($.attr(element, "tabindex"))); + }, + + tabbable: function (element) { + var tabIndex = $.attr(element, "tabindex"), + isTabIndexNaN = isNaN(tabIndex); + return ( isTabIndexNaN || tabIndex >= 0 ) && focusable(element, !isTabIndexNaN); + } + }); + +// support: jQuery <1.8 + if (!$("<a>").outerWidth(1).jquery) { + $.each(["Width", "Height"], function (i, name) { + var side = name === "Width" ? ["Left", "Right"] : ["Top", "Bottom"], + type = name.toLowerCase(), + orig = { + innerWidth: $.fn.innerWidth, + innerHeight: $.fn.innerHeight, + outerWidth: $.fn.outerWidth, + outerHeight: $.fn.outerHeight + }; + + function reduce(elem, size, border, margin) { + $.each(side, function () { + size -= parseFloat($.css(elem, "padding" + this)) || 0; + if (border) { + size -= parseFloat($.css(elem, "border" + this + "Width")) || 0; + } + if (margin) { + size -= parseFloat($.css(elem, "margin" + this)) || 0; + } + }); + return size; + } + + $.fn["inner" + name] = function (size) { + if (size === undefined) { + return orig["inner" + name].call(this); + } + + return this.each(function () { + $(this).css(type, reduce(this, size) + "px"); + }); + }; + + $.fn["outer" + name] = function (size, margin) { + if (typeof size !== "number") { + return orig["outer" + name].call(this, size); + } + + return this.each(function () { + $(this).css(type, reduce(this, size, true, margin) + "px"); + }); + }; + }); + } + +// support: jQuery <1.8 + if (!$.fn.addBack) { + $.fn.addBack = function (selector) { + return this.add(selector == null ? + this.prevObject : this.prevObject.filter(selector) + ); + }; + } + +// support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413) + if ($("<a>").data("a-b", "a").removeData("a-b").data("a-b")) { + $.fn.removeData = (function (removeData) { + return function (key) { + if (arguments.length) { + return removeData.call(this, $.camelCase(key)); + } else { + return removeData.call(this); + } + }; + })($.fn.removeData); + } + +// deprecated + $.ui.ie = !!/msie [\w.]+/.exec(navigator.userAgent.toLowerCase()); + + $.fn.extend({ + focus: (function (orig) { + return function (delay, fn) { + return typeof delay === "number" ? + this.each(function () { + var elem = this; + setTimeout(function () { + $(elem).focus(); + if (fn) { + fn.call(elem); + } + }, delay); + }) : + orig.apply(this, arguments); + }; + })($.fn.focus), + + disableSelection: (function () { + var eventType = "onselectstart" in document.createElement("div") ? + "selectstart" : + "mousedown"; + + return function () { + return this.bind(eventType + ".ui-disableSelection", function (event) { + event.preventDefault(); + }); + }; + })(), + + enableSelection: function () { + return this.unbind(".ui-disableSelection"); + }, + + zIndex: function (zIndex) { + if (zIndex !== undefined) { + return this.css("zIndex", zIndex); + } + + if (this.length) { + var elem = $(this[0]), position, value; + while (elem.length && elem[0] !== document) { + // Ignore z-index if position is set to a value where z-index is ignored by the browser + // This makes behavior of this function consistent across browsers + // WebKit always returns auto if the element is positioned + position = elem.css("position"); + if (position === "absolute" || position === "relative" || position === "fixed") { + // IE returns 0 when zIndex is not specified + // other browsers return a string + // we ignore the case of nested elements with an explicit value of 0 + // <div style="z-index: -10;"><div style="z-index: 0;"></div></div> + value = parseInt(elem.css("zIndex"), 10); + if (!isNaN(value) && value !== 0) { + return value; + } + } + elem = elem.parent(); + } + } + + return 0; + } + }); + +// $.ui.plugin is deprecated. Use $.widget() extensions instead. + $.ui.plugin = { + add: function (module, option, set) { + var i, + proto = $.ui[module].prototype; + for (i in set) { + proto.plugins[i] = proto.plugins[i] || []; + proto.plugins[i].push([option, set[i]]); + } + }, + call: function (instance, name, args, allowDisconnected) { + var i, + set = instance.plugins[name]; + + if (!set) { + return; + } + + if (!allowDisconnected && ( !instance.element[0].parentNode || instance.element[0].parentNode.nodeType === 11 )) { + return; + } + + for (i = 0; i < set.length; i++) { + if (instance.options[set[i][0]]) { + set[i][1].apply(instance.element, args); + } + } + } + }; + + + /*! + * jQuery UI Widget 1.11.4 + * http://jqueryui.com + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license. + * http://jquery.org/license + * + * http://api.jqueryui.com/jQuery.widget/ + */ + + + var widget_uuid = 0, + widget_slice = 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 fullName, existingConstructor, constructor, basePrototype, + // proxiedPrototype allows the provided prototype to remain unmodified + // so that it can be used as a mixin for multiple widgets (#8876) + proxiedPrototype = {}, + namespace = name.split(".")[0]; + + name = name.split(".")[1]; + fullName = namespace + "-" + name; + + if (!prototype) { + prototype = base; + base = $.Widget; + } + + // 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 () { + var _super = function () { + return base.prototype[prop].apply(this, arguments); + }, + _superApply = function (args) { + return base.prototype[prop].apply(this, args); + }; + return function () { + var __super = this._super, + __superApply = this._superApply, + 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 = widget_slice.call(arguments, 1), + inputIndex = 0, + inputLength = input.length, + key, + 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", + args = widget_slice.call(arguments, 1), + returnValue = this; + + if (isMethodCall) { + this.each(function () { + var methodValue, + 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: { + disabled: false, + + // callbacks + create: null + }, + _createWidget: function (options, element) { + element = $(element || this.defaultElement || this)[0]; + this.element = $(element); + this.uuid = widget_uuid++; + this.eventNamespace = "." + this.widgetName + this.uuid; + + this.bindings = $(); + this.hoverable = $(); + this.focusable = $(); + + 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(); + this._trigger("create", null, this._getCreateEventData()); + this._init(); + }, + _getCreateOptions: $.noop, + _getCreateEventData: $.noop, + _create: $.noop, + _init: $.noop, + + destroy: function () { + this._destroy(); + // we can probably remove the unbind calls in 2.0 + // all event bindings should go through this._on() + this.element + .unbind(this.eventNamespace) + .removeData(this.widgetFullName) + // support: jquery <1.6.3 + // http://bugs.jquery.com/ticket/9413 + .removeData($.camelCase(this.widgetFullName)); + this.widget() + .unbind(this.eventNamespace) + .removeAttr("aria-disabled") + .removeClass( + this.widgetFullName + "-disabled " + + "ui-state-disabled"); + + // clean up events and states + this.bindings.unbind(this.eventNamespace); + this.hoverable.removeClass("ui-state-hover"); + this.focusable.removeClass("ui-state-focus"); + }, + _destroy: $.noop, + + widget: function () { + return this.element; + }, + + option: function (key, value) { + var options = key, + parts, + curOption, + 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) { + this.options[key] = value; + + if (key === "disabled") { + this.widget() + .toggleClass(this.widgetFullName + "-disabled", !!value); + + // If the widget is becoming disabled, then nothing is interactive + if (value) { + this.hoverable.removeClass("ui-state-hover"); + this.focusable.removeClass("ui-state-focus"); + } + } + + return this; + }, + + enable: function () { + return this._setOptions({disabled: false}); + }, + disable: function () { + return this._setOptions({disabled: true}); + }, + + _on: function (suppressDisabledCheck, element, handlers) { + var delegateElement, + 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*(.*)$/), + eventName = match[1] + instance.eventNamespace, + selector = match[2]; + if (selector) { + delegateElement.delegate(selector, eventName, handlerProxy); + } else { + element.bind(eventName, handlerProxy); + } + }); + }, + + _off: function (element, eventName) { + eventName = (eventName || "").split(" ").join(this.eventNamespace + " ") + + this.eventNamespace; + element.unbind(eventName).undelegate(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) { + $(event.currentTarget).addClass("ui-state-hover"); + }, + mouseleave: function (event) { + $(event.currentTarget).removeClass("ui-state-hover"); + } + }); + }, + + _focusable: function (element) { + this.focusable = this.focusable.add(element); + this._on(element, { + focusin: function (event) { + $(event.currentTarget).addClass("ui-state-focus"); + }, + focusout: function (event) { + $(event.currentTarget).removeClass("ui-state-focus"); + } + }); + }, + + _trigger: function (type, event, data) { + var prop, orig, + 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, + 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 Mouse 1.11.4 + * http://jqueryui.com + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license. + * http://jquery.org/license + * + * http://api.jqueryui.com/mouse/ + */ + + + var mouseHandled = false; + $(document).mouseup(function () { + mouseHandled = false; + }); + + var mouse = $.widget("ui.mouse", { + version: "1.11.4", + options: { + cancel: "input,textarea,button,select,option", + distance: 1, + delay: 0 + }, + _mouseInit: function () { + var that = this; + + this.element + .bind("mousedown." + this.widgetName, function (event) { + return that._mouseDown(event); + }) + .bind("click." + this.widgetName, function (event) { + if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) { + $.removeData(event.target, that.widgetName + ".preventClickEvent"); + event.stopImmediatePropagation(); + return false; + } + }); + + this.started = false; + }, + + // TODO: make sure destroying one instance of mouse doesn't mess with + // other instances of mouse + _mouseDestroy: function () { + this.element.unbind("." + this.widgetName); + if (this._mouseMoveDelegate) { + this.document + .unbind("mousemove." + this.widgetName, this._mouseMoveDelegate) + .unbind("mouseup." + this.widgetName, this._mouseUpDelegate); + } + }, + + _mouseDown: function (event) { + // don't let more than one widget handle mouseStart + if (mouseHandled) { + return; + } + + this._mouseMoved = false; + + // we may have missed mouseup (out of window) + (this._mouseStarted && this._mouseUp(event)); + + this._mouseDownEvent = event; + + var that = this, + btnIsLeft = (event.which === 1), + // event.target.nodeName works around a bug in IE 8 with + // disabled inputs (#7620) + elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false); + if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) { + return true; + } + + this.mouseDelayMet = !this.options.delay; + if (!this.mouseDelayMet) { + this._mouseDelayTimer = setTimeout(function () { + that.mouseDelayMet = true; + }, this.options.delay); + } + + if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) { + this._mouseStarted = (this._mouseStart(event) !== false); + if (!this._mouseStarted) { + event.preventDefault(); + return true; + } + } + + // Click event may never have fired (Gecko & Opera) + if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) { + $.removeData(event.target, this.widgetName + ".preventClickEvent"); + } + + // these delegates are required to keep context + this._mouseMoveDelegate = function (event) { + return that._mouseMove(event); + }; + this._mouseUpDelegate = function (event) { + return that._mouseUp(event); + }; + + this.document + .bind("mousemove." + this.widgetName, this._mouseMoveDelegate) + .bind("mouseup." + this.widgetName, this._mouseUpDelegate); + + event.preventDefault(); + + mouseHandled = true; + return true; + }, + + _mouseMove: function (event) { + // Only check for mouseups outside the document if you've moved inside the document + // at least once. This prevents the firing of mouseup in the case of IE<9, which will + // fire a mousemove event if content is placed under the cursor. See #7778 + // Support: IE <9 + if (this._mouseMoved) { + // IE mouseup check - mouseup happened when mouse was out of window + if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) { + return this._mouseUp(event); + + // Iframe mouseup check - mouseup occurred in another document + } else if (!event.which) { + return this._mouseUp(event); + } + } + + if (event.which || event.button) { + this._mouseMoved = true; + } + + if (this._mouseStarted) { + this._mouseDrag(event); + return event.preventDefault(); + } + + if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) { + this._mouseStarted = + (this._mouseStart(this._mouseDownEvent, event) !== false); + (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event)); + } + + return !this._mouseStarted; + }, + + _mouseUp: function (event) { + this.document + .unbind("mousemove." + this.widgetName, this._mouseMoveDelegate) + .unbind("mouseup." + this.widgetName, this._mouseUpDelegate); + + if (this._mouseStarted) { + this._mouseStarted = false; + + if (event.target === this._mouseDownEvent.target) { + $.data(event.target, this.widgetName + ".preventClickEvent", true); + } + + this._mouseStop(event); + } + + mouseHandled = false; + return false; + }, + + _mouseDistanceMet: function (event) { + return (Math.max( + Math.abs(this._mouseDownEvent.pageX - event.pageX), + Math.abs(this._mouseDownEvent.pageY - event.pageY) + ) >= this.options.distance + ); + }, + + _mouseDelayMet: function (/* event */) { + return this.mouseDelayMet; + }, + + // These are placeholder methods, to be overriden by extending plugin + _mouseStart: function (/* event */) { + }, + _mouseDrag: function (/* event */) { + }, + _mouseStop: function (/* event */) { + }, + _mouseCapture: function (/* event */) { + return true; + } + }); + + + /*! + * jQuery UI Position 1.11.4 + * http://jqueryui.com + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license. + * http://jquery.org/license + * + * http://api.jqueryui.com/position/ + */ + + (function () { + + $.ui = $.ui || {}; + + var cachedScrollbarWidth, supportsOffsetFractions, + max = Math.max, + abs = Math.abs, + round = Math.round, + rhorizontal = /left|center|right/, + rvertical = /top|center|bottom/, + roffset = /[\+\-]\d+(\.[\d]+)?%?/, + rposition = /^\w+/, + rpercent = /%$/, + _position = $.fn.position; + + function getOffsets(offsets, width, height) { + return [ + parseFloat(offsets[0]) * ( rpercent.test(offsets[0]) ? width / 100 : 1 ), + parseFloat(offsets[1]) * ( rpercent.test(offsets[1]) ? height / 100 : 1 ) + ]; + } + + function parseCss(element, property) { + return parseInt($.css(element, property), 10) || 0; + } + + function getDimensions(elem) { + var raw = elem[0]; + if (raw.nodeType === 9) { + return { + width: elem.width(), + height: elem.height(), + offset: {top: 0, left: 0} + }; + } + if ($.isWindow(raw)) { + return { + width: elem.width(), + height: elem.height(), + offset: {top: elem.scrollTop(), left: elem.scrollLeft()} + }; + } + if (raw.preventDefault) { + return { + width: 0, + height: 0, + offset: {top: raw.pageY, left: raw.pageX} + }; + } + return { + width: elem.outerWidth(), + height: elem.outerHeight(), + offset: elem.offset() + }; + } + + $.position = { + scrollbarWidth: function () { + if (cachedScrollbarWidth !== undefined) { + return cachedScrollbarWidth; + } + var w1, w2, + div = $("<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>"), + innerDiv = div.children()[0]; + + $("body").append(div); + w1 = innerDiv.offsetWidth; + div.css("overflow", "scroll"); + + w2 = innerDiv.offsetWidth; + + if (w1 === w2) { + w2 = div[0].clientWidth; + } + + div.remove(); + + return (cachedScrollbarWidth = w1 - w2); + }, + getScrollInfo: function (within) { + var overflowX = within.isWindow || within.isDocument ? "" : + within.element.css("overflow-x"), + overflowY = within.isWindow || within.isDocument ? "" : + within.element.css("overflow-y"), + hasOverflowX = overflowX === "scroll" || + ( overflowX === "auto" && within.width < within.element[0].scrollWidth ), + hasOverflowY = overflowY === "scroll" || + ( overflowY === "auto" && within.height < within.element[0].scrollHeight ); + return { + width: hasOverflowY ? $.position.scrollbarWidth() : 0, + height: hasOverflowX ? $.position.scrollbarWidth() : 0 + }; + }, + getWithinInfo: function (element) { + var withinElement = $(element || window), + isWindow = $.isWindow(withinElement[0]), + isDocument = !!withinElement[0] && withinElement[0].nodeType === 9; + return { + element: withinElement, + isWindow: isWindow, + isDocument: isDocument, + offset: withinElement.offset() || {left: 0, top: 0}, + scrollLeft: withinElement.scrollLeft(), + scrollTop: withinElement.scrollTop(), + + // support: jQuery 1.6.x + // jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows + width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(), + height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight() + }; + } + }; + + $.fn.position = function (options) { + if (!options || !options.of) { + return _position.apply(this, arguments); + } + + // make a copy, we don't want to modify arguments + options = $.extend({}, options); + + var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions, + target = $(options.of), + within = $.position.getWithinInfo(options.within), + scrollInfo = $.position.getScrollInfo(within), + collision = ( options.collision || "flip" ).split(" "), + offsets = {}; + + dimensions = getDimensions(target); + if (target[0].preventDefault) { + // force left top to allow flipping + options.at = "left top"; + } + targetWidth = dimensions.width; + targetHeight = dimensions.height; + targetOffset = dimensions.offset; + // clone to reuse original targetOffset later + basePosition = $.extend({}, targetOffset); + + // force my and at to have valid horizontal and vertical positions + // if a value is missing or invalid, it will be converted to center + $.each(["my", "at"], function () { + var pos = ( options[this] || "" ).split(" "), + horizontalOffset, + verticalOffset; + + if (pos.length === 1) { + pos = rhorizontal.test(pos[0]) ? + pos.concat(["center"]) : + rvertical.test(pos[0]) ? + ["center"].concat(pos) : + ["center", "center"]; + } + pos[0] = rhorizontal.test(pos[0]) ? pos[0] : "center"; + pos[1] = rvertical.test(pos[1]) ? pos[1] : "center"; + + // calculate offsets + horizontalOffset = roffset.exec(pos[0]); + verticalOffset = roffset.exec(pos[1]); + offsets[this] = [ + horizontalOffset ? horizontalOffset[0] : 0, + verticalOffset ? verticalOffset[0] : 0 + ]; + + // reduce to just the positions without the offsets + options[this] = [ + rposition.exec(pos[0])[0], + rposition.exec(pos[1])[0] + ]; + }); + + // normalize collision option + if (collision.length === 1) { + collision[1] = collision[0]; + } + + if (options.at[0] === "right") { + basePosition.left += targetWidth; + } else if (options.at[0] === "center") { + basePosition.left += targetWidth / 2; + } + + if (options.at[1] === "bottom") { + basePosition.top += targetHeight; + } else if (options.at[1] === "center") { + basePosition.top += targetHeight / 2; + } + + atOffset = getOffsets(offsets.at, targetWidth, targetHeight); + basePosition.left += atOffset[0]; + basePosition.top += atOffset[1]; + + return this.each(function () { + var collisionPosition, using, + elem = $(this), + elemWidth = elem.outerWidth(), + elemHeight = elem.outerHeight(), + marginLeft = parseCss(this, "marginLeft"), + marginTop = parseCss(this, "marginTop"), + collisionWidth = elemWidth + marginLeft + parseCss(this, "marginRight") + scrollInfo.width, + collisionHeight = elemHeight + marginTop + parseCss(this, "marginBottom") + scrollInfo.height, + position = $.extend({}, basePosition), + myOffset = getOffsets(offsets.my, elem.outerWidth(), elem.outerHeight()); + + if (options.my[0] === "right") { + position.left -= elemWidth; + } else if (options.my[0] === "center") { + position.left -= elemWidth / 2; + } + + if (options.my[1] === "bottom") { + position.top -= elemHeight; + } else if (options.my[1] === "center") { + position.top -= elemHeight / 2; + } + + position.left += myOffset[0]; + position.top += myOffset[1]; + + // if the browser doesn't support fractions, then round for consistent results + if (!supportsOffsetFractions) { + position.left = round(position.left); + position.top = round(position.top); + } + + collisionPosition = { + marginLeft: marginLeft, + marginTop: marginTop + }; + + $.each(["left", "top"], function (i, dir) { + if ($.ui.position[collision[i]]) { + $.ui.position[collision[i]][dir](position, { + targetWidth: targetWidth, + targetHeight: targetHeight, + elemWidth: elemWidth, + elemHeight: elemHeight, + collisionPosition: collisionPosition, + collisionWidth: collisionWidth, + collisionHeight: collisionHeight, + offset: [atOffset[0] + myOffset[0], atOffset [1] + myOffset[1]], + my: options.my, + at: options.at, + within: within, + elem: elem + }); + } + }); + + if (options.using) { + // adds feedback as second argument to using callback, if present + using = function (props) { + var left = targetOffset.left - position.left, + right = left + targetWidth - elemWidth, + top = targetOffset.top - position.top, + bottom = top + targetHeight - elemHeight, + feedback = { + target: { + element: target, + left: targetOffset.left, + top: targetOffset.top, + width: targetWidth, + height: targetHeight + }, + element: { + element: elem, + left: position.left, + top: position.top, + width: elemWidth, + height: elemHeight + }, + horizontal: right < 0 ? "left" : left > 0 ? "right" : "center", + vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle" + }; + if (targetWidth < elemWidth && abs(left + right) < targetWidth) { + feedback.horizontal = "center"; + } + if (targetHeight < elemHeight && abs(top + bottom) < targetHeight) { + feedback.vertical = "middle"; + } + if (max(abs(left), abs(right)) > max(abs(top), abs(bottom))) { + feedback.important = "horizontal"; + } else { + feedback.important = "vertical"; + } + options.using.call(this, props, feedback); + }; + } + + elem.offset($.extend(position, {using: using})); + }); + }; + + $.ui.position = { + fit: { + left: function (position, data) { + var within = data.within, + withinOffset = within.isWindow ? within.scrollLeft : within.offset.left, + outerWidth = within.width, + collisionPosLeft = position.left - data.collisionPosition.marginLeft, + overLeft = withinOffset - collisionPosLeft, + overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset, + newOverRight; + + // element is wider than within + if (data.collisionWidth > outerWidth) { + // element is initially over the left side of within + if (overLeft > 0 && overRight <= 0) { + newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset; + position.left += overLeft - newOverRight; + // element is initially over right side of within + } else if (overRight > 0 && overLeft <= 0) { + position.left = withinOffset; + // element is initially over both left and right sides of within + } else { + if (overLeft > overRight) { + position.left = withinOffset + outerWidth - data.collisionWidth; + } else { + position.left = withinOffset; + } + } + // too far left -> align with left edge + } else if (overLeft > 0) { + position.left += overLeft; + // too far right -> align with right edge + } else if (overRight > 0) { + position.left -= overRight; + // adjust based on position and margin + } else { + position.left = max(position.left - collisionPosLeft, position.left); + } + }, + top: function (position, data) { + var within = data.within, + withinOffset = within.isWindow ? within.scrollTop : within.offset.top, + outerHeight = data.within.height, + collisionPosTop = position.top - data.collisionPosition.marginTop, + overTop = withinOffset - collisionPosTop, + overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset, + newOverBottom; + + // element is taller than within + if (data.collisionHeight > outerHeight) { + // element is initially over the top of within + if (overTop > 0 && overBottom <= 0) { + newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset; + position.top += overTop - newOverBottom; + // element is initially over bottom of within + } else if (overBottom > 0 && overTop <= 0) { + position.top = withinOffset; + // element is initially over both top and bottom of within + } else { + if (overTop > overBottom) { + position.top = withinOffset + outerHeight - data.collisionHeight; + } else { + position.top = withinOffset; + } + } + // too far up -> align with top + } else if (overTop > 0) { + position.top += overTop; + // too far down -> align with bottom edge + } else if (overBottom > 0) { + position.top -= overBottom; + // adjust based on position and margin + } else { + position.top = max(position.top - collisionPosTop, position.top); + } + } + }, + flip: { + left: function (position, data) { + var within = data.within, + withinOffset = within.offset.left + within.scrollLeft, + outerWidth = within.width, + offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left, + collisionPosLeft = position.left - data.collisionPosition.marginLeft, + overLeft = collisionPosLeft - offsetLeft, + overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft, + myOffset = data.my[0] === "left" ? + -data.elemWidth : + data.my[0] === "right" ? + data.elemWidth : + 0, + atOffset = data.at[0] === "left" ? + data.targetWidth : + data.at[0] === "right" ? + -data.targetWidth : + 0, + offset = -2 * data.offset[0], + newOverRight, + newOverLeft; + + if (overLeft < 0) { + newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset; + if (newOverRight < 0 || newOverRight < abs(overLeft)) { + position.left += myOffset + atOffset + offset; + } + } else if (overRight > 0) { + newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft; + if (newOverLeft > 0 || abs(newOverLeft) < overRight) { + position.left += myOffset + atOffset + offset; + } + } + }, + top: function (position, data) { + var within = data.within, + withinOffset = within.offset.top + within.scrollTop, + outerHeight = within.height, + offsetTop = within.isWindow ? within.scrollTop : within.offset.top, + collisionPosTop = position.top - data.collisionPosition.marginTop, + overTop = collisionPosTop - offsetTop, + overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop, + top = data.my[1] === "top", + myOffset = top ? + -data.elemHeight : + data.my[1] === "bottom" ? + data.elemHeight : + 0, + atOffset = data.at[1] === "top" ? + data.targetHeight : + data.at[1] === "bottom" ? + -data.targetHeight : + 0, + offset = -2 * data.offset[1], + newOverTop, + newOverBottom; + if (overTop < 0) { + newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset; + if (newOverBottom < 0 || newOverBottom < abs(overTop)) { + position.top += myOffset + atOffset + offset; + } + } else if (overBottom > 0) { + newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop; + if (newOverTop > 0 || abs(newOverTop) < overBottom) { + position.top += myOffset + atOffset + offset; + } + } + } + }, + flipfit: { + left: function () { + $.ui.position.flip.left.apply(this, arguments); + $.ui.position.fit.left.apply(this, arguments); + }, + top: function () { + $.ui.position.flip.top.apply(this, arguments); + $.ui.position.fit.top.apply(this, arguments); + } + } + }; + +// fraction support test + (function () { + var testElement, testElementParent, testElementStyle, offsetLeft, i, + body = document.getElementsByTagName("body")[0], + div = document.createElement("div"); + + //Create a "fake body" for testing based on method used in jQuery.support + testElement = document.createElement(body ? "div" : "body"); + testElementStyle = { + visibility: "hidden", + width: 0, + height: 0, + border: 0, + margin: 0, + background: "none" + }; + if (body) { + $.extend(testElementStyle, { + position: "absolute", + left: "-1000px", + top: "-1000px" + }); + } + for (i in testElementStyle) { + testElement.style[i] = testElementStyle[i]; + } + testElement.appendChild(div); + testElementParent = body || document.documentElement; + testElementParent.insertBefore(testElement, testElementParent.firstChild); + + div.style.cssText = "position: absolute; left: 10.7432222px;"; + + offsetLeft = $(div).offset().left; + supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11; + + testElement.innerHTML = ""; + testElementParent.removeChild(testElement); + })(); + + })(); + + var position = $.ui.position; + + + /*! + * jQuery UI Accordion 1.11.4 + * http://jqueryui.com + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license. + * http://jquery.org/license + * + * http://api.jqueryui.com/accordion/ + */ + + + var accordion = $.widget("ui.accordion", { + version: "1.11.4", + options: { + active: 0, + animate: {}, + 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.element.addClass("ui-accordion ui-widget ui-helper-reset") + // ARIA + .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 icons = this.options.icons; + if (icons) { + $("<span>") + .addClass("ui-accordion-header-icon ui-icon " + icons.header) + .prependTo(this.headers); + this.active.children(".ui-accordion-header-icon") + .removeClass(icons.header) + .addClass(icons.activeHeader); + this.headers.addClass("ui-accordion-icons"); + } + }, + + _destroyIcons: function () { + this.headers + .removeClass("ui-accordion-icons") + .children(".ui-accordion-header-icon") + .remove(); + }, + + _destroy: function () { + var contents; + + // clean up main element + this.element + .removeClass("ui-accordion ui-widget ui-helper-reset") + .removeAttr("role"); + + // clean up headers + this.headers + .removeClass("ui-accordion-header ui-accordion-header-active ui-state-default " + + "ui-corner-all ui-state-active ui-state-disabled ui-corner-top") + .removeAttr("role") + .removeAttr("aria-expanded") + .removeAttr("aria-selected") + .removeAttr("aria-controls") + .removeAttr("tabIndex") + .removeUniqueId(); + + this._destroyIcons(); + + // clean up content panels + contents = this.headers.next() + .removeClass("ui-helper-reset ui-widget-content ui-corner-bottom " + + "ui-accordion-content ui-accordion-content-active ui-state-disabled") + .css("display", "") + .removeAttr("role") + .removeAttr("aria-hidden") + .removeAttr("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(); + } + } + + // #5332 - opacity doesn't cascade to positioned elements in IE + // so we need to add the disabled class to the headers and panels + if (key === "disabled") { + this.element + .toggleClass("ui-state-disabled", !!value) + .attr("aria-disabled", value); + this.headers.add(this.headers.next()) + .toggleClass("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.focus(); + event.preventDefault(); + } + }, + + _panelKeyDown: function (event) { + if (event.keyCode === $.ui.keyCode.UP && event.ctrlKey) { + $(event.currentTarget).prev().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) + .addClass("ui-accordion-header ui-state-default ui-corner-all"); + + this.panels = this.headers.next() + .addClass("ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom") + .filter(":not(.ui-accordion-content-active)") + .hide(); + + // 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) + .addClass("ui-accordion-header-active ui-state-active ui-corner-top") + .removeClass("ui-corner-all"); + this.active.next() + .addClass("ui-accordion-content-active") + .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 () { + maxHeight = Math.max(maxHeight, $(this).css("height", "").height()); + }) + .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 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 + active.removeClass("ui-accordion-header-active ui-state-active"); + if (options.icons) { + active.children(".ui-accordion-header-icon") + .removeClass(options.icons.activeHeader) + .addClass(options.icons.header); + } + + if (!clickedIsActive) { + clicked + .removeClass("ui-corner-all") + .addClass("ui-accordion-header-active ui-state-active ui-corner-top"); + if (options.icons) { + clicked.children(".ui-accordion-header-icon") + .removeClass(options.icons.header) + .addClass(options.icons.activeHeader); + } + + clicked + .next() + .addClass("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; + + toHide + .removeClass("ui-accordion-content-active") + .prev() + .removeClass("ui-corner-top") + .addClass("ui-corner-all"); + + // Work around for rendering bug in IE (#5421) + if (toHide.length) { + toHide.parent()[0].className = toHide.parent()[0].className; + } + this._trigger("activate", null, data); + } + }); + + + /*! + * jQuery UI Menu 1.11.4 + * http://jqueryui.com + * + * Copyright jQuery Foundation and other contributors + * Released under the MIT license. + * http://jquery.org/license + * + * http://api.jqueryui.com/menu/ + */ + + + var menu = $.widget("ui.menu", { + version: "1.11.4", + defaultElement: "<ul>", + delay: 300, + options: { + icons: { + submenu: "ui-icon-carat-1-e" + }, + items: "> *", + menus: "ul", + position: { + my: "left-1 top", + at: "right top" + }, + role: "menu", + + // callbacks + blur: null, + focus: null, + select: null + }, + + _create: function () { + this.activeMenu = this.element; + + // Flag used to prevent firing of the click handler + // as the event bubbles up through nested menus + this.mouseHandled = false; + this.element + .uniqueId() + .addClass("ui-menu ui-widget ui-widget-content") + .toggleClass("ui-menu-icons", !!this.element.find(".ui-icon").length) + .attr({ + role: this.options.role, + tabIndex: 0 + }); + + if (this.options.disabled) { + this.element + .addClass("ui-state-disabled") + .attr("aria-disabled", "true"); + } + + this._on({ + // Prevent focus from sticking to links inside menu after clicking + // them (focus should always stay on UL during navigation). + "mousedown .ui-menu-item": function (event) { + event.preventDefault(); + }, + "click .ui-menu-item": function (event) { + var target = $(event.target); + if (!this.mouseHandled && target.not(".ui-state-disabled").length) { + this.select(event); + + // Only set the mouseHandled flag if the event will bubble, see #9469. + if (!event.isPropagationStopped()) { + this.mouseHandled = true; + } + + // Open submenu on click + if (target.has(".ui-menu").length) { + this.expand(event); + } else if (!this.element.is(":focus") && $(this.document[0].activeElement).closest(".ui-menu").length) { + + // Redirect focus to the menu + this.element.trigger("focus", [true]); + + // If the active item is on the top level, let it stay active. + // Otherwise, blur the active item since it is no longer visible. + if (this.active && this.active.parents(".ui-menu").length === 1) { + clearTimeout(this.timer); + } + } + } + }, + "mouseenter .ui-menu-item": function (event) { + // Ignore mouse events while typeahead is active, see #10458. + // Prevents focusing the wrong item when typeahead causes a scroll while the mouse + // is over an item in the menu + if (this.previousFilter) { + return; + } + var target = $(event.currentTarget); + // Remove ui-state-active class from siblings of the newly focused menu item + // to avoid a jump caused by adjacent elements both having a class with a border + target.siblings(".ui-state-active").removeClass("ui-state-active"); + this.focus(event, target); + }, + mouseleave: "collapseAll", + "mouseleave .ui-menu": "collapseAll", + focus: function (event, keepActiveItem) { + // If there's already an active item, keep it active + // If not, activate the first item + var item = this.active || this.element.find(this.options.items).eq(0); + + if (!keepActiveItem) { + this.focus(event, item); + } + }, + blur: function (event) { + this._delay(function () { + if (!$.contains(this.element[0], this.document[0].activeElement)
<TRUNCATED>
