All Downloads are FREE. Search and download functionalities are using the official Maven repository.

template.js.base.jquery-ui.js Maven / Gradle / Ivy

There is a newer version: 5.0.4
Show newest version
/*! jQuery UI - v1.10.4 - 2014-04-02
 * http://jqueryui.com
 * Includes: jquery.ui.core.js, jquery.ui.widget.js, jquery.ui.mouse.js, jquery.ui.position.js, jquery.ui.accordion.js, jquery.ui.autocomplete.js, jquery.ui.button.js, jquery.ui.datepicker.js, jquery.ui.dialog.js, jquery.ui.draggable.js, jquery.ui.droppable.js, jquery.ui.effect.js, jquery.ui.effect-blind.js, jquery.ui.effect-bounce.js, jquery.ui.effect-clip.js, jquery.ui.effect-drop.js, jquery.ui.effect-explode.js, jquery.ui.effect-fade.js, jquery.ui.effect-fold.js, jquery.ui.effect-highlight.js, jquery.ui.effect-pulsate.js, jquery.ui.effect-scale.js, jquery.ui.effect-shake.js, jquery.ui.effect-slide.js, jquery.ui.effect-transfer.js, jquery.ui.menu.js, jquery.ui.progressbar.js, jquery.ui.resizable.js, jquery.ui.selectable.js, jquery.ui.slider.js, jquery.ui.sortable.js, jquery.ui.spinner.js, jquery.ui.tabs.js, jquery.ui.tooltip.js
 * Copyright 2014 jQuery Foundation and other contributors; Licensed MIT */

(function ($, undefined) {

    var uuid = 0,
        runiqueId = /^ui-id-\d+$/;

// $.ui might exist from components with no dependencies, e.g., $.ui.position
    $.ui = $.ui || {};

    $.extend($.ui, {
        version: "1.10.4",

        keyCode: {
            BACKSPACE: 8,
            COMMA: 188,
            DELETE: 46,
            DOWN: 40,
            END: 35,
            ENTER: 13,
            ESCAPE: 27,
            HOME: 36,
            LEFT: 37,
            NUMPAD_ADD: 107,
            NUMPAD_DECIMAL: 110,
            NUMPAD_DIVIDE: 111,
            NUMPAD_ENTER: 108,
            NUMPAD_MULTIPLY: 106,
            NUMPAD_SUBTRACT: 109,
            PAGE_DOWN: 34,
            PAGE_UP: 33,
            PERIOD: 190,
            RIGHT: 39,
            SPACE: 32,
            TAB: 9,
            UP: 38
        }
    });

// plugins
    $.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),

        scrollParent: function () {
            var scrollParent;
            if (($.ui.ie && (/(static|relative)/).test(this.css("position"))) || (/absolute/).test(this.css("position"))) {
                scrollParent = this.parents().filter(function () {
                    return (/(relative|absolute|fixed)/).test($.css(this, "position")) && (/(auto|scroll)/).test($.css(this, "overflow") + $.css(this, "overflow-y") + $.css(this, "overflow-x"));
                }).eq(0);
            } else {
                scrollParent = this.parents().filter(function () {
                    return (/(auto|scroll)/).test($.css(this, "overflow") + $.css(this, "overflow-y") + $.css(this, "overflow-x"));
                }).eq(0);
            }

            return (/fixed/).test(this.css("position")) || !scrollParent.length ? $(document) : scrollParent;
        },

        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
                        // 
value = parseInt(elem.css("zIndex"), 10); if (!isNaN(value) && value !== 0) { return value; } } elem = elem.parent(); } } return 0; }, uniqueId: function () { return this.each(function () { if (!this.id) { this.id = "ui-id-" + (++uuid); } }); }, removeUniqueId: function () { return this.each(function () { if (runiqueId.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 (!$("").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 ($("").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()); $.support.selectstart = "onselectstart" in document.createElement("div"); $.fn.extend({ disableSelection: function () { return this.bind(( $.support.selectstart ? "selectstart" : "mousedown" ) + ".ui-disableSelection", function (event) { event.preventDefault(); }); }, enableSelection: function () { return this.unbind(".ui-disableSelection"); } }); $.extend($.ui, { // $.ui.plugin is deprecated. Use $.widget() extensions instead. 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) { var i, set = instance.plugins[ name ]; if (!set || !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); } } } }, // only used by resizable hasScroll: function (el, a) { //If overflow is hidden, the element might have extra content, but the user wants to hide it if ($(el).css("overflow") === "hidden") { return false; } var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop", has = false; if (el[ scroll ] > 0) { return true; } // TODO: determine which cases actually cause this to happen // if the element doesn't have the scroll set, see if it's possible to // set the scroll el[ scroll ] = 1; has = ( el[ scroll ] > 0 ); el[ scroll ] = 0; return has; } }); })(jQuery); (function ($, undefined) { var uuid = 0, slice = Array.prototype.slice, _cleanData = $.cleanData; $.cleanData = function (elems) { for (var i = 0, elem; (elem = elems[i]) != null; i++) { try { $(elem).triggerHandler("remove"); // http://bugs.jquery.com/ticket/8235 } catch (e) { } } _cleanData(elems); }; $.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); }; $.widget.extend = function (target) { var input = 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 = slice.call(arguments, 1), returnValue = this; // allow multiple hashes to be passed on init options = !isMethodCall && args.length ? $.widget.extend.apply(null, [ options ].concat(args)) : options; if (isMethodCall) { this.each(function () { var methodValue, instance = $.data(this, fullName); 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 { this.each(function () { var instance = $.data(this, fullName); if (instance) { instance.option(options || {})._init(); } else { $.data(this, fullName, new object(options, this)); } }); } return returnValue; }; }; $.Widget = function (/* options, element */) { }; $.Widget._childConstructors = []; $.Widget.prototype = { widgetName: "widget", widgetEventPrefix: "", defaultElement: "
", options: { disabled: false, // callbacks create: null }, _createWidget: function (options, element) { element = $(element || this.defaultElement || this)[ 0 ]; this.element = $(element); this.uuid = uuid++; this.eventNamespace = "." + this.widgetName + this.uuid; this.options = $.widget.extend({}, this.options, this._getCreateOptions(), options); 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._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) // 1.9 BC for #7810 // TODO remove dual storage .removeData(this.widgetName) .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 ui-state-disabled", !!value) .attr("aria-disabled", value); this.hoverable.removeClass("ui-state-hover"); this.focusable.removeClass("ui-state-focus"); } return this; }, enable: function () { return this._setOption("disabled", false); }, disable: function () { return this._setOption("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 { // accept selectors, DOM elements 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); }, _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(); }); } }; }); })(jQuery); (function ($, undefined) { var mouseHandled = false; $(document).mouseup(function () { mouseHandled = false; }); $.widget("ui.mouse", { version: "1.10.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) { $(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; } // 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); }; $(document) .bind("mousemove." + this.widgetName, this._mouseMoveDelegate) .bind("mouseup." + this.widgetName, this._mouseUpDelegate); event.preventDefault(); mouseHandled = true; return true; }, _mouseMove: function (event) { // 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); } 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) { $(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); } 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); (function ($, undefined) { $.ui = $.ui || {}; var cachedScrollbarWidth, 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 = $("
"), 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(), width: isWindow ? withinElement.width() : withinElement.outerWidth(), height: isWindow ? 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 (!$.support.offsetFractions) { 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 (( position.top + myOffset + atOffset + offset) > overTop && ( 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 (( position.top + myOffset + atOffset + offset) > overBottom && ( 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; $.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11; testElement.innerHTML = ""; testElementParent.removeChild(testElement); })(); }(jQuery) ); (function ($, undefined) { var uid = 0, hideProps = {}, showProps = {}; hideProps.height = hideProps.paddingTop = hideProps.paddingBottom = hideProps.borderTopWidth = hideProps.borderBottomWidth = "hide"; showProps.height = showProps.paddingTop = showProps.paddingBottom = showProps.borderTopWidth = showProps.borderBottomWidth = "show"; $.widget("ui.accordion", { version: "1.10.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 }, _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(), content: !this.active.length ? $() : this.active.next() }; }, _createIcons: function () { var icons = this.options.icons; if (icons) { $("") .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-helper-reset 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") .each(function () { if (/^ui-accordion/.test(this.id)) { this.removeAttribute("id"); } }); this._destroyIcons(); // clean up content panels contents = this.headers.next() .css("display", "") .removeAttr("role") .removeAttr("aria-hidden") .removeAttr("aria-labelledby") .removeClass("ui-helper-reset ui-widget-content ui-corner-bottom ui-accordion-content ui-accordion-content-active ui-state-disabled") .each(function () { if (/^ui-accordion/.test(this.id)) { this.removeAttribute("id"); } }); 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.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 () { this.headers = this.element.find(this.options.header) .addClass("ui-accordion-header ui-helper-reset ui-state-default ui-corner-all"); this.headers.next() .addClass("ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom") .filter(":not(.ui-accordion-content-active)") .hide(); }, _refresh: function () { var maxHeight, options = this.options, heightStyle = options.heightStyle, parent = this.element.parent(), accordionId = this.accordionId = "ui-accordion-" + (this.element.attr("id") || ++uid); 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 (i) { var header = $(this), headerId = header.attr("id"), panel = header.next(), panelId = panel.attr("id"); if (!headerId) { headerId = accordionId + "-header-" + i; header.attr("id", headerId); } if (!panelId) { panelId = accordionId + "-panel-" + i; panel.attr("id", panelId); } 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"); // 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 $(this).attr("tabIndex") === 0; }) .attr("tabIndex", -1); } toShow .attr("aria-hidden", "false") .prev() .attr({ "aria-selected": "true", tabIndex: 0, "aria-expanded": "true" }); }, _animate: function (toShow, toHide, data) { var total, easing, duration, that = this, adjust = 0, 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(showProps, duration, easing, complete); } if (!toShow.length) { return toHide.animate(hideProps, duration, easing, complete); } total = toShow.show().outerHeight(); toHide.animate(hideProps, { duration: duration, easing: easing, step: function (now, fx) { fx.now = Math.round(now); } }); toShow .hide() .animate(showProps, { duration: duration, easing: easing, complete: complete, step: function (now, fx) { fx.now = Math.round(now); if (fx.prop !== "height") { 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); (function ($, undefined) { $.widget("ui.autocomplete", { version: "1.10.4", defaultElement: "", options: { appendTo: null, autoFocus: false, delay: 300, minLength: 1, position: { my: "left top", at: "left bottom", collision: "none" }, source: null, // callbacks change: null, close: null, focus: null, open: null, response: null, search: null, select: null }, requestIndex: 0, pending: 0, _create: function () { // Some browsers only repeat keydown events, not keypress events, // so we use the suppressKeyPress flag to determine if we've already // handled the keydown event. #7269 // Unfortunately the code for & in keypress is the same as the up arrow, // so we use the suppressKeyPressRepeat flag to avoid handling keypress // events when we know the keydown event was used to modify the // search term. #7799 var suppressKeyPress, suppressKeyPressRepeat, suppressInput, nodeName = this.element[0].nodeName.toLowerCase(), isTextarea = nodeName === "textarea", isInput = nodeName === "input"; this.isMultiLine = // Textareas are always multi-line isTextarea ? true : // Inputs are always single-line, even if inside a contentEditable element // IE also treats inputs as contentEditable isInput ? false : // All other element types are determined by whether or not they're contentEditable this.element.prop("isContentEditable"); this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ]; this.isNewMenu = true; this.element .addClass("ui-autocomplete-input") .attr("autocomplete", "off"); this._on(this.element, { keydown: function (event) { if (this.element.prop("readOnly")) { suppressKeyPress = true; suppressInput = true; suppressKeyPressRepeat = true; return; } suppressKeyPress = false; suppressInput = false; suppressKeyPressRepeat = false; var keyCode = $.ui.keyCode; switch (event.keyCode) { case keyCode.PAGE_UP: suppressKeyPress = true; this._move("previousPage", event); break; case keyCode.PAGE_DOWN: suppressKeyPress = true; this._move("nextPage", event); break; case keyCode.UP: suppressKeyPress = true; this._keyEvent("previous", event); break; case keyCode.DOWN: suppressKeyPress = true; this._keyEvent("next", event); break; case keyCode.ENTER: case keyCode.NUMPAD_ENTER: // when menu is open and has focus if (this.menu.active) { // #6055 - Opera still allows the keypress to occur // which causes forms to submit suppressKeyPress = true; event.preventDefault(); this.menu.select(event); } break; case keyCode.TAB: if (this.menu.active) { this.menu.select(event); } break; case keyCode.ESCAPE: if (this.menu.element.is(":visible")) { this._value(this.term); this.close(event); // Different browsers have different default behavior for escape // Single press can mean undo or clear // Double press in IE means clear the whole form event.preventDefault(); } break; default: suppressKeyPressRepeat = true; // search timeout should be triggered before the input value is changed this._searchTimeout(event); break; } }, keypress: function (event) { if (suppressKeyPress) { suppressKeyPress = false; if (!this.isMultiLine || this.menu.element.is(":visible")) { event.preventDefault(); } return; } if (suppressKeyPressRepeat) { return; } // replicate some key handlers to allow them to repeat in Firefox and Opera var keyCode = $.ui.keyCode; switch (event.keyCode) { case keyCode.PAGE_UP: this._move("previousPage", event); break; case keyCode.PAGE_DOWN: this._move("nextPage", event); break; case keyCode.UP: this._keyEvent("previous", event); break; case keyCode.DOWN: this._keyEvent("next", event); break; } }, input: function (event) { if (suppressInput) { suppressInput = false; event.preventDefault(); return; } this._searchTimeout(event); }, focus: function () { this.selectedItem = null; this.previous = this._value(); }, blur: function (event) { if (this.cancelBlur) { delete this.cancelBlur; return; } clearTimeout(this.searching); this.close(event); this._change(event); } }); this._initSource(); this.menu = $("