",
+ 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: "")
+ .addClass("ui-autocomplete ui-front")
+ .appendTo(this._appendTo())
+ .menu({
+ // disable ARIA support, the live region takes care of that
+ role: null,
+ })
+ .hide()
+ .data("ui-menu");
+
+ this._on(this.menu.element, {
+ mousedown: function (event) {
+ // prevent moving focus out of the text field
+ event.preventDefault();
+
+ // IE doesn't prevent moving focus even with event.preventDefault()
+ // so we set a flag to know when we should ignore the blur event
+ this.cancelBlur = true;
+ this._delay(function () {
+ delete this.cancelBlur;
+ });
+
+ // clicking on the scrollbar causes focus to shift to the body
+ // but we can't detect a mouseup or a click immediately afterward
+ // so we have to track the next mousedown and close the menu if
+ // the user clicks somewhere outside of the autocomplete
+ var menuElement = this.menu.element[0];
+ if (!$(event.target).closest(".ui-menu-item").length) {
+ this._delay(function () {
+ var that = this;
+ this.document.one("mousedown", function (event) {
+ if (
+ event.target !== that.element[0] &&
+ event.target !== menuElement &&
+ !$.contains(menuElement, event.target)
+ ) {
+ that.close();
+ }
+ });
+ });
+ }
+ },
+ menufocus: function (event, ui) {
+ // support: Firefox
+ // Prevent accidental activation of menu items in Firefox (#7024 #9118)
+ if (this.isNewMenu) {
+ this.isNewMenu = false;
+ if (
+ event.originalEvent &&
+ /^mouse/.test(event.originalEvent.type)
+ ) {
+ this.menu.blur();
+
+ this.document.one("mousemove", function () {
+ $(event.target).trigger(event.originalEvent);
+ });
+
+ return;
+ }
+ }
+
+ var item = ui.item.data("ui-autocomplete-item");
+ if (
+ false !== this._trigger("focus", event, { item: item })
+ ) {
+ // use value to match what will end up in the input, if it was a key event
+ if (
+ event.originalEvent &&
+ /^key/.test(event.originalEvent.type)
+ ) {
+ this._value(item.value);
+ }
+ } else {
+ // Normally the input is populated with the item's value as the
+ // menu is navigated, causing screen readers to notice a change and
+ // announce the item. Since the focus event was canceled, this doesn't
+ // happen, so we update the live region so that screen readers can
+ // still notice the change and announce it.
+ this.liveRegion.text(item.value);
+ }
+ },
+ menuselect: function (event, ui) {
+ var item = ui.item.data("ui-autocomplete-item"),
+ previous = this.previous;
+
+ // only trigger when focus was lost (click on menu)
+ if (this.element[0] !== this.document[0].activeElement) {
+ this.element.focus();
+ this.previous = previous;
+ // #6109 - IE triggers two focus events and the second
+ // is asynchronous, so we need to reset the previous
+ // term synchronously and asynchronously :-(
+ this._delay(function () {
+ this.previous = previous;
+ this.selectedItem = item;
+ });
+ }
+
+ if (
+ false !== this._trigger("select", event, { item: item })
+ ) {
+ this._value(item.value);
+ }
+ // reset the term after the select event
+ // this allows custom select handling to work properly
+ this.term = this._value();
+
+ this.close(event);
+ this.selectedItem = item;
+ },
+ });
+
+ this.liveRegion = $("", {
+ role: "status",
+ "aria-live": "polite",
+ })
+ .addClass("ui-helper-hidden-accessible")
+ .insertBefore(this.element);
+
+ // turning off autocomplete prevents the browser from remembering the
+ // value when navigating through history, so we re-enable autocomplete
+ // if the page is unloaded before the widget is destroyed. #7790
+ this._on(this.window, {
+ beforeunload: function () {
+ this.element.removeAttr("autocomplete");
+ },
+ });
+ },
+
+ _destroy: function () {
+ clearTimeout(this.searching);
+ this.element
+ .removeClass("ui-autocomplete-input")
+ .removeAttr("autocomplete");
+ this.menu.element.remove();
+ this.liveRegion.remove();
+ },
+
+ _setOption: function (key, value) {
+ this._super(key, value);
+ if (key === "source") {
+ this._initSource();
+ }
+ if (key === "appendTo") {
+ this.menu.element.appendTo(this._appendTo());
+ }
+ if (key === "disabled" && value && this.xhr) {
+ this.xhr.abort();
+ }
+ },
+
+ _appendTo: function () {
+ var element = this.options.appendTo;
+
+ if (element) {
+ element =
+ element.jquery || element.nodeType
+ ? $(element)
+ : this.document.find(element).eq(0);
+ }
+
+ if (!element) {
+ element = this.element.closest(".ui-front");
+ }
+
+ if (!element.length) {
+ element = this.document[0].body;
+ }
+
+ return element;
+ },
+
+ _initSource: function () {
+ var array,
+ url,
+ that = this;
+ if ($.isArray(this.options.source)) {
+ array = this.options.source;
+ this.source = function (request, response) {
+ response($.ui.autocomplete.filter(array, request.term));
+ };
+ } else if (typeof this.options.source === "string") {
+ url = this.options.source;
+ this.source = function (request, response) {
+ if (that.xhr) {
+ that.xhr.abort();
+ }
+ that.xhr = $.ajax({
+ url: url,
+ data: request,
+ dataType: "json",
+ success: function (data) {
+ response(data);
+ },
+ error: function () {
+ response([]);
+ },
+ });
+ };
+ } else {
+ this.source = this.options.source;
+ }
+ },
+
+ _searchTimeout: function (event) {
+ clearTimeout(this.searching);
+ this.searching = this._delay(function () {
+ // only search if the value has changed
+ if (this.term !== this._value()) {
+ this.selectedItem = null;
+ this.search(null, event);
+ }
+ }, this.options.delay);
+ },
+
+ search: function (value, event) {
+ value = value != null ? value : this._value();
+
+ // always save the actual value, not the one passed as an argument
+ this.term = this._value();
+
+ if (value.length < this.options.minLength) {
+ return this.close(event);
+ }
+
+ if (this._trigger("search", event) === false) {
+ return;
+ }
+
+ return this._search(value);
+ },
+
+ _search: function (value) {
+ this.pending++;
+ this.element.addClass("ui-autocomplete-loading");
+ this.cancelSearch = false;
+
+ this.source({ term: value }, this._response());
+ },
+
+ _response: function () {
+ var index = ++this.requestIndex;
+
+ return $.proxy(function (content) {
+ if (index === this.requestIndex) {
+ this.__response(content);
+ }
+
+ this.pending--;
+ if (!this.pending) {
+ this.element.removeClass("ui-autocomplete-loading");
+ }
+ }, this);
+ },
+
+ __response: function (content) {
+ if (content) {
+ content = this._normalize(content);
+ }
+ this._trigger("response", null, { content: content });
+ if (
+ !this.options.disabled &&
+ content &&
+ content.length &&
+ !this.cancelSearch
+ ) {
+ this._suggest(content);
+ this._trigger("open");
+ } else {
+ // use ._close() instead of .close() so we don't cancel future searches
+ this._close();
+ }
+ },
+
+ close: function (event) {
+ this.cancelSearch = true;
+ this._close(event);
+ },
+
+ _close: function (event) {
+ if (this.menu.element.is(":visible")) {
+ this.menu.element.hide();
+ this.menu.blur();
+ this.isNewMenu = true;
+ this._trigger("close", event);
+ }
+ },
+
+ _change: function (event) {
+ if (this.previous !== this._value()) {
+ this._trigger("change", event, { item: this.selectedItem });
+ }
+ },
+
+ _normalize: function (items) {
+ // assume all items have the right format when the first item is complete
+ if (items.length && items[0].label && items[0].value) {
+ return items;
+ }
+ return $.map(items, function (item) {
+ if (typeof item === "string") {
+ return {
+ label: item,
+ value: item,
+ };
+ }
+ return $.extend(
+ {
+ label: item.label || item.value,
+ value: item.value || item.label,
+ },
+ item
+ );
+ });
+ },
+
+ _suggest: function (items) {
+ var ul = this.menu.element.empty();
+ this._renderMenu(ul, items);
+ this.isNewMenu = true;
+ this.menu.refresh();
+
+ // size and position menu
+ ul.show();
+ this._resizeMenu();
+ ul.position(
+ $.extend(
+ {
+ of: this.element,
+ },
+ this.options.position
+ )
+ );
+
+ if (this.options.autoFocus) {
+ this.menu.next();
+ }
+ },
+
+ _resizeMenu: function () {
+ var ul = this.menu.element;
+ ul.outerWidth(
+ Math.max(
+ // Firefox wraps long text (possibly a rounding bug)
+ // so we add 1px to avoid the wrapping (#7513)
+ ul.width("").outerWidth() + 1,
+ this.element.outerWidth()
+ )
+ );
+ },
+
+ _renderMenu: function (ul, items) {
+ var that = this;
+ $.each(items, function (index, item) {
+ that._renderItemData(ul, item);
+ });
+ },
+
+ _renderItemData: function (ul, item) {
+ return this._renderItem(ul, item).data(
+ "ui-autocomplete-item",
+ item
+ );
+ },
+
+ _renderItem: function (ul, item) {
+ return $("").append($("").text(item.label)).appendTo(ul);
+ },
+
+ _move: function (direction, event) {
+ if (!this.menu.element.is(":visible")) {
+ this.search(null, event);
+ return;
+ }
+ if (
+ (this.menu.isFirstItem() && /^previous/.test(direction)) ||
+ (this.menu.isLastItem() && /^next/.test(direction))
+ ) {
+ this._value(this.term);
+ this.menu.blur();
+ return;
+ }
+ this.menu[direction](event);
+ },
+
+ widget: function () {
+ return this.menu.element;
+ },
+
+ _value: function () {
+ return this.valueMethod.apply(this.element, arguments);
+ },
+
+ _keyEvent: function (keyEvent, event) {
+ if (!this.isMultiLine || this.menu.element.is(":visible")) {
+ this._move(keyEvent, event);
+
+ // prevents moving cursor to beginning/end of the text field in some browsers
+ event.preventDefault();
+ }
+ },
+ });
+
+ $.extend($.ui.autocomplete, {
+ escapeRegex: function (value) {
+ return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+ },
+ filter: function (array, term) {
+ var matcher = new RegExp($.ui.autocomplete.escapeRegex(term), "i");
+ return $.grep(array, function (value) {
+ return matcher.test(value.label || value.value || value);
+ });
+ },
+ });
+
+ // live region extension, adding a `messages` option
+ // NOTE: This is an experimental API. We are still investigating
+ // a full solution for string manipulation and internationalization.
+ $.widget("ui.autocomplete", $.ui.autocomplete, {
+ options: {
+ messages: {
+ noResults: "No search results.",
+ results: function (amount) {
+ return (
+ amount +
+ (amount > 1 ? " results are" : " result is") +
+ " available, use up and down arrow keys to navigate."
+ );
+ },
+ },
+ },
+
+ __response: function (content) {
+ var message;
+ this._superApply(arguments);
+ if (this.options.disabled || this.cancelSearch) {
+ return;
+ }
+ if (content && content.length) {
+ message = this.options.messages.results(content.length);
+ } else {
+ message = this.options.messages.noResults;
+ }
+ this.liveRegion.text(message);
+ },
+ });
+})(jQuery);
+(function ($, undefined) {
+ var lastActive,
+ baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
+ typeClasses =
+ "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
+ formResetHandler = function () {
+ var form = $(this);
+ setTimeout(function () {
+ form.find(":ui-button").button("refresh");
+ }, 1);
+ },
+ radioGroup = function (radio) {
+ var name = radio.name,
+ form = radio.form,
+ radios = $([]);
+ if (name) {
+ name = name.replace(/'/g, "\\'");
+ if (form) {
+ radios = $(form).find("[name='" + name + "']");
+ } else {
+ radios = $(
+ "[name='" + name + "']",
+ radio.ownerDocument
+ ).filter(function () {
+ return !this.form;
+ });
+ }
+ }
+ return radios;
+ };
+
+ $.widget("ui.button", {
+ version: "1.10.4",
+ defaultElement: "",
+ options: {
+ disabled: null,
+ text: true,
+ label: null,
+ icons: {
+ primary: null,
+ secondary: null,
+ },
+ },
+ _create: function () {
+ this.element
+ .closest("form")
+ .unbind("reset" + this.eventNamespace)
+ .bind("reset" + this.eventNamespace, formResetHandler);
+
+ if (typeof this.options.disabled !== "boolean") {
+ this.options.disabled = !!this.element.prop("disabled");
+ } else {
+ this.element.prop("disabled", this.options.disabled);
+ }
+
+ this._determineButtonType();
+ this.hasTitle = !!this.buttonElement.attr("title");
+
+ var that = this,
+ options = this.options,
+ toggleButton =
+ this.type === "checkbox" || this.type === "radio",
+ activeClass = !toggleButton ? "ui-state-active" : "";
+
+ if (options.label === null) {
+ options.label =
+ this.type === "input"
+ ? this.buttonElement.val()
+ : this.buttonElement.html();
+ }
+
+ this._hoverable(this.buttonElement);
+
+ this.buttonElement
+ .addClass(baseClasses)
+ .attr("role", "button")
+ .bind("mouseenter" + this.eventNamespace, function () {
+ if (options.disabled) {
+ return;
+ }
+ if (this === lastActive) {
+ $(this).addClass("ui-state-active");
+ }
+ })
+ .bind("mouseleave" + this.eventNamespace, function () {
+ if (options.disabled) {
+ return;
+ }
+ $(this).removeClass(activeClass);
+ })
+ .bind("click" + this.eventNamespace, function (event) {
+ if (options.disabled) {
+ event.preventDefault();
+ event.stopImmediatePropagation();
+ }
+ });
+
+ // Can't use _focusable() because the element that receives focus
+ // and the element that gets the ui-state-focus class are different
+ this._on({
+ focus: function () {
+ this.buttonElement.addClass("ui-state-focus");
+ },
+ blur: function () {
+ this.buttonElement.removeClass("ui-state-focus");
+ },
+ });
+
+ if (toggleButton) {
+ this.element.bind("change" + this.eventNamespace, function () {
+ that.refresh();
+ });
+ }
+
+ if (this.type === "checkbox") {
+ this.buttonElement.bind(
+ "click" + this.eventNamespace,
+ function () {
+ if (options.disabled) {
+ return false;
+ }
+ }
+ );
+ } else if (this.type === "radio") {
+ this.buttonElement.bind(
+ "click" + this.eventNamespace,
+ function () {
+ if (options.disabled) {
+ return false;
+ }
+ $(this).addClass("ui-state-active");
+ that.buttonElement.attr("aria-pressed", "true");
+
+ var radio = that.element[0];
+ radioGroup(radio)
+ .not(radio)
+ .map(function () {
+ return $(this).button("widget")[0];
+ })
+ .removeClass("ui-state-active")
+ .attr("aria-pressed", "false");
+ }
+ );
+ } else {
+ this.buttonElement
+ .bind("mousedown" + this.eventNamespace, function () {
+ if (options.disabled) {
+ return false;
+ }
+ $(this).addClass("ui-state-active");
+ lastActive = this;
+ that.document.one("mouseup", function () {
+ lastActive = null;
+ });
+ })
+ .bind("mouseup" + this.eventNamespace, function () {
+ if (options.disabled) {
+ return false;
+ }
+ $(this).removeClass("ui-state-active");
+ })
+ .bind("keydown" + this.eventNamespace, function (event) {
+ if (options.disabled) {
+ return false;
+ }
+ if (
+ event.keyCode === $.ui.keyCode.SPACE ||
+ event.keyCode === $.ui.keyCode.ENTER
+ ) {
+ $(this).addClass("ui-state-active");
+ }
+ })
+ // see #8559, we bind to blur here in case the button element loses
+ // focus between keydown and keyup, it would be left in an "active" state
+ .bind(
+ "keyup" +
+ this.eventNamespace +
+ " blur" +
+ this.eventNamespace,
+ function () {
+ $(this).removeClass("ui-state-active");
+ }
+ );
+
+ if (this.buttonElement.is("a")) {
+ this.buttonElement.keyup(function (event) {
+ if (event.keyCode === $.ui.keyCode.SPACE) {
+ // TODO pass through original event correctly (just as 2nd argument doesn't work)
+ $(this).click();
+ }
+ });
+ }
+ }
+
+ // TODO: pull out $.Widget's handling for the disabled option into
+ // $.Widget.prototype._setOptionDisabled so it's easy to proxy and can
+ // be overridden by individual plugins
+ this._setOption("disabled", options.disabled);
+ this._resetButton();
+ },
+
+ _determineButtonType: function () {
+ var ancestor, labelSelector, checked;
+
+ if (this.element.is("[type=checkbox]")) {
+ this.type = "checkbox";
+ } else if (this.element.is("[type=radio]")) {
+ this.type = "radio";
+ } else if (this.element.is("input")) {
+ this.type = "input";
+ } else {
+ this.type = "button";
+ }
+
+ if (this.type === "checkbox" || this.type === "radio") {
+ // we don't search against the document in case the element
+ // is disconnected from the DOM
+ ancestor = this.element.parents().last();
+ labelSelector = "label[for='" + this.element.attr("id") + "']";
+ this.buttonElement = ancestor.find(labelSelector);
+ if (!this.buttonElement.length) {
+ ancestor = ancestor.length
+ ? ancestor.siblings()
+ : this.element.siblings();
+ this.buttonElement = ancestor.filter(labelSelector);
+ if (!this.buttonElement.length) {
+ this.buttonElement = ancestor.find(labelSelector);
+ }
+ }
+ this.element.addClass("ui-helper-hidden-accessible");
+
+ checked = this.element.is(":checked");
+ if (checked) {
+ this.buttonElement.addClass("ui-state-active");
+ }
+ this.buttonElement.prop("aria-pressed", checked);
+ } else {
+ this.buttonElement = this.element;
+ }
+ },
+
+ widget: function () {
+ return this.buttonElement;
+ },
+
+ _destroy: function () {
+ this.element.removeClass("ui-helper-hidden-accessible");
+ this.buttonElement
+ .removeClass(baseClasses + " ui-state-active " + typeClasses)
+ .removeAttr("role")
+ .removeAttr("aria-pressed")
+ .html(this.buttonElement.find(".ui-button-text").html());
+
+ if (!this.hasTitle) {
+ this.buttonElement.removeAttr("title");
+ }
+ },
+
+ _setOption: function (key, value) {
+ this._super(key, value);
+ if (key === "disabled") {
+ this.element.prop("disabled", !!value);
+ if (value) {
+ this.buttonElement.removeClass("ui-state-focus");
+ }
+ return;
+ }
+ this._resetButton();
+ },
+
+ refresh: function () {
+ //See #8237 & #8828
+ var isDisabled = this.element.is("input, button")
+ ? this.element.is(":disabled")
+ : this.element.hasClass("ui-button-disabled");
+
+ if (isDisabled !== this.options.disabled) {
+ this._setOption("disabled", isDisabled);
+ }
+ if (this.type === "radio") {
+ radioGroup(this.element[0]).each(function () {
+ if ($(this).is(":checked")) {
+ $(this)
+ .button("widget")
+ .addClass("ui-state-active")
+ .attr("aria-pressed", "true");
+ } else {
+ $(this)
+ .button("widget")
+ .removeClass("ui-state-active")
+ .attr("aria-pressed", "false");
+ }
+ });
+ } else if (this.type === "checkbox") {
+ if (this.element.is(":checked")) {
+ this.buttonElement
+ .addClass("ui-state-active")
+ .attr("aria-pressed", "true");
+ } else {
+ this.buttonElement
+ .removeClass("ui-state-active")
+ .attr("aria-pressed", "false");
+ }
+ }
+ },
+
+ _resetButton: function () {
+ if (this.type === "input") {
+ if (this.options.label) {
+ this.element.val(this.options.label);
+ }
+ return;
+ }
+ var buttonElement = this.buttonElement.removeClass(typeClasses),
+ buttonText = $("
"
+ )
+ );
+ }
+
+ $.extend(Datepicker.prototype, {
+ /* Class name added to elements to indicate already configured with a date picker. */
+ markerClassName: "hasDatepicker",
+
+ //Keep track of the maximum number of rows displayed (see #7043)
+ maxRows: 4,
+
+ // TODO rename to "widget" when switching to widget factory
+ _widgetDatepicker: function () {
+ return this.dpDiv;
+ },
+
+ /* Override the default settings for all instances of the date picker.
+ * @param settings object - the new settings to use as defaults (anonymous object)
+ * @return the manager object
+ */
+ setDefaults: function (settings) {
+ extendRemove(this._defaults, settings || {});
+ return this;
+ },
+
+ /* Attach the date picker to a jQuery selection.
+ * @param target element - the target input field or division or span
+ * @param settings object - the new settings to use for this date picker instance (anonymous)
+ */
+ _attachDatepicker: function (target, settings) {
+ var nodeName, inline, inst;
+ nodeName = target.nodeName.toLowerCase();
+ inline = nodeName === "div" || nodeName === "span";
+ if (!target.id) {
+ this.uuid += 1;
+ target.id = "dp" + this.uuid;
+ }
+ inst = this._newInst($(target), inline);
+ inst.settings = $.extend({}, settings || {});
+ if (nodeName === "input") {
+ this._connectDatepicker(target, inst);
+ } else if (inline) {
+ this._inlineDatepicker(target, inst);
+ }
+ },
+
+ /* Create a new instance object. */
+ _newInst: function (target, inline) {
+ var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
+ return {
+ id: id,
+ input: target, // associated target
+ selectedDay: 0,
+ selectedMonth: 0,
+ selectedYear: 0, // current selection
+ drawMonth: 0,
+ drawYear: 0, // month being drawn
+ inline: inline, // is datepicker inline or not
+ dpDiv: !inline
+ ? this.dpDiv // presentation div
+ : bindHover(
+ $(
+ "
"
+ )
+ ),
+ };
+ },
+
+ /* Attach the date picker to an input field. */
+ _connectDatepicker: function (target, inst) {
+ var input = $(target);
+ inst.append = $([]);
+ inst.trigger = $([]);
+ if (input.hasClass(this.markerClassName)) {
+ return;
+ }
+ this._attachments(input, inst);
+ input
+ .addClass(this.markerClassName)
+ .keydown(this._doKeyDown)
+ .keypress(this._doKeyPress)
+ .keyup(this._doKeyUp);
+ this._autoSize(inst);
+ $.data(target, PROP_NAME, inst);
+ //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
+ if (inst.settings.disabled) {
+ this._disableDatepicker(target);
+ }
+ },
+
+ /* Make attachments based on settings. */
+ _attachments: function (input, inst) {
+ var showOn,
+ buttonText,
+ buttonImage,
+ appendText = this._get(inst, "appendText"),
+ isRTL = this._get(inst, "isRTL");
+
+ if (inst.append) {
+ inst.append.remove();
+ }
+ if (appendText) {
+ inst.append = $(
+ "" +
+ appendText +
+ " "
+ );
+ input[isRTL ? "before" : "after"](inst.append);
+ }
+
+ input.unbind("focus", this._showDatepicker);
+
+ if (inst.trigger) {
+ inst.trigger.remove();
+ }
+
+ showOn = this._get(inst, "showOn");
+ if (showOn === "focus" || showOn === "both") {
+ // pop-up date picker when in the marked field
+ input.focus(this._showDatepicker);
+ }
+ if (showOn === "button" || showOn === "both") {
+ // pop-up date picker when button clicked
+ buttonText = this._get(inst, "buttonText");
+ buttonImage = this._get(inst, "buttonImage");
+ inst.trigger = $(
+ this._get(inst, "buttonImageOnly")
+ ? $("" +
+ prevText +
+ " " +
+ prevText +
+ " " +
+ nextText +
+ " " +
+ nextText +
+ " " +
+ this._get(inst, "closeText") +
+ " "
+ : "";
+
+ buttonPanel = showButtonPanel
+ ? "" +
+ (isRTL ? controls : "") +
+ (this._isInRange(inst, gotoDate)
+ ? "" +
+ currentText +
+ " "
+ : "") +
+ (isRTL ? "" : controls) +
+ "
"
+ : "";
+
+ firstDay = parseInt(this._get(inst, "firstDay"), 10);
+ firstDay = isNaN(firstDay) ? 0 : firstDay;
+
+ showWeek = this._get(inst, "showWeek");
+ dayNames = this._get(inst, "dayNames");
+ dayNamesMin = this._get(inst, "dayNamesMin");
+ monthNames = this._get(inst, "monthNames");
+ monthNamesShort = this._get(inst, "monthNamesShort");
+ beforeShowDay = this._get(inst, "beforeShowDay");
+ showOtherMonths = this._get(inst, "showOtherMonths");
+ selectOtherMonths = this._get(inst, "selectOtherMonths");
+ defaultDate = this._getDefaultDate(inst);
+ html = "";
+ dow;
+ for (row = 0; row < numMonths[0]; row++) {
+ group = "";
+ this.maxRows = 4;
+ for (col = 0; col < numMonths[1]; col++) {
+ selectedDate = this._daylightSavingAdjust(
+ new Date(drawYear, drawMonth, inst.selectedDay)
+ );
+ cornerClass = " ui-corner-all";
+ calender = "";
+ if (isMultiMonth) {
+ calender += "";
+ }
+ calender +=
+ "
" +
+ "";
+ thead = showWeek
+ ? "" +
+ this._get(inst, "weekHeader") +
+ " "
+ : "";
+ for (dow = 0; dow < 7; dow++) {
+ // days of the week
+ day = (dow + firstDay) % 7;
+ thead +=
+ "= 5
+ ? " class='ui-datepicker-week-end'"
+ : "") +
+ ">" +
+ "" +
+ dayNamesMin[day] +
+ " ";
+ }
+ calender += thead + " ";
+ daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
+ if (
+ drawYear === inst.selectedYear &&
+ drawMonth === inst.selectedMonth
+ ) {
+ inst.selectedDay = Math.min(
+ inst.selectedDay,
+ daysInMonth
+ );
+ }
+ leadDays =
+ (this._getFirstDayOfMonth(drawYear, drawMonth) -
+ firstDay +
+ 7) %
+ 7;
+ curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
+ numRows = isMultiMonth
+ ? this.maxRows > curRows
+ ? this.maxRows
+ : curRows
+ : curRows; //If multiple months, use the higher number of rows (see #7043)
+ this.maxRows = numRows;
+ printDate = this._daylightSavingAdjust(
+ new Date(drawYear, drawMonth, 1 - leadDays)
+ );
+ for (dRow = 0; dRow < numRows; dRow++) {
+ // create date picker rows
+ calender += "";
+ tbody = !showWeek
+ ? ""
+ : "" +
+ this._get(inst, "calculateWeek")(printDate) +
+ " ";
+ for (dow = 0; dow < 7; dow++) {
+ // create date picker days
+ daySettings = beforeShowDay
+ ? beforeShowDay.apply(
+ inst.input ? inst.input[0] : null,
+ [printDate]
+ )
+ : [true, ""];
+ otherMonth = printDate.getMonth() !== drawMonth;
+ unselectable =
+ (otherMonth && !selectOtherMonths) ||
+ !daySettings[0] ||
+ (minDate && printDate < minDate) ||
+ (maxDate && printDate > maxDate);
+ tbody +=
+ "" + // actions
+ (otherMonth && !showOtherMonths
+ ? " " // display for other months
+ : unselectable
+ ? "" +
+ printDate.getDate() +
+ " "
+ : "" +
+ printDate.getDate() +
+ " ") +
+ " "; // display selectable date
+ printDate.setDate(printDate.getDate() + 1);
+ printDate = this._daylightSavingAdjust(printDate);
+ }
+ calender += tbody + " ";
+ }
+ drawMonth++;
+ if (drawMonth > 11) {
+ drawMonth = 0;
+ drawYear++;
+ }
+ calender +=
+ "
" +
+ (isMultiMonth
+ ? "
"
+ : "")
+ : "");
+ group += calender;
+ }
+ html += group;
+ }
+ html += buttonPanel;
+ inst._keyEvent = false;
+ return html;
+ },
+
+ /* Generate the month and year header. */
+ _generateMonthYearHeader: function (
+ inst,
+ drawMonth,
+ drawYear,
+ minDate,
+ maxDate,
+ secondary,
+ monthNames,
+ monthNamesShort
+ ) {
+ var inMinYear,
+ inMaxYear,
+ month,
+ years,
+ thisYear,
+ determineYear,
+ year,
+ endYear,
+ changeMonth = this._get(inst, "changeMonth"),
+ changeYear = this._get(inst, "changeYear"),
+ showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
+ html = "",
+ monthHtml = "";
+
+ // month selection
+ if (secondary || !changeMonth) {
+ monthHtml +=
+ "" +
+ monthNames[drawMonth] +
+ " ";
+ } else {
+ inMinYear = minDate && minDate.getFullYear() === drawYear;
+ inMaxYear = maxDate && maxDate.getFullYear() === drawYear;
+ monthHtml +=
+ "";
+ for (month = 0; month < 12; month++) {
+ if (
+ (!inMinYear || month >= minDate.getMonth()) &&
+ (!inMaxYear || month <= maxDate.getMonth())
+ ) {
+ monthHtml +=
+ "" +
+ monthNamesShort[month] +
+ " ";
+ }
+ }
+ monthHtml += " ";
+ }
+
+ if (!showMonthAfterYear) {
+ html +=
+ monthHtml +
+ (secondary || !(changeMonth && changeYear) ? " " : "");
+ }
+
+ // year selection
+ if (!inst.yearshtml) {
+ inst.yearshtml = "";
+ if (secondary || !changeYear) {
+ html +=
+ "" +
+ drawYear +
+ " ";
+ } else {
+ // determine range of years to display
+ years = this._get(inst, "yearRange").split(":");
+ thisYear = new Date().getFullYear();
+ determineYear = function (value) {
+ var year = value.match(/c[+\-].*/)
+ ? drawYear + parseInt(value.substring(1), 10)
+ : value.match(/[+\-].*/)
+ ? thisYear + parseInt(value, 10)
+ : parseInt(value, 10);
+ return isNaN(year) ? thisYear : year;
+ };
+ year = determineYear(years[0]);
+ endYear = Math.max(year, determineYear(years[1] || ""));
+ year = minDate
+ ? Math.max(year, minDate.getFullYear())
+ : year;
+ endYear = maxDate
+ ? Math.min(endYear, maxDate.getFullYear())
+ : endYear;
+ inst.yearshtml +=
+ "";
+ for (; year <= endYear; year++) {
+ inst.yearshtml +=
+ "" +
+ year +
+ " ";
+ }
+ inst.yearshtml += " ";
+
+ html += inst.yearshtml;
+ inst.yearshtml = null;
+ }
+ }
+
+ html += this._get(inst, "yearSuffix");
+ if (showMonthAfterYear) {
+ html +=
+ (secondary || !(changeMonth && changeYear)
+ ? " "
+ : "") + monthHtml;
+ }
+ html += "
"; // Close datepicker_header
+ return html;
+ },
+
+ /* Adjust one of the date sub-fields. */
+ _adjustInstDate: function (inst, offset, period) {
+ var year = inst.drawYear + (period === "Y" ? offset : 0),
+ month = inst.drawMonth + (period === "M" ? offset : 0),
+ day =
+ Math.min(
+ inst.selectedDay,
+ this._getDaysInMonth(year, month)
+ ) + (period === "D" ? offset : 0),
+ date = this._restrictMinMax(
+ inst,
+ this._daylightSavingAdjust(new Date(year, month, day))
+ );
+
+ inst.selectedDay = date.getDate();
+ inst.drawMonth = inst.selectedMonth = date.getMonth();
+ inst.drawYear = inst.selectedYear = date.getFullYear();
+ if (period === "M" || period === "Y") {
+ this._notifyChange(inst);
+ }
+ },
+
+ /* Ensure a date is within any min/max bounds. */
+ _restrictMinMax: function (inst, date) {
+ var minDate = this._getMinMaxDate(inst, "min"),
+ maxDate = this._getMinMaxDate(inst, "max"),
+ newDate = minDate && date < minDate ? minDate : date;
+ return maxDate && newDate > maxDate ? maxDate : newDate;
+ },
+
+ /* Notify change of month/year. */
+ _notifyChange: function (inst) {
+ var onChange = this._get(inst, "onChangeMonthYear");
+ if (onChange) {
+ onChange.apply(inst.input ? inst.input[0] : null, [
+ inst.selectedYear,
+ inst.selectedMonth + 1,
+ inst,
+ ]);
+ }
+ },
+
+ /* Determine the number of months to show. */
+ _getNumberOfMonths: function (inst) {
+ var numMonths = this._get(inst, "numberOfMonths");
+ return numMonths == null
+ ? [1, 1]
+ : typeof numMonths === "number"
+ ? [1, numMonths]
+ : numMonths;
+ },
+
+ /* Determine the current maximum date - ensure no time components are set. */
+ _getMinMaxDate: function (inst, minMax) {
+ return this._determineDate(
+ inst,
+ this._get(inst, minMax + "Date"),
+ null
+ );
+ },
+
+ /* Find the number of days in a given month. */
+ _getDaysInMonth: function (year, month) {
+ return (
+ 32 -
+ this._daylightSavingAdjust(new Date(year, month, 32)).getDate()
+ );
+ },
+
+ /* Find the day of the week of the first of a month. */
+ _getFirstDayOfMonth: function (year, month) {
+ return new Date(year, month, 1).getDay();
+ },
+
+ /* Determines if we should allow a "next/prev" month display change. */
+ _canAdjustMonth: function (inst, offset, curYear, curMonth) {
+ var numMonths = this._getNumberOfMonths(inst),
+ date = this._daylightSavingAdjust(
+ new Date(
+ curYear,
+ curMonth +
+ (offset < 0 ? offset : numMonths[0] * numMonths[1]),
+ 1
+ )
+ );
+
+ if (offset < 0) {
+ date.setDate(
+ this._getDaysInMonth(date.getFullYear(), date.getMonth())
+ );
+ }
+ return this._isInRange(inst, date);
+ },
+
+ /* Is the given date in the accepted range? */
+ _isInRange: function (inst, date) {
+ var yearSplit,
+ currentYear,
+ minDate = this._getMinMaxDate(inst, "min"),
+ maxDate = this._getMinMaxDate(inst, "max"),
+ minYear = null,
+ maxYear = null,
+ years = this._get(inst, "yearRange");
+ if (years) {
+ yearSplit = years.split(":");
+ currentYear = new Date().getFullYear();
+ minYear = parseInt(yearSplit[0], 10);
+ maxYear = parseInt(yearSplit[1], 10);
+ if (yearSplit[0].match(/[+\-].*/)) {
+ minYear += currentYear;
+ }
+ if (yearSplit[1].match(/[+\-].*/)) {
+ maxYear += currentYear;
+ }
+ }
+
+ return (
+ (!minDate || date.getTime() >= minDate.getTime()) &&
+ (!maxDate || date.getTime() <= maxDate.getTime()) &&
+ (!minYear || date.getFullYear() >= minYear) &&
+ (!maxYear || date.getFullYear() <= maxYear)
+ );
+ },
+
+ /* Provide the configuration settings for formatting/parsing. */
+ _getFormatConfig: function (inst) {
+ var shortYearCutoff = this._get(inst, "shortYearCutoff");
+ shortYearCutoff =
+ typeof shortYearCutoff !== "string"
+ ? shortYearCutoff
+ : (new Date().getFullYear() % 100) +
+ parseInt(shortYearCutoff, 10);
+ return {
+ shortYearCutoff: shortYearCutoff,
+ dayNamesShort: this._get(inst, "dayNamesShort"),
+ dayNames: this._get(inst, "dayNames"),
+ monthNamesShort: this._get(inst, "monthNamesShort"),
+ monthNames: this._get(inst, "monthNames"),
+ };
+ },
+
+ /* Format the given date for display. */
+ _formatDate: function (inst, day, month, year) {
+ if (!day) {
+ inst.currentDay = inst.selectedDay;
+ inst.currentMonth = inst.selectedMonth;
+ inst.currentYear = inst.selectedYear;
+ }
+ var date = day
+ ? typeof day === "object"
+ ? day
+ : this._daylightSavingAdjust(new Date(year, month, day))
+ : this._daylightSavingAdjust(
+ new Date(
+ inst.currentYear,
+ inst.currentMonth,
+ inst.currentDay
+ )
+ );
+ return this.formatDate(
+ this._get(inst, "dateFormat"),
+ date,
+ this._getFormatConfig(inst)
+ );
+ },
+ });
+
+ /*
+ * Bind hover events for datepicker elements.
+ * Done via delegate so the binding only occurs once in the lifetime of the parent div.
+ * Global instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
+ */
+ function bindHover(dpDiv) {
+ var selector =
+ "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
+ return dpDiv
+ .delegate(selector, "mouseout", function () {
+ $(this).removeClass("ui-state-hover");
+ if (this.className.indexOf("ui-datepicker-prev") !== -1) {
+ $(this).removeClass("ui-datepicker-prev-hover");
+ }
+ if (this.className.indexOf("ui-datepicker-next") !== -1) {
+ $(this).removeClass("ui-datepicker-next-hover");
+ }
+ })
+ .delegate(selector, "mouseover", function () {
+ if (
+ !$.datepicker._isDisabledDatepicker(
+ instActive.inline
+ ? dpDiv.parent()[0]
+ : instActive.input[0]
+ )
+ ) {
+ $(this)
+ .parents(".ui-datepicker-calendar")
+ .find("a")
+ .removeClass("ui-state-hover");
+ $(this).addClass("ui-state-hover");
+ if (this.className.indexOf("ui-datepicker-prev") !== -1) {
+ $(this).addClass("ui-datepicker-prev-hover");
+ }
+ if (this.className.indexOf("ui-datepicker-next") !== -1) {
+ $(this).addClass("ui-datepicker-next-hover");
+ }
+ }
+ });
+ }
+
+ /* jQuery extend now ignores nulls! */
+ function extendRemove(target, props) {
+ $.extend(target, props);
+ for (var name in props) {
+ if (props[name] == null) {
+ target[name] = props[name];
+ }
+ }
+ return target;
+ }
+
+ /* Invoke the datepicker functionality.
+ @param options string - a command, optionally followed by additional parameters or
+ Object - settings for attaching new datepicker functionality
+ @return jQuery object */
+ $.fn.datepicker = function (options) {
+ /* Verify an empty collection wasn't passed - Fixes #6976 */
+ if (!this.length) {
+ return this;
+ }
+
+ /* Initialise the date picker. */
+ if (!$.datepicker.initialized) {
+ $(document).mousedown($.datepicker._checkExternalClick);
+ $.datepicker.initialized = true;
+ }
+
+ /* Append datepicker main container to body if not exist. */
+ if ($("#" + $.datepicker._mainDivId).length === 0) {
+ $("body").append($.datepicker.dpDiv);
+ }
+
+ var otherArgs = Array.prototype.slice.call(arguments, 1);
+ if (
+ typeof options === "string" &&
+ (options === "isDisabled" ||
+ options === "getDate" ||
+ options === "widget")
+ ) {
+ return $.datepicker["_" + options + "Datepicker"].apply(
+ $.datepicker,
+ [this[0]].concat(otherArgs)
+ );
+ }
+ if (
+ options === "option" &&
+ arguments.length === 2 &&
+ typeof arguments[1] === "string"
+ ) {
+ return $.datepicker["_" + options + "Datepicker"].apply(
+ $.datepicker,
+ [this[0]].concat(otherArgs)
+ );
+ }
+ return this.each(function () {
+ typeof options === "string"
+ ? $.datepicker["_" + options + "Datepicker"].apply(
+ $.datepicker,
+ [this].concat(otherArgs)
+ )
+ : $.datepicker._attachDatepicker(this, options);
+ });
+ };
+
+ $.datepicker = new Datepicker(); // singleton instance
+ $.datepicker.initialized = false;
+ $.datepicker.uuid = new Date().getTime();
+ $.datepicker.version = "1.10.4";
+})(jQuery);
+(function ($, undefined) {
+ var sizeRelatedOptions = {
+ buttons: true,
+ height: true,
+ maxHeight: true,
+ maxWidth: true,
+ minHeight: true,
+ minWidth: true,
+ width: true,
+ },
+ resizableRelatedOptions = {
+ maxHeight: true,
+ maxWidth: true,
+ minHeight: true,
+ minWidth: true,
+ };
+
+ $.widget("ui.dialog", {
+ version: "1.10.4",
+ options: {
+ appendTo: "body",
+ autoOpen: true,
+ buttons: [],
+ closeOnEscape: true,
+ closeText: "close",
+ dialogClass: "",
+ draggable: true,
+ hide: null,
+ height: "auto",
+ maxHeight: null,
+ maxWidth: null,
+ minHeight: 150,
+ minWidth: 150,
+ modal: false,
+ position: {
+ my: "center",
+ at: "center",
+ of: window,
+ collision: "fit",
+ // Ensure the titlebar is always visible
+ using: function (pos) {
+ var topOffset = $(this).css(pos).offset().top;
+ if (topOffset < 0) {
+ $(this).css("top", pos.top - topOffset);
+ }
+ },
+ },
+ resizable: true,
+ show: null,
+ title: null,
+ width: 300,
+
+ // callbacks
+ beforeClose: null,
+ close: null,
+ drag: null,
+ dragStart: null,
+ dragStop: null,
+ focus: null,
+ open: null,
+ resize: null,
+ resizeStart: null,
+ resizeStop: null,
+ },
+
+ _create: function () {
+ this.originalCss = {
+ display: this.element[0].style.display,
+ width: this.element[0].style.width,
+ minHeight: this.element[0].style.minHeight,
+ maxHeight: this.element[0].style.maxHeight,
+ height: this.element[0].style.height,
+ };
+ this.originalPosition = {
+ parent: this.element.parent(),
+ index: this.element.parent().children().index(this.element),
+ };
+ this.originalTitle = this.element.attr("title");
+ this.options.title = this.options.title || this.originalTitle;
+
+ this._createWrapper();
+
+ this.element
+ .show()
+ .removeAttr("title")
+ .addClass("ui-dialog-content ui-widget-content")
+ .appendTo(this.uiDialog);
+
+ this._createTitlebar();
+ this._createButtonPane();
+
+ if (this.options.draggable && $.fn.draggable) {
+ this._makeDraggable();
+ }
+ if (this.options.resizable && $.fn.resizable) {
+ this._makeResizable();
+ }
+
+ this._isOpen = false;
+ },
+
+ _init: function () {
+ if (this.options.autoOpen) {
+ this.open();
+ }
+ },
+
+ _appendTo: function () {
+ var element = this.options.appendTo;
+ if (element && (element.jquery || element.nodeType)) {
+ return $(element);
+ }
+ return this.document.find(element || "body").eq(0);
+ },
+
+ _destroy: function () {
+ var next,
+ originalPosition = this.originalPosition;
+
+ this._destroyOverlay();
+
+ this.element
+ .removeUniqueId()
+ .removeClass("ui-dialog-content ui-widget-content")
+ .css(this.originalCss)
+ // Without detaching first, the following becomes really slow
+ .detach();
+
+ this.uiDialog.stop(true, true).remove();
+
+ if (this.originalTitle) {
+ this.element.attr("title", this.originalTitle);
+ }
+
+ next = originalPosition.parent
+ .children()
+ .eq(originalPosition.index);
+ // Don't try to place the dialog next to itself (#8613)
+ if (next.length && next[0] !== this.element[0]) {
+ next.before(this.element);
+ } else {
+ originalPosition.parent.append(this.element);
+ }
+ },
+
+ widget: function () {
+ return this.uiDialog;
+ },
+
+ disable: $.noop,
+ enable: $.noop,
+
+ close: function (event) {
+ var activeElement,
+ that = this;
+
+ if (
+ !this._isOpen ||
+ this._trigger("beforeClose", event) === false
+ ) {
+ return;
+ }
+
+ this._isOpen = false;
+ this._destroyOverlay();
+
+ if (!this.opener.filter(":focusable").focus().length) {
+ // support: IE9
+ // IE9 throws an "Unspecified error" accessing document.activeElement from an 
+
+A modern, community-driven Retro CMS built with Laravel 12.x
+
+[](https://discord.gg/pP6HyZedAj)
+[](https://laravel.com)
+[](https://php.net)
+
+[Live Demos](#-live-preview) β’ [Installation](#-installation) β’ [Documentation](https://github.com/atom-retros/atomcms/wiki) β’ [Contributing](#-contributing)
+
+