(line-break) tag. +* These commands always run from $SPLUNK_HOME +* The default "Developer options" buttons/actions (incl the heading) can be customised/removed by overriding their stanzas. + +label =
');
+ var scrollbarDummyElement0 = scrollbarDummyElement[0];
+ var dummyContainerChild = FRAMEWORK(scrollbarDummyElement.children('div').eq(0));
+
+ bodyElement.append(scrollbarDummyElement);
+ scrollbarDummyElement.hide().show(); //fix IE8 bug (incorrect measuring)
+
+ var nativeScrollbarSize = calcNativeScrollbarSize(scrollbarDummyElement0);
+ var nativeScrollbarIsOverlaid = {
+ x: nativeScrollbarSize.x === 0,
+ y: nativeScrollbarSize.y === 0
+ };
+
+ FRAMEWORK.extend(_base, {
+ defaultOptions : defaultOptions,
+ autoUpdateLoop : false,
+ autoUpdateRecommended : !COMPATIBILITY.mO(),
+ nativeScrollbarSize : nativeScrollbarSize,
+ nativeScrollbarIsOverlaid : nativeScrollbarIsOverlaid,
+ nativeScrollbarStyling : (function() {
+ scrollbarDummyElement.addClass('os-viewport-native-scrollbars-invisible');
+ //fix opera bug: scrollbar styles will only appear if overflow value is scroll or auto during the activation of the style.
+ //and set overflow to scroll
+ scrollbarDummyElement.css(strOverflow, strHidden).hide().css(strOverflow, strScroll).show();
+ return (scrollbarDummyElement0[LEXICON.oH] - scrollbarDummyElement0[LEXICON.cH]) === 0 && (scrollbarDummyElement0[LEXICON.oW] - scrollbarDummyElement0[LEXICON.cW]) === 0;
+ })(),
+ overlayScrollbarDummySize : { x: 30, y: 30 },
+ msie : (function() {
+ var ua = window.navigator.userAgent;
+ var strIndexOf = 'indexOf';
+ var strSubString = 'substring';
+ var msie = ua[strIndexOf]('MSIE ');
+ var trident = ua[strIndexOf]('Trident/');
+ var edge = ua[strIndexOf]('Edge/');
+ var rv = ua[strIndexOf]('rv:');
+ var result;
+ var parseInt = window.parseInt;
+
+ // IE 10 or older => return version number
+ if (msie > 0)
+ result = parseInt(ua[strSubString](msie + 5, ua[strIndexOf]('.', msie)), 10);
+
+ // IE 11 => return version number
+ else if (trident > 0)
+ result = parseInt(ua[strSubString](rv + 3, ua[strIndexOf]('.', rv)), 10);
+
+ // Edge (IE 12+) => return version number
+ else if (edge > 0)
+ result = parseInt(ua[strSubString](edge + 5, ua[strIndexOf]('.', edge)), 10);
+
+ // other browser
+ return result;
+ })(),
+ cssCalc : (function() {
+ var dummy = document.createElement('div');
+ var props = ['calc', '-webkit-calc', '-moz-calc', '-o-calc'];
+ var i;
+ var prop;
+
+ for (i = 0; i < props.length; ++i) {
+ prop = props[i];
+ dummy[LEXICON.s].cssText = 'width:' + prop + '(1px);';
+ if (dummy[LEXICON.s].length)
+ return prop;
+ }
+ return null;
+ })(),
+ restrictedMeasuring : (function() {
+ //https://bugzilla.mozilla.org/show_bug.cgi?id=1439305
+ scrollbarDummyElement.css(strOverflow, strHidden);
+ var scrollSize = {
+ w : scrollbarDummyElement0[LEXICON.sW],
+ h : scrollbarDummyElement0[LEXICON.sH]
+ };
+ scrollbarDummyElement.css(strOverflow, 'visible');
+ var scrollSize2 = {
+ w : scrollbarDummyElement0[LEXICON.sW],
+ h : scrollbarDummyElement0[LEXICON.sH]
+ };
+ return (scrollSize.w - scrollSize2.w) !== 0 || (scrollSize.h - scrollSize2.h) !== 0;
+ })(),
+ rtlScrollBehavior : (function() {
+ scrollbarDummyElement.css({ 'overflow-y' : strHidden, 'overflow-x' : strScroll, 'direction' : 'rtl' }).scrollLeft(0);
+ var dummyContainerOffset = scrollbarDummyElement.offset();
+ var dummyContainerChildOffset = dummyContainerChild.offset();
+ scrollbarDummyElement.scrollLeft(999);
+ var dummyContainerScrollOffsetAfterScroll = dummyContainerChild.offset();
+ return {
+ //origin direction = determines if the zero scroll position is on the left or right side
+ //'i' means 'invert' (i === true means that the axis must be inverted to be correct)
+ //true = on the left side
+ //false = on the right side
+ i : dummyContainerOffset.left === dummyContainerChildOffset.left,
+ //negative = determines if the maximum scroll is positive or negative
+ //'n' means 'negate' (n === true means that the axis must be negated to be correct)
+ //true = negative
+ //false = positive
+ n : dummyContainerChildOffset.left - dummyContainerScrollOffsetAfterScroll.left === 0
+ };
+ })(),
+ supportTransform : detectCSSFeature('transform'),
+ supportTransition : detectCSSFeature('transition'),
+ supportPassiveEvents : (function() {
+ var supportsPassive = false;
+ try {
+ window.addEventListener('test', null, Object.defineProperty({ }, 'passive', {
+ get: function() {
+ supportsPassive = true;
+ }
+ }));
+ } catch (e) { }
+ return supportsPassive;
+ })(),
+ supportResizeObserver : !!COMPATIBILITY.rO(),
+ supportMutationObserver : !!COMPATIBILITY.mO()
+ });
+
+ scrollbarDummyElement.removeAttr(LEXICON.s).remove();
+
+ //Catch zoom event:
+ (function () {
+ if(nativeScrollbarIsOverlaid.x && nativeScrollbarIsOverlaid.y)
+ return;
+
+ var abs = Math.abs;
+ var windowWidth = COMPATIBILITY.wW();
+ var windowHeight = COMPATIBILITY.wH();
+ var windowDpr = getWindowDPR();
+ var onResize = function() {
+ if(INSTANCES().length > 0) {
+ var newW = COMPATIBILITY.wW();
+ var newH = COMPATIBILITY.wH();
+ var deltaW = newW - windowWidth;
+ var deltaH = newH - windowHeight;
+
+ if (deltaW === 0 && deltaH === 0)
+ return;
+
+ var deltaWRatio = Math.round(newW / (windowWidth / 100.0));
+ var deltaHRatio = Math.round(newH / (windowHeight / 100.0));
+ var absDeltaW = abs(deltaW);
+ var absDeltaH = abs(deltaH);
+ var absDeltaWRatio = abs(deltaWRatio);
+ var absDeltaHRatio = abs(deltaHRatio);
+ var newDPR = getWindowDPR();
+
+ var deltaIsBigger = absDeltaW > 2 && absDeltaH > 2;
+ var difference = !differenceIsBiggerThanOne(absDeltaWRatio, absDeltaHRatio);
+ var dprChanged = newDPR !== windowDpr && windowDpr > 0;
+ var isZoom = deltaIsBigger && difference && dprChanged;
+ var oldScrollbarSize = _base.nativeScrollbarSize;
+ var newScrollbarSize;
+
+ if (isZoom) {
+ bodyElement.append(scrollbarDummyElement);
+ newScrollbarSize = _base.nativeScrollbarSize = calcNativeScrollbarSize(scrollbarDummyElement[0]);
+ scrollbarDummyElement.remove();
+ if(oldScrollbarSize.x !== newScrollbarSize.x || oldScrollbarSize.y !== newScrollbarSize.y) {
+ FRAMEWORK.each(INSTANCES(), function () {
+ if(INSTANCES(this))
+ INSTANCES(this).update('zoom');
+ });
+ }
+ }
+
+ windowWidth = newW;
+ windowHeight = newH;
+ windowDpr = newDPR;
+ }
+ };
+
+ function differenceIsBiggerThanOne(valOne, valTwo) {
+ var absValOne = abs(valOne);
+ var absValTwo = abs(valTwo);
+ return !(absValOne === absValTwo || absValOne + 1 === absValTwo || absValOne - 1 === absValTwo);
+ }
+
+ function getWindowDPR() {
+ var dDPI = window.screen.deviceXDPI || 0;
+ var sDPI = window.screen.logicalXDPI || 1;
+ return window.devicePixelRatio || (dDPI / sDPI);
+ }
+
+ FRAMEWORK(window).on('resize', onResize);
+ })();
+
+ function detectCSSFeature(featurename) {
+ var feature = false;
+ var domPrefixes = 'Webkit Moz ms O'.split(' ');
+ var elm = document.createElement('div');
+ var featurenameCapital = null;
+ var i = 0;
+
+ featurename = featurename.toLowerCase();
+
+ if (elm[LEXICON.s][featurename] !== undefined)
+ feature = true;
+
+ if (!feature) {
+ featurenameCapital = featurename.charAt(0).toUpperCase() + featurename.substr(1);
+ for (; i < domPrefixes.length; i++) {
+ if (elm[LEXICON.s][domPrefixes[i] + featurenameCapital] !== undefined) {
+ feature = true;
+ break;
+ }
+ }
+ }
+ return feature;
+ }
+
+ function calcNativeScrollbarSize(measureElement) {
+ return {
+ x: measureElement[LEXICON.oH] - measureElement[LEXICON.cH],
+ y: measureElement[LEXICON.oW] - measureElement[LEXICON.cW]
+ };
+ }
+ }
+
+ /**
+ * The object which manages the auto update loop for all OverlayScrollbars objects. This object is initialized only once: if the first OverlayScrollbars object gets initialized.
+ * @constructor
+ */
+ function OverlayScrollbarsAutoUpdateLoop(globals) {
+ var _base = this;
+ var _strAutoUpdate = 'autoUpdate';
+ var _strAutoUpdateInterval = _strAutoUpdate + 'Interval';
+ var _strLength = LEXICON.l;
+
+ var _loopingInstances = [ ];
+ var _loopingInstancesIntervalCache = [ ];
+ var _loopIsActive = false;
+ var _loopIntervalDefault = 33;
+ var _loopInterval = _loopIntervalDefault;
+ var _loopTimeOld = COMPATIBILITY.now();
+ var _loopID;
+
+ /**
+ * The auto update loop which will run every 50 milliseconds or less if the update interval of a instance is lower than 50 milliseconds.
+ */
+ var loop = function() {
+ if(_loopingInstances[_strLength] > 0 && _loopIsActive) {
+ _loopID = COMPATIBILITY.rAF()(function () {
+ loop();
+ });
+ var timeNew = COMPATIBILITY.now();
+ var timeDelta = timeNew - _loopTimeOld;
+
+ if (timeDelta > _loopInterval) {
+ _loopTimeOld = timeNew - (timeDelta % _loopInterval);
+ var lowestInterval = _loopIntervalDefault;
+ for(var i = 0; i < _loopingInstances[_strLength]; i++) {
+ var instance = _loopingInstances[i];
+ if (instance !== undefined) {
+ var instanceOptions = instance.options();
+ var instanceAutoUpdateAllowed = instanceOptions[_strAutoUpdate];
+ var instanceAutoUpdateInterval = Math.max(1, instanceOptions[_strAutoUpdateInterval]);
+ var now = COMPATIBILITY.now();
+ if ((instanceAutoUpdateAllowed === true || instanceAutoUpdateAllowed === null) && (now - _loopingInstancesIntervalCache[i]) > instanceAutoUpdateInterval) {
+ instance.update('auto');
+ _loopingInstancesIntervalCache[i] = new Date(now += instanceAutoUpdateInterval);
+ }
+ lowestInterval = Math.max(1, Math.min(lowestInterval, instanceAutoUpdateInterval));
+ }
+ }
+ _loopInterval = lowestInterval;
+ }
+ } else {
+ _loopInterval = _loopIntervalDefault;
+ }
+ };
+
+ /**
+ * Add OverlayScrollbars instance to the auto update loop. Only successful if the instance isn't already added.
+ * @param instance The instance which shall be updated in a loop automatically.
+ */
+ _base.add = function(instance) {
+ if(FRAMEWORK.inArray(instance, _loopingInstances) === -1) {
+ _loopingInstances.push(instance);
+ _loopingInstancesIntervalCache.push(COMPATIBILITY.now());
+ if (_loopingInstances[_strLength] > 0 && !_loopIsActive) {
+ _loopIsActive = true;
+ globals.autoUpdateLoop = _loopIsActive;
+ loop();
+ }
+ }
+ };
+
+ /**
+ * Remove OverlayScrollbars instance from the auto update loop. Only successful if the instance was added before.
+ * @param instance The instance which shall be updated in a loop automatically.
+ */
+ _base.remove = function(instance) {
+ var index = FRAMEWORK.inArray(instance, _loopingInstances);
+ if(index > -1) {
+ //remove from loopingInstances list
+ _loopingInstancesIntervalCache.splice(index, 1);
+ _loopingInstances.splice(index, 1);
+
+ //correct update loop behavior
+ if (_loopingInstances[_strLength] === 0 && _loopIsActive) {
+ _loopIsActive = false;
+ globals.autoUpdateLoop = _loopIsActive;
+ if(_loopID !== undefined) {
+ COMPATIBILITY.cAF()(_loopID);
+ _loopID = -1;
+ }
+ }
+ }
+ };
+ }
+
+ /**
+ * A object which manages the scrollbars visibility of the target element.
+ * @param pluginTargetElement The element from which the scrollbars shall be hidden.
+ * @param options The custom options.
+ * @param extensions The custom extensions.
+ * @param globals
+ * @param autoUpdateLoop
+ * @returns {*}
+ * @constructor
+ */
+ function OverlayScrollbarsInstance(pluginTargetElement, options, extensions, globals, autoUpdateLoop) {
+ //if passed element is no HTML element: skip and return
+ if(!isHTMLElement(pluginTargetElement))
+ return;
+
+ //if passed element is already initialized: set passed options if there are any and return its instance
+ if(INSTANCES(pluginTargetElement)) {
+ var inst = INSTANCES(pluginTargetElement);
+ inst.options(options);
+ return inst;
+ }
+
+ //make correct instanceof
+ var _base = new window[PLUGINNAME]();
+ var _frameworkProto = FRAMEWORK[LEXICON.p];
+
+ //globals:
+ var _nativeScrollbarIsOverlaid;
+ var _overlayScrollbarDummySize;
+ var _rtlScrollBehavior;
+ var _autoUpdateRecommended;
+ var _msieVersion;
+ var _nativeScrollbarStyling;
+ var _cssCalc;
+ var _nativeScrollbarSize;
+ var _supportTransition;
+ var _supportTransform;
+ var _supportPassiveEvents;
+ var _supportResizeObserver;
+ var _restrictedMeasuring;
+
+ //general readonly:
+ var _initialized;
+ var _destroyed;
+ var _isTextarea;
+ var _isBody;
+ var _documentMixed;
+
+ //general:
+ var _isBorderBox;
+ var _sizeAutoObserverAdded;
+ var _paddingX;
+ var _paddingY;
+ var _borderX;
+ var _borderY;
+ var _marginX;
+ var _marginY;
+ var _isRTL;
+ var _isSleeping;
+ var _contentBorderSize = { };
+ var _scrollHorizontalInfo = { };
+ var _scrollVerticalInfo = { };
+ var _viewportSize = { };
+ var _nativeScrollbarMinSize = { };
+
+ //scroll
+ var _scrollStopDelay = 175;
+ var _scrollStopTimeoutId;
+
+ //naming:
+ var _strMinusHidden = '-hidden';
+ var _strMarginMinus = 'margin-';
+ var _strPaddingMinus = 'padding-';
+ var _strBorderMinus = 'border-';
+ var _strTop = 'top';
+ var _strRight = 'right';
+ var _strBottom = 'bottom';
+ var _strLeft = 'left';
+ var _strMinMinus = 'min-';
+ var _strMaxMinus = 'max-';
+ var _strWidth = 'width';
+ var _strHeight = 'height';
+ var _strFloat = 'float';
+ var _strEmpty = '';
+ var _strAuto = 'auto';
+ var _strScroll = 'scroll';
+ var _strHundredPercent = '100%';
+ var _strX = 'x';
+ var _strY = 'y';
+ var _strDot = '.';
+ var _strSpace = ' ';
+ var _strScrollbar = 'scrollbar';
+ var _strMinusHorizontal = '-horizontal';
+ var _strMinusVertical = '-vertical';
+ var _strScrollLeft = _strScroll + 'Left';
+ var _strScrollTop = _strScroll + 'Top';
+ var _strMouseTouchDownEvent = 'mousedown touchstart';
+ var _strMouseTouchUpEvent = 'mouseup touchend touchcancel';
+ var _strMouseTouchMoveEvent = 'mousemove touchmove';
+ var _strMouseTouchEnter = 'mouseenter';
+ var _strMouseTouchLeave = 'mouseleave';
+ var _strKeyDownEvent = 'keydown';
+ var _strKeyUpEvent = 'keyup';
+ var _strSelectStartEvent = 'selectstart';
+ var _strTransitionEndEvent = 'transitionend webkitTransitionEnd oTransitionEnd';
+ var _strResizeObserverProperty = '__overlayScrollbarsRO__';
+
+ //class names:
+ var _cassNamesPrefix = 'os-';
+ var _classNameHTMLElement = _cassNamesPrefix + 'html';
+ var _classNameHostElement = _cassNamesPrefix + 'host';
+ var _classNameHostTextareaElement = _classNameHostElement + '-textarea';
+ var _classNameHostScrollbarHorizontalHidden = _classNameHostElement + '-' + _strScrollbar + _strMinusHorizontal + _strMinusHidden;
+ var _classNameHostScrollbarVerticalHidden = _classNameHostElement + '-' + _strScrollbar + _strMinusVertical + _strMinusHidden;
+ var _classNameHostTransition = _classNameHostElement + '-transition';
+ var _classNameHostRTL = _classNameHostElement + '-rtl';
+ var _classNameHostResizeDisabled = _classNameHostElement + '-resize-disabled';
+ var _classNameHostScrolling = _classNameHostElement + '-scrolling';
+ var _classNameHostOverflow = _classNameHostElement + '-overflow';
+ var _classNameHostOverflowX = _classNameHostOverflow + '-x';
+ var _classNameHostOverflowY = _classNameHostOverflow + '-y';
+ var _classNameTextareaElement = _cassNamesPrefix + 'textarea';
+ var _classNameTextareaCoverElement = _classNameTextareaElement + '-cover';
+ var _classNamePaddingElement = _cassNamesPrefix + 'padding';
+ var _classNameViewportElement = _cassNamesPrefix + 'viewport';
+ var _classNameViewportNativeScrollbarsInvisible = _classNameViewportElement + '-native-scrollbars-invisible';
+ var _classNameViewportNativeScrollbarsOverlaid = _classNameViewportElement + '-native-scrollbars-overlaid';
+ var _classNameContentElement = _cassNamesPrefix + 'content';
+ var _classNameContentArrangeElement = _cassNamesPrefix + 'content-arrange';
+ var _classNameContentGlueElement = _cassNamesPrefix + 'content-glue';
+ var _classNameSizeAutoObserverElement = _cassNamesPrefix + 'size-auto-observer';
+ var _classNameResizeObserverElement = _cassNamesPrefix + 'resize-observer';
+ var _classNameResizeObserverItemElement = _cassNamesPrefix + 'resize-observer-item';
+ var _classNameResizeObserverItemFinalElement = _classNameResizeObserverItemElement + '-final';
+ var _classNameTextInherit = _cassNamesPrefix + 'text-inherit';
+ var _classNameScrollbar = _cassNamesPrefix + _strScrollbar;
+ var _classNameScrollbarTrack = _classNameScrollbar + '-track';
+ var _classNameScrollbarTrackOff = _classNameScrollbarTrack + '-off';
+ var _classNameScrollbarHandle = _classNameScrollbar + '-handle';
+ var _classNameScrollbarHandleOff = _classNameScrollbarHandle + '-off';
+ var _classNameScrollbarUnusable = _classNameScrollbar + '-unusable';
+ var _classNameScrollbarAutoHidden = _classNameScrollbar + '-' + _strAuto + _strMinusHidden;
+ var _classNameScrollbarCorner = _classNameScrollbar + '-corner';
+ var _classNameScrollbarCornerResize = _classNameScrollbarCorner + '-resize';
+ var _classNameScrollbarCornerResizeB = _classNameScrollbarCornerResize + '-both';
+ var _classNameScrollbarCornerResizeH = _classNameScrollbarCornerResize + _strMinusHorizontal;
+ var _classNameScrollbarCornerResizeV = _classNameScrollbarCornerResize + _strMinusVertical;
+ var _classNameScrollbarHorizontal = _classNameScrollbar + _strMinusHorizontal;
+ var _classNameScrollbarVertical = _classNameScrollbar + _strMinusVertical;
+ var _classNameDragging = _cassNamesPrefix + 'dragging';
+ var _classNameThemeNone = _cassNamesPrefix + 'theme-none';
+
+ //options:
+ var _defaultOptions;
+ var _currentOptions;
+ var _currentPreparedOptions;
+
+ //extensions:
+ var _extensions = { };
+ var _extensionsPrivateMethods = "added removed on contract";
+
+ //update
+ var _lastUpdateTime;
+ var _swallowedUpdateParams = { };
+ var _swallowedUpdateTimeout;
+ var _swallowUpdateLag = 42;
+ var _imgs = [ ];
+
+ //DOM elements:
+ var _windowElement;
+ var _documentElement;
+ var _htmlElement;
+ var _bodyElement;
+ var _targetElement; //the target element of this OverlayScrollbars object
+ var _hostElement; //the host element of this OverlayScrollbars object -> may be the same as targetElement
+ var _sizeAutoObserverElement; //observes size auto changes
+ var _sizeObserverElement; //observes size and padding changes
+ var _contentGlueElement; //has always the size of the content element
+ var _paddingElement; //manages the padding
+ var _viewportElement; //is the viewport of our scrollbar model
+ var _contentArrangeElement; //is needed for correct sizing of the content element (only if native scrollbars are overlays)
+ var _contentElement; //the element which holds the content
+ var _textareaCoverElement; //only applied if target is a textarea element. Used for correct size calculation and for prevention of uncontrolled scrolling
+ var _scrollbarCornerElement;
+ var _scrollbarHorizontalElement;
+ var _scrollbarHorizontalTrackElement;
+ var _scrollbarHorizontalHandleElement;
+ var _scrollbarVerticalElement;
+ var _scrollbarVerticalTrackElement;
+ var _scrollbarVerticalHandleElement;
+
+ //Cache:
+ var _hostSizeCache;
+ var _contentScrollSizeCache;
+ var _arrangeContentSizeCache;
+ var _hasOverflowCache;
+ var _hideOverflowCache;
+ var _widthAutoCache;
+ var _heightAutoCache;
+ var _cssMaxValueCache;
+ var _cssBoxSizingCache;
+ var _cssPaddingCache;
+ var _cssBorderCache;
+ var _cssMarginCache;
+ var _cssDirectionCache;
+ var _cssDirectionDetectedCache;
+ var _paddingAbsoluteCache;
+ var _clipAlwaysCache;
+ var _contentGlueSizeCache;
+ var _overflowBehaviorCache;
+ var _overflowAmountCache;
+ var _ignoreOverlayScrollbarHidingCache;
+ var _autoUpdateCache;
+ var _sizeAutoCapableCache;
+ var _textareaAutoWrappingCache;
+ var _textareaInfoCache;
+ var _updateAutoHostElementIdCache;
+ var _updateAutoHostElementClassCache;
+ var _updateAutoHostElementStyleCache;
+ var _updateAutoHostElementVisibleCache;
+ var _updateAutoTargetElementRowsCache;
+ var _updateAutoTargetElementColsCache;
+ var _updateAutoTargetElementWrapCache;
+ var _contentElementScrollSizeChangeDetectedCache;
+ var _hostElementSizeChangeDetectedCache;
+ var _scrollbarsVisibilityCache;
+ var _scrollbarsAutoHideCache;
+ var _scrollbarsClickScrollingCache;
+ var _scrollbarsDragScrollingCache;
+ var _resizeCache;
+ var _normalizeRTLCache;
+ var _classNameCache;
+ var _oldClassName;
+ var _textareaDynHeightCache;
+ var _textareaDynWidthCache;
+ var _bodyMinSizeCache;
+ var _viewportScrollSizeCache;
+ var _displayIsHiddenCache;
+
+ //MutationObserver:
+ var _mutationObserverContentLag = 11;
+ var _mutationObserverHost;
+ var _mutationObserverContent;
+ var _mutationObserverConnected;
+ var _supportMutationObserver;
+
+ //textarea:
+ var _textareaKeyDownRestrictedKeyCodes = [
+ 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 123, //F1 to F12
+ 33, 34, //page up, page down
+ 37, 38, 39, 40, //left, up, right, down arrows
+ 16, 17, 18, 19, 20, 144 //Shift, Ctrl, Alt, Pause, CapsLock, NumLock
+ ];
+ var _textareaKeyDownKeyCodesList = [ ];
+ var _textareaUpdateIntervalID;
+ var _textareaHasFocus;
+
+ //scrollbars:
+ var _scrollbarsAutoHideTimeoutId;
+ var _scrollbarsAutoHideMoveTimeoutId;
+ var _scrollbarsAutoHideDelay;
+ var _scrollbarsAutoHideNever;
+ var _scrollbarsAutoHideScroll;
+ var _scrollbarsAutoHideMove;
+ var _scrollbarsAutoHideLeave;
+ var _scrollbarsTouchSupport;
+ var _scrollbarsAutoHideFlagScrollAndHovered;
+
+ //resize
+ var _resizeReconnectMutationObserver;
+ var _resizeNone;
+ var _resizeBoth;
+ var _resizeHorizontal;
+ var _resizeVertical;
+ var _resizeDragStartPosition = { };
+ var _resizeDragStartSize = { };
+
+
+ //==== Add / Remove Passive Event Listener ====//
+
+ /**
+ * Adds a passive event listener to the given element.
+ * @param element The element to which the event listener shall be applied.
+ * @param eventNames The name(s) of the event listener.
+ * @param listener The listener method which shall be called.
+ */
+ function addPassiveEventListener(element, eventNames, listener) {
+ var events = eventNames.split(_strSpace);
+ for (var i = 0; i < events.length; i++)
+ element[0].addEventListener(events[i], listener, {passive: true});
+ }
+
+ /**
+ * Removes a passive event listener to the given element.
+ * @param element The element from which the event listener shall be removed.
+ * @param eventNames The name(s) of the event listener.
+ * @param listener The listener method which shall be removed.
+ */
+ function removePassiveEventListener(element, eventNames, listener) {
+ var events = eventNames.split(_strSpace);
+ for (var i = 0; i < events.length; i++)
+ element[0].removeEventListener(events[i], listener, {passive: true});
+ }
+
+
+ //==== Add / Remove / Freeze / Unfreeze Resize Observer ====//
+
+ /**
+ * Adds a resize observer to the given element.
+ * @param targetElement The element to which the resize observer shall be applied.
+ * @param onElementResizedCallback The callback which is fired every time the resize observer registers a size change.
+ */
+ function addResizeObserver(targetElement, onElementResizedCallback) {
+ var constMaximum = 3333333;
+ var resizeObserver = COMPATIBILITY.rO();
+ var strAnimationStartEvent = 'animationstart mozAnimationStart webkitAnimationStart MSAnimationStart';
+ var strChildNodes = 'childNodes';
+ var callback = function () {
+ targetElement[_strScrollTop](constMaximum)[_strScrollLeft](_isRTL ? _rtlScrollBehavior.n ? -constMaximum : _rtlScrollBehavior.i ? 0 : constMaximum : constMaximum);
+ onElementResizedCallback();
+ };
+ if (_supportResizeObserver) {
+ var element = targetElement.append(generateDiv(_classNameResizeObserverElement + ' observed')).contents()[0];
+ var observer = element[_strResizeObserverProperty] = new resizeObserver(callback);
+ observer.observe(element);
+ }
+ else {
+ if (_msieVersion > 9 || !_autoUpdateRecommended) {
+ targetElement.prepend(
+ generateDiv(_classNameResizeObserverElement,
+ generateDiv({ className : _classNameResizeObserverItemElement, dir : "ltr" },
+ generateDiv(_classNameResizeObserverItemElement,
+ generateDiv(_classNameResizeObserverItemFinalElement)
+ ) +
+ generateDiv(_classNameResizeObserverItemElement,
+ generateDiv({ className : _classNameResizeObserverItemFinalElement, style : 'width: 200%; height: 200%' })
+ )
+ )
+ )
+ );
+
+ var observerElement = targetElement[0][strChildNodes][0][strChildNodes][0];
+ var shrinkElement = FRAMEWORK(observerElement[strChildNodes][1]);
+ var expandElement = FRAMEWORK(observerElement[strChildNodes][0]);
+ var expandElementChild = FRAMEWORK(expandElement[0][strChildNodes][0]);
+ var widthCache = observerElement[LEXICON.oW];
+ var heightCache = observerElement[LEXICON.oH];
+ var isDirty;
+ var rAFId;
+ var currWidth;
+ var currHeight;
+ var factor = 2;
+ var nativeScrollbarSize = globals.nativeScrollbarSize; //care don't make changes to this object!!!
+ var reset = function () {
+ /*
+ var sizeResetWidth = observerElement[LEXICON.oW] + nativeScrollbarSize.x * factor + nativeScrollbarSize.y * factor + _overlayScrollbarDummySize.x + _overlayScrollbarDummySize.y;
+ var sizeResetHeight = observerElement[LEXICON.oH] + nativeScrollbarSize.x * factor + nativeScrollbarSize.y * factor + _overlayScrollbarDummySize.x + _overlayScrollbarDummySize.y;
+ var expandChildCSS = {};
+ expandChildCSS[_strWidth] = sizeResetWidth;
+ expandChildCSS[_strHeight] = sizeResetHeight;
+ expandElementChild.css(expandChildCSS);
+
+
+ expandElement[_strScrollLeft](sizeResetWidth)[_strScrollTop](sizeResetHeight);
+ shrinkElement[_strScrollLeft](sizeResetWidth)[_strScrollTop](sizeResetHeight);
+ */
+ expandElement[_strScrollLeft](constMaximum)[_strScrollTop](constMaximum);
+ shrinkElement[_strScrollLeft](constMaximum)[_strScrollTop](constMaximum);
+ };
+ var onResized = function () {
+ rAFId = 0;
+ if (!isDirty)
+ return;
+
+ widthCache = currWidth;
+ heightCache = currHeight;
+ callback();
+ };
+ var onScroll = function (event) {
+ currWidth = observerElement[LEXICON.oW];
+ currHeight = observerElement[LEXICON.oH];
+ isDirty = currWidth != widthCache || currHeight != heightCache;
+
+ if (event && isDirty && !rAFId) {
+ COMPATIBILITY.cAF()(rAFId);
+ rAFId = COMPATIBILITY.rAF()(onResized);
+ }
+ else if(!event)
+ onResized();
+
+ reset();
+ if (event) {
+ COMPATIBILITY.prvD(event);
+ COMPATIBILITY.stpP(event);
+ }
+ return false;
+ };
+ var expandChildCSS = {};
+ var observerElementCSS = {};
+
+ observerElementCSS[_strTop] = (-((nativeScrollbarSize.y + 1) * factor));
+ observerElementCSS[_strRight] = (nativeScrollbarSize.x * -factor);
+ observerElementCSS[_strBottom] = (nativeScrollbarSize.y * -factor);
+ observerElementCSS[_strLeft] = (-((nativeScrollbarSize.x + 1) * factor));
+
+ FRAMEWORK(observerElement).css(observerElementCSS);
+ expandElement.on(_strScroll, onScroll);
+ shrinkElement.on(_strScroll, onScroll);
+ targetElement.on(strAnimationStartEvent, function () {
+ onScroll(false);
+ });
+ //lets assume that the divs will never be that large and a constant value is enough
+ expandChildCSS[_strWidth] = constMaximum;
+ expandChildCSS[_strHeight] = constMaximum;
+ expandElementChild.css(expandChildCSS);
+
+ reset();
+ }
+ else {
+ var doc = _documentElement[0];
+ var attachEvent = doc.attachEvent;
+ var isIE = _msieVersion !== undefined;
+ if (attachEvent) {
+ targetElement.prepend(generateDiv(_classNameResizeObserverElement));
+ findFirst(targetElement, _strDot + _classNameResizeObserverElement)[0].attachEvent('onresize', callback);
+ }
+ else {
+ var obj = doc.createElement(TYPES.o);
+ obj.setAttribute('tabindex', '-1');
+ obj.setAttribute(LEXICON.c, _classNameResizeObserverElement);
+ obj.onload = function () {
+ var wnd = this.contentDocument.defaultView;
+ wnd.addEventListener('resize', callback);
+ wnd.document.documentElement.style.display = 'none';
+ };
+ obj.type = 'text/html';
+ if (isIE)
+ targetElement.prepend(obj);
+ obj.data = 'about:blank';
+ if (!isIE)
+ targetElement.prepend(obj);
+ targetElement.on(strAnimationStartEvent, callback);
+ }
+ }
+ }
+
+ //direction change detection:
+ if (targetElement[0] === _sizeObserverElement[0]) {
+ var directionChanged = function () {
+ var dir = _hostElement.css('direction');
+ var css = {};
+ var scrollLeftValue = 0;
+ var result = false;
+ if (dir !== _cssDirectionDetectedCache) {
+ if (dir === 'ltr') {
+ css[_strLeft] = 0;
+ css[_strRight] = _strAuto;
+ scrollLeftValue = constMaximum;
+ }
+ else {
+ css[_strLeft] = _strAuto;
+ css[_strRight] = 0;
+ scrollLeftValue = _rtlScrollBehavior.n ? -constMaximum : _rtlScrollBehavior.i ? 0 : constMaximum;
+ }
+ _sizeObserverElement.children().eq(0).css(css);
+ targetElement[_strScrollLeft](scrollLeftValue)[_strScrollTop](constMaximum);
+ _cssDirectionDetectedCache = dir;
+ result = true;
+ }
+ return result;
+ };
+ directionChanged();
+ targetElement.on(_strScroll, function (event) {
+ if (directionChanged())
+ update();
+ COMPATIBILITY.prvD(event);
+ COMPATIBILITY.stpP(event);
+ return false;
+ });
+ }
+ }
+
+ /**
+ * Removes a resize observer from the given element.
+ * @param targetElement The element to which the target resize observer is applied.
+ */
+ function removeResizeObserver(targetElement) {
+ if (_supportResizeObserver) {
+ var element = targetElement.contents()[0];
+ element[_strResizeObserverProperty].disconnect();
+ delete element[_strResizeObserverProperty];
+ }
+ else {
+ remove(targetElement.children(_strDot + _classNameResizeObserverElement).eq(0));
+ }
+ }
+
+ /**
+ * Freezes the given resize observer.
+ * @param targetElement The element to which the target resize observer is applied.
+ */
+ function freezeResizeObserver(targetElement) {
+ if (targetElement !== undefined) {
+ /*
+ if (_supportResizeObserver) {
+ var element = targetElement.contents()[0];
+ element[_strResizeObserverProperty].unobserve(element);
+ }
+ else {
+ targetElement = targetElement.children(_strDot + _classNameResizeObserverElement).eq(0);
+ var w = targetElement.css(_strWidth);
+ var h = targetElement.css(_strHeight);
+ var css = {};
+ css[_strWidth] = w;
+ css[_strHeight] = h;
+ targetElement.css(css);
+ }
+ */
+ }
+ }
+
+ /**
+ * Unfreezes the given resize observer.
+ * @param targetElement The element to which the target resize observer is applied.
+ */
+ function unfreezeResizeObserver(targetElement) {
+ if (targetElement !== undefined) {
+ /*
+ if (_supportResizeObserver) {
+ var element = targetElement.contents()[0];
+ element[_strResizeObserverProperty].observe(element);
+ }
+ else {
+ var css = { };
+ css[_strHeight] = _strEmpty;
+ css[_strWidth] = _strEmpty;
+ targetElement.children(_strDot + _classNameResizeObserverElement).eq(0).css(css);
+ }
+ */
+ }
+ }
+
+
+ //==== Connect / Disconnect Mutation Observer ====//
+
+ /**
+ * Connects the MutationObservers if they are supported.
+ */
+ function mutationObserversConnect() {
+ if (_supportMutationObserver && !_mutationObserverConnected) {
+ _mutationObserverHost.observe(_hostElement[0], {
+ attributes: true,
+ attributeOldValue: true,
+ attributeFilter: [LEXICON.i, LEXICON.c, LEXICON.s]
+ });
+
+ _mutationObserverContent.observe(_isTextarea ? _targetElement[0] : _contentElement[0], {
+ attributes: true,
+ attributeOldValue: true,
+ subtree: !_isTextarea,
+ childList: !_isTextarea,
+ characterData: !_isTextarea,
+ attributeFilter: _isTextarea ? ['wrap', 'cols', 'rows'] : [LEXICON.i, LEXICON.c, LEXICON.s]
+ });
+
+ _mutationObserverConnected = true;
+ }
+ }
+
+ /**
+ * Disconnects the MutationObservers if they are supported.
+ */
+ function mutationObserversDisconnect() {
+ if (_supportMutationObserver && _mutationObserverConnected) {
+ _mutationObserverHost.disconnect();
+ _mutationObserverContent.disconnect();
+
+ _mutationObserverConnected = false;
+ }
+ }
+
+
+ //==== Events of elements ====//
+
+ /**
+ * This method gets called every time the host element gets resized. IMPORTANT: Padding changes are detected too!!
+ * It refreshes the hostResizedEventArgs and the hostSizeResizeCache.
+ * If there are any size changes, the update method gets called.
+ */
+ function hostOnResized() {
+ if (_isSleeping)
+ return;
+ var measureElement = _sizeObserverElement[0];
+ var hostSize = {
+ w: measureElement[LEXICON.sW],
+ h: measureElement[LEXICON.sH]
+ };
+ if (_initialized) {
+ var changed = checkCacheDouble(hostSize, _hostElementSizeChangeDetectedCache);
+ _hostElementSizeChangeDetectedCache = hostSize;
+ if (changed)
+ update(true, false);
+ }
+ else {
+ _hostElementSizeChangeDetectedCache = hostSize;
+ }
+ }
+
+ /**
+ * The mouse enter event of the host element. This event is only needed for the autoHide feature.
+ */
+ function hostOnMouseEnter() {
+ if (_scrollbarsAutoHideLeave)
+ refreshScrollbarsAutoHide(true);
+ }
+
+ /**
+ * The mouse leave event of the host element. This event is only needed for the autoHide feature.
+ */
+ function hostOnMouseLeave() {
+ if (_scrollbarsAutoHideLeave && !_bodyElement.hasClass(_classNameDragging))
+ refreshScrollbarsAutoHide(false);
+ }
+
+ /**
+ * The mouse move event of the host element. This event is only needed for the autoHide "move" feature.
+ */
+ function hostOnMouseMove() {
+ if (_scrollbarsAutoHideMove) {
+ refreshScrollbarsAutoHide(true);
+ clearTimeout(_scrollbarsAutoHideMoveTimeoutId);
+ _scrollbarsAutoHideMoveTimeoutId = setTimeout(function () {
+ if (_scrollbarsAutoHideMove && !_destroyed)
+ refreshScrollbarsAutoHide(false);
+ }, 100);
+ }
+ }
+
+ /**
+ * The scroll event of the viewport element. That is the main scroll event. It controls also the "scroll", "scrollStart" and "scrollStop" callbacks.
+ * @param event The scroll event.
+ */
+ function viewportOnScroll(event) {
+ if (_isSleeping)
+ return;
+
+ if (_scrollStopTimeoutId !== undefined)
+ clearTimeout(_scrollStopTimeoutId);
+ else {
+ if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove)
+ refreshScrollbarsAutoHide(true);
+
+ if (!nativeOverlayScrollbarsAreActive())
+ addClass(_hostElement, _classNameHostScrolling);
+
+ callCallback("onScrollStart", event);
+ }
+
+ refreshScrollbarHandleOffset(true, _viewportElement[_strScrollLeft]());
+ refreshScrollbarHandleOffset(false, _viewportElement[_strScrollTop]());
+ callCallback("onScroll", event);
+
+ _scrollStopTimeoutId = setTimeout(function () {
+ if(!_destroyed) {
+ viewportOnScrollStop();
+ callCallback("onScrollStop", event);
+ }
+ }, _scrollStopDelay);
+ }
+
+ /**
+ * This method gets called if the scroll event stopped for a specified amount of time.
+ */
+ function viewportOnScrollStop() {
+ clearTimeout(_scrollStopTimeoutId);
+ _scrollStopTimeoutId = undefined;
+ if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove)
+ refreshScrollbarsAutoHide(false);
+
+ if (!nativeOverlayScrollbarsAreActive())
+ removeClass(_hostElement, _classNameHostScrolling);
+ }
+
+ /**
+ * The key input event of the textarea element.
+ */
+ function textareaOnInput() {
+ textareaUpdate();
+ _base.update(_strAuto);
+ }
+
+ /**
+ * The key down event of the textarea element. Is only applied if the input event isn't fully supported.
+ * @param event The key down event.
+ */
+ function textareaOnKeyDown(event) {
+ var keyCode = event.keyCode;
+ if (textareaIsRestrictedKeyCode(keyCode))
+ return;
+ if (_textareaKeyDownKeyCodesList.length === 0) {
+ var action = function () {
+ textareaUpdate();
+ _base.update(_strAuto);
+ };
+ action();
+ _textareaUpdateIntervalID = setInterval(action, 1000 / 60);
+ }
+ if (FRAMEWORK.inArray(keyCode, _textareaKeyDownKeyCodesList) === -1)
+ _textareaKeyDownKeyCodesList.push(keyCode);
+ }
+
+ /**
+ * The key up event of the textarea element. Is only applied if the input event isn't fully supported.
+ * @param event The key up event.
+ */
+ function textareaOnKeyUp(event) {
+ var keyCode = event.keyCode;
+ if (textareaIsRestrictedKeyCode(keyCode))
+ return;
+ var index = FRAMEWORK.inArray(keyCode, _textareaKeyDownKeyCodesList);
+ if (index > -1)
+ _textareaKeyDownKeyCodesList.splice(index, 1);
+ if (_textareaKeyDownKeyCodesList.length === 0) {
+ textareaUpdate();
+ _base.update(_strAuto);
+ clearInterval(_textareaUpdateIntervalID);
+ }
+ }
+
+ /**
+ * The drop event of the textarea element.
+ */
+ function textareaOnDrop() {
+ setTimeout(function () {
+ if(!_destroyed) {
+ textareaUpdate();
+ _base.update(_strAuto);
+ }
+ }, 50);
+ }
+
+ /**
+ * The focus event of the textarea element.
+ */
+ function textareaOnFocus() {
+ _textareaHasFocus = true;
+ }
+
+ /**
+ * The focus out event of the textarea element.
+ */
+ function textareaOnFocusOut() {
+ _textareaHasFocus = false;
+ clearInterval(_textareaUpdateIntervalID);
+ _textareaKeyDownKeyCodesList = [ ];
+ textareaUpdate();
+ _base.update(_strAuto);
+ }
+
+ /**
+ * The scroll event of the textarea element.
+ * @param event The scroll event.
+ */
+ function textareaOnScroll(event) {
+ _targetElement[_strScrollLeft](_rtlScrollBehavior.i && _normalizeRTLCache ? 9999999 : 0);
+ _targetElement[_strScrollTop](0);
+ COMPATIBILITY.prvD(event);
+ COMPATIBILITY.stpP(event);
+ return false;
+ }
+
+ /**
+ * The mouse down event of the scrollbar corner element.
+ * @param event The mouse down event.
+ */
+ function scrollbarCornerOnMouseDown(event) {
+ if (_isSleeping)
+ return;
+
+ var originalEvent = event.originalEvent || event;
+ var isTouchEvent = originalEvent.touches !== undefined;
+
+ if (COMPATIBILITY.mBtn(event) === 1 || isTouchEvent) {
+ if (_mutationObserverConnected) {
+ _resizeReconnectMutationObserver = true;
+ mutationObserversDisconnect();
+ }
+
+ _resizeDragStartPosition = COMPATIBILITY.page(event);
+
+ _resizeDragStartSize.w = _hostElement[0][LEXICON.oW] - (!_isBorderBox ? _paddingX : 0);
+ _resizeDragStartSize.h = _hostElement[0][LEXICON.oH] - (!_isBorderBox ? _paddingY : 0);
+
+ _documentElement.on(_strSelectStartEvent, documentOnSelectStart)
+ .on(_strMouseTouchMoveEvent, scrollbarCornerOnResize)
+ .on(_strMouseTouchUpEvent, scrollbarCornerOnResized);
+
+ addClass(_bodyElement, _classNameDragging);
+ if (_scrollbarCornerElement.setCapture)
+ _scrollbarCornerElement.setCapture();
+
+ COMPATIBILITY.prvD(event);
+ COMPATIBILITY.stpP(event);
+ }
+ }
+
+ /**
+ * The mouse move event if the scrollbar corner element is resizable and gets dragged.
+ * @param event The mouse move event.
+ */
+ function scrollbarCornerOnResize(event) {
+ var pageOffset = COMPATIBILITY.page(event);
+ var hostElementCSS = { };
+ if (_resizeHorizontal || _resizeBoth)
+ hostElementCSS[_strWidth] = (_resizeDragStartSize.w + pageOffset.x - _resizeDragStartPosition.x);
+ if (_resizeVertical || _resizeBoth)
+ hostElementCSS[_strHeight] = (_resizeDragStartSize.h + pageOffset.y - _resizeDragStartPosition.y);
+ _hostElement.css(hostElementCSS);
+ COMPATIBILITY.stpP(event);
+ }
+
+ /**
+ * The mouse up event if the scrollbar corner element is resizable and was dragged and now the mouse button is released.
+ * @param event The mouse up event.
+ */
+ function scrollbarCornerOnResized(event) {
+ var eventIsTrusted = event !== undefined;
+
+ _documentElement.off(_strSelectStartEvent, documentOnSelectStart)
+ .off(_strMouseTouchMoveEvent, scrollbarCornerOnResize)
+ .off(_strMouseTouchUpEvent, scrollbarCornerOnResized);
+
+ removeClass(_bodyElement, _classNameDragging);
+ if (_scrollbarCornerElement.releaseCapture)
+ _scrollbarCornerElement.releaseCapture();
+
+ if (eventIsTrusted) {
+ if (_resizeReconnectMutationObserver)
+ mutationObserversConnect();
+ _base.update(_strAuto);
+ }
+ _resizeReconnectMutationObserver = false;
+ }
+
+ /**
+ * Prevents text from deselection if attached to the document element on the mousedown event of a DOM element.
+ * @param event The select start event.
+ */
+ function documentOnSelectStart(event) {
+ COMPATIBILITY.prvD(event);
+ return false;
+ }
+
+ /**
+ * A callback which will be called after a img element has downloaded its src asynchronous.
+ */
+ function imgOnLoad() {
+ update();
+ }
+
+
+ //==== Update Detection ====//
+
+ /**
+ * Measures the min width and min height of the body element and refreshes the related cache.
+ * @returns {boolean} True if the min width or min height has changed, false otherwise.
+ */
+ function bodyMinSizeChanged() {
+ var bodyMinSize = {};
+ if (_isBody && _contentArrangeElement) {
+ bodyMinSize.w = parseToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strWidth));
+ bodyMinSize.h = parseToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strHeight));
+ bodyMinSize.c = checkCacheDouble(bodyMinSize, _bodyMinSizeCache);
+ bodyMinSize.f = true; //flag for "measured at least once"
+ }
+ _bodyMinSizeCache = bodyMinSize;
+ return bodyMinSize.c || false;
+ }
+
+ /**
+ * Returns true if the class names really changed (new class without plugin host prefix)
+ * @param oldCassNames The old ClassName string.
+ * @param newClassNames The new ClassName string.
+ * @returns {boolean} True if the class names has really changed, false otherwise.
+ */
+ function hostClassNamesChanged(oldCassNames, newClassNames) {
+ var currClasses = (newClassNames !== undefined && newClassNames !== null) ? newClassNames.split(_strSpace) : _strEmpty;
+ var oldClasses = (oldCassNames !== undefined && oldCassNames !== null) ? oldCassNames.split(_strSpace) : _strEmpty;
+ if (currClasses === _strEmpty && oldClasses === _strEmpty)
+ return false;
+ var diff = getArrayDifferences(oldClasses, currClasses);
+ var changed = false;
+ var oldClassNames = _oldClassName !== undefined && _oldClassName !== null ? _oldClassName.split(_strSpace) : [_strEmpty];
+ var currClassNames = _classNameCache !== undefined && _classNameCache !== null ? _classNameCache.split(_strSpace) : [_strEmpty];
+
+ //remove none theme from diff list to prevent update
+ var idx = FRAMEWORK.inArray(_classNameThemeNone, diff);
+ var curr = diff[i];
+ var i;
+ var v;
+ var o;
+ var c;
+
+ if (idx > -1)
+ diff.splice(idx, 1);
+
+ for (i = 0; i < diff.length; i++) {
+ curr = diff[i];
+ if (curr.indexOf(_classNameHostElement) !== 0) {
+ o = true;
+ c = true;
+ for (v = 0; v < oldClassNames.length; v++) {
+ if (curr === oldClassNames[v]) {
+ o = false;
+ break;
+ }
+ }
+ for (v = 0; v < currClassNames.length; v++) {
+ if (curr === currClassNames[v]) {
+ c = false;
+ break;
+ }
+ }
+ if (o && c) {
+ changed = true;
+ break;
+ }
+ }
+
+ }
+ return changed;
+ }
+
+ /**
+ * Returns true if the given mutation is not from a from the plugin generated element. If the target element is a textarea the mutation is always unknown.
+ * @param mutation The mutation which shall be checked.
+ * @returns {boolean} True if the mutation is from a unknown element, false otherwise.
+ */
+ function isUnknownMutation(mutation) {
+ var attributeName = mutation.attributeName;
+ var mutationTarget = mutation.target;
+ var mutationType = mutation.type;
+ var strClosest = 'closest';
+
+ if (mutationTarget === _contentElement[0])
+ return attributeName === null;
+ if (mutationType === 'attributes' && (attributeName === LEXICON.c || attributeName === LEXICON.s) && !_isTextarea) {
+ //only do it of browser support it natively
+ if (typeof mutationTarget[strClosest] != TYPES.f)
+ return true;
+ if (mutationTarget[strClosest](_strDot + _classNameResizeObserverElement) !== null ||
+ mutationTarget[strClosest](_strDot + _classNameScrollbar) !== null ||
+ mutationTarget[strClosest](_strDot + _classNameScrollbarCorner) !== null)
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * Returns true if the content size was changed since the last time this method was called.
+ * @returns {boolean} True if the content size was changed, false otherwise.
+ */
+ function updateAutoContentSizeChanged() {
+ if (_isSleeping)
+ return false;
+
+ var float;
+ var textareaValueLength = _isTextarea && _widthAutoCache && !_textareaAutoWrappingCache ? _targetElement.val().length : 0;
+ var setCSS = !_mutationObserverConnected && _widthAutoCache && !_isTextarea;
+ var viewportScrollSize = { };
+ var css = { };
+
+ //fix for https://bugzilla.mozilla.org/show_bug.cgi?id=1439305, it only works with "clipAlways : true"
+ //it can work with "clipAlways : false" too, but we had to set the overflow of the viewportElement to hidden every time before measuring
+ if(_restrictedMeasuring) {
+ viewportScrollSize = {
+ x : _viewportElement[0][LEXICON.sW],
+ y : _viewportElement[0][LEXICON.sH]
+ }
+ }
+ if (setCSS) {
+ float = _contentElement.css(_strFloat);
+ css[_strFloat] = _isRTL ? _strRight : _strLeft;
+ css[_strWidth] = _strAuto;
+ _contentElement.css(css);
+ }
+ var contentElementScrollSize = {
+ w: getContentMeasureElement()[LEXICON.sW] + textareaValueLength,
+ h: getContentMeasureElement()[LEXICON.sH] + textareaValueLength
+ };
+ if (setCSS) {
+ css[_strFloat] = float;
+ css[_strWidth] = _strHundredPercent;
+ _contentElement.css(css);
+ }
+
+ var bodyMinSizeC = bodyMinSizeChanged();
+ var changed = checkCacheDouble(contentElementScrollSize, _contentElementScrollSizeChangeDetectedCache);
+ var viewportScrollSizeChanged = checkCacheDouble(viewportScrollSize, _viewportScrollSizeCache, _strX, _strY);
+ _contentElementScrollSizeChangeDetectedCache = contentElementScrollSize;
+ _viewportScrollSizeCache = viewportScrollSize;
+
+ return changed || bodyMinSizeC || viewportScrollSizeChanged;
+ }
+
+ /**
+ * Returns true if the host element attributes (id, class, style) was changed since the last time this method was called.
+ * @returns {boolean}
+ */
+ function meaningfulAttrsChanged() {
+ if (_isSleeping || _mutationObserverConnected)
+ return false;
+
+ var hostElementId = _hostElement.attr(LEXICON.i) || _strEmpty;
+ var hostElementIdChanged = checkCacheSingle(hostElementId, _updateAutoHostElementIdCache);
+ var hostElementClass = _hostElement.attr(LEXICON.c) || _strEmpty;
+ var hostElementClassChanged = checkCacheSingle(hostElementClass, _updateAutoHostElementClassCache);
+ var hostElementStyle = _hostElement.attr(LEXICON.s) || _strEmpty;
+ var hostElementStyleChanged = checkCacheSingle(hostElementStyle, _updateAutoHostElementStyleCache);
+ var hostElementVisible = _hostElement.is(':visible') || _strEmpty;
+ var hostElementVisibleChanged = checkCacheSingle(hostElementVisible, _updateAutoHostElementVisibleCache);
+ var targetElementRows = _isTextarea ? (_targetElement.attr('rows') || _strEmpty) : _strEmpty;
+ var targetElementRowsChanged = checkCacheSingle(targetElementRows, _updateAutoTargetElementRowsCache);
+ var targetElementCols = _isTextarea ? (_targetElement.attr('cols') || _strEmpty) : _strEmpty;
+ var targetElementColsChanged = checkCacheSingle(targetElementCols, _updateAutoTargetElementColsCache);
+ var targetElementWrap = _isTextarea ? (_targetElement.attr('wrap') || _strEmpty) : _strEmpty;
+ var targetElementWrapChanged = checkCacheSingle(targetElementWrap, _updateAutoTargetElementWrapCache);
+
+ _updateAutoHostElementIdCache = hostElementId;
+ if (hostElementClassChanged)
+ hostElementClassChanged = hostClassNamesChanged(_updateAutoHostElementClassCache, hostElementClass);
+ _updateAutoHostElementClassCache = hostElementClass;
+ _updateAutoHostElementStyleCache = hostElementStyle;
+ _updateAutoHostElementVisibleCache = hostElementVisible;
+ _updateAutoTargetElementRowsCache = targetElementRows;
+ _updateAutoTargetElementColsCache = targetElementCols;
+ _updateAutoTargetElementWrapCache = targetElementWrap;
+
+ return hostElementIdChanged || hostElementClassChanged || hostElementStyleChanged || hostElementVisibleChanged || targetElementRowsChanged || targetElementColsChanged || targetElementWrapChanged;
+ }
+
+ /**
+ * Checks is a CSS Property of a child element is affecting the scroll size of the content.
+ * @param propertyName The CSS property name.
+ * @returns {boolean} True if the property is affecting the content scroll size, false otherwise.
+ */
+ function isSizeAffectingCSSProperty(propertyName) {
+ if (!_initialized)
+ return true;
+ var flexGrow = 'flex-grow';
+ var flexShrink = 'flex-shrink';
+ var flexBasis = 'flex-basis';
+ var affectingPropsX = [
+ _strWidth,
+ _strMinMinus + _strWidth,
+ _strMaxMinus + _strWidth,
+ _strMarginMinus + _strLeft,
+ _strMarginMinus + _strRight,
+ _strLeft,
+ _strRight,
+ 'font-weight',
+ 'word-spacing',
+ flexGrow,
+ flexShrink,
+ flexBasis
+ ];
+ var affectingPropsXContentBox = [
+ _strPaddingMinus + _strLeft,
+ _strPaddingMinus + _strRight,
+ _strBorderMinus + _strLeft + _strWidth,
+ _strBorderMinus + _strRight + _strWidth
+ ];
+ var affectingPropsY = [
+ _strHeight,
+ _strMinMinus + _strHeight,
+ _strMaxMinus + _strHeight,
+ _strMarginMinus + _strTop,
+ _strMarginMinus + _strBottom,
+ _strTop,
+ _strBottom,
+ 'line-height',
+ flexGrow,
+ flexShrink,
+ flexBasis
+ ];
+ var affectingPropsYContentBox = [
+ _strPaddingMinus + _strTop,
+ _strPaddingMinus + _strBottom,
+ _strBorderMinus + _strTop + _strWidth,
+ _strBorderMinus + _strBottom + _strWidth
+ ];
+ var _strS = 's';
+ var _strVS = 'v-s';
+ var checkX = _overflowBehaviorCache.x === _strS || _overflowBehaviorCache.x === _strVS;
+ var checkY = _overflowBehaviorCache.y === _strS || _overflowBehaviorCache.y === _strVS;
+ var sizeIsAffected = false;
+ var checkPropertyName = function (arr, name) {
+ for (var i = 0; i < arr.length; i++) {
+ if (arr[i] === name)
+ return true;
+ }
+ return false;
+ };
+
+ if (checkY) {
+ sizeIsAffected = checkPropertyName(affectingPropsY, propertyName);
+ if (!sizeIsAffected && !_isBorderBox)
+ sizeIsAffected = checkPropertyName(affectingPropsYContentBox, propertyName);
+ }
+ if (checkX && !sizeIsAffected) {
+ sizeIsAffected = checkPropertyName(affectingPropsX, propertyName);
+ if (!sizeIsAffected && !_isBorderBox)
+ sizeIsAffected = checkPropertyName(affectingPropsXContentBox, propertyName);
+ }
+ return sizeIsAffected;
+ }
+
+
+ //==== Update ====//
+
+ /**
+ * Updates the variables and size of the textarea element, and manages the scroll on new line or new character.
+ */
+ function textareaUpdate() {
+ if (_isSleeping)
+ return;
+
+ var wrapAttrOff = !_textareaAutoWrappingCache;
+ var minWidth = _viewportSize.w - (!_isBorderBox && !_paddingAbsoluteCache && _widthAutoCache ? _paddingY + _borderY : 0);
+ var minHeight = _viewportSize.h - (!_isBorderBox && !_paddingAbsoluteCache && _heightAutoCache ? _paddingY + _borderY : 0);
+ var css = { };
+ var doMeasure = _widthAutoCache || wrapAttrOff;
+ var measureElement = _targetElement[0];
+ var origWidth;
+ var width;
+ var origHeight;
+ var height;
+
+ //reset min size
+ css[_strMinMinus + _strWidth] = _strEmpty;
+ css[_strMinMinus + _strHeight] = _strEmpty;
+
+ //set width auto
+ css[_strWidth] = _strAuto;
+ _targetElement.css(css);
+
+ //measure width
+ origWidth = measureElement[LEXICON.oW];
+ width = doMeasure ? Math.max(origWidth, measureElement[LEXICON.sW] - 1) : 1;
+ width += (_widthAutoCache ? _marginX + (!_isBorderBox ? wrapAttrOff ? 0 : _paddingX + _borderX : 0) : 0);
+
+ //set measured width and height auto
+ css[_strWidth] = _widthAutoCache ? width : _strHundredPercent;
+ css[_strHeight] = _strAuto; //_strAuto
+ _targetElement.css(css);
+
+ //measure height
+ origHeight = measureElement[LEXICON.oH];
+ height = Math.max(origHeight, measureElement[LEXICON.sH] - 1);
+
+ //append correct size values
+ css[_strWidth] = width;
+ css[_strHeight] = height;
+ _textareaCoverElement.css(css);
+
+ //apply min width / min height to prevent textarea collapsing
+ css[_strMinMinus + _strWidth] = minWidth + (!_isBorderBox && _widthAutoCache ? _paddingX + _borderX : 0);
+ css[_strMinMinus + _strHeight] = minHeight + (!_isBorderBox && _heightAutoCache ? _paddingY + _borderY : 0);
+ _targetElement.css(css);
+
+ return {
+ ow: origWidth,
+ oh: origHeight,
+ dw: width,
+ dh: height
+ };
+ }
+
+ /**
+ * Updates the plugin and DOM to the current options.
+ * This method should only be called if a update is 100% required.
+ * @param hostSizeChanged True if this method was called due to a host size change.
+ * @param contentSizeChanged True if this method was called due to a content size change.
+ * @param force True if every property shall be updated and the cache shall be ignored.
+ * @param preventSwallowing True if this method shall be executed event if it could be swallowed.
+ */
+ function update(hostSizeChanged, contentSizeChanged, force, preventSwallowing) {
+ var now = COMPATIBILITY.now();
+ var swallow = _swallowUpdateLag > 0 && _initialized && (now - _lastUpdateTime) < _swallowUpdateLag && (!_heightAutoCache && !_widthAutoCache) && !preventSwallowing;
+ var displayIsHidden = _hostElement.is(':hidden');
+ var displayIsHiddenChanged = checkCacheSingle(displayIsHidden, _displayIsHiddenCache, force);
+ _displayIsHiddenCache = displayIsHidden;
+ clearTimeout(_swallowedUpdateTimeout);
+
+ if (swallow) {
+ _swallowedUpdateParams.h = hostSizeChanged;
+ _swallowedUpdateParams.c = contentSizeChanged;
+ _swallowedUpdateParams.f = force;
+ _swallowedUpdateTimeout = setTimeout(update, _swallowUpdateLag);
+ }
+
+ //abort update due to:
+ //destroyed
+ //swallowing
+ //sleeping
+ //host is hidden or has false display
+ if (_destroyed || swallow || _isSleeping || (_initialized && !force && displayIsHidden) || _hostElement.css('display') === 'inline')
+ return;
+
+ _lastUpdateTime = now;
+ hostSizeChanged = hostSizeChanged || _swallowedUpdateParams.h;
+ contentSizeChanged = contentSizeChanged || _swallowedUpdateParams.c;
+ force = force || _swallowedUpdateParams.f;
+ _swallowedUpdateParams = {};
+
+ hostSizeChanged = hostSizeChanged === undefined ? false : hostSizeChanged;
+ contentSizeChanged = contentSizeChanged === undefined ? false : contentSizeChanged;
+ force = force === undefined ? false : force;
+
+ //if scrollbar styling is possible and native scrollbars aren't overlaid the scrollbar styling will be applied which hides the native scrollbars completely.
+ if (_nativeScrollbarStyling && !(_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y)) {
+ //native scrollbars are hidden, so change the values to zero
+ _nativeScrollbarSize.x = 0;
+ _nativeScrollbarSize.y = 0;
+ }
+ else {
+ //refresh native scrollbar size (in case of zoom)
+ _nativeScrollbarSize = extend(true, {}, globals.nativeScrollbarSize);
+ }
+
+ // Scrollbar padding is needed for firefox, because firefox hides scrollbar automatically if the size of the div is too small.
+ // The calculation: [scrollbar size +3 *3]
+ // (+3 because of possible decoration e.g. borders, margins etc., but only if native scrollbar is NOT a overlaid scrollbar)
+ // (*3 because (1)increase / (2)decrease -button and (3)resize handle)
+ _nativeScrollbarMinSize = {
+ x: (_nativeScrollbarSize.x + (_nativeScrollbarIsOverlaid.x ? 0 : 3)) * 3,
+ y: (_nativeScrollbarSize.y + (_nativeScrollbarIsOverlaid.y ? 0 : 3)) * 3
+ };
+
+ freezeResizeObserver(_sizeObserverElement);
+ freezeResizeObserver(_sizeAutoObserverElement);
+
+ //save current scroll offset
+ var currScroll = {
+ l: _viewportElement[_strScrollLeft](),
+ t: _viewportElement[_strScrollTop]()
+ };
+ var currentPreparedOptionsScrollbars = _currentPreparedOptions.scrollbars;
+ var currentPreparedOptionsTextarea = _currentPreparedOptions.textarea;
+
+ //scrollbars visibility:
+ var scrollbarsVisibility = currentPreparedOptionsScrollbars.visibility;
+ var scrollbarsVisibilityChanged = checkCacheSingle(scrollbarsVisibility, _scrollbarsVisibilityCache, force);
+
+ //scrollbars autoHide:
+ var scrollbarsAutoHide = currentPreparedOptionsScrollbars.autoHide;
+ var scrollbarsAutoHideChanged = checkCacheSingle(scrollbarsAutoHide, _scrollbarsAutoHideCache, force);
+
+ //scrollbars click scrolling
+ var scrollbarsClickScrolling = currentPreparedOptionsScrollbars.clickScrolling;
+ var scrollbarsClickScrollingChanged = checkCacheSingle(scrollbarsClickScrolling, _scrollbarsClickScrollingCache, force);
+
+ //scrollbars drag scrolling
+ var scrollbarsDragScrolling = currentPreparedOptionsScrollbars.dragScrolling;
+ var scrollbarsDragScrollingChanged = checkCacheSingle(scrollbarsDragScrolling, _scrollbarsDragScrollingCache, force);
+
+ //className
+ var className = _currentPreparedOptions.className;
+ var classNameChanged = checkCacheSingle(className, _classNameCache, force);
+
+ //resize
+ var resize = _currentPreparedOptions.resize;
+ var resizeChanged = checkCacheSingle(resize, _resizeCache, force) && !_isBody; //body can't be resized since the window itself acts as resize possibility.
+
+ //textarea AutoWrapping
+ var textareaAutoWrapping = _isTextarea ? _targetElement.attr('wrap') !== 'off' : false;
+ var textareaAutoWrappingChanged = checkCacheSingle(textareaAutoWrapping, _textareaAutoWrappingCache, force);
+
+ //paddingAbsolute
+ var paddingAbsolute = _currentPreparedOptions.paddingAbsolute;
+ var paddingAbsoluteChanged = checkCacheSingle(paddingAbsolute, _paddingAbsoluteCache, force);
+
+ //clipAlways
+ var clipAlways = _currentPreparedOptions.clipAlways;
+ var clipAlwaysChanged = checkCacheSingle(clipAlways, _clipAlwaysCache, force);
+
+ //sizeAutoCapable
+ var sizeAutoCapable = _currentPreparedOptions.sizeAutoCapable && !_isBody; //body can never be size auto, because it shall be always as big as the viewport.
+ var sizeAutoCapableChanged = checkCacheSingle(sizeAutoCapable, _sizeAutoCapableCache, force);
+
+ //showNativeScrollbars
+ var ignoreOverlayScrollbarHiding = _currentPreparedOptions.nativeScrollbarsOverlaid.showNativeScrollbars;
+ var ignoreOverlayScrollbarHidingChanged = checkCacheSingle(ignoreOverlayScrollbarHiding, _ignoreOverlayScrollbarHidingCache);
+
+ //autoUpdate
+ var autoUpdate = _currentPreparedOptions.autoUpdate;
+ var autoUpdateChanged = checkCacheSingle(autoUpdate, _autoUpdateCache);
+
+ //overflowBehavior
+ var overflowBehavior = _currentPreparedOptions.overflowBehavior;
+ var overflowBehaviorChanged = checkCacheDouble(overflowBehavior, _overflowBehaviorCache, _strX, _strY, force);
+
+ //dynWidth:
+ var textareaDynWidth = currentPreparedOptionsTextarea.dynWidth;
+ var textareaDynWidthChanged = checkCacheSingle(_textareaDynWidthCache, textareaDynWidth);
+
+ //dynHeight:
+ var textareaDynHeight = currentPreparedOptionsTextarea.dynHeight;
+ var textareaDynHeightChanged = checkCacheSingle(_textareaDynHeightCache, textareaDynHeight);
+
+ //scrollbars visibility
+ _scrollbarsAutoHideNever = scrollbarsAutoHide === 'n';
+ _scrollbarsAutoHideScroll = scrollbarsAutoHide === 's';
+ _scrollbarsAutoHideMove = scrollbarsAutoHide === 'm';
+ _scrollbarsAutoHideLeave = scrollbarsAutoHide === 'l';
+
+ //scrollbars autoHideDelay
+ _scrollbarsAutoHideDelay = currentPreparedOptionsScrollbars.autoHideDelay;
+
+ //scrollbars support touch
+ _scrollbarsTouchSupport = currentPreparedOptionsScrollbars.touchSupport;
+
+ //old className
+ _oldClassName = _classNameCache;
+
+ //resize
+ _resizeNone = resize === 'n';
+ _resizeBoth = resize === 'b';
+ _resizeHorizontal = resize === 'h';
+ _resizeVertical = resize === 'v';
+
+ //normalizeRTL
+ _normalizeRTLCache = _currentPreparedOptions.normalizeRTL;
+
+ //ignore overlay scrollbar hiding
+ ignoreOverlayScrollbarHiding = ignoreOverlayScrollbarHiding && (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y);
+
+ //refresh options cache
+ _scrollbarsVisibilityCache = scrollbarsVisibility;
+ _scrollbarsAutoHideCache = scrollbarsAutoHide;
+ _scrollbarsClickScrollingCache = scrollbarsClickScrolling;
+ _scrollbarsDragScrollingCache = scrollbarsDragScrolling;
+ _classNameCache = className;
+ _resizeCache = resize;
+ _textareaAutoWrappingCache = textareaAutoWrapping;
+ _paddingAbsoluteCache = paddingAbsolute;
+ _clipAlwaysCache = clipAlways;
+ _sizeAutoCapableCache = sizeAutoCapable;
+ _ignoreOverlayScrollbarHidingCache = ignoreOverlayScrollbarHiding;
+ _autoUpdateCache = autoUpdate;
+ _overflowBehaviorCache = extend(true, {}, overflowBehavior);
+ _textareaDynWidthCache = textareaDynWidth;
+ _textareaDynHeightCache = textareaDynHeight;
+ _hasOverflowCache = _hasOverflowCache || { x: false, y: false };
+
+ //set correct class name to the host element
+ if (classNameChanged) {
+ removeClass(_hostElement, _oldClassName + _strSpace + _classNameThemeNone);
+ addClass(_hostElement, className !== undefined && className !== null && className.length > 0 ? className : _classNameThemeNone);
+ }
+
+ //set correct auto Update
+ if (autoUpdateChanged) {
+ if (autoUpdate === true) {
+ mutationObserversDisconnect();
+ autoUpdateLoop.add(_base);
+ }
+ else if (autoUpdate === null) {
+ if (_autoUpdateRecommended) {
+ mutationObserversDisconnect();
+ autoUpdateLoop.add(_base);
+ }
+ else {
+ autoUpdateLoop.remove(_base);
+ mutationObserversConnect();
+ }
+ }
+ else {
+ autoUpdateLoop.remove(_base);
+ mutationObserversConnect();
+ }
+ }
+
+ //activate or deactivate size auto capability
+ if (sizeAutoCapableChanged) {
+ if (sizeAutoCapable) {
+ if (_contentGlueElement === undefined) {
+ _contentGlueElement = FRAMEWORK(generateDiv(_classNameContentGlueElement));
+ _paddingElement.before(_contentGlueElement);
+ }
+ if (_sizeAutoObserverAdded) {
+ _sizeAutoObserverElement.show();
+ }
+ else {
+ _sizeAutoObserverElement = FRAMEWORK(generateDiv(_classNameSizeAutoObserverElement));
+ _contentGlueElement.before(_sizeAutoObserverElement);
+ var oldSize = {w: -1, h: -1};
+ addResizeObserver(_sizeAutoObserverElement, function () {
+ var newSize = {
+ w: _sizeAutoObserverElement[0][LEXICON.oW],
+ h: _sizeAutoObserverElement[0][LEXICON.oH]
+ };
+ if (checkCacheDouble(newSize, oldSize)) {
+ if (_initialized && (_heightAutoCache && newSize.h > 0) || (_widthAutoCache && newSize.w > 0)) {
+ update();
+ }
+ else if (_initialized && (!_heightAutoCache && newSize.h === 0) || (!_widthAutoCache && newSize.w === 0)) {
+ update();
+ }
+ }
+ oldSize = newSize;
+ });
+ _sizeAutoObserverAdded = true;
+ //fix heightAuto detector bug if height is fixed but contentHeight is 0.
+ //the probability this bug will ever happen is very very low, thats why its ok if we use calc which isn't supported in IE8.
+ if (_cssCalc !== null)
+ _sizeAutoObserverElement.css(_strHeight, _cssCalc + '(100% + 1px)');
+ }
+ }
+ else {
+ if (_sizeAutoObserverAdded)
+ _sizeAutoObserverElement.hide();
+ }
+ }
+
+ //if force, update all resizeObservers too
+ if (force) {
+ _sizeObserverElement.find('*').trigger(_strScroll);
+ if (_sizeAutoObserverAdded)
+ _sizeAutoObserverElement.find('*').trigger(_strScroll);
+ }
+
+ //detect direction:
+ var cssDirection = _hostElement.css('direction');
+ var cssDirectionChanged = checkCacheSingle(cssDirection, _cssDirectionCache, force);
+
+ //detect box-sizing:
+ var boxSizing = _hostElement.css('box-sizing');
+ var boxSizingChanged = checkCacheSingle(boxSizing, _cssBoxSizingCache, force);
+
+ //detect padding:
+ var padding = {
+ c: force,
+ t: parseToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strTop)),
+ r: parseToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strRight)),
+ b: parseToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strBottom)),
+ l: parseToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strLeft))
+ };
+
+ //width + height auto detecting var:
+ var sizeAutoObserverElementBCRect;
+ //exception occurs in IE8 sometimes (unknown exception)
+ try {
+ sizeAutoObserverElementBCRect = _sizeAutoObserverAdded ? _sizeAutoObserverElement[0].getBoundingClientRect() : null;
+ } catch (ex) {
+ return;
+ }
+
+ _isRTL = cssDirection === 'rtl';
+ _isBorderBox = (boxSizing === 'border-box');
+ var isRTLLeft = _isRTL ? _strLeft : _strRight;
+ var isRTLRight = _isRTL ? _strRight : _strLeft;
+ var hostElement = _hostElement[0];
+ var paddingElement = _paddingElement[0];
+
+ //detect width auto:
+ var widthAutoResizeDetection = false;
+ var widthAutoObserverDetection = (_sizeAutoObserverAdded && (_hostElement.css(_strFloat) !== 'none' /*|| _isTextarea */)) ? (Math.round(sizeAutoObserverElementBCRect.right - sizeAutoObserverElementBCRect.left) === 0) && (!paddingAbsolute ? (hostElement[LEXICON.cW] - _paddingX) > 0 : true) : false;
+ if (sizeAutoCapable && !widthAutoObserverDetection) {
+ var tmpCurrHostWidth = hostElement[LEXICON.oW];
+ var tmpCurrContentGlueWidth = _contentGlueElement.css(_strWidth);
+ _contentGlueElement.css(_strWidth, _strAuto);
+
+ var tmpNewHostWidth = hostElement[LEXICON.oW];
+ _contentGlueElement.css(_strWidth, tmpCurrContentGlueWidth);
+ widthAutoResizeDetection = tmpCurrHostWidth !== tmpNewHostWidth;
+ if (!widthAutoResizeDetection) {
+ _contentGlueElement.css(_strWidth, tmpCurrHostWidth + 1);
+ tmpNewHostWidth = hostElement[LEXICON.oW];
+ _contentGlueElement.css(_strWidth, tmpCurrContentGlueWidth);
+ widthAutoResizeDetection = tmpCurrHostWidth !== tmpNewHostWidth;
+ }
+ }
+ var widthAuto = (widthAutoObserverDetection || widthAutoResizeDetection) && sizeAutoCapable && !displayIsHidden;
+ var widthAutoChanged = checkCacheSingle(widthAuto, _widthAutoCache, force);
+ var wasWidthAuto = !widthAuto && _widthAutoCache;
+
+ //detect height auto:
+ var heightAuto = _sizeAutoObserverAdded && !displayIsHidden ? (Math.round(sizeAutoObserverElementBCRect.bottom - sizeAutoObserverElementBCRect.top) === 0) /* && (!paddingAbsolute && (_msieVersion > 9 || !_msieVersion) ? true : true) */ : false;
+ var heightAutoChanged = checkCacheSingle(heightAuto, _heightAutoCache, force);
+ var wasHeightAuto = !heightAuto && _heightAutoCache;
+
+ //detect border:
+ //we need the border only if border box and auto size
+ var strMinusWidth = '-' + _strWidth;
+ var updateBorderX = (widthAuto && _isBorderBox) || !_isBorderBox;
+ var updateBorderY = (heightAuto && _isBorderBox) || !_isBorderBox;
+ var border = {
+ c: force,
+ t: updateBorderY ? parseToZeroOrNumber(_hostElement.css(_strBorderMinus + _strTop + strMinusWidth), true) : 0,
+ r: updateBorderX ? parseToZeroOrNumber(_hostElement.css(_strBorderMinus + _strRight + strMinusWidth), true) : 0,
+ b: updateBorderY ? parseToZeroOrNumber(_hostElement.css(_strBorderMinus + _strBottom + strMinusWidth), true) : 0,
+ l: updateBorderX ? parseToZeroOrNumber(_hostElement.css(_strBorderMinus + _strLeft + strMinusWidth), true) : 0
+ };
+
+ //detect margin:
+ var margin = {
+ c: force,
+ t: parseToZeroOrNumber(_hostElement.css(_strMarginMinus + _strTop)),
+ r: parseToZeroOrNumber(_hostElement.css(_strMarginMinus + _strRight)),
+ b: parseToZeroOrNumber(_hostElement.css(_strMarginMinus + _strBottom)),
+ l: parseToZeroOrNumber(_hostElement.css(_strMarginMinus + _strLeft))
+ };
+
+ //detect css max width & height:
+ var cssMaxValue = {
+ h: String(_hostElement.css(_strMaxMinus + _strHeight)),
+ w: String(_hostElement.css(_strMaxMinus + _strWidth))
+ };
+
+ //vars to apply correct css
+ var contentElementCSS = { };
+ var contentGlueElementCSS = { };
+
+ //funcs
+ var getHostSize = function() {
+ return {
+ w: hostElement[LEXICON.cW],
+ h: hostElement[LEXICON.cH]
+ };
+ };
+ var getViewportSize = function() {
+ var brect = paddingElement.getBoundingClientRect()
+ return brect[_strWidth]
+ ? {
+ w: brect[_strWidth],
+ h: brect[_strHeight]
+ } : {
+ w: paddingElement[LEXICON.oW],
+ h: paddingElement[LEXICON.oH]
+ };
+ };
+
+ //set info for padding
+ _paddingX = padding.l + padding.r;
+ _paddingY = padding.t + padding.b;
+ padding.ax = paddingAbsolute ? _paddingX : 0;
+ padding.ay = paddingAbsolute ? _paddingY : 0;
+ padding.c = checkCacheTRBL(padding, _cssPaddingCache);
+
+ //set info for border
+ _borderX = border.l + border.r;
+ _borderY = border.t + border.b;
+ border.c = checkCacheTRBL(border, _cssBorderCache);
+
+ //set info for margin
+ _marginX = margin.l + margin.r;
+ _marginY = margin.t + margin.b;
+ margin.c = checkCacheTRBL(margin, _cssMarginCache);
+
+ //set info for css max value
+ cssMaxValue.ih = parseToZeroOrNumber(cssMaxValue.h); //ih = integer height
+ cssMaxValue.iw = parseToZeroOrNumber(cssMaxValue.w); //iw = integer width
+ cssMaxValue.ch = cssMaxValue.h.indexOf('px') > -1; //ch = correct height
+ cssMaxValue.cw = cssMaxValue.w.indexOf('px') > -1; //cw = correct width
+ cssMaxValue.c = checkCacheDouble(cssMaxValue, _cssMaxValueCache, force);
+
+ //refresh cache
+ _cssDirectionCache = cssDirection;
+ _cssBoxSizingCache = boxSizing;
+ _widthAutoCache = widthAuto;
+ _heightAutoCache = heightAuto;
+ _cssPaddingCache = padding;
+ _cssBorderCache = border;
+ _cssMarginCache = margin;
+ _cssMaxValueCache = cssMaxValue;
+
+ //IEFix direction changed
+ if (cssDirectionChanged && _sizeAutoObserverAdded)
+ _sizeAutoObserverElement.css(_strFloat, isRTLRight);
+
+ //apply padding:
+ if (padding.c || cssDirectionChanged || paddingAbsoluteChanged || widthAutoChanged || heightAutoChanged || boxSizingChanged || sizeAutoCapableChanged) {
+ var paddingElementCSS = {};
+ var textareaCSS = {};
+ setTopRightBottomLeft(contentGlueElementCSS, _strMarginMinus, [-padding.t, -padding.r, -padding.b, -padding.l]);
+ if (paddingAbsolute) {
+ setTopRightBottomLeft(paddingElementCSS, _strEmpty, [padding.t, padding.r, padding.b, padding.l]);
+ if (_isTextarea)
+ setTopRightBottomLeft(textareaCSS, _strPaddingMinus);
+ else
+ setTopRightBottomLeft(contentElementCSS, _strPaddingMinus);
+ }
+ else {
+ setTopRightBottomLeft(paddingElementCSS, _strEmpty);
+ if (_isTextarea)
+ setTopRightBottomLeft(textareaCSS, _strPaddingMinus, [padding.t, padding.r, padding.b, padding.l]);
+ else
+ setTopRightBottomLeft(contentElementCSS, _strPaddingMinus, [padding.t, padding.r, padding.b, padding.l]);
+ }
+ _paddingElement.css(paddingElementCSS);
+ _targetElement.css(textareaCSS);
+ }
+
+ //viewport size is padding container because it never has padding, margin and a border.
+ _viewportSize = getViewportSize();
+
+ //update Textarea
+ var textareaSize = _isTextarea ? textareaUpdate() : false;
+
+ //fix height auto / width auto in cooperation with current padding & boxSizing behavior:
+ if (heightAuto && (heightAutoChanged || paddingAbsoluteChanged || boxSizingChanged || cssMaxValue.c || padding.c || border.c)) {
+ if (cssMaxValue.cw)
+ contentElementCSS[_strMaxMinus + _strHeight] =
+ (cssMaxValue.ch ? (cssMaxValue.ih - padding.ay + (_isBorderBox ? -_borderY : _paddingY))
+ : _strEmpty);
+ contentElementCSS[_strHeight] = _strAuto;
+ }
+ else if (heightAutoChanged || paddingAbsoluteChanged) {
+ contentElementCSS[_strMaxMinus + _strHeight] = _strEmpty;
+ contentElementCSS[_strHeight] = _strHundredPercent;
+ }
+ if (widthAuto && (widthAutoChanged || paddingAbsoluteChanged || boxSizingChanged || cssMaxValue.c || padding.c || border.c || cssDirectionChanged)) {
+ if (cssMaxValue.cw)
+ contentElementCSS[_strMaxMinus + _strWidth] =
+ (cssMaxValue.cw ? (cssMaxValue.iw - padding.ax + (_isBorderBox ? -_borderX : _paddingX)) +
+ (_nativeScrollbarIsOverlaid.y /*&& _hasOverflowCache.y && widthAuto */ ? _overlayScrollbarDummySize.y : 0)
+ : _strEmpty);
+ contentElementCSS[_strWidth] = _strAuto;
+ contentGlueElementCSS[_strMaxMinus + _strWidth] = _strHundredPercent; //IE Fix
+ }
+ else if (widthAutoChanged || paddingAbsoluteChanged) {
+ contentElementCSS[_strMaxMinus + _strWidth] = _strEmpty;
+ contentElementCSS[_strWidth] = _strHundredPercent;
+ contentElementCSS[_strFloat] = _strEmpty;
+ contentGlueElementCSS[_strMaxMinus + _strWidth] = _strEmpty; //IE Fix
+ }
+ if (widthAuto) {
+ if (!cssMaxValue.cw)
+ contentElementCSS[_strMaxMinus + _strWidth] = _strEmpty;
+ contentGlueElementCSS[_strWidth] = _isTextarea && textareaDynWidth ? textareaSize.dw : _strAuto;
+
+ contentElementCSS[_strWidth] = _strAuto;
+ contentElementCSS[_strFloat] = isRTLRight;
+ }
+ if (heightAuto) {
+ if (!cssMaxValue.ch)
+ contentElementCSS[_strMaxMinus + _strHeight] = _strEmpty;
+ //fix dyn height collapse bug: (doesn't works for width!)
+ //contentGlueElementCSS[_strHeight] = _isTextarea && textareaDynHeight ? textareaSize.dh : _strAuto;
+ contentGlueElementCSS[_strHeight] = _isTextarea ? textareaDynHeight ? textareaSize.dh : _strAuto : _contentElement[0][LEXICON.cH];
+ }
+ if (sizeAutoCapable)
+ _contentGlueElement.css(contentGlueElementCSS);
+ _contentElement.css(contentElementCSS);
+
+ //CHECKPOINT HERE ~
+ contentElementCSS = {};
+ contentGlueElementCSS = {};
+
+ //if [content(host) client / scroll size, or target element direction, or content(host) max-sizes] changed, or force is true
+ if (hostSizeChanged || contentSizeChanged || cssDirectionChanged || boxSizingChanged || paddingAbsoluteChanged || widthAutoChanged || widthAuto || heightAutoChanged || heightAuto || cssMaxValue.c || ignoreOverlayScrollbarHidingChanged || overflowBehaviorChanged || clipAlwaysChanged || resizeChanged || scrollbarsVisibilityChanged || textareaDynWidthChanged || textareaDynHeightChanged || textareaAutoWrappingChanged || force) {
+ var strOverflow = 'overflow';
+ var strOverflowX = strOverflow + '-x';
+ var strOverflowY = strOverflow + '-y';
+ var strHidden = 'hidden';
+ var strVisible = 'visible';
+ //decide whether the content overflow must get hidden for correct overflow measuring, it MUST be always hidden if the height is auto
+ var hideOverflow4CorrectMeasuring = _restrictedMeasuring ?
+ (_nativeScrollbarIsOverlaid.x || _nativeScrollbarIsOverlaid.y) || //it must be hidden if native scrollbars are overlaid
+ (_viewportSize.w < _nativeScrollbarMinSize.y || _viewportSize.h < _nativeScrollbarMinSize.x) || //it must be hidden if host-element is too small
+ heightAuto || displayIsHiddenChanged //it must be hidden if height is auto or display was change
+ : heightAuto; //if there is not the restricted Measuring bug, it must be hidden if the height is auto
+
+ //Reset the viewport (very important for natively overlaid scrollbars and zoom change
+ var viewportElementResetCSS = {};
+ var resetXTmp = _hasOverflowCache.y && _hideOverflowCache.ys && !ignoreOverlayScrollbarHiding ? (_nativeScrollbarIsOverlaid.y ? _viewportElement.css(isRTLLeft) : -_nativeScrollbarSize.y) : 0;
+ var resetBottomTmp = _hasOverflowCache.x && _hideOverflowCache.xs && !ignoreOverlayScrollbarHiding ? (_nativeScrollbarIsOverlaid.x ? _viewportElement.css(_strBottom) : -_nativeScrollbarSize.x) : 0;
+ setTopRightBottomLeft(viewportElementResetCSS, _strEmpty);
+ _viewportElement.css(viewportElementResetCSS);
+ if(hideOverflow4CorrectMeasuring)
+ _contentElement.css(strOverflow, strHidden);
+
+ //measure several sizes:
+ var contentMeasureElement = getContentMeasureElement();
+ //in Firefox content element has to have overflow hidden, else element margins aren't calculated properly, this element prevents this bug, but only if scrollbars aren't overlaid
+ var contentMeasureElementGuaranty = _restrictedMeasuring && !hideOverflow4CorrectMeasuring ? _viewportElement[0] : contentMeasureElement;
+ var clientSize = {
+ w: contentMeasureElement[LEXICON.cW],
+ h: contentMeasureElement[LEXICON.cH]
+ };
+ var scrollSize = {
+ w: Math.max(contentMeasureElement[LEXICON.sW], contentMeasureElementGuaranty[LEXICON.sW]),
+ h: Math.max(contentMeasureElement[LEXICON.sH], contentMeasureElementGuaranty[LEXICON.sH])
+ };
+ var contentClientSize = {
+ w: _isTextarea && textareaSize && !textareaDynWidth ? textareaSize.ow : widthAuto ? clientSize.w : scrollSize.w,
+ h: _isTextarea && textareaSize && !textareaDynHeight ? textareaSize.oh : heightAuto ? clientSize.h : scrollSize.h
+ };
+
+ //apply the correct viewport style and measure viewport size
+ viewportElementResetCSS[_strBottom] = wasHeightAuto ? _strEmpty : resetBottomTmp;
+ viewportElementResetCSS[isRTLLeft] = wasWidthAuto ? _strEmpty : resetXTmp;
+ _viewportElement.css(viewportElementResetCSS);
+ //viewport size is padding container because it never has padding, margin and a border.
+ _viewportSize = getViewportSize();
+
+ //measure and correct several sizes
+ //has to be clientSize because offsetSize respect borders.
+ var hostSize = getHostSize();
+ var contentGlueSize = {
+ w: Math.max(contentClientSize.w + padding.ax, hostSize.w - _paddingX) - (textareaDynWidth ? (_isTextarea && widthAuto ? _marginX + (!_isBorderBox ? _paddingX + _borderX : 0) : 0) : 0),
+ h: Math.max(contentClientSize.h + padding.ay, hostSize.h - _paddingY)
+ };
+ contentGlueSize.c = checkCacheDouble(contentGlueSize, _contentGlueSizeCache, force);
+ _contentGlueSizeCache = contentGlueSize;
+
+ //apply correct contentGlue size
+ if (sizeAutoCapable) {
+ //size contentGlue correctly to make sure the element has correct size if the sizing switches to auto
+ if (contentGlueSize.c || (heightAuto || widthAuto)) {
+ contentGlueElementCSS[_strWidth] = contentGlueSize.w;
+ contentGlueElementCSS[_strHeight] = contentGlueSize.h;
+ }
+
+ var maxWidth = contentGlueElementCSS[_strWidth] + (_isBorderBox ? _borderX : -_paddingX);
+ var maxHeight = contentGlueElementCSS[_strHeight] + (_isBorderBox ? _borderY : -_paddingX);
+ var textareaCoverCSS = {};
+
+ //make contentGlue size -1 if element is not auto sized, to make sure that a resize event happens when the element shrinks
+ if (!widthAuto || (!widthAuto && border.c))
+ contentGlueElementCSS[_strWidth] = hostSize.w - (_isBorderBox ? 0 : _paddingX + _borderX) - 1 - _marginX;
+ if (!heightAuto || (!heightAuto && border.c))
+ contentGlueElementCSS[_strHeight] = hostSize.h - (_isBorderBox ? 0 : _paddingY + _borderY) - 1 - _marginY;
+
+ //if size is auto and host is same size as max size, make content glue size +1 to make sure size changes will be detected
+ if (cssMaxValue.cw && cssMaxValue.iw === maxWidth)
+ contentGlueElementCSS[_strWidth] = maxWidth + (_isBorderBox ? 0 : _paddingX) + 1;
+ if (cssMaxValue.ch && cssMaxValue.ih === maxHeight)
+ contentGlueElementCSS[_strHeight] = maxHeight + (_isBorderBox ? 0 : _paddingY) + 1;
+
+ //if size is auto and host is smaller than size as min size, make content glue size -1 to make sure size changes will be detected (this is only needed if padding is 0)
+ if (widthAuto && (clientSize.w < _viewportSize.w || _isTextarea && !textareaAutoWrapping) && _paddingX === 0) {
+ if (_isTextarea)
+ textareaCoverCSS[_strWidth] = parseToZeroOrNumber(_textareaCoverElement.css(_strWidth)) - 1;
+ contentGlueElementCSS[_strWidth] -= 1;
+ }
+ if (heightAuto && (clientSize.h < _viewportSize.h || _isTextarea) && _paddingY === 0) {
+ if (_isTextarea)
+ textareaCoverCSS[_strHeight] = parseToZeroOrNumber(_textareaCoverElement.css(_strHeight)) - 1;
+ contentGlueElementCSS[_strHeight] -= 1;
+ }
+
+ //make sure content glue size at least 1
+ if (contentClientSize.h > 0) {
+ contentGlueElementCSS[_strWidth] = Math.max(1, contentGlueElementCSS[_strWidth]);
+ contentGlueElementCSS[_strHeight] = Math.max(1, contentGlueElementCSS[_strHeight]);
+ }
+
+ if (_isTextarea)
+ _textareaCoverElement.css(textareaCoverCSS);
+ _contentGlueElement.css(contentGlueElementCSS);
+ }
+ if (widthAuto)
+ contentElementCSS[_strWidth] = _strHundredPercent;
+ if (widthAuto && !_isBorderBox && !_mutationObserverConnected)
+ contentElementCSS[_strFloat] = 'none';
+
+
+ //apply and reset content style
+ _contentElement.css(contentElementCSS);
+ contentElementCSS = {};
+
+ //measure again, but this time all correct sizes:
+ var contentBCRect = contentMeasureElement.getBoundingClientRect();
+ var contentBCRectW = contentBCRect[_strWidth] || 0;
+ var contentBCRectH = contentBCRect[_strHeight] || 0;
+ var contentScrollSize = {
+ w: Math.max(contentMeasureElement[LEXICON.sW], contentMeasureElementGuaranty[LEXICON.sW]) + parseToZeroOrNumber(contentBCRectW) - contentBCRectW,
+ h: Math.max(contentMeasureElement[LEXICON.sH], contentMeasureElementGuaranty[LEXICON.sH]) + parseToZeroOrNumber(contentBCRectH) - contentBCRectH
+ };
+ contentScrollSize.c = contentSizeChanged = checkCacheDouble(contentScrollSize, _contentScrollSizeCache, force);
+ _contentScrollSizeCache = contentScrollSize;
+
+ if(hideOverflow4CorrectMeasuring)
+ _contentElement.css(strOverflow, _strEmpty);
+
+ //refresh viewport size after correct measuring
+ _viewportSize = getViewportSize();
+
+ //has to be clientSize because offsetSize respect borders.
+ hostSize = getHostSize();
+ hostSizeChanged = checkCacheDouble(hostSize, _hostSizeCache);
+ _hostSizeCache = hostSize;
+
+ var overflowBehaviorIsVS = {
+ x: overflowBehavior.x === 'v-s',
+ y: overflowBehavior.y === 'v-s'
+ };
+ var overflowBehaviorIsVH = {
+ x: overflowBehavior.x === 'v-h',
+ y: overflowBehavior.y === 'v-h'
+ };
+ var overflowBehaviorIsS = {
+ x: overflowBehavior.x === 's',
+ y: overflowBehavior.y === 's'
+ };
+ var overflowAmount = {
+ x: Math.max(0, Math.round((contentScrollSize.w - _viewportSize.w) * 100) / 100),
+ y: Math.max(0, Math.round((contentScrollSize.h - _viewportSize.h) * 100) / 100)
+ };
+ var hideOverflowForceTextarea = _isTextarea && (_viewportSize.w === 0 || _viewportSize.h === 0);
+ var hideOverflowForceRounding = (_viewportElement[0].scrollLeftMax === 0 && overflowAmount.x > 0 && overflowAmount.x < 1) || (_viewportElement[0].scrollTopMax === 0 && overflowAmount.y > 0 && overflowAmount.y < 1);
+ if (hideOverflowForceTextarea || hideOverflowForceRounding)
+ overflowAmount.x = overflowAmount.y = 0;
+ var hasOverflow = {
+ x: overflowAmount.x > 0,
+ y: overflowAmount.y > 0
+ };
+ //hideOverflow:
+ //x || y : true === overflow is hidden by "overflow: scroll" OR "overflow: hidden"
+ //xs || ys : true === overflow is hidden by "overflow: scroll"
+ var hideOverflow = {x: hasOverflow.x, y: hasOverflow.y};
+ if (overflowBehaviorIsVS.x || overflowBehaviorIsVH.x)
+ hideOverflow.x = (hasOverflow.y && !overflowBehaviorIsVS.y && !overflowBehaviorIsVH.y);
+ if (overflowBehaviorIsVS.y || overflowBehaviorIsVH.y)
+ hideOverflow.y = (hasOverflow.x && !overflowBehaviorIsVS.x && !overflowBehaviorIsVH.x);
+ hideOverflow.xs = hideOverflow.x ? (overflowBehaviorIsS.x || overflowBehaviorIsVS.x) : false;
+ hideOverflow.ys = hideOverflow.y ? (overflowBehaviorIsS.y || overflowBehaviorIsVS.y) : false;
+
+ var canScroll = {
+ x: hasOverflow.x && hideOverflow.xs,
+ y: hasOverflow.y && hideOverflow.ys
+ };
+ var previousOverflow = _overflowAmountCache;
+ overflowAmount.c = checkCacheDouble(overflowAmount, _overflowAmountCache, _strX, _strY, force);
+ _overflowAmountCache = overflowAmount;
+ hasOverflow.c = checkCacheDouble(hasOverflow, _hasOverflowCache, _strX, _strY, force);
+ _hasOverflowCache = hasOverflow;
+ hideOverflow.c = checkCacheDouble(hideOverflow, _hideOverflowCache, _strX, _strY, force);
+ _hideOverflowCache = hideOverflow;
+
+ //if native scrollbar is overlay at x OR y axis, prepare DOM
+ if (_nativeScrollbarIsOverlaid.x || _nativeScrollbarIsOverlaid.y) {
+ var borderDesign = 'px solid transparent';
+ var contentArrangeElementCSS = { };
+ var arrangeContent = { };
+ var arrangeChanged = force;
+ if (hasOverflow.x || hasOverflow.y) {
+ arrangeContent.w = _nativeScrollbarIsOverlaid.y && hasOverflow.y ? contentScrollSize.w + _overlayScrollbarDummySize.y : _strEmpty;
+ arrangeContent.h = _nativeScrollbarIsOverlaid.x && hasOverflow.x ? contentScrollSize.h + _overlayScrollbarDummySize.x : _strEmpty;
+ arrangeChanged = checkCacheSingle(arrangeContent, _arrangeContentSizeCache, force);
+ _arrangeContentSizeCache = arrangeContent;
+ }
+
+ if (hasOverflow.c || hideOverflow.c || contentScrollSize.c || cssDirectionChanged || widthAutoChanged || heightAutoChanged || widthAuto || heightAuto || ignoreOverlayScrollbarHidingChanged) {
+ contentElementCSS[_strMarginMinus + isRTLRight] = contentElementCSS[_strBorderMinus + isRTLRight] = _strEmpty;
+ if (_nativeScrollbarIsOverlaid.x && hasOverflow.x && hideOverflow.xs) {
+ contentElementCSS[_strMarginMinus + _strBottom] = heightAuto ? (ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize.x) : _strEmpty;
+ contentElementCSS[_strBorderMinus + _strBottom] = (!heightAuto && !ignoreOverlayScrollbarHiding) ? (_overlayScrollbarDummySize.x + borderDesign) : _strEmpty;
+ }
+ else {
+ arrangeContent.h =
+ contentElementCSS[_strMarginMinus + _strBottom] =
+ contentElementCSS[_strBorderMinus + _strBottom] = _strEmpty;
+ arrangeChanged = true;
+ }
+ if (_nativeScrollbarIsOverlaid.y && hasOverflow.y && hideOverflow.ys) {
+ contentElementCSS[_strMarginMinus + isRTLLeft] = widthAuto ? (ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize.y) : _strEmpty;
+ contentElementCSS[_strBorderMinus + isRTLLeft] = (/* !widthAuto && */ !ignoreOverlayScrollbarHiding) ? (_overlayScrollbarDummySize.y + borderDesign) : _strEmpty;
+ }
+ else {
+ arrangeContent.w =
+ contentElementCSS[_strMarginMinus + isRTLLeft] =
+ contentElementCSS[_strBorderMinus + isRTLLeft] = _strEmpty;
+ arrangeChanged = true;
+ }
+ }
+ if (ignoreOverlayScrollbarHiding) {
+ arrangeContent.w = arrangeContent.h = _strEmpty;
+ arrangeChanged = true;
+ }
+ if (arrangeChanged) {
+ contentArrangeElementCSS[_strWidth] = hideOverflow.y ? arrangeContent.w : _strEmpty;
+ contentArrangeElementCSS[_strHeight] = hideOverflow.x ? arrangeContent.h : _strEmpty;
+
+ if (!_contentArrangeElement) {
+ _contentArrangeElement = FRAMEWORK(generateDiv(_classNameContentArrangeElement));
+ _viewportElement.prepend(_contentArrangeElement);
+ }
+ _contentArrangeElement.css(contentArrangeElementCSS);
+ }
+ _contentElement.css(contentElementCSS);
+ }
+
+ var viewportElementCSS = {};
+ var paddingElementCSS = {};
+ if (hostSizeChanged || hasOverflow.c || hideOverflow.c || contentScrollSize.c || overflowBehaviorChanged || boxSizingChanged || ignoreOverlayScrollbarHidingChanged || cssDirectionChanged || clipAlwaysChanged || heightAutoChanged) {
+ viewportElementCSS[isRTLRight] = _strEmpty;
+ var resetScrollbarHidingX = function () {
+ viewportElementCSS[_strBottom] = _strEmpty;
+ _contentBorderSize.h = 0;
+ };
+ var resetScrollbarHidingY = function () {
+ viewportElementCSS[isRTLLeft] = _strEmpty;
+ _contentBorderSize.w = 0;
+ };
+ if (hasOverflow.x && hideOverflow.xs) {
+ viewportElementCSS[strOverflowX] = _strScroll;
+ if (!ignoreOverlayScrollbarHiding) {
+ viewportElementCSS[_strBottom] = -(_nativeScrollbarIsOverlaid.x ? _overlayScrollbarDummySize.x : _nativeScrollbarSize.x);
+ _contentBorderSize.h = _nativeScrollbarIsOverlaid.x ? _overlayScrollbarDummySize.y : 0;
+ }
+ else
+ resetScrollbarHidingX();
+ } else {
+ viewportElementCSS[strOverflowX] = _strEmpty;
+ resetScrollbarHidingX();
+ }
+ if (hasOverflow.y && hideOverflow.ys) {
+ viewportElementCSS[strOverflowY] = _strScroll;
+ if (!ignoreOverlayScrollbarHiding) {
+ viewportElementCSS[isRTLLeft] = -(_nativeScrollbarIsOverlaid.y ? _overlayScrollbarDummySize.y : _nativeScrollbarSize.y);
+ _contentBorderSize.w = _nativeScrollbarIsOverlaid.y ? _overlayScrollbarDummySize.x : 0;
+ }
+ else
+ resetScrollbarHidingY();
+ } else {
+ viewportElementCSS[strOverflowY] = _strEmpty;
+ resetScrollbarHidingY();
+ }
+
+ // if the scroll container is too small and if there is any overflow with not overlay scrollbar, make viewport element greater in size (Firefox hide Scrollbars fix)
+ // because firefox starts hiding scrollbars on too small elements
+ // with this behavior the overflow calculation may be incorrect or the scrollbars would appear suddenly
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=292284
+ if ((_viewportSize.h < _nativeScrollbarMinSize.x || _viewportSize.w < _nativeScrollbarMinSize.y)
+ && ((hasOverflow.x && hideOverflow.x && !_nativeScrollbarIsOverlaid.x) || (hasOverflow.y && hideOverflow.y && !_nativeScrollbarIsOverlaid.y))) {
+ viewportElementCSS[_strPaddingMinus + _strTop] = _nativeScrollbarMinSize.x;
+ viewportElementCSS[_strMarginMinus + _strTop] = -_nativeScrollbarMinSize.x;
+
+ viewportElementCSS[_strPaddingMinus + isRTLRight] = _nativeScrollbarMinSize.y;
+ viewportElementCSS[_strMarginMinus + isRTLRight] = -_nativeScrollbarMinSize.y;
+ }
+ else {
+ viewportElementCSS[_strPaddingMinus + _strTop] =
+ viewportElementCSS[_strMarginMinus + _strTop] =
+ viewportElementCSS[_strPaddingMinus + isRTLRight] =
+ viewportElementCSS[_strMarginMinus + isRTLRight] = _strEmpty;
+ }
+ viewportElementCSS[_strPaddingMinus + isRTLLeft] =
+ viewportElementCSS[_strMarginMinus + isRTLLeft] = _strEmpty;
+
+ //if there is any overflow (x OR y axis) and this overflow shall be hidden, make overflow hidden, else overflow visible
+ if ((hasOverflow.x && hideOverflow.x) || (hasOverflow.y && hideOverflow.y) || hideOverflowForceTextarea) {
+ //only hide if is Textarea
+ if (_isTextarea && hideOverflowForceTextarea) {
+ paddingElementCSS[strOverflowX] =
+ paddingElementCSS[strOverflowY] = strHidden;
+ }
+ }
+ else {
+ if (!clipAlways || (overflowBehaviorIsVH.x || overflowBehaviorIsVS.x || overflowBehaviorIsVH.y || overflowBehaviorIsVS.y)) {
+ //only un-hide if Textarea
+ if (_isTextarea) {
+ paddingElementCSS[strOverflowX] =
+ paddingElementCSS[strOverflowY] = _strEmpty;
+ }
+ viewportElementCSS[strOverflowX] =
+ viewportElementCSS[strOverflowY] = strVisible;
+ }
+ }
+
+ _paddingElement.css(paddingElementCSS);
+ _viewportElement.css(viewportElementCSS);
+ viewportElementCSS = { };
+
+ //force soft redraw in webkit because without the scrollbars will may appear because DOM wont be redrawn under special conditions
+ if ((hasOverflow.c || boxSizingChanged || widthAutoChanged || heightAutoChanged) && !(_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y)) {
+ var element = _contentElement[0];
+ var elementStyle = element[LEXICON.s];
+ var dump;
+ elementStyle.webkitTransform = 'scale(1)';
+ elementStyle.display = 'run-in';
+ dump = element[LEXICON.oH];
+ elementStyle.display = _strEmpty; //|| dump; //use dump to prevent it from deletion if minify
+ elementStyle.webkitTransform = _strEmpty;
+ }
+ //force hard redraw in webkit if native overlaid scrollbars shall appear
+ if (ignoreOverlayScrollbarHidingChanged && ignoreOverlayScrollbarHiding) {
+ //_hostElement.hide();
+ //var dump = hostElement[LEXICON.oH];
+ //_hostElement.show();
+ }
+ }
+
+ //change to direction RTL and width auto Bugfix in Webkit
+ //without this fix, the DOM still thinks the scrollbar is LTR and thus the content is shifted to the left
+ contentElementCSS = {};
+ if (cssDirectionChanged || widthAutoChanged || heightAutoChanged) {
+ if (_isRTL && widthAuto) {
+ var floatTmp = _contentElement.css(_strFloat);
+ var posLeftWithoutFloat = Math.round(_contentElement.css(_strFloat, _strEmpty).css(_strLeft, _strEmpty).position().left);
+ _contentElement.css(_strFloat, floatTmp);
+ var posLeftWithFloat = Math.round(_contentElement.position().left);
+
+ if (posLeftWithoutFloat !== posLeftWithFloat)
+ contentElementCSS[_strLeft] = posLeftWithoutFloat;
+ }
+ else {
+ contentElementCSS[_strLeft] = _strEmpty;
+ }
+ }
+ _contentElement.css(contentElementCSS);
+
+ //scrollbars management:
+ var scrollbarsVisibilityVisible = scrollbarsVisibility === 'v';
+ var scrollbarsVisibilityHidden = scrollbarsVisibility === 'h';
+ var scrollbarsVisibilityAuto = scrollbarsVisibility === 'a';
+
+ var showScrollbarH = COMPATIBILITY.bind(refreshScrollbarAppearance, 0, true, true, canScroll.x);
+ var showScrollbarV = COMPATIBILITY.bind(refreshScrollbarAppearance, 0, false, true, canScroll.y);
+ var hideScrollbarH = COMPATIBILITY.bind(refreshScrollbarAppearance, 0, true, false, canScroll.x);
+ var hideScrollbarV = COMPATIBILITY.bind(refreshScrollbarAppearance, 0, false, false, canScroll.y);
+
+ //manage class name which indicates scrollable overflow
+ if (hideOverflow.x || hideOverflow.y)
+ addClass(_hostElement, _classNameHostOverflow);
+ else
+ removeClass(_hostElement, _classNameHostOverflow);
+ if (hideOverflow.x)
+ addClass(_hostElement, _classNameHostOverflowX);
+ else
+ removeClass(_hostElement, _classNameHostOverflowX);
+ if (hideOverflow.y)
+ addClass(_hostElement, _classNameHostOverflowY);
+ else
+ removeClass(_hostElement, _classNameHostOverflowY);
+
+ //add or remove rtl class name for styling purposes
+ if (cssDirectionChanged) {
+ if (_isRTL)
+ addClass(_hostElement, _classNameHostRTL);
+ else
+ removeClass(_hostElement, _classNameHostRTL);
+ }
+
+ //manage the resize feature (CSS3 resize "polyfill" for this plugin)
+ if (_isBody)
+ addClass(_hostElement, _classNameHostResizeDisabled);
+ if (resizeChanged) {
+ var addCornerEvents = function () { _scrollbarCornerElement.on(_strMouseTouchDownEvent, scrollbarCornerOnMouseDown); };
+ var removeCornerEvents = function () { _scrollbarCornerElement.off(_strMouseTouchDownEvent, scrollbarCornerOnMouseDown); };
+ if (_resizeNone) {
+ addClass(_hostElement, _classNameHostResizeDisabled);
+ removeClass(_scrollbarCornerElement, [
+ _classNameScrollbarCornerResize,
+ _classNameScrollbarCornerResizeB,
+ _classNameScrollbarCornerResizeH,
+ _classNameScrollbarCornerResizeV].join(_strSpace));
+ removeCornerEvents();
+ }
+ else {
+ removeClass(_hostElement, _classNameHostResizeDisabled);
+ addClass(_scrollbarCornerElement, _classNameScrollbarCornerResize);
+ if (_resizeBoth)
+ addClass(_scrollbarCornerElement, _classNameScrollbarCornerResizeB);
+ else if (_resizeHorizontal)
+ addClass(_scrollbarCornerElement, _classNameScrollbarCornerResizeH);
+ else if (_resizeVertical)
+ addClass(_scrollbarCornerElement, _classNameScrollbarCornerResizeV);
+
+ removeCornerEvents();
+ addCornerEvents();
+ }
+ }
+
+ //manage the scrollbars general visibility + the scrollbar interactivity (unusable class name)
+ if (scrollbarsVisibilityChanged || overflowBehaviorChanged || hideOverflow.c || hasOverflow.c || ignoreOverlayScrollbarHidingChanged) {
+ if (ignoreOverlayScrollbarHiding) {
+ if (ignoreOverlayScrollbarHidingChanged) {
+ removeClass(_hostElement, _classNameHostScrolling);
+ if (ignoreOverlayScrollbarHiding) {
+ hideScrollbarH();
+ hideScrollbarV();
+ }
+ }
+ }
+ else if (scrollbarsVisibilityAuto) {
+ if (canScroll.x)
+ showScrollbarH();
+ else
+ hideScrollbarH();
+
+ if (canScroll.y)
+ showScrollbarV();
+ else
+ hideScrollbarV();
+ }
+ else if (scrollbarsVisibilityVisible) {
+ showScrollbarH();
+ showScrollbarV();
+ }
+ else if (scrollbarsVisibilityHidden) {
+ hideScrollbarH();
+ hideScrollbarV();
+ }
+ }
+
+ //manage the scrollbars auto hide feature (auto hide them after specific actions)
+ if (scrollbarsAutoHideChanged || ignoreOverlayScrollbarHidingChanged) {
+ var addMouseTouchEvents = function (move) {
+ if (_supportPassiveEvents) {
+ if(move)
+ addPassiveEventListener(_hostElement, _strMouseTouchMoveEvent, hostOnMouseMove);
+ else {
+ addPassiveEventListener(_hostElement, _strMouseTouchEnter, hostOnMouseEnter);
+ addPassiveEventListener(_hostElement, _strMouseTouchLeave, hostOnMouseLeave);
+ }
+ }
+ else {
+ if(move)
+ _hostElement.on(_strMouseTouchMoveEvent, hostOnMouseMove);
+ else {
+ _hostElement.on(_strMouseTouchEnter, hostOnMouseEnter)
+ .on(_strMouseTouchLeave, hostOnMouseLeave);
+ }
+ }
+
+ //if the plugin is initialized and the mouse is over the host element, make the scrollbars visible
+ if(!_initialized)
+ _hostElement.one("mouseover", hostOnMouseEnter);
+ };
+ var removeMouseTouchEvents = function () {
+ if (_supportPassiveEvents) {
+ removePassiveEventListener(_hostElement, _strMouseTouchMoveEvent, hostOnMouseMove);
+ removePassiveEventListener(_hostElement, _strMouseTouchEnter, hostOnMouseEnter);
+ removePassiveEventListener(_hostElement, _strMouseTouchLeave, hostOnMouseLeave);
+ }
+ else {
+ _hostElement.off(_strMouseTouchMoveEvent, hostOnMouseMove)
+ .off(_strMouseTouchEnter, hostOnMouseEnter)
+ .off(_strMouseTouchLeave, hostOnMouseLeave);
+ }
+ };
+ if (_scrollbarsAutoHideLeave || _scrollbarsAutoHideMove) {
+ removeMouseTouchEvents();
+ addMouseTouchEvents(_scrollbarsAutoHideMove);
+ }
+ else {
+ removeMouseTouchEvents();
+ }
+
+ if (_scrollbarsAutoHideNever)
+ refreshScrollbarsAutoHide(true);
+ else
+ refreshScrollbarsAutoHide(false, true);
+ }
+
+ //manage scrollbars handle length and offset
+ if (hostSizeChanged || overflowAmount.c || heightAutoChanged || widthAutoChanged || resizeChanged || boxSizingChanged || paddingAbsoluteChanged || ignoreOverlayScrollbarHidingChanged || cssDirectionChanged) {
+ refreshScrollbarHandleLength(true);
+ refreshScrollbarHandleOffset(true, currScroll.l);
+ refreshScrollbarHandleLength(false);
+ refreshScrollbarHandleOffset(false, currScroll.t);
+ }
+
+ //manage interactivity
+ if (scrollbarsClickScrollingChanged)
+ refreshScrollbarsInteractive(true, scrollbarsClickScrolling);
+ if (scrollbarsDragScrollingChanged)
+ refreshScrollbarsInteractive(false, scrollbarsDragScrolling);
+
+ //handle scroll
+ if (_isTextarea && contentSizeChanged) {
+ var textareaInfo = getTextareaInfo();
+ if (textareaInfo) {
+ var textareaRowsChanged = _textareaInfoCache === undefined ? true : textareaInfo.rows !== _textareaInfoCache.rows;
+ var cursorRow = textareaInfo.cR;
+ var cursorCol = textareaInfo.cC;
+ var widestRow = textareaInfo.w;
+ var lastRow = textareaInfo.r;
+ var lastCol = textareaInfo.c;
+ var cursorPos = textareaInfo.p;
+ var cursorMax = textareaInfo.m;
+ var cursorIsLastPosition = (cursorMax === cursorPos && _textareaHasFocus);
+ var doScroll = {
+ x: (!textareaAutoWrapping && (cursorCol === lastCol && cursorRow === widestRow)) ? _overflowAmountCache.x : -1,
+ y: (textareaAutoWrapping ? cursorIsLastPosition || textareaRowsChanged && (previousOverflow !== undefined ? (currScroll.t === previousOverflow.y) : false) : (cursorIsLastPosition || textareaRowsChanged) && cursorRow === lastRow) ? _overflowAmountCache.y : -1
+ };
+ var doScrollX = doScroll.x > -1;
+ var doScrollY = doScroll.y > -1;
+
+ if (doScrollX || doScrollY) {
+ if (doScrollY)
+ _viewportElement[_strScrollTop](doScroll.y);
+ if (doScrollX) {
+ if (_isRTL && _normalizeRTLCache && _rtlScrollBehavior.i)
+ _viewportElement[_strScrollLeft](0); //if inverted, scroll to 0 -> normalized this means to max scroll offset.
+ else
+ _viewportElement[_strScrollLeft](doScroll.x);
+ }
+ }
+ }
+ _textareaInfoCache = textareaInfo;
+ }
+ else if (!_isTextarea) {
+ if (_isRTL && _rtlScrollBehavior.i && _nativeScrollbarIsOverlaid.y && hasOverflow.x && _normalizeRTLCache)
+ currScroll.l += _contentBorderSize.w || 0;
+ _viewportElement[_strScrollLeft](currScroll.l);
+ _viewportElement[_strScrollTop](currScroll.t);
+ }
+
+ if (cssDirectionChanged) {
+ callCallback("onDirectionChanged", {
+ isRTL: _isRTL,
+ dir: cssDirection
+ });
+ }
+ if (hostSizeChanged) {
+ callCallback("onHostSizeChanged", {
+ width: _hostSizeCache.w,
+ height: _hostSizeCache.h
+ });
+ }
+ if (contentSizeChanged) {
+ callCallback("onContentSizeChanged", {
+ width: _contentScrollSizeCache.w,
+ height: _contentScrollSizeCache.h
+ });
+ }
+ if (hasOverflow.c || hideOverflow.c) {
+ callCallback("onOverflowChanged", {
+ x: hasOverflow.x,
+ y: hasOverflow.y,
+ xScrollable: hideOverflow.xs,
+ yScrollable: hideOverflow.ys,
+ clipped: hideOverflow.x || hideOverflow.y
+ });
+ }
+ if (overflowAmount.c) {
+ callCallback("onOverflowAmountChanged", {
+ x: overflowAmount.x,
+ y: overflowAmount.y
+ });
+ }
+ }
+
+ //fix body min size
+ if (_isBody && (_hasOverflowCache.c || _bodyMinSizeCache.c)) {
+ //its possible that no min size was measured until now, because the content arrange element was just added now, in this case, measure now the min size.
+ if (!_bodyMinSizeCache.f)
+ bodyMinSizeChanged();
+ if (_nativeScrollbarIsOverlaid.y && _hasOverflowCache.x)
+ _contentElement.css(_strMinMinus + _strWidth, _bodyMinSizeCache.w + _overlayScrollbarDummySize.y);
+ if (_nativeScrollbarIsOverlaid.x && _hasOverflowCache.y)
+ _contentElement.css(_strMinMinus + _strHeight, _bodyMinSizeCache.h + _overlayScrollbarDummySize.x);
+ _bodyMinSizeCache.c = false;
+ }
+
+ unfreezeResizeObserver(_sizeObserverElement);
+ unfreezeResizeObserver(_sizeAutoObserverElement);
+
+ callCallback("onUpdated", { forced: force });
+ }
+
+
+ //==== Options ====//
+
+ /**
+ * Sets new options but doesn't call the update method.
+ * @param newOptions The object which contains the new options.
+ */
+ function setOptions(newOptions) {
+ _currentOptions = extend(true, {}, _currentOptions, _pluginsOptions.v(newOptions, _pluginsOptions.t, true));
+ _currentPreparedOptions = extend(true, {}, _currentPreparedOptions, _pluginsOptions.v(newOptions, _pluginsOptions.t, false, true));
+ }
+
+
+ //==== Scrollbars ====//
+
+ /**
+ * Builds all scrollbars if they aren't already build.
+ */
+ function buildScrollbars() {
+ _scrollbarHorizontalElement = FRAMEWORK(generateDiv(_classNameScrollbar + _strSpace + _classNameScrollbarHorizontal));
+ _scrollbarHorizontalTrackElement = FRAMEWORK(generateDiv(_classNameScrollbarTrack));
+ _scrollbarHorizontalHandleElement = FRAMEWORK(generateDiv(_classNameScrollbarHandle));
+ _scrollbarVerticalElement = FRAMEWORK(generateDiv(_classNameScrollbar + _strSpace + _classNameScrollbarVertical));
+ _scrollbarVerticalTrackElement = FRAMEWORK(generateDiv(_classNameScrollbarTrack));
+ _scrollbarVerticalHandleElement = FRAMEWORK(generateDiv(_classNameScrollbarHandle));
+
+ _scrollbarHorizontalElement.append(_scrollbarHorizontalTrackElement);
+ _scrollbarHorizontalTrackElement.append(_scrollbarHorizontalHandleElement);
+ _scrollbarVerticalElement.append(_scrollbarVerticalTrackElement);
+ _scrollbarVerticalTrackElement.append(_scrollbarVerticalHandleElement);
+
+ _paddingElement.after(_scrollbarVerticalElement);
+ _paddingElement.after(_scrollbarHorizontalElement);
+
+ //scrollbar events
+ if (_supportTransition) {
+ _scrollbarHorizontalElement.on(_strTransitionEndEvent, function (event) {
+ if (event.target !== _scrollbarHorizontalElement[0])
+ return;
+ refreshScrollbarHandleLength(true);
+ refreshScrollbarHandleOffset(true, _viewportElement[_strScrollLeft]());
+ });
+ _scrollbarVerticalElement.on(_strTransitionEndEvent, function (event) {
+ if (event.target !== _scrollbarVerticalElement[0])
+ return;
+ refreshScrollbarHandleLength(false);
+ refreshScrollbarHandleOffset(false, _viewportElement[_strScrollTop]());
+ });
+ }
+ initScrollbarInteractivity(true);
+ initScrollbarInteractivity(false);
+ _scrollbarCornerElement = FRAMEWORK(generateDiv(_classNameScrollbarCorner));
+ _hostElement.append(_scrollbarCornerElement);
+ }
+
+ /**
+ * Initializes all scrollbar interactivity. (track and handle dragging, clicking, scrolling)
+ * @param isHorizontal True if the target scrollbar is the horizontal scrollbar, false if the target scrollbar is the vertical scrollbar.
+ */
+ function initScrollbarInteractivity(isHorizontal) {
+ var scrollbarVars = getScrollbarVars(isHorizontal);
+ var insideIFrame = _windowElement.top !== _windowElement;
+ var mouseDownScroll;
+ var mouseDownOffset;
+ var xy = scrollbarVars.xy;
+ var XY = scrollbarVars.XY;
+ var scroll = _strScroll + scrollbarVars.LT;
+ var strActive = 'active';
+ var trackTimeout;
+ var scrollDurationFactor = 1;
+ var increaseDecreaseScrollAmountKeyCodes = [ 16, 17 ]; //shift, ctrl
+ function increaseTrackScrollAmount() {
+ scrollDurationFactor = 0.5;
+ };
+ function decreaseTrackScrollAmount() {
+ scrollDurationFactor = 1;
+ };
+ function documentKeyDown(event) {
+ if (FRAMEWORK.inArray(event.keyCode, increaseDecreaseScrollAmountKeyCodes) > -1)
+ increaseTrackScrollAmount();
+ };
+ function documentKeyUp(event) {
+ if (FRAMEWORK.inArray(event.keyCode, increaseDecreaseScrollAmountKeyCodes) > -1)
+ decreaseTrackScrollAmount();
+ };
+ function onMouseTouchDownContinue(event) {
+ var originalEvent = event.originalEvent || event;
+ var isTouchEvent = originalEvent.touches !== undefined;
+ return _isSleeping || nativeOverlayScrollbarsAreActive() || !_scrollbarsDragScrollingCache || (isTouchEvent && !_scrollbarsTouchSupport) ? false : COMPATIBILITY.mBtn(event) === 1 || isTouchEvent;
+ };
+ function handleDragMove(event) {
+ if(!onMouseTouchDownContinue(event)) {
+ documentMouseTouchUp(event);
+ return;
+ }
+
+ var trackLength = scrollbarVars.i.tl;
+ var handleLength = scrollbarVars.i.hl;
+ var scrollRange = scrollbarVars.i.ms;
+ var scrollRaw = (_msieVersion && insideIFrame ? event['screen' + XY] : COMPATIBILITY.page(event)[xy]) - mouseDownOffset; //use screen coordinates in EDGE & IE because the page values are incorrect in frames.
+ var scrollDeltaPercent = scrollRaw / (trackLength - handleLength);
+ var scrollDelta = (scrollRange * scrollDeltaPercent);
+ scrollDelta = isFinite(scrollDelta) ? scrollDelta : 0;
+ if (_isRTL && isHorizontal && !_rtlScrollBehavior.i)
+ scrollDelta *= -1;
+ _viewportElement[scroll](mouseDownScroll + scrollDelta);
+
+ if (!_supportPassiveEvents)
+ COMPATIBILITY.prvD(event);
+ };
+ function documentMouseTouchUp(event) {
+ event = event || event.originalEvent;
+
+ removeClass(_bodyElement, _classNameDragging);
+ removeClass(scrollbarVars.h, strActive);
+ removeClass(scrollbarVars.t, strActive);
+ removeClass(scrollbarVars.s, strActive);
+
+ _documentElement.off(_strMouseTouchMoveEvent, handleDragMove)
+ .off(_strMouseTouchUpEvent, documentMouseTouchUp)
+ .off(_strKeyDownEvent, documentKeyDown)
+ .off(_strKeyUpEvent, documentKeyUp)
+ .off(_strSelectStartEvent, documentOnSelectStart);
+
+ decreaseTrackScrollAmount();
+ mouseDownScroll = undefined;
+ mouseDownOffset = undefined;
+ if (trackTimeout !== undefined) {
+ _base.scrollStop();
+ clearTimeout(trackTimeout);
+ trackTimeout = undefined;
+ }
+
+ var rect = _hostElement[0].getBoundingClientRect();
+ var mouseInsideHost = event.clientX >= rect.left && event.clientX <= rect.right && event.clientY >= rect.top && event.clientY <= rect.bottom;
+
+ //if mouse is outside host element
+ if (!mouseInsideHost)
+ hostOnMouseLeave();
+
+ if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove)
+ refreshScrollbarsAutoHide(false);
+ };
+ function onHandleMouseTouchDown(event) {
+ mouseDownScroll = _viewportElement[scroll]();
+ mouseDownScroll = mouseDownScroll === undefined ? 0 : mouseDownScroll;
+ if (_isRTL && isHorizontal && !_rtlScrollBehavior.n || !_isRTL)
+ mouseDownScroll = mouseDownScroll < 0 ? 0 : mouseDownScroll;
+ mouseDownOffset = _msieVersion && insideIFrame ? event['screen' + XY] : COMPATIBILITY.page(event)[xy]; //use screen coordinates in EDGE & IE because the page values are incorrect in frames.
+
+ addClass(_bodyElement, _classNameDragging);
+ addClass(scrollbarVars.h, strActive);
+ addClass(scrollbarVars.s, strActive);
+
+ _documentElement.on(_strMouseTouchMoveEvent, handleDragMove)
+ .on(_strMouseTouchUpEvent, documentMouseTouchUp)
+ .on(_strSelectStartEvent, documentOnSelectStart);
+
+ if(_msieVersion || !_documentMixed)
+ COMPATIBILITY.prvD(event);
+ COMPATIBILITY.stpP(event);
+ };
+ scrollbarVars.h.on(_strMouseTouchDownEvent, function(event) {
+ if (onMouseTouchDownContinue(event))
+ onHandleMouseTouchDown(event);
+ });
+ scrollbarVars.t.on(_strMouseTouchDownEvent, function(event) {
+ if (onMouseTouchDownContinue(event)) {
+ var scrollDistance = _viewportSize[scrollbarVars._wh];
+ var trackOffset = scrollbarVars.t.offset()[scrollbarVars.lt];
+ var ctrlKey = event.ctrlKey;
+ var instantScroll = event.shiftKey;
+ var instantScrollTransition = instantScroll && ctrlKey;
+ var isFirstIteration = true;
+ var easing = 'linear';
+ var decreaseScroll;
+ var finishedCondition;
+ var scrollAction = function () {
+ if(!_destroyed) {
+ var mouseOffset = mouseDownOffset - trackOffset;
+ var trackLength = scrollbarVars.i.tl;
+ var handleOffset = scrollbarVars.i.ho;
+ var handleLength = scrollbarVars.i.hl;
+ var scrollRange = scrollbarVars.i.ms;
+ var scrollDuration = 270 * scrollDurationFactor;
+ var timeoutDelay = isFirstIteration ? Math.max(400, scrollDuration) : scrollDuration;
+ var instantScrollPosition = scrollRange * ((mouseOffset - (handleLength / 2)) / (trackLength - handleLength)); // 100% * positionPercent
+ var rtlIsNormal = _isRTL && isHorizontal && ((!_rtlScrollBehavior.i && !_rtlScrollBehavior.n) || _normalizeRTLCache);
+ var decreaseScrollCondition = rtlIsNormal ? handleOffset < mouseOffset : handleOffset > mouseOffset;
+ var scrollObj = { };
+
+ if(instantScroll) {
+ instantScrollPosition = isFinite(instantScrollPosition) ? instantScrollPosition : 0;
+ if (_isRTL && isHorizontal && !_rtlScrollBehavior.i)
+ instantScrollPosition = (scrollRange - instantScrollPosition);
+ if(instantScrollTransition) {
+ scrollObj.n = false;
+ scrollObj[xy] = instantScrollPosition;
+ _base.scroll(scrollObj, 130, easing, function() { onHandleMouseTouchDown(event); });
+ }
+ else {
+ _viewportElement[scroll](instantScrollPosition);
+ onHandleMouseTouchDown(event);
+ }
+ }
+ else {
+ decreaseScroll = isFirstIteration ? decreaseScrollCondition : decreaseScroll;
+ finishedCondition = rtlIsNormal ? decreaseScroll ? handleOffset + handleLength >= mouseOffset : handleOffset <= mouseOffset : decreaseScroll ? handleOffset <= mouseOffset : handleOffset + handleLength >= mouseOffset;
+
+ scrollObj[xy] = decreaseScroll ? '-=' + scrollDistance : '+=' + scrollDistance;
+ _base.scrollStop();
+ _base.scroll(scrollObj, scrollDuration, easing);
+
+ if (finishedCondition) {
+ clearTimeout(trackTimeout);
+ _base.scrollStop();
+ trackTimeout = undefined;
+ }
+ else
+ trackTimeout = setTimeout(scrollAction, timeoutDelay);
+ isFirstIteration = false;
+ }
+ }
+ };
+ if (ctrlKey)
+ increaseTrackScrollAmount();
+ mouseDownOffset = COMPATIBILITY.page(event)[xy];
+
+ addClass(_bodyElement, _classNameDragging);
+ addClass(scrollbarVars.t, strActive);
+ addClass(scrollbarVars.s, strActive);
+
+ _documentElement.on(_strMouseTouchUpEvent, documentMouseTouchUp)
+ .on(_strKeyDownEvent, documentKeyDown)
+ .on(_strKeyUpEvent, documentKeyUp)
+ .on(_strSelectStartEvent, documentOnSelectStart);
+
+ scrollAction();
+ COMPATIBILITY.prvD(event);
+ COMPATIBILITY.stpP(event);
+ }
+ }).on(_strMouseTouchEnter, function() { //make sure both scrollbars will stay visible if one scrollbar is hovered if autoHide is "scroll".
+ if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) {
+ _scrollbarsAutoHideFlagScrollAndHovered = true;
+ refreshScrollbarsAutoHide(true);
+ }
+ }).on(_strMouseTouchLeave, function() {
+ if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) {
+ _scrollbarsAutoHideFlagScrollAndHovered = false;
+ refreshScrollbarsAutoHide(false);
+ }
+ });
+ scrollbarVars.s.on(_strMouseTouchDownEvent, function(event) {
+ COMPATIBILITY.stpP(event);
+ });
+ }
+
+ /**
+ * Shows or hides the given scrollbar and applied a class name which indicates if the scrollbar is scrollable or not.
+ * @param isHorizontal True if the horizontal scrollbar is the target, false if the vertical scrollbar is the target.
+ * @param shallBeVisible True if the scrollbar shall be shown, false if hidden.
+ * @param canScroll True if the scrollbar is scrollable, false otherwise.
+ */
+ function refreshScrollbarAppearance(isHorizontal, shallBeVisible, canScroll) {
+ var scrollbarClassName = isHorizontal ? _classNameHostScrollbarHorizontalHidden : _classNameHostScrollbarVerticalHidden;
+ var scrollbarElement = isHorizontal ? _scrollbarHorizontalElement : _scrollbarVerticalElement;
+
+ if (shallBeVisible)
+ removeClass(_hostElement, scrollbarClassName);
+ else
+ addClass(_hostElement, scrollbarClassName);
+
+ if (canScroll)
+ removeClass(scrollbarElement, _classNameScrollbarUnusable);
+ else
+ addClass(scrollbarElement, _classNameScrollbarUnusable);
+ }
+
+ /**
+ * Autoshows / autohides both scrollbars with.
+ * @param shallBeVisible True if the scrollbars shall be autoshown (only the case if they are hidden by a autohide), false if the shall be auto hidden.
+ * @param delayfree True if the scrollbars shall be hidden without a delay, false or undefined otherwise.
+ */
+ function refreshScrollbarsAutoHide(shallBeVisible, delayfree) {
+ clearTimeout(_scrollbarsAutoHideTimeoutId);
+ if (shallBeVisible) {
+ //if(_hasOverflowCache.x && _hideOverflowCache.xs)
+ removeClass(_scrollbarHorizontalElement, _classNameScrollbarAutoHidden);
+ //if(_hasOverflowCache.y && _hideOverflowCache.ys)
+ removeClass(_scrollbarVerticalElement, _classNameScrollbarAutoHidden);
+ }
+ else {
+ var strActive = 'active';
+ var hide = function () {
+ if (!_scrollbarsAutoHideFlagScrollAndHovered && !_destroyed) {
+ var anyActive = _scrollbarHorizontalHandleElement.hasClass(strActive) || _scrollbarVerticalHandleElement.hasClass(strActive);
+ if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave))
+ addClass(_scrollbarHorizontalElement, _classNameScrollbarAutoHidden);
+ if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave))
+ addClass(_scrollbarVerticalElement, _classNameScrollbarAutoHidden);
+ }
+ };
+ if (_scrollbarsAutoHideDelay > 0 && delayfree !== true)
+ _scrollbarsAutoHideTimeoutId = setTimeout(hide, _scrollbarsAutoHideDelay);
+ else
+ hide();
+ }
+ }
+
+ /**
+ * Refreshes the handle length of the given scrollbar.
+ * @param isHorizontal True if the horizontal scrollbar handle shall be refreshed, false if the vertical one shall be refreshed.
+ */
+ function refreshScrollbarHandleLength(isHorizontal) {
+ var handleCSS = {};
+ var scrollbarVars = getScrollbarVars(isHorizontal);
+ var digit = 1000000;
+ //get and apply intended handle length
+ var handleRatio = Math.min(1, (_hostSizeCache[scrollbarVars._wh] - (_paddingAbsoluteCache ? (isHorizontal ? _paddingX : _paddingY) : 0)) / _contentScrollSizeCache[scrollbarVars._wh]);
+ handleCSS[scrollbarVars.wh] = (Math.floor(handleRatio * 100 * digit) / digit) + "%"; //the last * digit / digit is for flooring to the 4th digit
+
+ if (!nativeOverlayScrollbarsAreActive())
+ scrollbarVars.h.css(handleCSS);
+
+ //measure the handle length to respect min & max length
+ scrollbarVars.i.hl = scrollbarVars.h[0]['offset' + scrollbarVars.WH]; //hl = handle length
+ scrollbarVars.i.hlr = handleRatio; //hr = handle length ratio
+ }
+
+ /**
+ * Refreshes the handle offset of the given scrollbar.
+ * @param isHorizontal True if the horizontal scrollbar handle shall be refreshed, false if the vertical one shall be refreshed.
+ * @param currentScroll The current scroll offset of the given scrollbar axis. (if isHorizontal ? scrollLeft : scrollTop)
+ */
+ function refreshScrollbarHandleOffset(isHorizontal, currentScroll) {
+ var isRTLisHorizontal = _isRTL && isHorizontal;
+ var handleCSS = {};
+ var scrollbarVars = getScrollbarVars(isHorizontal);
+ var strTranslateBrace = 'translate(';
+ var strTransform = 'transform';
+ var translateValue;
+
+ //measure the handle length to respect min & max length
+ //DONT use the variable '_contentScrollSizeCache[scrollbarVars._wh]' instead of '_viewportElement[0]['scroll' + scrollbarVars.WH]'
+ // because its a bit behind during the small delay when content size updates
+ //(delay = _mutationObserverContentLag, if its 0 then this var could be used)
+ var maxScroll = _viewportElement[0][_strScroll + scrollbarVars.WH] - _viewportElement[0]['client' + scrollbarVars.WH];
+ var handleLength = scrollbarVars.i.hl;
+ var trackLength = scrollbarVars.t[0]['offset' + scrollbarVars.WH];
+ var handleTrackDiff = trackLength - handleLength;
+ var offset = handleTrackDiff;
+ var transformOffset;
+ var posRatio;
+
+ //if rtl scroll max is negative
+ if (_rtlScrollBehavior.n && isRTLisHorizontal)
+ maxScroll *= -1;
+
+ posRatio = currentScroll / maxScroll;
+ posRatio = isNaN(posRatio) ? 0 : Math.min(1, posRatio);
+
+ scrollbarVars.i.ms = maxScroll; //ms = max scroll
+ scrollbarVars.i.cs = currentScroll; //cs = current scroll
+ scrollbarVars.i.csr = posRatio; //csr = current scroll Ratio
+
+ offset *= posRatio;
+ offset = isNaN(offset) ? 0 : offset;
+ if (isRTLisHorizontal && !_rtlScrollBehavior.i)
+ offset = trackLength - handleLength - offset;
+ offset = Math.max(0, offset);
+
+ if (_supportTransform) {
+ transformOffset = isRTLisHorizontal ? -(trackLength - handleLength - offset) : offset; //in px
+ //transformOffset = (transformOffset / trackLength * 100) * (trackLength / handleLength); //in %
+ translateValue = isHorizontal ? strTranslateBrace + transformOffset + 'px, 0)' : strTranslateBrace + '0, ' + transformOffset + 'px)';
+ handleCSS['-webkit-' + strTransform] = translateValue;
+ handleCSS['-moz-' + strTransform] = translateValue;
+ handleCSS['-ms-' + strTransform] = translateValue;
+ handleCSS['-o-' + strTransform] = translateValue;
+ handleCSS[strTransform] = translateValue;
+ }
+ else
+ handleCSS[scrollbarVars.lt] = offset;
+
+ //only apply css if offset has changed and overflow exists.
+ if (!nativeOverlayScrollbarsAreActive())
+ scrollbarVars.h.css(handleCSS);
+
+ scrollbarVars.i.ho = offset; //ho = handle offset
+ scrollbarVars.i.tl = trackLength; //tl = track length
+ }
+
+ /**
+ * Refreshes the interactivity of the given scrollbar element.
+ * @param isTrack True if the track element is the target, false if the handle element is the target.
+ * @param value True for interactivity false for no interactivity.
+ */
+ function refreshScrollbarsInteractive(isTrack, value) {
+ var action = value ? 'removeClass' : 'addClass';
+ var element1 = isTrack ? _scrollbarHorizontalTrackElement : _scrollbarHorizontalHandleElement;
+ var element2 = isTrack ? _scrollbarVerticalTrackElement : _scrollbarVerticalHandleElement;
+ var className = isTrack ? _classNameScrollbarTrackOff : _classNameScrollbarHandleOff;
+
+ element1[action](className);
+ element2[action](className);
+ }
+
+ /**
+ * Returns a object which is used for fast access for specific variables.
+ * @param isHorizontal True if the horizontal scrollbar vars shall be accessed, false if the vertical scrollbar vars shall be accessed.
+ * @returns {{wh: string, WH: string, lt: string, _wh: string, _lt: string, t: *, h: *, c: {}, s: *}}
+ */
+ function getScrollbarVars(isHorizontal) {
+ return {
+ wh: isHorizontal ? _strWidth : _strHeight,
+ WH: isHorizontal ? 'Width' : 'Height',
+ lt: isHorizontal ? _strLeft : _strTop,
+ LT: isHorizontal ? 'Left' : 'Top',
+ xy: isHorizontal ? _strX : _strY,
+ XY: isHorizontal ? 'X' : 'Y',
+ _wh: isHorizontal ? 'w' : 'h',
+ _lt: isHorizontal ? 'l' : 't',
+ t: isHorizontal ? _scrollbarHorizontalTrackElement : _scrollbarVerticalTrackElement,
+ h: isHorizontal ? _scrollbarHorizontalHandleElement : _scrollbarVerticalHandleElement,
+ s: isHorizontal ? _scrollbarHorizontalElement : _scrollbarVerticalElement,
+ i: isHorizontal ? _scrollHorizontalInfo : _scrollVerticalInfo
+ };
+ }
+
+
+ //==== Utils ====//
+
+ /**
+ * Calls the callback with the given name. The Context of this callback is always _base (this).
+ * @param name The name of the target which shall be called.
+ * @param args The args with which the callback shall be called.
+ */
+ function callCallback(name, args) {
+ if(_initialized) {
+ var callback = _currentPreparedOptions.callbacks[name];
+ var extensionOnName = name;
+ var ext;
+
+ if(extensionOnName.substr(0, 2) === "on")
+ extensionOnName = extensionOnName.substr(2, 1).toLowerCase() + extensionOnName.substr(3);
+
+ if(type(callback) == TYPES.f)
+ callback.call(_base, args);
+
+ FRAMEWORK.each(_extensions, function() {
+ ext = this;
+ if(type(ext.on) == TYPES.f)
+ ext.on(extensionOnName, args);
+ });
+ }
+ }
+
+ /**
+ * Sets the "top, right, bottom, left" properties, with a given prefix, of the given css object.
+ * @param targetCSSObject The css object to which the values shall be applied.
+ * @param prefix The prefix of the "top, right, bottom, left" css properties. (example: 'padding-' is a valid prefix)
+ * @param values A array of values which shall be applied to the "top, right, bottom, left" -properties. The array order is [top, right, bottom, left].
+ * If this argument is undefined the value '' (empty string) will be applied to all properties.
+ */
+ function setTopRightBottomLeft(targetCSSObject, prefix, values) {
+ if (values === undefined)
+ values = [_strEmpty, _strEmpty, _strEmpty, _strEmpty];
+
+ targetCSSObject[prefix + _strTop] = values[0];
+ targetCSSObject[prefix + _strRight] = values[1];
+ targetCSSObject[prefix + _strBottom] = values[2];
+ targetCSSObject[prefix + _strLeft] = values[3];
+ }
+
+ /**
+ * Checks whether the given object is a HTMLElement.
+ * @param o The object which shall be checked.
+ * @returns {boolean} True the given object is a HTMLElement, false otherwise.
+ */
+ function isHTMLElement(o) {
+ var strOwnerDocument = 'ownerDocument';
+ var strHTMLElement = 'HTMLElement';
+ var wnd = o && o[strOwnerDocument] ? (o[strOwnerDocument].parentWindow || window) : window;
+ return (
+ typeof wnd[strHTMLElement] == TYPES.o ? o instanceof wnd[strHTMLElement] : //DOM2
+ o && typeof o == TYPES.o && o !== null && o.nodeType === 1 && typeof o.nodeName == TYPES.s
+ );
+ }
+
+ /**
+ * Compares 2 arrays and returns the differences between them as a array.
+ * @param a1 The first array which shall be compared.
+ * @param a2 The second array which shall be compared.
+ * @returns {Array} The differences between the two arrays.
+ */
+ function getArrayDifferences(a1, a2) {
+ var a = [ ];
+ var diff = [ ];
+ var i;
+ var k;
+ for (i = 0; i < a1.length; i++)
+ a[a1[i]] = true;
+ for (i = 0; i < a2.length; i++) {
+ if (a[a2[i]])
+ delete a[a2[i]];
+ else
+ a[a2[i]] = true;
+ }
+ for (k in a)
+ diff.push(k);
+ return diff;
+ }
+
+ /**
+ * Returns Zero or the number to which the value can be parsed.
+ * @param value The value which shall be parsed.
+ * @param toFloat Indicates whether the number shall be parsed to a float.
+ */
+ function parseToZeroOrNumber(value, toFloat) {
+ var num = toFloat ? window.parseFloat(value) : window.parseInt(value);
+ return isNaN(num) ? 0 : num;
+ }
+
+
+ /**
+ * Gets several information of the textarea and returns them as a object or undefined if the browser doesn't support it.
+ * @returns {{cursorRow: Number, cursorCol, rows: Number, cols: number, wRow: number, pos: number, max : number}} or undefined if not supported.
+ */
+ function getTextareaInfo() {
+ //read needed values
+ var textareaCursorPosition = _targetElement[0].selectionStart;
+ if (textareaCursorPosition === undefined)
+ return;
+
+ var strLength = 'length';
+ var textareaValue = _targetElement.val();
+ var textareaLength = textareaValue[strLength];
+ var textareaRowSplit = textareaValue.split("\n");
+ var textareaLastRow = textareaRowSplit[strLength];
+ var textareaCurrentCursorRowSplit = textareaValue.substr(0, textareaCursorPosition).split("\n");
+ var widestRow = 0;
+ var textareaLastCol = 0;
+ var cursorRow = textareaCurrentCursorRowSplit[strLength];
+ var cursorCol = textareaCurrentCursorRowSplit[textareaCurrentCursorRowSplit[strLength] - 1][strLength];
+ var rowCols;
+ var i;
+
+ //get widest Row and the last column of the textarea
+ for (i = 0; i < textareaRowSplit[strLength]; i++) {
+ rowCols = textareaRowSplit[i][strLength];
+ if (rowCols > textareaLastCol) {
+ widestRow = i + 1;
+ textareaLastCol = rowCols;
+ }
+ }
+
+ return {
+ cR: cursorRow, //cursorRow
+ cC: cursorCol, //cursorCol
+ r: textareaLastRow, //rows
+ c: textareaLastCol, //cols
+ w: widestRow, //wRow
+ p: textareaCursorPosition, //pos
+ m: textareaLength //max
+ };
+ }
+
+ /**
+ * Checks the given key code and returns a boolean which is indicating if the given key code is a restricted one.
+ * @param keyCode The key code which shall be checked.
+ * @returns {boolean} True if the given key code is restricted, false otherwise.
+ */
+ function textareaIsRestrictedKeyCode(keyCode) {
+ for (var i = 0; i < _textareaKeyDownRestrictedKeyCodes.length; i++) {
+ if (keyCode === _textareaKeyDownRestrictedKeyCodes[i])
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Determines whether native overlay scrollbars are active.
+ * @returns {boolean} True if native overlay scrollbars are active, false otherwise.
+ */
+ function nativeOverlayScrollbarsAreActive() {
+ return (_ignoreOverlayScrollbarHidingCache && (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y));
+ }
+
+ /**
+ * Gets the element which is used to measure the content size.
+ * @returns {*} TextareaCover if target element is textarea else the ContentElement.
+ */
+ function getContentMeasureElement() {
+ return _isTextarea ? _textareaCoverElement[0] : _contentElement[0];
+ }
+
+ /**
+ * Generates a string which represents a HTML div with the given classes or attributes.
+ * @param classesOrAttrs The class of the div as string or a object which represents the attributes of the div. (The class attribute can also be written as "className".)
+ * @param content The content of the div as string.
+ * @returns {string} The concated string which represents a HTML div and its content.
+ */
+ function generateDiv(classesOrAttrs, content) {
+ return '
' +
+ (content ? content : _strEmpty) +
+ '
';
+ }
+
+ /**
+ * Gets the value of the given property from the given object.
+ * @param obj The object from which the property value shall be got.
+ * @param path The property of which the value shall be got.
+ * @returns {*} Returns the value of the searched property or undefined of the property wasn't found.
+ */
+ function getObjectPropVal(obj, path) {
+ var splits = path.split(_strDot);
+ var i = 0;
+ var val;
+ for(; i < splits.length; i++) {
+ if(!obj.hasOwnProperty(splits[i]))
+ return;
+ val = obj[splits[i]];
+ if(i < splits.length && type(val) == TYPES.o)
+ obj = val;
+ }
+ return val;
+ }
+
+ /**
+ * Sets the value of the given property from the given object.
+ * @param obj The object from which the property value shall be set.
+ * @param path The property of which the value shall be set.
+ * @param val The value of the property which shall be set.
+ */
+ function setObjectPropVal(obj, path, val) {
+ var splits = path.split(_strDot);
+ var splitsLength = splits.length;
+ var i = 0;
+ var extendObj = { };
+ var extendObjRoot = extendObj;
+ for(; i < splitsLength; i++)
+ extendObj = extendObj[splits[i]] = i + 1 < splitsLength ? { } : val;
+ FRAMEWORK.extend(obj, extendObjRoot, true);
+ }
+
+ //==== Utils Cache ====//
+
+ /**
+ * Compares two values and returns the result of the comparison as a boolean.
+ * @param current The first value which shall be compared.
+ * @param cache The second value which shall be compared.
+ * @param force If true the returned value is always true.
+ * @returns {boolean} True if both variables aren't equal or some of them is undefined or when the force parameter is true, false otherwise.
+ */
+ function checkCacheSingle(current, cache, force) {
+ if (force === true)
+ return force;
+ if (cache === undefined)
+ return true;
+ else if (current !== cache)
+ return true;
+ return false;
+ }
+
+ /**
+ * Compares two objects with two properties and returns the result of the comparison as a boolean.
+ * @param current The first object which shall be compared.
+ * @param cache The second object which shall be compared.
+ * @param prop1 The name of the first property of the objects which shall be compared.
+ * @param prop2 The name of the second property of the objects which shall be compared.
+ * @param force If true the returned value is always true.
+ * @returns {boolean} True if both variables aren't equal or some of them is undefined or when the force parameter is true, false otherwise.
+ */
+ function checkCacheDouble(current, cache, prop1, prop2, force) {
+ if (force === true)
+ return force;
+ if (prop2 === undefined && force === undefined) {
+ if (prop1 === true)
+ return prop1;
+ else
+ prop1 = undefined;
+ }
+ prop1 = prop1 === undefined ? 'w' : prop1;
+ prop2 = prop2 === undefined ? 'h' : prop2;
+ if (cache === undefined)
+ return true;
+ else if (current[prop1] !== cache[prop1] || current[prop2] !== cache[prop2])
+ return true;
+ return false;
+ }
+
+ /**
+ * Compares two objects which have four properties and returns the result of the comparison as a boolean.
+ * @param current The first object with four properties.
+ * @param cache The second object with four properties.
+ * @returns {boolean} True if both objects aren't equal or some of them is undefined, false otherwise.
+ */
+ function checkCacheTRBL(current, cache) {
+ if (cache === undefined)
+ return true;
+ else if (current.t !== cache.t ||
+ current.r !== cache.r ||
+ current.b !== cache.b ||
+ current.l !== cache.l)
+ return true;
+ return false;
+ }
+
+
+ //==== Shortcuts ====//
+
+ /**
+ * jQuery type method shortcut.
+ */
+ function type(obj) {
+ return COMPATIBILITY.type(obj);
+ }
+
+ /**
+ * jQuery extend method shortcut.
+ */
+ function extend() {
+ return FRAMEWORK.extend.apply(this, arguments);
+ }
+
+ /**
+ * jQuery addClass method shortcut.
+ */
+ function addClass(el, classes) {
+ return _frameworkProto.addClass.call(el, classes);
+ }
+
+ /**
+ * jQuery removeClass method shortcut.
+ */
+ function removeClass(el, classes) {
+ return _frameworkProto.removeClass.call(el, classes);
+ }
+
+ /**
+ * jQuery remove method shortcut.
+ */
+ function remove(el) {
+ return _frameworkProto.remove.call(el);
+ }
+
+ /**
+ * Finds the first child element with the given selector of the given element.
+ * @param el The root element from which the selector shall be valid.
+ * @param selector The selector of the searched element.
+ * @returns {*} The first element which is a child of the given element and matches the givens selector.
+ */
+ function findFirst(el, selector) {
+ return _frameworkProto.find.call(el, selector).eq(0);
+ }
+
+
+ //==== API ====//
+
+ /**
+ * Puts the instance to sleep. It wont respond to any changes in the DOM and won't update. Scrollbar Interactivity is also disabled as well as the resize handle.
+ * This behavior can be reset by calling the update method.
+ */
+ _base.sleep = function () {
+ _isSleeping = true;
+ };
+
+ /**
+ * Updates the plugin and DOM to the current options.
+ * This method should only be called if a update is 100% required.
+ * @param force True if every property shall be updated and the cache shall be ignored.
+ * !INTERNAL USAGE! : force can be a string "auto", "auto+" or "zoom" too
+ * if this is the case then before a real update the content size and host element attributes gets checked, and if they changed only then the update method will be called.
+ */
+ _base.update = function (force) {
+ var attrsChanged;
+ var contentSizeC;
+ var isString = type(force) == TYPES.s;
+ var imgElementSelector = 'img';
+ var imgElementLoadEvent = 'load';
+ if(isString) {
+ if (force.indexOf(_strAuto) === 0) {
+ attrsChanged = meaningfulAttrsChanged();
+ contentSizeC = updateAutoContentSizeChanged();
+ if (attrsChanged || contentSizeC)
+ update(false, contentSizeC, false, force.slice(-1) == "+");
+ }
+ else if (force === 'zoom')
+ update(true, true);
+ }
+ else {
+ force = _isSleeping || force;
+ _isSleeping = false;
+ update(false, false, force, true);
+ }
+ if(!_isTextarea) {
+ _contentElement.find(imgElementSelector).each(function(i, el) {
+ var index = COMPATIBILITY.inA(el, _imgs);
+ if (index === -1)
+ FRAMEWORK(el).off(imgElementLoadEvent, imgOnLoad).on(imgElementLoadEvent, imgOnLoad);
+ });
+ }
+ };
+
+ /**
+ Gets or sets the current options. The update method will be called automatically if new options were set.
+ * @param newOptions If new options are given, then the new options will be set, if new options aren't given (undefined or a not a plain object) then the current options will be returned.
+ * @param value If new options is a property path string, then this value will be used to set the option to which the property path string leads.
+ * @returns {*}
+ */
+ _base.options = function (newOptions, value) {
+ //return current options if newOptions are undefined or empty
+ if (FRAMEWORK.isEmptyObject(newOptions) || !FRAMEWORK.isPlainObject(newOptions)) {
+ if (type(newOptions) == TYPES.s) {
+ if (arguments.length >= 2) {
+ var option = { };
+ setObjectPropVal(option, newOptions, value);
+ setOptions(option);
+ update();
+ return;
+ }
+ else
+ return getObjectPropVal(_currentOptions, newOptions);
+ }
+ else
+ return _currentOptions;
+ }
+ setOptions(newOptions);
+ var isSleepingTmp = _isSleeping || false;
+ _isSleeping = false;
+ update();
+ _isSleeping = isSleepingTmp;
+ };
+
+ /**
+ * Restore the DOM, disconnects all observers, remove all resize observers and destroy all methods.
+ */
+ _base.destroy = function () {
+ _destroyed = true;
+
+ autoUpdateLoop.remove(_base);
+ mutationObserversDisconnect();
+ removeResizeObserver(_sizeObserverElement);
+ if (_sizeAutoObserverAdded)
+ removeResizeObserver(_sizeAutoObserverElement);
+
+ for(var extName in _extensions)
+ _base.removeExt(extName);
+
+ remove(_sizeObserverElement);
+ if (_contentGlueElement !== undefined)
+ remove(_contentGlueElement);
+ if (_contentArrangeElement !== undefined)
+ remove(_contentArrangeElement);
+ if (_sizeAutoObserverAdded)
+ remove(_sizeAutoObserverElement);
+
+ if (_supportPassiveEvents) {
+ removePassiveEventListener(_hostElement, _strMouseTouchMoveEvent, hostOnMouseMove);
+ removePassiveEventListener(_hostElement, _strMouseTouchEnter, hostOnMouseEnter);
+ removePassiveEventListener(_hostElement, _strMouseTouchLeave, hostOnMouseLeave);
+ }
+ else {
+ _hostElement.off(_strMouseTouchMoveEvent, hostOnMouseMove)
+ .off(_strMouseTouchEnter, hostOnMouseEnter)
+ .off(_strMouseTouchLeave, hostOnMouseLeave);
+ }
+
+ remove(_scrollbarHorizontalElement);
+ remove(_scrollbarVerticalElement);
+ if(_scrollbarCornerElement)
+ remove(_scrollbarCornerElement);
+ if (!_resizeNone)
+ scrollbarCornerOnResized();
+
+ _contentElement.contents()
+ .unwrap()
+ .unwrap()
+ .unwrap();
+
+ if (_isBody)
+ removeClass(_htmlElement, _classNameHTMLElement);
+
+
+ if (_isTextarea) {
+ _targetElement.off(_strScroll, textareaOnScroll)
+ .off('drop', textareaOnDrop)
+ .off('focus', textareaOnFocus)
+ .off('focusout', textareaOnFocusOut);
+ if (_msieVersion > 9 || !_autoUpdateRecommended)
+ _targetElement.off('input', textareaOnInput);
+ else {
+ _targetElement.off(_strKeyDownEvent, textareaOnKeyDown)
+ .off(_strKeyUpEvent, textareaOnKeyUp);
+ }
+
+ remove(_textareaCoverElement);
+ removeClass(_targetElement, _classNameTextareaElement + _strSpace + _classNameTextInherit)
+ .unwrap()
+ .removeAttr(LEXICON.s);
+ remove(_hostElement);
+ }
+ else {
+ removeClass(_targetElement, _classNameHostElement);
+ removeClass(_hostElement, [
+ _classNameHostElement,
+ _classNameHostResizeDisabled,
+ _classNameHostRTL,
+ _classNameHostScrollbarHorizontalHidden,
+ _classNameHostScrollbarVerticalHidden,
+ _classNameHostTransition,
+ _classNameHostScrolling,
+ _classNameHostOverflow,
+ _classNameHostOverflowX,
+ _classNameHostOverflowY,
+ _classNameThemeNone,
+ _classNameCache].join(_strSpace));
+ }
+
+ for(var i = 0; i < _imgs.length; i++)
+ FRAMEWORK(_imgs[i]).off('load', imgOnLoad);
+ _imgs = undefined;
+
+ INSTANCES(pluginTargetElement, 0);
+ callCallback("onDestroyed");
+
+ for (var property in _base)
+ delete _base[property];
+ _base = undefined;
+ };
+
+ /**
+ * Scrolls to a given position or element.
+ * @param coordinates
+ * 1. Can be "coordinates" which looks like:
+ * { x : ?, y : ? } OR Object with x and y properties
+ * { left : ?, top : ? } OR Object with left and top properties
+ * { l : ?, t : ? } OR Object with l and t properties
+ * [ ?, ? ] OR Array where the first two element are the coordinates (first is x, second is y)
+ * ? A single value which stays for both axis
+ * A value can be a number, a string or a calculation.
+ *
+ * Operators:
+ * [NONE] The current scroll will be overwritten by the value.
+ * '+=' The value will be added to the current scroll offset
+ * '-=' The value will be subtracted from the current scroll offset
+ * '*=' The current scroll wil be multiplicated by the value.
+ * '/=' The current scroll wil be divided by the value.
+ *
+ * Units:
+ * [NONE] The value is the final scroll amount. final = (value * 1)
+ * 'px' Same as none
+ * '%' The value is dependent on the current scroll value. final = ((currentScrollValue / 100) * value)
+ * 'vw' The value is multiplicated by the viewport width. final = (value * viewportWidth)
+ * 'vh' The value is multiplicated by the viewport height. final = (value * viewportHeight)
+ *
+ * example final values:
+ * 200, '200px', '50%', '1vw', '1vh', '+=200', '/=1vw', '*=2px', '-=5vh', '+=33%', '+= 50% - 2px', '-= 1vw - 50%'
+ *
+ * 2. Can be a HTML or jQuery element:
+ * The final scroll offset is the offset (without margin) of the given HTML / jQuery element.
+ *
+ * 3. Can be a object with a HTML or jQuery element with additional settings:
+ * {
+ * el : [HTMLElement, jQuery element], MUST be specified, else this object isn't valid.
+ * scroll : [string, array, object], Default value is 'always'.
+ * block : [string, array, object], Default value is 'begin'.
+ * margin : [number, boolean array, object] Default value is false.
+ * }
+ *
+ * Possible scroll settings are:
+ * 'always' Scrolls always.
+ * 'ifneeded' Scrolls only if the element isnt fully in view.
+ * 'never' Scrolls never.
+ *
+ * Possible block settings are:
+ * 'begin' Both axis shall be docked to the "begin" edge. - The element will be docked to the top and left edge of the viewport.
+ * 'end' Both axis shall be docked to the "end" edge. - The element will be docked to the bottom and right edge of the viewport. (If direction is RTL to the bottom and left edge.)
+ * 'center' Both axis shall be docked to "center". - The element will be centered in the viewport.
+ * 'nearest' The element will be docked to the nearest edge(s).
+ *
+ * Possible margin settings are: -- The actual margin of the element wont be affect, this option affects only the final scroll offset.
+ * [BOOLEAN] If true the css margin of the element will be used, if false no margin will be used.
+ * [NUMBER] The margin will be used for all edges.
+ *
+ * @param duration The duration of the scroll animation, OR a jQuery animation configuration object.
+ * @param easing The animation easing.
+ * @param complete The animation complete callback.
+ * @returns
+ * {
+ * x: {position: *, ratio: (number|*), max: (number|*), handleOffset: (number|*), handleLength: *, handleLengthRatio: (number|*), trackLength: *, isRTL: *, isRTLNormalized: *},
+ * y: {position: *, ratio: (number|*), max: (number|*), handleOffset: (number|*), handleLength: *, handleLengthRatio: (number|*), trackLength: *}
+ * }
+ */
+ _base.scroll = function (coordinates, duration, easing, complete) {
+ if (arguments.length === 0 || coordinates === undefined) {
+ var infoX = _scrollHorizontalInfo;
+ var infoY = _scrollVerticalInfo;
+ var normalizeInvert = _normalizeRTLCache && _isRTL && _rtlScrollBehavior.i;
+ var normalizeNegate = _normalizeRTLCache && _isRTL && _rtlScrollBehavior.n;
+ var scrollX = infoX.cs;
+ var scrollXRatio = infoX.csr;
+ var maxScrollX = infoX.ms;
+ scrollXRatio = normalizeInvert ? 1 - scrollXRatio : scrollXRatio;
+ scrollX = normalizeInvert ? maxScrollX - scrollX : scrollX;
+ scrollX *= normalizeNegate ? -1 : 1;
+ maxScrollX *= normalizeNegate ? -1 : 1;
+ return {
+ x: {
+ position: scrollX,
+ ratio: scrollXRatio,
+ max: maxScrollX,
+ handleOffset: infoX.ho,
+ handleLength: infoX.hl,
+ handleLengthRatio: infoX.hlr,
+ trackLength: infoX.tl,
+ isRTL: _isRTL,
+ isRTLNormalized: _normalizeRTLCache
+ },
+ y: {
+ position: infoY.cs,
+ ratio: infoY.csr,
+ max: infoY.ms,
+ handleOffset: infoY.ho,
+ handleLength: infoY.hl,
+ handleLengthRatio: infoY.hlr,
+ trackLength: infoY.tl
+ }
+ };
+ }
+
+ var normalizeRTL = _normalizeRTLCache;
+ var coordinatesXAxisProps = [_strX, _strLeft, 'l'];
+ var coordinatesYAxisProps = [_strY, _strTop, 't'];
+ var coordinatesOperators = ['+=', '-=', '*=', '/='];
+ var i;
+ var finalScroll = { };
+ var doScrollLeft;
+ var doScrollTop;
+ var animationOptions;
+ var durationIsObject = type(duration) == TYPES.o;
+ var strEnd = 'end';
+ var strBegin = 'begin';
+ var strCenter = 'center';
+ var strNearest = 'nearest';
+ var strAlways = 'always';
+ var strNever = 'never';
+ var strIfNeeded = 'ifneeded';
+ var strLength = LEXICON.l;
+ var settingsAxis;
+ var settingsScroll;
+ var settingsBlock;
+ var settingsMargin;
+ var finalElement;
+ var elementObjSettingsAxisValues = [_strX, _strY, 'xy', 'yx'];
+ var elementObjSettingsBlockValues = [strBegin, strEnd, strCenter, strNearest];
+ var elementObjSettingsScrollValues = [strAlways, strNever, strIfNeeded];
+ var coordinatesIsElementObj = coordinates.hasOwnProperty('el');
+ var possibleElement = coordinatesIsElementObj ? coordinates.el : coordinates;
+ var possibleElementIsJQuery = possibleElement instanceof FRAMEWORK || JQUERY ? possibleElement instanceof JQUERY : false;
+ var possibleElementIsHTMLElement = possibleElementIsJQuery ? false : isHTMLElement(possibleElement);
+ var checkSettingsStringValue = function (currValue, allowedValues) {
+ for (i = 0; i < allowedValues[strLength]; i++) {
+ if (currValue === allowedValues[i])
+ return true;
+ }
+ return false;
+ };
+ var getRawScroll = function (coordinates) {
+ var rawScroll = {};
+ if (type(coordinates) == TYPES.a && coordinates[strLength] > 0) {
+ rawScroll.x = coordinates[0];
+ rawScroll.y = coordinates[1];
+ }
+ else if (type(coordinates) == TYPES.s || type(coordinates) == TYPES.n) {
+ rawScroll.x = coordinates;
+ rawScroll.y = coordinates;
+ }
+ else if (type(coordinates) == TYPES.o) {
+ normalizeRTL = type(coordinates.n) == TYPES.b ? coordinates.n : normalizeRTL;
+ coordinates = extend({}, coordinates);
+ i = 0;
+ for (var key in coordinates) {
+ if (coordinates.hasOwnProperty(key)) {
+ if (i > 2)
+ delete coordinates[key];
+ i++;
+ }
+ }
+ var getRawScrollValue = function (isX) {
+ var coordinateProps = isX ? coordinatesXAxisProps : coordinatesYAxisProps;
+ for (i = 0; i < coordinateProps[strLength]; i++) {
+ if (coordinateProps[i] in coordinates) {
+ return coordinates[coordinateProps[i]];
+ }
+ }
+ };
+ rawScroll.x = getRawScrollValue(true);
+ rawScroll.y = getRawScrollValue(false);
+ }
+ return rawScroll;
+ };
+ var getFinalScroll = function (isX, rawScroll) {
+ var isString = type(rawScroll) == TYPES.s;
+ if(isString)
+ _base.update(_strAuto + "+");
+ var operator;
+ var amount;
+ var scrollInfo = isX ? _scrollHorizontalInfo : _scrollVerticalInfo;
+ var currScroll = scrollInfo.cs;
+ var maxScroll = scrollInfo.ms;
+ var mult = ' * ';
+ var finalValue;
+ var isRTLisX = _isRTL && isX;
+ var normalizeShortcuts = isRTLisX && _rtlScrollBehavior.n && !normalizeRTL;
+ var strReplace = 'replace';
+ if (isString) {
+ //check operator
+ if (rawScroll[strLength] > 2) {
+ var possibleOperator = rawScroll.substr(0, 2);
+ for (i = 0; i < coordinatesOperators[strLength]; i++) {
+ if (possibleOperator === coordinatesOperators[i]) {
+ operator = coordinatesOperators[i];
+ break;
+ }
+ }
+ }
+
+ //calculate units and shortcuts
+ rawScroll = operator !== undefined ? rawScroll.substr(2) : rawScroll;
+ rawScroll = rawScroll[strReplace](/min/g, 0); //'min' = 0%
+ rawScroll = rawScroll[strReplace](//g, (normalizeShortcuts ? '-' : _strEmpty) + _strHundredPercent); //'>' = 100%
+ rawScroll = rawScroll[strReplace](/px/g, _strEmpty);
+ rawScroll = rawScroll[strReplace](/%/g, mult + (maxScroll * (isRTLisX && _rtlScrollBehavior.n ? -1 : 1) / 100.0));
+ rawScroll = rawScroll[strReplace](/vw/g, mult + _viewportSize.w);
+ rawScroll = rawScroll[strReplace](/vh/g, mult + _viewportSize.h);
+ amount = parseToZeroOrNumber(parseToZeroOrNumber(window.eval(rawScroll), true).toFixed());
+ }
+ else {
+ amount = rawScroll;
+ }
+
+ if (amount !== undefined && !isNaN(amount) && type(amount) == TYPES.n) {
+ var normalizeIsRTLisX = normalizeRTL && isRTLisX;
+ var operatorCurrScroll = currScroll * (normalizeIsRTLisX && _rtlScrollBehavior.n ? -1 : 1);
+ var invert = normalizeIsRTLisX && _rtlScrollBehavior.i;
+ var negate = normalizeIsRTLisX && _rtlScrollBehavior.n;
+ operatorCurrScroll = invert ? (maxScroll - operatorCurrScroll) : operatorCurrScroll;
+ switch (operator) {
+ case '+=':
+ finalValue = operatorCurrScroll + amount;
+ break;
+ case '-=':
+ finalValue = operatorCurrScroll - amount;
+ break;
+ case '*=':
+ finalValue = operatorCurrScroll * amount;
+ break;
+ case '/=':
+ finalValue = operatorCurrScroll / amount;
+ break;
+ default:
+ finalValue = amount;
+ break;
+ }
+ finalValue = invert ? maxScroll - finalValue : finalValue;
+ finalValue *= negate ? -1 : 1;
+ finalValue = isRTLisX && _rtlScrollBehavior.n ? Math.min(0, Math.max(maxScroll, finalValue)) : Math.max(0, Math.min(maxScroll, finalValue));
+ }
+ return finalValue === currScroll ? undefined : finalValue;
+ };
+ var getPerAxisValue = function (value, valueInternalType, defaultValue, allowedValues) {
+ var resultDefault = [ defaultValue, defaultValue ];
+ var valueType = type(value);
+ var valueArrLength;
+ var valueArrItem;
+
+ //value can be [ string, or array of two strings ]
+ if (valueType == valueInternalType) {
+ value = [value, value];
+ }
+ else if (valueType == TYPES.a) {
+ valueArrLength = value[strLength];
+ if (valueArrLength > 2 || valueArrLength < 1)
+ value = resultDefault;
+ else {
+ if (valueArrLength === 1)
+ value[1] = defaultValue;
+ for (i = 0; i < valueArrLength; i++) {
+ valueArrItem = value[i];
+ if (type(valueArrItem) != valueInternalType || !checkSettingsStringValue(valueArrItem, allowedValues)) {
+ value = resultDefault;
+ break;
+ }
+ }
+ }
+ }
+ else if (valueType == TYPES.o)
+ value = [ value[_strX]|| defaultValue, value[_strY] || defaultValue];
+ else
+ value = resultDefault;
+ return { x : value[0], y : value[1] };
+ };
+ var generateMargin = function (marginTopRightBottomLeftArray) {
+ var result = [ ];
+ var currValue;
+ var currValueType;
+ var valueDirections = [ _strTop, _strRight, _strBottom, _strLeft ];
+ for(i = 0; i < marginTopRightBottomLeftArray[strLength]; i++) {
+ if(i === valueDirections[strLength])
+ break;
+ currValue = marginTopRightBottomLeftArray[i];
+ currValueType = type(currValue);
+ if(currValueType == TYPES.b)
+ result.push(currValue ? parseToZeroOrNumber(finalElement.css(_strMarginMinus + valueDirections[i])) : 0);
+ else
+ result.push(currValueType == TYPES.n ? currValue : 0);
+ }
+ return result;
+ };
+
+ if (possibleElementIsJQuery || possibleElementIsHTMLElement) {
+ //get settings
+ var margin = coordinatesIsElementObj ? coordinates.margin : 0;
+ var axis = coordinatesIsElementObj ? coordinates.axis : 0;
+ var scroll = coordinatesIsElementObj ? coordinates.scroll : 0;
+ var block = coordinatesIsElementObj ? coordinates.block : 0;
+ var marginDefault = [ 0, 0, 0, 0 ];
+ var marginType = type(margin);
+ var marginLength;
+ finalElement = possibleElementIsJQuery ? possibleElement : FRAMEWORK(possibleElement);
+ if (finalElement[strLength] === 0)
+ return;
+
+ _base.update(_strAuto + "+");
+
+ //margin can be [ boolean, number, array of 2, array of 4, object ]
+ if (marginType == TYPES.n || marginType == TYPES.b)
+ margin = generateMargin([margin, margin, margin, margin]);
+ else if (marginType == TYPES.a) {
+ marginLength = margin[strLength];
+ if(marginLength === 2)
+ margin = generateMargin([margin[0], margin[1], margin[0], margin[1]]);
+ else if(marginLength >= 4)
+ margin = generateMargin(margin);
+ else
+ margin = marginDefault;
+ }
+ else if (marginType == TYPES.o)
+ margin = generateMargin([margin[_strTop], margin[_strRight], margin[_strBottom], margin[_strLeft]]);
+ else
+ margin = marginDefault;
+
+ //block = type(block) === TYPES.b ? block ? [ strNearest, strBegin ] : [ strNearest, strEnd ] : block;
+ settingsAxis = checkSettingsStringValue(axis, elementObjSettingsAxisValues) ? axis : 'xy';
+ settingsScroll = getPerAxisValue(scroll, TYPES.s, strAlways, elementObjSettingsScrollValues);
+ settingsBlock = getPerAxisValue(block, TYPES.s, strBegin, elementObjSettingsBlockValues);
+ settingsMargin = margin;
+
+ var viewportScroll = {
+ l: _scrollHorizontalInfo.cs,
+ t: _scrollVerticalInfo.cs
+ };
+ // use padding element instead of viewport element because padding element has never padding, margin or position applied.
+ var viewportOffset = _paddingElement.offset();
+
+ //get coordinates
+ var elementOffset = finalElement.offset();
+ var doNotScroll = {
+ x : settingsScroll.x == strNever || settingsAxis == _strY,
+ y : settingsScroll.y == strNever || settingsAxis == _strX
+ };
+ elementOffset[_strTop] -= settingsMargin[0];
+ elementOffset[_strLeft] -= settingsMargin[3];
+ var elementScrollCoordinates = {
+ x: Math.round(elementOffset[_strLeft] - viewportOffset[_strLeft] + viewportScroll.l),
+ y: Math.round(elementOffset[_strTop] - viewportOffset[_strTop] + viewportScroll.t)
+ };
+ if (_isRTL) {
+ if (!_rtlScrollBehavior.n && !_rtlScrollBehavior.i)
+ elementScrollCoordinates.x = Math.round(viewportOffset[_strLeft] - elementOffset[_strLeft] + viewportScroll.l);
+ if (_rtlScrollBehavior.n && normalizeRTL)
+ elementScrollCoordinates.x *= -1;
+ if (_rtlScrollBehavior.i && normalizeRTL)
+ elementScrollCoordinates.x = Math.round(viewportOffset[_strLeft] - elementOffset[_strLeft] + (_scrollHorizontalInfo.ms - viewportScroll.l));
+ }
+
+ //measuring is required
+ if (settingsBlock.x != strBegin || settingsBlock.y != strBegin || settingsScroll.x == strIfNeeded || settingsScroll.y == strIfNeeded || _isRTL) {
+ var measuringElm = finalElement[0];
+ var rawElementSize = _supportTransform ? measuringElm.getBoundingClientRect() : {
+ width : measuringElm[LEXICON.oW],
+ height : measuringElm[LEXICON.oH]
+ };
+ var elementSize = {
+ w: rawElementSize[_strWidth] + settingsMargin[3] + settingsMargin[1],
+ h: rawElementSize[_strHeight] + settingsMargin[0] + settingsMargin[2]
+ };
+ var finalizeBlock = function(isX) {
+ var vars = getScrollbarVars(isX);
+ var wh = vars._wh;
+ var lt = vars.lt;
+ var xy = vars.xy;
+ var blockIsEnd = settingsBlock[xy] == (isX ? _isRTL ? strBegin : strEnd : strEnd);
+ var blockIsCenter = settingsBlock[xy] == strCenter;
+ var blockIsNearest = settingsBlock[xy] == strNearest;
+ var scrollNever = settingsScroll[xy] == strNever;
+ var scrollIfNeeded = settingsScroll[xy] == strIfNeeded;
+ var vpSize = _viewportSize[wh];
+ var vpOffset = viewportOffset[lt];
+ var elSize = elementSize[wh];
+ var elOffset = elementOffset[lt];
+ var divide = blockIsCenter ? 2 : 1;
+ var elementCenterOffset = elOffset + (elSize / 2);
+ var viewportCenterOffset = vpOffset + (vpSize / 2);
+ var isInView =
+ elSize <= vpSize
+ && elOffset >= vpOffset
+ && elOffset + elSize <= vpOffset + vpSize;
+
+ if(scrollNever)
+ doNotScroll[xy] = true;
+ else if(!doNotScroll[xy]) {
+ if (blockIsNearest || scrollIfNeeded) {
+ doNotScroll[xy] = scrollIfNeeded ? isInView : false;
+ blockIsEnd = elSize < vpSize ? elementCenterOffset > viewportCenterOffset : elementCenterOffset < viewportCenterOffset;
+ }
+ elementScrollCoordinates[xy] -= blockIsEnd || blockIsCenter ? ((vpSize / divide) - (elSize / divide)) * (isX && _isRTL && normalizeRTL ? -1 : 1) : 0;
+ }
+ };
+ finalizeBlock(true);
+ finalizeBlock(false);
+ }
+
+ if (doNotScroll.y)
+ delete elementScrollCoordinates.y;
+ if (doNotScroll.x)
+ delete elementScrollCoordinates.x;
+
+ coordinates = elementScrollCoordinates;
+ }
+
+ finalScroll[_strScrollLeft] = getFinalScroll(true, getRawScroll(coordinates).x);
+ finalScroll[_strScrollTop] = getFinalScroll(false, getRawScroll(coordinates).y);
+ doScrollLeft = finalScroll[_strScrollLeft] !== undefined;
+ doScrollTop = finalScroll[_strScrollTop] !== undefined;
+
+ if ((doScrollLeft || doScrollTop) && (duration > 0 || durationIsObject)) {
+ if (durationIsObject)
+ _viewportElement.animate(finalScroll, duration);
+ else {
+ animationOptions = {
+ duration: duration,
+ complete: complete
+ };
+ if (type(easing) == TYPES.a) {
+ var specialEasing = {};
+ specialEasing[_strScrollLeft] = easing[0];
+ specialEasing[_strScrollTop] = easing[1];
+ animationOptions.specialEasing = specialEasing;
+ }
+ else {
+ animationOptions.easing = easing;
+ }
+ _viewportElement.animate(finalScroll, animationOptions);
+ }
+ }
+ else {
+ if (doScrollLeft)
+ _viewportElement[_strScrollLeft](finalScroll[_strScrollLeft]);
+ if (doScrollTop)
+ _viewportElement[_strScrollTop](finalScroll[_strScrollTop]);
+ }
+ };
+
+ /**
+ * Stops all scroll animations.
+ * @returns {*} The current OverlayScrollbars instance (for chaining).
+ */
+ _base.scrollStop = function (param1, param2, param3) {
+ _viewportElement.stop(param1, param2, param3);
+ return _base;
+ };
+
+ /**
+ * Returns all relevant elements.
+ * @param elementName The name of the element which shall be returned.
+ * @returns {{target: *, host: *, padding: *, viewport: *, content: *, scrollbarHorizontal: {scrollbar: *, track: *, handle: *}, scrollbarVertical: {scrollbar: *, track: *, handle: *}, scrollbarCorner: *} | *}
+ */
+ _base.getElements = function (elementName) {
+ var obj = {
+ target: _targetElement[0],
+ host: _hostElement[0],
+ padding: _paddingElement[0],
+ viewport: _viewportElement[0],
+ content: _contentElement[0],
+ scrollbarHorizontal: {
+ scrollbar: _scrollbarHorizontalElement[0],
+ track: _scrollbarHorizontalTrackElement[0],
+ handle: _scrollbarHorizontalHandleElement[0]
+ },
+ scrollbarVertical: {
+ scrollbar: _scrollbarVerticalElement[0],
+ track: _scrollbarVerticalTrackElement[0],
+ handle: _scrollbarVerticalHandleElement[0]
+ },
+ scrollbarCorner: _scrollbarCornerElement[0]
+ };
+ return type(elementName) == TYPES.s ? getObjectPropVal(obj, elementName) : obj;
+ };
+
+ /**
+ * Returns a object which describes the current state of this instance.
+ * @param stateProperty A specific property from the state object which shall be returned.
+ * @returns {{widthAuto, heightAuto, overflowAmount, hideOverflow, hasOverflow, contentScrollSize, viewportSize, hostSize, autoUpdate} | *}
+ */
+ _base.getState = function (stateProperty) {
+ var prepare = function (obj) {
+ if (!FRAMEWORK.isPlainObject(obj))
+ return obj;
+ var extended = extend(true, {}, obj);
+ var changePropertyName = function (from, to) {
+ if (extended.hasOwnProperty(from)) {
+ extended[to] = extended[from];
+ delete extended[from];
+ }
+ };
+ changePropertyName('w', _strWidth); //change w to width
+ changePropertyName('h', _strHeight); //change h to height
+ delete extended.c; //delete c (the 'changed' prop)
+ return extended;
+ };
+ var obj = {
+ sleeping: prepare(_isSleeping) || false,
+ autoUpdate: prepare(!_mutationObserverConnected),
+ widthAuto: prepare(_widthAutoCache),
+ heightAuto: prepare(_heightAutoCache),
+ padding: prepare(_cssPaddingCache),
+ overflowAmount: prepare(_overflowAmountCache),
+ hideOverflow: prepare(_hideOverflowCache),
+ hasOverflow: prepare(_hasOverflowCache),
+ contentScrollSize: prepare(_contentScrollSizeCache),
+ viewportSize: prepare(_viewportSize),
+ hostSize: prepare(_hostSizeCache),
+ documentMixed : prepare(_documentMixed)
+ };
+ return type(stateProperty) == TYPES.s ? getObjectPropVal(obj, stateProperty) : obj;
+ };
+
+ /**
+ * Gets all or specific extension instance.
+ * @param extName The name of the extension from which the instance shall be got.
+ * @returns {{}} The instance of the extension with the given name or undefined if the instance couldn't be found.
+ */
+ _base.ext = function(extName) {
+ var result;
+ var privateMethods = _extensionsPrivateMethods.split(' ');
+ var i = 0;
+ if(type(extName) == TYPES.s) {
+ if(_extensions.hasOwnProperty(extName)) {
+ result = extend(true, {}, _extensions[extName]);
+ for (; i < privateMethods.length; i++)
+ delete result[privateMethods[i]];
+ }
+ }
+ else {
+ result = { };
+ for(i in _extensions)
+ result[i] = extend(true, { }, _base.ext(i));
+ }
+ return result;
+ };
+
+ /**
+ * Adds a extension to this instance.
+ * @param extName The name of the extension which shall be added.
+ * @param extensionOptions The extension options which shall be used.
+ * @returns {{}} The instance of the added extension or undefined if the extension couldn't be added properly.
+ */
+ _base.addExt = function(extName, extensionOptions) {
+ var registeredExtensionObj = window[PLUGINNAME].extension(extName);
+ var instance;
+ var instanceAdded;
+ var instanceContract;
+ var contractResult;
+ var contractFulfilled = true;
+ if(registeredExtensionObj) {
+ if(!_extensions.hasOwnProperty(extName)) {
+ instance = registeredExtensionObj.extension.call(_base,
+ extend(true, { }, registeredExtensionObj.defaultOptions),
+ FRAMEWORK,
+ COMPATIBILITY);
+
+ if (instance) {
+ instanceContract = instance.contract;
+ if (type(instanceContract) == TYPES.f) {
+ contractResult = instanceContract(window);
+ contractFulfilled = type(contractResult) == TYPES.b ? contractResult : contractFulfilled;
+ }
+ if(contractFulfilled) {
+ _extensions[extName] = instance;
+ instanceAdded = instance.added;
+ if(type(instanceAdded) == TYPES.f)
+ instanceAdded(extensionOptions);
+
+ return _base.ext(extName);
+ }
+ }
+ }
+ else
+ return _base.ext(extName);
+ }
+ else
+ console.warn("A extension with the name \"" + extName + "\" isn't registered.");
+ };
+
+ /**
+ * Removes a extension from this instance.
+ * @param extName The name of the extension which shall be removed.
+ * @returns {boolean} True if the extension was removed, false otherwise e.g. if the extension wasn't added before.
+ */
+ _base.removeExt = function(extName) {
+ var instance = _extensions[extName];
+ var instanceRemoved;
+ if(instance) {
+ delete _extensions[extName];
+
+ instanceRemoved = instance.removed;
+ if(type(instanceRemoved) == TYPES.f)
+ instanceRemoved();
+
+ return true;
+ }
+ return false;
+ };
+
+ /**
+ * Constructs the plugin.
+ * @param targetElement The element to which the plugin shall be applied.
+ * @param options The initial options of the plugin.
+ * @param extensions The extension(s) which shall be added right after the initialization.
+ * @returns {boolean} True if the plugin was successfully initialized, false otherwise.
+ */
+ function construct(targetElement, options, extensions) {
+ _defaultOptions = globals.defaultOptions;
+ _nativeScrollbarStyling = globals.nativeScrollbarStyling;
+ _nativeScrollbarSize = extend(true, {}, globals.nativeScrollbarSize);
+ _nativeScrollbarIsOverlaid = extend(true, {}, globals.nativeScrollbarIsOverlaid);
+ _overlayScrollbarDummySize = extend(true, {}, globals.overlayScrollbarDummySize);
+ _rtlScrollBehavior = extend(true, {}, globals.rtlScrollBehavior);
+
+ //parse & set options but don't update
+ setOptions(extend(true, { }, _defaultOptions, options));
+
+ //check if the plugin hasn't to be initialized
+ if (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.x && !_currentPreparedOptions.nativeScrollbarsOverlaid.initialize) {
+ callCallback("onInitializationWithdrawn");
+ return false;
+ }
+
+ _cssCalc = globals.cssCalc;
+ _msieVersion = globals.msie;
+ _autoUpdateRecommended = globals.autoUpdateRecommended;
+ _supportTransition = globals.supportTransition;
+ _supportTransform = globals.supportTransform;
+ _supportPassiveEvents = globals.supportPassiveEvents;
+ _supportResizeObserver = globals.supportResizeObserver;
+ _supportMutationObserver = globals.supportMutationObserver;
+ _restrictedMeasuring = globals.restrictedMeasuring;
+ _documentElement = FRAMEWORK(targetElement.ownerDocument);
+ _windowElement = FRAMEWORK(_documentElement[0].defaultView || _documentElement[0].parentWindow);
+ _htmlElement = findFirst(_documentElement, 'html');
+ _bodyElement = findFirst(_htmlElement, 'body');
+ _targetElement = FRAMEWORK(targetElement);
+ _isTextarea = _targetElement.is('textarea');
+ _isBody = _targetElement.is('body');
+ _documentMixed = _documentElement[0] !== document;
+
+ var initBodyScroll;
+ if (_isBody) {
+ initBodyScroll = {};
+ initBodyScroll.l = Math.max(_targetElement[_strScrollLeft](), _htmlElement[_strScrollLeft](), _windowElement[_strScrollLeft]());
+ initBodyScroll.t = Math.max(_targetElement[_strScrollTop](), _htmlElement[_strScrollTop](), _windowElement[_strScrollTop]());
+ }
+
+ //build Hide-scrollbars DOM
+ if (_isTextarea) {
+ _targetElement.wrap(generateDiv(_classNameHostTextareaElement));
+ addClass(_targetElement, _classNameTextareaElement + _strSpace + _classNameTextInherit);
+ _hostElement = _targetElement.parent();
+ var hostElementCSS = {};
+ if (!_currentPreparedOptions.sizeAutoCapable) {
+ hostElementCSS[_strWidth] = _targetElement.css(_strWidth);
+ hostElementCSS[_strHeight] = _targetElement.css(_strHeight);
+ }
+ _hostElement.css(hostElementCSS)
+ .wrapInner(generateDiv(_classNameContentElement + _strSpace + _classNameTextInherit))
+ .wrapInner(generateDiv(_classNameViewportElement + _strSpace + _classNameTextInherit))
+ .wrapInner(generateDiv(_classNamePaddingElement + _strSpace + _classNameTextInherit));
+ _contentElement = findFirst(_hostElement, _strDot + _classNameContentElement);
+ _viewportElement = findFirst(_hostElement, _strDot + _classNameViewportElement);
+ _paddingElement = findFirst(_hostElement, _strDot + _classNamePaddingElement);
+ _textareaCoverElement = FRAMEWORK(generateDiv(_classNameTextareaCoverElement));
+ _contentElement.prepend(_textareaCoverElement);
+
+ _targetElement.on(_strScroll, textareaOnScroll)
+ .on('drop', textareaOnDrop)
+ .on('focus', textareaOnFocus)
+ .on('focusout', textareaOnFocusOut);
+ if (_msieVersion > 9 || !_autoUpdateRecommended) {
+ _targetElement.on('input', textareaOnInput);
+ }
+ else {
+ _targetElement.on(_strKeyDownEvent, textareaOnKeyDown)
+ .on(_strKeyUpEvent, textareaOnKeyUp);
+ }
+ } else {
+ addClass(_targetElement, _classNameHostElement);
+ _hostElement = _targetElement;
+ _hostElement.wrapInner(generateDiv(_classNameContentElement))
+ .wrapInner(generateDiv(_classNameViewportElement))
+ .wrapInner(generateDiv(_classNamePaddingElement));
+ _contentElement = findFirst(_hostElement, _strDot + _classNameContentElement);
+ _viewportElement = findFirst(_hostElement, _strDot + _classNameViewportElement);
+ _paddingElement = findFirst(_hostElement, _strDot + _classNamePaddingElement);
+
+ //add transitionend event
+ _contentElement.on(_strTransitionEndEvent, function (event) {
+ if (_autoUpdateCache === true)
+ return;
+ event = event.originalEvent || event;
+ if (isSizeAffectingCSSProperty(event.propertyName))
+ update(_strAuto);
+ });
+ }
+
+ buildScrollbars();
+
+ //add scroll event
+ if (_supportPassiveEvents)
+ addPassiveEventListener(_viewportElement, _strScroll, viewportOnScroll);
+ else
+ _viewportElement.on(_strScroll, viewportOnScroll);
+
+ if (_nativeScrollbarStyling)
+ addClass(_viewportElement, _nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y ? _classNameViewportNativeScrollbarsOverlaid : _classNameViewportNativeScrollbarsInvisible);
+
+ //build mutation observers
+ if (_supportMutationObserver) {
+ var mutationObserver = COMPATIBILITY.mO();
+ var contentLastUpdate = COMPATIBILITY.now();
+ var mutationTarget;
+ var mutationAttrName;
+ var contentTimeout;
+ var now;
+ var sizeAuto;
+ var action;
+
+ _mutationObserverHost = new mutationObserver(function (mutations) {
+ if (!_initialized || _isSleeping)
+ return;
+
+ var doUpdate = false;
+ //var doUpdateScrollbars = false;
+ var mutation;
+ FRAMEWORK.each(mutations, function () {
+ mutation = this;
+ mutationTarget = mutation.target;
+ mutationAttrName = mutation.attributeName;
+
+ if (mutationAttrName === LEXICON.c)
+ doUpdate = hostClassNamesChanged(mutation.oldValue, mutationTarget.className);
+ else if (mutationAttrName === LEXICON.s)
+ doUpdate = mutation.oldValue !== mutationTarget[LEXICON.s].cssText;
+ else
+ doUpdate = true;
+
+ if (doUpdate)
+ return false;
+ });
+
+ if (doUpdate)
+ _base.update(_strAuto);
+ /*
+ if(doUpdateScrollbars) {
+ refreshScrollbarHandleLength(true);
+ refreshScrollbarHandleOffset(true, _scrollHorizontalInfo.cs);
+ refreshScrollbarHandleLength(false);
+ refreshScrollbarHandleOffset(false, _scrollVerticalInfo.cs);
+ }
+ */
+ });
+ _mutationObserverContent = new mutationObserver(function (mutations) {
+ if (!_initialized || _isSleeping)
+ return;
+
+ var doUpdate = false;
+ var mutation;
+ FRAMEWORK.each(mutations, function () {
+ mutation = this;
+ doUpdate = isUnknownMutation(mutation);
+ return !doUpdate;
+ });
+
+ if (doUpdate) {
+ now = COMPATIBILITY.now();
+ sizeAuto = (_heightAutoCache || _widthAutoCache);
+ action = function () {
+ if(!_destroyed) {
+ contentLastUpdate = now;
+
+ //if cols, rows or wrap attr was changed
+ if (_isTextarea)
+ textareaUpdate();
+
+ if (sizeAuto)
+ update();
+ else
+ _base.update(_strAuto);
+ }
+ };
+ clearTimeout(contentTimeout);
+ if (_mutationObserverContentLag <= 0 || now - contentLastUpdate > _mutationObserverContentLag || !sizeAuto)
+ action();
+ else
+ contentTimeout = setTimeout(action, _mutationObserverContentLag);
+ }
+ });
+ }
+
+ //build resize observer for the host element
+ if (_isBody) {
+ addClass(_htmlElement, _classNameHTMLElement);
+
+ //apply the body scroll to handle it right in the update method
+ _viewportElement[_strScrollLeft](initBodyScroll.l);
+ _viewportElement[_strScrollTop](initBodyScroll.t);
+ }
+ _sizeObserverElement = FRAMEWORK(generateDiv('os-resize-observer-host'));
+ _hostElement.prepend(_sizeObserverElement);
+ addResizeObserver(_sizeObserverElement, hostOnResized);
+
+ //update for the first time
+ hostOnResized(); //initialize cache for host size
+ _base.update(_strAuto); //initialize cache for content
+
+ //add the transition class for transitions AFTER the first update (for preventing unwanted transitions)
+ setTimeout(function () {
+ if (_supportTransition && !_destroyed)
+ addClass(_hostElement, _classNameHostTransition)
+ }, 333);
+
+ //the plugin is initialized now!
+ _initialized = true;
+ callCallback("onInitialized");
+
+ //add extensions
+ if(type(extensions) == TYPES.s)
+ extensions = [ extensions ];
+ if(COMPATIBILITY.isA(extensions))
+ FRAMEWORK.each(extensions, function () {_base.addExt(this); });
+ else if(FRAMEWORK.isPlainObject(extensions))
+ FRAMEWORK.each(extensions, function (key, value) { _base.addExt(key, value); });
+
+ return _initialized;
+ }
+
+ if (construct(pluginTargetElement, options, extensions)) {
+ INSTANCES(pluginTargetElement, _base);
+ return _base;
+ }
+ _base = undefined;
+ }
+
+ /**
+ * Initializes a new OverlayScrollbarsInstance object or changes options if already initialized or returns the current instance.
+ * @param pluginTargetElements The elements to which the Plugin shall be initialized.
+ * @param options The custom options with which the plugin shall be initialized.
+ * @param extensions The extension(s) which shall be added right after initialization.
+ * @returns {*}
+ */
+ window[PLUGINNAME] = function(pluginTargetElements, options, extensions) {
+ if(arguments.length === 0)
+ return this;
+
+ initOverlayScrollbarsStatics();
+
+ var arr = [ ];
+ var inst;
+ var result;
+ if(FRAMEWORK.isPlainObject(options)) {
+ if (pluginTargetElements && pluginTargetElements.length) {
+ FRAMEWORK.each(pluginTargetElements, function () {
+ inst = this;
+ if(inst !== undefined)
+ arr.push(OverlayScrollbarsInstance(inst, options, extensions, _pluginsGlobals, _pluginsAutoUpdateLoop));
+ });
+ result = arr.length > 1 ? arr : arr[0];
+ }
+ else
+ result = OverlayScrollbarsInstance(pluginTargetElements, options, extensions, _pluginsGlobals, _pluginsAutoUpdateLoop);
+ }
+ else if(pluginTargetElements) {
+ if(pluginTargetElements.length && pluginTargetElements.length > 0) {
+ FRAMEWORK.each(pluginTargetElements, function() {
+ inst = INSTANCES(this);
+ if(options === '!') {
+ if(inst instanceof window[PLUGINNAME])
+ arr.push(inst);
+ }
+ else
+ arr.push(inst);
+ });
+ result = arr.length > 1 ? arr : arr[0];
+ }
+ else
+ result = INSTANCES(pluginTargetElements);
+ }
+ return result;
+ };
+
+ /**
+ * Returns a object which contains global information about the plugin and each instance of it.
+ * The returned object is just a copy, that means that changes to the returned object won't have any effect to the original object.
+ */
+ window[PLUGINNAME].globals = function () {
+ initOverlayScrollbarsStatics();
+ var globals = FRAMEWORK.extend(true, { }, _pluginsGlobals);
+ delete globals['msie'];
+ return globals;
+ };
+
+ /**
+ * Gets or Sets the default options for each new plugin initialization.
+ * @param newDefaultOptions The object with which the default options shall be extended.
+ */
+ window[PLUGINNAME].defaultOptions = function(newDefaultOptions) {
+ initOverlayScrollbarsStatics();
+ var currDefaultOptions = _pluginsGlobals.defaultOptions;
+ if(newDefaultOptions === undefined)
+ return FRAMEWORK.extend(true, { }, currDefaultOptions);
+
+ //set the new default options
+ _pluginsGlobals.defaultOptions = FRAMEWORK.extend(true, { }, currDefaultOptions , _pluginsOptions.v(newDefaultOptions, _pluginsOptions.t, true));
+ };
+
+ /**
+ * Registers, Unregisters or returns a extension.
+ * Register: Pass the name and the extension. (defaultOptions is optional)
+ * Unregister: Pass the name and anything except a function as extension parameter.
+ * Get extension: Pass the name of the extension which shall be got.
+ * Get all extensions: Pass no arguments.
+ * @param extensionName The name of the extension which shall be registered, unregistered or returned.
+ * @param extension A function which generates the instance of the extension or anything other to remove a already registered extension.
+ * @param defaultOptions The default options which shall be used for the registered extension.
+ */
+ window[PLUGINNAME].extension = function(extensionName, extension, defaultOptions) {
+ var extNameTypeString = COMPATIBILITY.type(extensionName) == TYPES.s;
+ var argLen = arguments[LEXICON.l];
+ var i = 0;
+ if(argLen < 1 || !extNameTypeString) {
+ //return a copy of all extension objects
+ return FRAMEWORK.extend(true, { length : _pluginsExtensions[LEXICON.l] }, _pluginsExtensions);
+ }
+ else if(extNameTypeString) {
+ if(COMPATIBILITY.type(extension) == TYPES.f) {
+ //register extension
+ _pluginsExtensions.push({
+ name : extensionName,
+ extension : extension,
+ defaultOptions : defaultOptions
+ });
+ }
+ else {
+ for(; i < _pluginsExtensions[LEXICON.l]; i++) {
+ if (_pluginsExtensions[i].name === extensionName) {
+ if(argLen > 1)
+ _pluginsExtensions.splice(i, 1); //remove extension
+ else
+ return FRAMEWORK.extend(true, { }, _pluginsExtensions[i]); //return extension with the given name
+ }
+ }
+ }
+ }
+ };
+
+ return window[PLUGINNAME];
+ })();
+
+ if(JQUERY && JQUERY.fn) {
+ /**
+ * The jQuery initialization interface.
+ * @param options The initial options for the construction of the plugin. To initialize the plugin, this option has to be a object! If it isn't a object, the instance(s) are returned and the plugin wont be initialized.
+ * @param extensions The extension(s) which shall be added right after initialization.
+ * @returns {*} After initialization it returns the jQuery element array, else it returns the instance(s) of the elements which are selected.
+ */
+ JQUERY.fn.overlayScrollbars = function (options, extensions) {
+ var _elements = this;
+ if(JQUERY.isPlainObject(options)) {
+ JQUERY.each(_elements, function() { PLUGIN(this, options, extensions); });
+ return _elements;
+ }
+ else
+ return PLUGIN(_elements, options);
+ };
+ }
+ return PLUGIN;
+ }
+));
\ No newline at end of file
diff --git a/apps/config_explorer/appserver/static/OverlayScrollbars.min.css b/apps/config_explorer/appserver/static/OverlayScrollbars.min.css
new file mode 100755
index 00000000..e405c52f
--- /dev/null
+++ b/apps/config_explorer/appserver/static/OverlayScrollbars.min.css
@@ -0,0 +1,13 @@
+/*!
+ * OverlayScrollbars
+ * https://github.com/KingSora/OverlayScrollbars
+ *
+ * Version: 1.5.3
+ *
+ * Copyright KingSora.
+ * https://github.com/KingSora
+ *
+ * Released under the MIT license.
+ * Date: 07.11.2018
+ */
+html.os-html,html.os-html>.os-host{display:block;overflow:hidden;box-sizing:border-box;height:100%!important;width:100%!important;min-width:100%!important;min-height:100%!important;margin:0!important;position:absolute!important}.os-padding,.os-viewport{top:0;left:0;right:0;margin:0;padding:0;bottom:0}html.os-html>.os-host>.os-padding{position:absolute}body.os-dragging,body.os-dragging *{cursor:default}.os-host,.os-host-textarea{position:relative;overflow:visible!important;flex-direction:column;flex-wrap:wrap;justify-content:flex-start;align-content:flex-start;align-items:flex-start}.os-host-flexbox{overflow:hidden!important;display:flex}.os-host-flexbox>.os-padding>.os-viewport>.os-content{display:flex}#hs-dummy-scrollbar-size{position:fixed;opacity:0;-ms-filter:'progid:DXImageTransform.Microsoft.Alpha(Opacity=0)';visibility:hidden;overflow:scroll;height:500px;width:500px}#hs-dummy-scrollbar-size,.os-viewport{-ms-overflow-style:scrollbar!important}.os-viewport-native-scrollbars-invisible#hs-dummy-scrollbar-size::-webkit-scrollbar,.os-viewport-native-scrollbars-invisible#hs-dummy-scrollbar-size::-webkit-scrollbar-corner,.os-viewport-native-scrollbars-invisible.os-viewport::-webkit-scrollbar,.os-viewport-native-scrollbars-invisible.os-viewport::-webkit-scrollbar-corner{display:none!important;width:0!important;height:0!important;visibility:hidden!important;background:0 0!important}.os-content-glue{max-height:100%;max-width:100%;width:100%;pointer-events:none}.os-padding{direction:inherit;position:absolute;overflow:visible;width:auto!important;height:auto!important;z-index:1}.os-host-overflow>.os-padding,.os-viewport{overflow:hidden}.os-viewport{direction:inherit!important;box-sizing:inherit!important;resize:none!important;position:absolute;-webkit-overflow-scrolling:touch}.os-content-arrange{position:absolute;z-index:-1;min-height:1px;min-width:1px;pointer-events:none}.os-content{direction:inherit;box-sizing:border-box!important;position:relative;display:block;height:100%;width:100%;visibility:visible}.os-content>.os-textarea{direction:inherit!important;float:none!important;margin:0!important;max-height:none!important;max-width:none!important;border:none!important;border-radius:0!important;background:0 0!important;outline:transparent 0!important;overflow:hidden!important;resize:none!important;position:absolute!important;top:0!important;left:0!important;z-index:1;padding:0}.os-host-rtl>.os-padding>.os-viewport>.os-content>.os-textarea{right:0!important}.os-content>.os-textarea-cover{z-index:-1;pointer-events:none}.os-content>.os-textarea[wrap=off]{white-space:pre!important;margin:0!important}.os-text-inherit{font-family:inherit;font-size:inherit;font-weight:inherit;font-style:inherit;font-variant:inherit;text-transform:inherit;text-decoration:inherit;text-indent:inherit;text-align:inherit;text-shadow:inherit;text-overflow:inherit;letter-spacing:inherit;word-spacing:inherit;line-height:inherit;unicode-bidi:inherit;direction:inherit;color:inherit;cursor:text}.os-resize-observer,.os-resize-observer-host{box-sizing:inherit;display:block;opacity:0;position:absolute;top:0;left:0;height:100%;width:100%;overflow:hidden;pointer-events:none;z-index:-1}.os-resize-observer-host{padding:inherit;border:solid inherit;box-sizing:border-box}.os-resize-observer-host:after{content:''}.os-resize-observer-host:after,.os-resize-observer-host>.os-resize-observer{height:200%;width:200%;padding:inherit;border:inherit;margin:0;display:block;box-sizing:content-box}.os-resize-observer.observed,object.os-resize-observer{box-sizing:border-box!important}.os-size-auto-observer{box-sizing:inherit!important;height:100%;width:inherit;max-width:1px;position:relative;float:left;max-height:1px;overflow:hidden;z-index:-1;padding:0;margin:0;pointer-events:none;flex-grow:inherit;flex-shrink:0;flex-basis:0}.os-size-auto-observer>.os-resize-observer{width:1000%;height:1000%;min-height:1px;min-width:1px}.os-resize-observer-item{position:absolute;top:0;right:0;bottom:0;left:0;overflow:hidden;z-index:-1;opacity:0;direction:ltr!important;-webkit-box-flex:0!important;-ms-flex:none!important;flex:none!important}.os-resize-observer-item-final{position:absolute;left:0;top:0;-webkit-transition:none!important;transition:none!important;-webkit-box-flex:0!important;-ms-flex:none!important;flex:none!important}.os-resize-observer{-webkit-animation-duration:1ms;animation-duration:1ms;-webkit-animation-name:hs-resize-observer-dummy-animation;animation-name:hs-resize-observer-dummy-animation}.os-host-transition>.os-scrollbar,.os-host-transition>.os-scrollbar-corner{-webkit-transition:opacity .3s,visibility .3s,top .3s,right .3s,bottom .3s,left .3s;transition:opacity .3s,visibility .3s,top .3s,right .3s,bottom .3s,left .3s}html.os-html>.os-host>.os-scrollbar{position:absolute;z-index:999999}.os-scrollbar,.os-scrollbar-corner{position:absolute;opacity:1;-ms-filter:'progid:DXImageTransform.Microsoft.Alpha(Opacity=100)';z-index:1}.os-scrollbar-corner{bottom:0;right:0}.os-scrollbar{pointer-events:none}.os-scrollbar-handle,.os-scrollbar-track{pointer-events:auto;width:100%;height:100%}.os-scrollbar-track{position:relative;padding:0!important;border:none!important}.os-scrollbar-handle{position:absolute}.os-scrollbar-handle-off,.os-scrollbar-track-off{pointer-events:none}.os-scrollbar.os-scrollbar-unusable,.os-scrollbar.os-scrollbar-unusable *{pointer-events:none!important}.os-scrollbar.os-scrollbar-unusable .os-scrollbar-handle{opacity:0!important}.os-scrollbar-horizontal{bottom:0;left:0}.os-scrollbar-vertical{top:0;right:0}.os-host-rtl>.os-scrollbar-horizontal{right:0}.os-host-rtl>.os-scrollbar-corner,.os-host-rtl>.os-scrollbar-vertical{right:auto;left:0}.os-host-resize-disabled.os-host-scrollbar-horizontal-hidden>.os-scrollbar-corner,.os-host-resize-disabled.os-host-scrollbar-vertical-hidden>.os-scrollbar-corner,.os-host-scrollbar-horizontal-hidden>.os-scrollbar-horizontal,.os-host-scrollbar-vertical-hidden>.os-scrollbar-vertical,.os-padding+.os-scrollbar-corner,.os-scrollbar-auto-hidden,.os-scrollbar-horizontal+.os-scrollbar-vertical.os-scrollbar-auto-hidden+.os-scrollbar-corner,.os-scrollbar-horizontal.os-scrollbar-auto-hidden+.os-scrollbar-vertical+.os-scrollbar-corner,.os-scrollbar-horizontal.os-scrollbar-auto-hidden+.os-scrollbar-vertical.os-scrollbar-auto-hidden+.os-scrollbar-corner{opacity:0;visibility:hidden;pointer-events:none}.os-scrollbar-corner-resize-both{cursor:nwse-resize}.os-host-rtl>.os-scrollbar-corner-resize-both{cursor:nesw-resize}.os-scrollbar-corner-resize-horizontal{cursor:ew-resize}.os-scrollbar-corner-resize-vertical{cursor:ns-resize}.os-dragging .os-scrollbar-corner.os-scrollbar-corner-resize{cursor:default}.os-host-resize-disabled.os-host-scrollbar-horizontal-hidden>.os-scrollbar-vertical{top:0;bottom:0}.os-host-resize-disabled.os-host-scrollbar-vertical-hidden>.os-scrollbar-horizontal,.os-host-rtl.os-host-resize-disabled.os-host-scrollbar-vertical-hidden>.os-scrollbar-horizontal{right:0;left:0}.os-scrollbar-corner.os-scrollbar-corner-resize,.os-scrollbar:hover{opacity:1!important;visibility:visible!important}.os-scrollbar-corner.os-scrollbar-corner-resize{background-image:url(data:image/svg+xml;base64,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);background-repeat:no-repeat;background-position:100% 100%;pointer-events:auto!important}.os-host-rtl>.os-scrollbar-corner.os-scrollbar-corner-resize{-webkit-transform:scale(-1,1);transform:scale(-1,1)}.os-host-overflow{overflow:hidden!important}@-webkit-keyframes hs-resize-observer-dummy-animation{from{z-index:0}to{z-index:-1}}@keyframes hs-resize-observer-dummy-animation{from{z-index:0}to{z-index:-1}}.os-theme-none>.os-scrollbar-corner,.os-theme-none>.os-scrollbar-horizontal,.os-theme-none>.os-scrollbar-vertical{display:none!important}.os-theme-none>.os-scrollbar-corner-resize{display:block!important;min-width:10px;min-height:10px}.os-theme-dark>.os-scrollbar-horizontal,.os-theme-light>.os-scrollbar-horizontal{right:10px;height:10px}.os-theme-dark>.os-scrollbar-vertical,.os-theme-light>.os-scrollbar-vertical{bottom:10px;width:10px}.os-theme-dark.os-host-rtl>.os-scrollbar-horizontal,.os-theme-light.os-host-rtl>.os-scrollbar-horizontal{left:10px;right:0}.os-theme-dark>.os-scrollbar-corner,.os-theme-light>.os-scrollbar-corner{height:10px;width:10px;background-color:transparent}.os-theme-dark>.os-scrollbar,.os-theme-light>.os-scrollbar{padding:2px;box-sizing:border-box;background:0 0}.os-theme-dark>.os-scrollbar.os-scrollbar-unusable,.os-theme-dark>.os-scrollbar>.os-scrollbar-track,.os-theme-light>.os-scrollbar.os-scrollbar-unusable,.os-theme-light>.os-scrollbar>.os-scrollbar-track{background:0 0}.os-theme-dark>.os-scrollbar-horizontal>.os-scrollbar-track>.os-scrollbar-handle,.os-theme-light>.os-scrollbar-horizontal>.os-scrollbar-track>.os-scrollbar-handle{min-width:30px}.os-theme-dark>.os-scrollbar-vertical>.os-scrollbar-track>.os-scrollbar-handle,.os-theme-light>.os-scrollbar-vertical>.os-scrollbar-track>.os-scrollbar-handle{min-height:30px}.os-theme-dark.os-host-transition>.os-scrollbar>.os-scrollbar-track>.os-scrollbar-handle,.os-theme-light.os-host-transition>.os-scrollbar>.os-scrollbar-track>.os-scrollbar-handle{-webkit-transition:background-color .3s;transition:background-color .3s}.os-theme-dark>.os-scrollbar>.os-scrollbar-track,.os-theme-dark>.os-scrollbar>.os-scrollbar-track>.os-scrollbar-handle,.os-theme-light>.os-scrollbar>.os-scrollbar-track,.os-theme-light>.os-scrollbar>.os-scrollbar-track>.os-scrollbar-handle{border-radius:10px}.os-theme-dark>.os-scrollbar>.os-scrollbar-track>.os-scrollbar-handle{background:rgba(0,0,0,.4)}.os-theme-light>.os-scrollbar>.os-scrollbar-track>.os-scrollbar-handle{background:rgba(255,255,255,.4)}.os-theme-dark>.os-scrollbar:hover>.os-scrollbar-track>.os-scrollbar-handle{background:rgba(0,0,0,.55)}.os-theme-light>.os-scrollbar:hover>.os-scrollbar-track>.os-scrollbar-handle{background:rgba(255,255,255,.55)}.os-theme-dark>.os-scrollbar>.os-scrollbar-track>.os-scrollbar-handle.active{background:rgba(0,0,0,.7)}.os-theme-light>.os-scrollbar>.os-scrollbar-track>.os-scrollbar-handle.active{background:rgba(255,255,255,.7)}.os-theme-dark>.os-scrollbar-horizontal .os-scrollbar-handle:before,.os-theme-dark>.os-scrollbar-vertical .os-scrollbar-handle:before,.os-theme-light>.os-scrollbar-horizontal .os-scrollbar-handle:before,.os-theme-light>.os-scrollbar-vertical .os-scrollbar-handle:before{content:'';position:absolute;left:0;right:0;top:0;bottom:0;display:block}.os-theme-dark.os-host-scrollbar-horizontal-hidden>.os-scrollbar-horizontal .os-scrollbar-handle:before,.os-theme-dark.os-host-scrollbar-vertical-hidden>.os-scrollbar-vertical .os-scrollbar-handle:before,.os-theme-light.os-host-scrollbar-horizontal-hidden>.os-scrollbar-horizontal .os-scrollbar-handle:before,.os-theme-light.os-host-scrollbar-vertical-hidden>.os-scrollbar-vertical .os-scrollbar-handle:before{display:none}.os-theme-dark>.os-scrollbar-horizontal .os-scrollbar-handle:before,.os-theme-light>.os-scrollbar-horizontal .os-scrollbar-handle:before{top:-6px;bottom:-2px}.os-theme-dark>.os-scrollbar-vertical .os-scrollbar-handle:before,.os-theme-light>.os-scrollbar-vertical .os-scrollbar-handle:before{left:-6px;right:-2px}.os-host-rtl.os-theme-dark>.os-scrollbar-vertical .os-scrollbar-handle:before,.os-host-rtl.os-theme-light>.os-scrollbar-vertical .os-scrollbar-handle:before{right:-6px;left:-2px}
\ No newline at end of file
diff --git a/apps/config_explorer/appserver/static/config.css b/apps/config_explorer/appserver/static/config.css
new file mode 100755
index 00000000..54ad289e
--- /dev/null
+++ b/apps/config_explorer/appserver/static/config.css
@@ -0,0 +1,1128 @@
+body {
+ display: flex;
+ flex-direction: column;
+ position: fixed;
+ width: 100%;
+ height: 100%;
+}
+header {
+ flex: 0 0 auto;
+}
+.dashboard-body {
+ flex: 1 0 0%;
+ position: relative;
+ overflow: hidden;
+ background-color: #1e1e1e;
+}
+.dashboard-title {
+ display: none;
+}
+.panel-body.html {
+ /* this only appears during loading */
+ background-color: #1e1e1e;
+}
+.red {
+ color: #dd6a6f;
+}
+.bold {
+ font-weight: bold;
+}
+.dashboard-body a,
+.dashboard-body a:hover {
+ color: #00A4FD
+}
+.dashboard-body.ce_loading {
+ height: 100%;
+ position: absolute;
+ width: 100%;
+}
+.ce_loading .ce_wrap {
+ visibility: hidden;
+}
+.ce_no_write_access .ce_add_file,
+.ce_no_write_access .ce_add_folder,
+.ce_no_write_access .ce_upload_file,
+.ce_no_write_access .ce_rename_icon,
+.ce_no_write_access .ce_delete_icon {
+ display: none;
+}
+.ce_no_run_access .ce_app_run {
+ display: none;
+}
+.ce_no_settings_access .ce_app_settings {
+ display: none;
+}
+.ce_no_git_access .ce_app_changelog {
+ display: none;
+}
+.dashboard-body * {
+ box-sizing: border-box;
+}
+.dashboard-body a:focus,
+.dashboard-body a:active {
+ box-shadow: none !important;
+}
+.ce_bg_image {
+ position: absolute;
+ right: -37px;
+ opacity: 0.2;
+ width: 450px;
+ bottom: -40px;
+}
+.ce_tab_saving_icon {
+ color: #00A4FD;
+ animation: pulsate 1s infinite linear;
+ z-index: 9;
+}
+@keyframes pulsate{
+ 0% {
+ transform: scale(0.8, 0.8);
+ opacity: 0.2;
+ }
+ 50% {
+ transform: scale(1.2, 1.2);
+ opacity: 1.0;
+ }
+ 100% {
+ transform: scale(0.8, 0.8);
+ opacity: 0.2;
+ }
+}
+.ce_cancel {
+ text-align: center;
+ margin: 30px 10px;
+}
+.ce_timer {
+ color: #ccc;
+ text-align: center;
+}
+.ce_wrap {
+ position: absolute;
+ background-color: #353535;
+ top: 0;
+ bottom: 0;
+ right: 0;
+ left: 0;
+}
+.ce_file_wrap i{
+ margin-left: -18px;
+ position: absolute;
+}
+.ce_leftnav {
+ cursor: pointer;
+ white-space: nowrap;
+ border-left: 3px solid #1d1d1d;
+ padding: 2px 10px 2px 30px;
+}
+.ce_leftnav:hover {
+ background-color:#2a2d2e;
+ border-left: 3px solid #00A4FD;
+}
+.ce_leftnav_highlighted {
+ background-color: rgba(0, 99, 153, 1) !important;
+}
+.ce_leftnav_keyboard_selected:before {
+ font-size: 20px;
+ content: "\25B8";
+ font-family: Splunk Icons;
+ font-style: normal;
+ font-weight: 400;
+ text-decoration: inherit;
+ line-height: inherit;
+ position: absolute;
+ color: #00A4FD;
+ margin-left: -28px;
+}
+.ce_leftnav_name {
+ display: inline-block;
+ min-width: 300px;
+ width: 50%;
+ vertical-align: top;
+ text-overflow: ellipsis;
+ overflow: hidden;
+}
+.ce_leftnav_time {
+ display: inline-block;
+ min-width: 140px;
+ width: 24%;
+ vertical-align: top;
+}
+.ce_leftnav_size {
+ display: inline-block;
+ min-width: 50px;
+ text-align: right;
+ width: 16%;
+ vertical-align: top;
+ padding-right: 20px;
+}
+.ce_opacity06 {
+ opacity: 0.6;
+}
+.ce_tree_pane {
+ position: absolute;
+ width: 280px;
+ height: 100%;
+ background-color: #1d1d1d;
+}
+.ce_tree_pane .ce_spinner {
+ position: absolute;
+ left: 0;
+ right: 0;
+ transform: scale(0.75);
+ text-align: center;
+}
+.ce_tree_icons{
+ max-height: 38px;
+ background-color: #404040;
+ padding-left: 4px;
+ overflow: hidden;
+
+}
+.ce_tree_icons .ce_clickable_icon {
+ border: 2px solid #404040;
+ border-radius: 6px;
+ padding: 6px 8px 8px 6px;
+ margin: 4px 2px 0 2px;
+ text-align: center;
+ width: 32px;
+}
+.ce_tree_icons .ce_selected {
+ background-color: #1d1d1d;
+ border: 0 none;
+ border-top-right-radius: 8px;
+ border-top-left-radius: 8px;
+ border-bottom-right-radius: 0;
+ border-bottom-left-radius: 0;
+ color: white;
+ box-shadow: inset -6px 0 6px 0px #1d1d1d, 0 0 15px #404040, 0 0 30px #404040;
+}
+
+.ce_tree_btn {
+ display: none;
+}
+
+.ce_tree_btn_tab, .ce_tree_btn_show {
+ display: inline-block;
+}
+
+.ce_icons_divider {
+ height: 21px;
+ width: 5px;
+ margin-right: 4px;
+ border-right: 1px solid #262626;
+ display: inline-block;
+ transform: translateY(5px);
+}
+
+.ce_treenothing .icon-warning, .ce_treeempty .icon-warning {
+ margin-right: 8px;
+}
+.ce_treenothing, .ce_treeempty {
+ white-space: nowrap;
+ padding: 40px 10px 2px 22px;
+ text-overflow: ellipsis;
+ overflow: hidden;
+}
+.ce_treeempty{
+ opacity: 0.4;
+ margin-left: 22px;
+}
+.ce_treehighlight,
+.ce_treenothing_text {
+ color: #00A4FD;
+}
+.ce_link {
+ color: #00A4FD;
+ text-decoration: underline;
+ cursor: pointer;
+}
+.tooltip.in {
+ opacity: 0.95
+}
+input[type=text].ce_treesearch_input{
+ background-color: rgb(64, 64, 64);
+ color: white;
+ position: absolute;
+ z-index: 9;
+ bottom: -10px;
+ border: 0px none;
+ left: 0;
+ height: 28px;
+ display: block;
+ box-shadow: none;
+ border-radius: 0;
+ width: 100%;
+ padding-left: 13px;
+}
+input[type=text].ce_treesearch_input::placeholder {
+ color: #bfbfbf;
+}
+.ce_file_path {
+ line-height: 22px;
+ white-space: nowrap;
+ padding: 8px 10px 2px 22px;
+ text-overflow: ellipsis;
+ overflow: hidden;
+ color: white;
+}
+.ce_file_list {
+ color: #ccc;
+ position: absolute !important;
+ margin: 0;
+ padding: 0;
+ top: 70px;
+ /* overflow-x: hidden; */
+ bottom: 30px;
+ width: 100%;
+}
+.ce_file_wrap {
+ opacity: 1;
+ transform: translate(0px, 0px);
+ padding: 4px 0;
+ transition: all 300ms;
+}
+.ce_move_fwd , .ce_move_back , .ce_move_none {
+ opacity: 0;
+}
+.ce_move_fwd {
+ transform: translate(-200px, 0px);
+}
+.ce_move_back {
+ transform: translate(200px, 0px);
+}
+.ce_rtl{
+ direction:rtl;
+}
+.ce_file_path > bdi {
+ display: none;
+}
+.ce_file_path.ce_rtl > bdi {
+ display: inline;
+}
+.ce_file_path.ce_rtl > span {
+ display: none;
+}
+.ce_file_path .ce_right_icon {
+ background-color: transparent;
+}
+.ce_container {
+ position: absolute;
+ left: 283px;
+ right: 0;
+ top: 0;
+ bottom: 0;
+ background-color: #404040;
+ padding-left: 6px;
+}
+.ce_resize_column {
+ top: 0;
+ bottom: 0;
+ left: 280px;
+ position: absolute;
+ background: #404040;
+ width: 3px;
+ cursor: col-resize;
+ z-index: 12;
+}
+.ce_tabs {
+ height: 38px;
+ position: absolute;
+ left: 34px;
+ right: 0;
+ top: 0;
+ display: flex;
+ background-color: #404040;
+ color: #ddd;
+ padding-right: 4px;
+}
+.ce_home_tab {
+ position: absolute;
+ width: 34px;
+ line-height: 34px;
+ cursor: pointer;
+ color: #ddd;
+ background-color: #404040;
+ left: 0;
+ padding-left: 6px;
+ top: 0;
+ height: 40px;
+ margin-top: 4px;
+}
+.ce_app_name {
+ font-size: 20px;
+ font-weight: 200;
+ padding-right: 20px;
+}
+.ce_app_name i {
+ font-size: 22px;
+}
+.ce_app_title {
+ color: white;
+ font-size: 26px;
+ letter-spacing: -1px;
+}
+.ce_theme_vs .ce_app_title {
+ color: black;
+}
+.ce_actions_header {
+ font-size: 16px;
+ margin-top: 16px;
+ margin-bottom: 10px;
+ font-weight: bold;
+}
+.ce_actions_text {
+ margin: 0 10px 0 6px
+}
+.ce_custom_actions{
+ margin:40px 60px 40px 0;
+ max-width:1200px;
+}
+.ce_footer_links {
+ margin-top:40px;
+}
+.ce_tagline {
+ font-size: 10px;
+ letter-spacing: 3px;
+ margin-bottom: 40px;
+ opacity: 0.3;
+}
+.ce_marginbottom {
+ margin-bottom:20px;
+}
+
+.ce_contents_home .btn:hover {
+ box-shadow: inset 0 -1px 0 #3c444d;
+ color: #fff;
+ filter: none;
+ text-decoration: none;
+ text-shadow: none;
+ transition: background .2s, border .2s, box-shadow .2s, text-decoration .2s;
+}
+.ce_contents_home .btn {
+ background-color: #5c6773;
+ border: 1px solid #32414c;
+ border-radius: 3px;
+ color: #ddd;
+ margin: 0 5px 5px 0;
+ /* background-color: #5c6773;
+ border: 1px solid #32414c;
+ border-radius: 3px;
+ -webkit-box-sizing: border-box;
+ box-sizing: border-box;
+ color: #ddd;
+ cursor: pointer;
+ display: inline-block;
+ font-size: 14px;
+ font-weight: 400;
+ height: auto;
+ line-height: 20px;
+ margin-bottom: 0;
+ padding: 5px 14px;
+ text-align: center;
+ vertical-align: middle;
+ white-space: nowrap; */
+}
+.ce_home_buttonset {
+ margin-top:30px;
+ margin-bottom: 30px;
+}
+.ce_tab {
+ position: relative;
+ width: 220px;
+ line-height: 36px;
+ white-space: nowrap;
+ overflow: hidden;
+ padding: 0 2px 0 8px;
+ cursor: pointer;
+ margin-top:4px;
+}
+.ce_fullPathTab {
+ width: 300px;
+ direction: rtl;
+ padding-right: 15px;
+ text-align: left;
+}
+.ce_pipe {
+ position: absolute;
+ right: 0px;
+ margin-top: 6px;
+ height: 21px;
+ width: 0px;
+ z-index: 4;
+ margin-right: 0px;
+ border-right: 1px solid #262626;
+}
+.ce_pipe_left {
+ position: absolute;
+ left: 0px;
+ margin-top: 6px;
+ border-left: 1px solid #262626;
+ height: 21px;
+ width: 0px;
+ z-index: 4;
+ margin-left: 0px;
+}
+.ce_tab_new {
+ width: 30px;
+ position: relative;
+ line-height: 32px;
+ border-right: 1px solid black;
+ text-align: center;
+}
+.ce_tab_new > i {
+ padding: 4px 8px;
+ cursor: pointer;
+ color: #c3cbd4;
+}
+.ce-dim{
+ color: #aaa;
+}
+.ce_tab_new > i:hover {
+ color: #00A4FD;
+}
+.ce_tab:hover {
+ color: white;
+}
+.ce_home_tab.ce_active,
+.ce_tab.ce_active {
+ background-color: #1d1d1d;
+ border-top-right-radius: 8px;
+ border-top-left-radius: 8px;
+ color: white;
+ z-index: 9;
+ box-shadow: inset -6px 0 6px 0px #1d1d1d;
+}
+.ce_tab.ce_active {
+ box-shadow: inset -6px 0 6px 0px #1d1d1d, 0 0 15px #404040, 0 0 30px #404040;
+}
+.ce_theme_vs .ce_home_tab.ce_active,
+.ce_theme_vs .ce_tab.ce_active {
+ background-color: #fffffe;
+ box-shadow: inset -6px 0 6px 0px #fffffe;
+ color: black;
+}
+.ce_theme_hc-black .ce_home_tab.ce_active,
+.ce_theme_hc-black .ce_tab.ce_active {
+ background-color: black;
+ box-shadow: inset -6px 0 6px 0px black;
+}
+.ce_tab .ce_right_icon {
+ background-color: #404040;
+ box-shadow: 0 0 4px 4px #404040;
+}
+.ce_tab.ce_active .ce_right_icon {
+ background-color: #1d1d1d;
+ box-shadow: 0 0 4px 4px #1d1d1d;
+}
+.ce_theme_vs .ce_tab.ce_active .ce_right_icon {
+ background-color: #fffffe;
+ box-shadow: 0 0 4px 4px #fffffe;
+}
+.ce_clickable_icon {
+ cursor: pointer;
+ color: white;
+ font-size: 18px;
+ padding: 5px;
+}
+.ce_theme_vs .ce_active .ce_clickable_icon {
+ color: black;
+}
+.ce_clickable_icon.ce_disabled {
+ opacity: 0.5;
+ cursor: not-allowed;
+}
+.ce_clickable_icon.ce_clickable_icon.ce_clickable_icon:not(.ce_disabled):hover {
+ color: #00A4FD;
+}
+.ce_right_icon {
+ position: absolute;
+ right: 7px;
+ padding: 2px 5px;
+ font-size: 18px;
+ margin-top: -2px;
+ height: 34px;
+}
+.ce_restore_session {
+ color: #c3cbd4;
+ margin: 12px 30px;
+ cursor: pointer;
+ position: relative;
+}
+.ce_restore_session i {
+ font-size: 18px;
+ color: white;
+ position: absolute;
+ left: -20px;
+ top: 0px;
+}
+.ce_restore_session:hover i {
+ color: #00A4FD;
+}
+.ce_restore_session:hover span {
+ text-decoration: underline;
+}
+.ce_recent_list {
+ background-color: #2d2f31;
+ color: white;
+ position: absolute;
+ max-width: 600px;
+ max-height: 600px;
+ overflow: hidden;
+ left: 226px;
+ top: 50px;
+ list-style-type: none;
+ padding: 10px;
+ box-shadow: 0 10px 20px rgba(0,0,0,0.19), 0 6px 6px rgba(0,0,0,0.23);
+ z-index:10;
+}
+.ce_recent_list li {
+ padding: 3px 6px 3px 9px;
+ margin: 1px 0 2px 0;
+ border-left: 3px solid transparent;
+}
+.ce_recent_list li.ce_selectable {
+ cursor: pointer;
+ color: #bbb;
+ border-left: 3px solid transparent;
+}
+.ce_recent_list li.ce_selectable:hover {
+ background-color: #262626;
+ border-left: 3px solid #00A4FD;
+}
+.ce_right_icon.ce_right_two {
+ right: 32px;
+}
+.ce_contents_home {
+ position:absolute;
+ overflow: hidden;
+ top: 38px;
+ z-index: 11;
+ bottom: 0;
+ left: 0;
+ right: 0;
+ color: #ccc;
+ padding: 27px 27px 0 27px;
+}
+.ce_theme_vs .ce_contents_home {
+ color: #4e4e4e;
+}
+.ce_contents {
+ top: 38px;
+ padding-top: 10px;
+ bottom: 0;
+ left: 0;
+ z-index: 11;
+ right: 0;
+ position: absolute;
+ background-color: #1e1e1e;
+}
+.ce_theme_vs .ce_contents {
+ background-color: #fffffe;
+}
+.ce_theme_hc-black .ce_contents {
+ background-color: black;
+}
+.ce_tab_container,
+.ce_editor_container,
+.ce_editor_sidecar_editor {
+ height: 100%;
+ margin: 6px;
+}
+.ce_editor_sidecar {
+ position: absolute;
+ height: 400px;
+ width: 600px;
+ border-left: 3px solid #5c5c5c;
+ border-right: 3px solid #5c5c5c;
+ bottom: 0;
+ right: 150px;
+ background-color: #1e1e1e;
+ opacity: 0;
+ /* transform: translateY(467px); */
+ transition: transform 300ms;
+ box-shadow: 0 19px 38px rgba(0,0,0,0.30), 0 15px 12px rgba(0,0,0,0.22);
+}
+.ce_editor_sidecar_pin_button {
+ color: orange;
+}
+.ce_editor_sidecar_autohide_on .ce_editor_sidecar_pin_button {
+ color: white;
+}
+
+.ce_theme_vs .ce_editor_sidecar {
+ background-color: #ffffff;
+}
+.ce_editor_sidecar_title {
+ height: 35px;
+ background-color: #5c5c5c;
+ color: white;
+ line-height: 35px;
+ padding-left: 10px;
+ cursor: pointer;
+ text-overflow: ellipsis;
+ padding-right: 27px;
+ white-space: nowrap;
+ overflow: hidden;
+}
+.ce_editor_sidecar_autohide {
+ height: 2px;
+ border-left-width: 0px;
+ border-left-color: transparent;
+ border-left-style: solid;
+ transition: border-left-width 5000ms;
+ display: none;
+}
+.ce_editor_sidecar_autohide_on .ce_editor_sidecar_autohide {
+ display: block;
+}
+.ce_editor_sidecar_resizer {
+ cursor: nw-resize;
+ position: absolute;
+ width: 20px;
+ height: 20px;
+ /*background-color: red;*/
+ top: -4px;
+ left: -6px;
+}
+.ce_editor_sidecar .ce_right_icon {
+ margin-top: 5px;
+}
+.ce_editor_sidecar .ce_spinner {
+ margin-top: 50px;
+}
+.ce_contents a,
+.ce_contents a:hover {
+ color: inherit;
+}
+.ce_contents p {
+ color: inherit;
+}
+.context-view.monaco-menu-container {
+ font-family: Splunk Platform Sans,Proxima Nova,Roboto,Droid,Helvetica Neue,Helvetica,Arial,sans-serif !important;
+ font-size: 14px;
+}
+.monaco-action-bar .actions-container {
+ padding: 10px 0;
+}
+.monaco-menu .monaco-action-bar.vertical .action-item > a,
+.monaco-menu .monaco-action-bar.vertical .action-item > span {
+ line-height: 2;
+}
+.monaco-menu .monaco-action-bar.vertical {
+ background-color: #2d2f31 !important;
+}
+.monaco-menu .monaco-action-bar.vertical .action-item:not(.disabled) > a{
+ background-color: inherit !important;
+ color: #ccc !important;
+}
+.monaco-menu .monaco-action-bar.vertical .action-item:not(.disabled) {
+ border-left: 3px solid transparent;
+ background-color: #2d2f31;
+}
+.monaco-menu .monaco-action-bar.vertical .action-item:not(.disabled):hover {
+ background-color: #262626;
+ border-left: 3px solid #00A4FD;
+}
+.monaco-editor .scroll-decoration{
+ /* disable the scroll shadow at the top */
+ box-shadow: none !important;
+}
+.ce_hidden {
+ display:none !important;
+}
+.ce_sort_menu_wrap {
+ position: absolute;
+ /* transition: opacity 300ms; */
+ background-color: #2d2f31;
+ padding: 8px;
+ box-shadow: 0 19px 38px rgba(0,0,0,0.30), 0 15px 12px rgba(0,0,0,0.22);
+ font-size: 13px;
+ color: #bbb;
+ z-index: 13;
+ line-height: 2;
+}
+.ce_sort_menu_wrap .ce_clickable_icon {
+ border: 2px solid #262626;
+ border-radius: 6px;
+ margin-right: 6px;
+}
+.ce_sort_menu_wrap .ce_clickable_icon:hover {
+ color: white;
+}
+.ce_sortby_selected {
+ border: 2px solid #00A4FD !important;
+ color: #00A4FD !important;
+}
+.ce_context_menu_overlay {
+ position:absolute;
+ background-color: rgba(0,0,0,0.2);
+ top: 0;
+ bottom: 0;
+ left: 0;
+ right: 0;
+ z-index: 12;
+}
+.ce_context_menu_wrap {
+ position: absolute;
+ opacity: 0;
+ top: -9999px;
+ left: -9999px;
+ right: auto;
+ bottom: auto;
+ transition: opacity 300ms;
+ background-color: #2d2f31;
+ padding: 2px;
+ min-width: 200px;
+ max-width: 440px;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ box-shadow: 0 19px 38px rgba(0,0,0,0.30), 0 15px 12px rgba(0,0,0,0.22);
+ font-size: 13px;
+ color: #bbb;
+ white-space: nowrap;
+ z-index: 13;
+}
+.ce_context_menu_wrap > div {
+ margin: 2px 2px;
+ padding: 4px 10px;
+ border-left: 3px solid transparent;
+}
+.ce_context_menu_wrap > div:hover {
+ background-color: #262626;
+ cursor: pointer;
+ border-left: 3px solid #00A4FD;
+}
+.ce_toaster {
+ background-color: #53a051;
+ width: 232px;
+ height: 60px;
+ position: absolute;
+ right: 50px;
+ top: 80px;
+ line-height: 60px;
+ padding: 0 20px;
+ box-shadow: 0 19px 38px rgba(0,0,0,0.30), 0 15px 12px rgba(0,0,0,0.22);
+ color: white;
+ visibility: hidden;
+ opacity: 0;
+ z-index:11;
+ transform: translateX(30px);
+ transition: all 200ms;
+}
+.ce_toaster i {
+ font-size: 50px;
+ position: absolute;
+ color: white;
+}
+.ce_toaster span {
+ margin-left: 60px;
+}
+.ce_toaster.ce_show {
+ opacity: 1;
+ visibility: visible;
+ transform: translateX(0);
+}
+.modal-body {
+ overflow: auto;
+}
+.modal-body .pre-no-color{
+ background-color: white;
+ padding: 0;
+ border: 0 none;
+}
+.modal-body img{
+ margin-bottom: 16px;
+ box-shadow: 0 10px 20px rgba(0,0,0,0.19), 0 6px 6px rgba(0,0,0,0.23);
+ border: 1px solid #e2e2e2;
+ width: 700px;
+}
+.btn.btn-danger {
+ color: #fff;
+ text-shadow: 0 -1px 0 rgba(0,0,0,.25);
+ box-shadow:none;
+ background-color: #da4f49;
+ background-image: linear-gradient(180deg,#ee5f5b,#bd362f);
+ background-repeat: repeat-x;
+ border-color: rgba(0,0,0,.1) rgba(0,0,0,.1) rgba(0,0,0,.25);
+}
+.btn.btn-danger:hover {
+ background: #e45753;
+}
+.btn.btn-inverse {
+ color: #fff;
+ text-shadow: 0 -1px 0 rgba(0,0,0,.25);
+ box-shadow:none;
+ background-color: #4983DA;
+ background-image: linear-gradient(180deg,#5B65EE,#2F31BD);
+ background-repeat: repeat-x;
+ border-color: rgba(0,0,0,.1) rgba(0,0,0,.1) rgba(0,0,0,.25);
+}
+.btn.btn-inverse:hover {
+ background: #5B65EE;
+}
+.btn.btn-warning {
+ color: #fff;
+ text-shadow: 0 -1px 0 rgba(0,0,0,.25);
+ box-shadow:none;
+ background-color: #CC9622;
+ background-image: linear-gradient(180deg,#E4A827,#CC9622);
+ background-repeat: repeat-x;
+ border-color: rgba(0,0,0,.1) rgba(0,0,0,.1) rgba(0,0,0,.25);
+}
+.btn.btn-warning:hover {
+ background: #E7B13B;
+}
+.btn-info {
+ color: #fff;
+ text-shadow: 0 -1px 0 rgba(0, 0, 0, 0.25);
+ box-shadow:none;
+ background-color: #49afcd;
+ background-image: linear-gradient(to bottom, #5bc0de, #2f96b4);
+ background-repeat: repeat-x;
+ border-color: rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);
+}
+.btn-info:hover {
+ color: #fff;
+ background: #2f96b4;
+}
+.btn.btn-disabled {
+ cursor: not-allowed;
+ opacity: 0.5;
+}
+.ceRedLine {
+ border-left: 8px solid rgba(255,0,0,0.75);
+}
+.ceGreeenLine {
+ border-left: 8px solid green;
+}
+.ceDimGreeenLine {
+ border-left: 8px solid rgba(0,128,0,0.5);
+}
+.ceOrangeLine {
+ border-left: 8px solid orange;
+}
+.ceBlueLine {
+ border-left: 8px solid #676767;
+}
+.ce_diff_addition { background-color: rgba(0,255,0,.2); }
+.ce_diff_deletion { background-color: rgba(255,0,0,.2); }
+.green {color: #65a637}
+.red { color: #d6563c;}
+.nobr {
+ white-space: nowrap;
+}
+.ar {
+ text-align:right;
+}
+.ce_changelog {
+ padding: 10px;
+ width: 100%;
+ color: #d4d4d4;
+ height: 100%;
+ overflow-x: auto;
+}
+.ce_changelog table {
+ width: 100%;
+}
+.ce_changelog tr:nth-child(even) {
+ background: rgba(0, 0, 0, 0.2);
+}
+.ce_changelog td{
+ padding: 4px 12px;
+}
+.ce_changelog_buttons {
+ width: 50px;
+ display: inline-block;
+}
+.ce_changelog_filescol {
+ width: 90%;
+}
+.ce_file_history {
+ width: 100%;
+ color: #d4d4d4;
+ padding: 0 10px 0 30px;
+ height: 100%;
+ overflow-x: auto;
+}
+.ce_file_history h1 {
+ margin-top:50px;
+ color: white;
+}
+.ce_file_history h1::first-letter {
+ text-transform: uppercase;
+}
+.ce_file_history h1 span {
+ font-size: 16px;
+}
+.ce_file_history p{
+ font-family: Consolas, "Courier New", monospace;
+ font-weight: normal;
+ font-size: 14px;
+ line-height: 19px;
+ letter-spacing: 0px;
+ margin:0;
+ position:relative;
+}
+.ce_diff_change p {
+ padding-left: 20px;
+}
+.ce_diff_addition:before {
+ content: "+";
+ position: absolute;
+ margin-left: -15px;
+ margin-top: -1px;
+}
+.ce_diff_deletion:before {
+ content: "-";
+ position: absolute;
+ margin-left: -15px;
+ margin-top: -1px;
+}
+.ce_diff_change {
+ margin: 6px 0 40px 0;
+ padding: 6px;
+ background-color: rgba(0, 0, 0, 0.2);
+}
+.ce_gitoutput {
+ padding: 20px;
+ color: #d4d4d4;
+ overflow-x: auto;
+ height: 100%;
+}
+.ce_gitoutput h2 {
+ color: #dd6a6f;
+}
+.ce_pre,
+.ce_gitoutput-out,
+.ce_gitoutput-cmd {
+ word-break: break-all;
+ word-wrap: break-word;
+ white-space: pre;
+ white-space: pre-wrap;
+ font-family: Consolas, "Courier New", monospace;
+ font-weight: normal;
+ font-size: 14px;
+ line-height: 19px;
+ letter-spacing: 0px;
+ background-color: #262626;
+ padding: 10px;
+}
+.ce_pre {
+ color: #ccc;
+ background-color: inherit;
+ border: 0 none;
+}
+.ce_theme_vs .ce_pre {
+ color: inherit;
+}
+.ce_gitoutput-cmd {
+ color: #569cd6;
+}
+.ce_gitoutput-desc {
+ color: #608b4e;
+ margin-top: 20px;
+ line-height: 32px;
+ font-weight: bold;
+ font-size: 16px;
+}
+/* http://tobiasahlin.com/spinkit/ */
+html .ce_spinner {
+ margin-top: 140px;
+}
+.spinner {
+ margin: 100px auto 0;
+ width: 70px;
+ text-align: center;
+}
+.spinner > div {
+ width: 18px;
+ height: 18px;
+ background-color: #00A4FD;
+
+ border-radius: 100%;
+ display: inline-block;
+ -webkit-animation: sk-bouncedelay 1.4s infinite ease-in-out both;
+ animation: sk-bouncedelay 1.4s infinite ease-in-out both;
+}
+.spinner .bounce1 {
+ -webkit-animation-delay: -0.32s;
+ animation-delay: -0.32s;
+}
+.spinner .bounce2 {
+ -webkit-animation-delay: -0.16s;
+ animation-delay: -0.16s;
+}
+@-webkit-keyframes sk-bouncedelay {
+ 0%, 80%, 100% { -webkit-transform: scale(0) }
+ 40% { -webkit-transform: scale(1.0) }
+}
+@keyframes sk-bouncedelay {
+ 0%, 80%, 100% {
+ -webkit-transform: scale(0);
+ transform: scale(0);
+ } 40% {
+ -webkit-transform: scale(1.0);
+ transform: scale(1.0);
+ }
+}
+input.ce_file_upload_extract[type=checkbox] {
+ transform: translateY(-3px);
+ margin-right: 8px;
+}
+input.ce_run_cwd_radio[type=radio] {
+ margin: 0 10px;
+}
+.ce_disclaimer {
+ font-size: 10px;
+}
+.ce_fs_slow_message{
+ margin-top: 200px;
+ text-align: center;
+}
+.ce_fs_slow_message > div{
+ margin-bottom: 10px;
+}
+.ce_pref_label {
+ display: inline-block;
+ margin-left: 20px;
+ transform: translateY(-2px);
+}
+.ce_pref_advanced {
+ width: 100%;
+ height: 174px;
+}
+.ce_postsave_arg1 {
+ margin-left:6px;
+ width:630px;
+}
+.ce_postsave_strmatch_bad,
+.ce_postsave_strmatch_good {
+ margin-left:6px;
+ width:150px;
+}
+.ce_postsave_background {
+ width: 60px;
+}
+.ce_postsave_suggestion {
+ color:#333;
+ cursor:pointer;
+}
+.monaco-editor .monaco-editor-hover code {
+ color: inherit;
+ background-color: inherit;
+ border: 0 none;
+}
+.ce-server-classes a,
+.ce-server-classes-all,
+.ce-debugrefresh-endpoints a {
+ margin: 10px 12px 0 0;
+ background-color: #f7f8fa;
+ padding: 6px 10px;
+ display: inline-block;
+ border-radius: 3px;
+}
+.ce-server-classes a:hover,
+.ce-server-classes-all:hover,
+.ce-debugrefresh-endpoints a:hover {
+ background-color: #ebeeef;
+}
\ No newline at end of file
diff --git a/apps/config_explorer/appserver/static/config.js b/apps/config_explorer/appserver/static/config.js
new file mode 100755
index 00000000..ad190332
--- /dev/null
+++ b/apps/config_explorer/appserver/static/config.js
@@ -0,0 +1,4490 @@
+// Copyright (C) 2018 Chris Younger
+
+/* jslint bitwise: true */
+/* globals require, monaco, BroadcastChannel, Promise */
+
+/*
+
+TODO
+ - Option to open a blank diffing window
+ - ability to stream results from a run window
+ - ability to see running config explorer commands and kill them?
+ - if you hit save when a post-save action is already running, two things run at once. Seems its not too bad anyway.
+ - the sidecar should allow rerun
+
+*/
+// Loading monaco from the CDN
+/*
+require.config({ paths: { 'vs': 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.15.0/min/vs' }});
+window.MonacoEnvironment = {
+ getWorkerUrl: function(workerId, label) {
+ return `data:text/javascript;charset=utf-8,${encodeURIComponent(`
+ self.MonacoEnvironment = { baseUrl: 'https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.15.0/min/' };
+ importScripts('https://cdnjs.cloudflare.com/ajax/libs/monaco-editor/0.15.0/min/vs/base/worker/workerMain.js');`
+ )}`;
+ }
+}*/
+
+// The splunk webserver prepends all scripts with a call to i18n_register() for internationalisation. This fails for web-workers becuase they dont know about this function yet.
+// The options are patch the function on-the-fly like so, or to edit the file on the filesystem (which makes upgrading monaco harder)
+(function() {
+ var mode = "min"; // or dev
+ require.config({
+ paths: {
+ 'vs': '../app/config_explorer/node_modules/monaco-editor/'+mode+'/vs',
+ }
+ });
+ window.MonacoEnvironment = {
+ getWorkerUrl: function(workerId, label) {
+ return "data:text/javascript;charset=utf-8," + encodeURIComponent(
+ //"console.log('shimming i18n_register for worker'); "+
+ "function i18n_register(){/*console.log('i18n_register shimmed');*/} "+
+ "self.MonacoEnvironment = { baseUrl: '" + window.location.origin + "/static/app/config_explorer/node_modules/monaco-editor/"+mode+"/' }; "+
+ "importScripts('" + window.location.origin + "/static/app/config_explorer/node_modules/monaco-editor/"+mode+"/vs/base/worker/workerMain.js');"
+ );
+ }
+ };
+})();
+
+require([
+ "splunkjs/mvc",
+ "jquery",
+ "vs/editor/editor.main",
+ "app/config_explorer/sortable.min",
+ "app/config_explorer/OverlayScrollbars"
+], function(
+ mvc,
+ $,
+ wat,
+ Sortable,
+ OverlayScrollbars
+) {
+
+ // Inject all the HTML contents
+ $(".dashboard-body").html(
+ ""+
+ ""+
+ ""+
+ ""+
+ "
"+
+ ""+
+ ""+
+ "
"+
+ ""+
+ "
"+
+ ""+
+ ""+
+ ""+
+ ""+
+ ""+
+ ""+
+ ""+
+ ""+
+ ""+
+ ""+
+ //""+
+ ""+
+ ""+
+ ""+
+ ""+
+ "
"+
+ ""+
+ ""+
+ ""+
+ "
"+
+ ""+
+ ""+
+ "
"+
+ ""+
+ ""+
+ "
"+
+ ""+
+ ""+
+ ""+
+ "
"+
+ " "+
+ ""+
+ "
"+
+ ""+
+ "Config Explorer for
"+
+ "by Chris Younger
"+
+ ""+
+ "Settings Theme: "+
+ "light"+
+ "dark"+
+ "high contrast"+
+ "Change log"+
+ "
"+
+ "Saved
"+
+ ""+
+ ""+
+ "");
+
+ // Mapping of all the tab types
+ // can_rerun - has a right click open in the editor for "rerun". This will close and reopen the tab. If this is "true" it must also exist in the hooksCfg list with the same name!
+ // reopen - tracked through hash and in "recent files". If this is "true" it must also exist in the hooksCfg list with the same name!
+ var tabCfg = {
+ 'btool': { can_rerun: true, can_reopen: true, },
+ 'btool-hidepaths': { can_rerun: true, can_reopen: true, },
+ 'btool-hidedefaults': { can_rerun: true, can_reopen: true, },
+ 'btool-hidesystemdefaults': { can_rerun: true, can_reopen: true, },
+ 'btool-check': { can_rerun: true, can_reopen: false, },
+ 'spec': { can_rerun: false, can_reopen: true, },
+ 'run': { can_rerun: true, can_reopen: false, },
+ 'deployserver': { can_rerun: true, can_reopen: false, },
+ 'read': { can_rerun: false, can_reopen: true, },
+ 'settings': { can_rerun: false, can_reopen: false, },
+ 'change-log': { can_rerun: false, can_reopen: false, },
+ 'diff': { can_rerun: false, can_reopen: false, },
+ 'history': { can_rerun: false, can_reopen: false, },
+ 'git': { can_rerun: false, can_reopen: false, },
+ 'live': { can_rerun: false, can_reopen: false, },
+ 'live-diff': { can_rerun: false, can_reopen: false, },
+ 'refresh': { can_rerun: true, can_reopen: false, },
+ 'internal': { can_rerun: false, can_reopen: false, },
+ 'rest': { can_rerun: false, can_reopen: true, },
+ };
+ // This is what will be executed in the following circumstances:
+ // - the URL hash on load (can_reopen=true above)
+ // - opening from the Recent file list (can_reopen=true above)
+ // - Editor>RightClick>Rerun option is chosen (can_rerun=true above)
+ // - custom [hook:Show change log
").on("click", function(){
+ showChangeLog();
+ }));
+ }
+ buildLeftContextMenu(actions, e);
+ }
+ });
+
+ // Click handler for left pane items
+ $ce_file_list.on("click", ".ce_leftnav", function(){
+ var elem = $(this);
+ // click on a conf file
+ if (elem.hasClass("ce_conf")) {
+ runBToolList($(this).attr('file'), 'btool');
+ // click on file
+ } else if (elem.hasClass("ce_is_report")) {
+ readFile(elem.attr('file'));
+ // recent files list
+ } else if (elem.hasClass("ce_leftnav_reopen")) {
+ hooksCfg[elem.attr('type')](elem.attr('file'));
+ // rest app
+ } else if (elem.hasClass("ce_leftnav_restapp")) {
+ inFolderRestApp = elem.attr('restapp');
+ leftPaneRestList();
+ // rest type
+ } else if (elem.hasClass("ce_leftnav_resttype")) {
+ inFolderRestType = elem.attr('resttype');
+ leftPaneRestList();
+ // rest file
+ } else if (elem.hasClass("ce_leftnav_restfile")) {
+ readFileRest(elem.attr('restfile'));
+ // Folder
+ } else {
+ if (! leftpane_ignore) {
+ readFolder(elem.attr('file'), 'fwd');
+ }
+ }
+ // Right click menu for left pane
+ }).on("contextmenu", ".ce_leftnav", function (e) {
+ var $leftnavElem = $(this);
+ var isFile = $leftnavElem.hasClass("ce_is_report");
+ var thisFile = $leftnavElem.attr('file');
+ var actions = [];
+ var j;
+ if (isFile) {
+ // Add the custom hook actions
+ for (j = 0; j < hooksActive.length; j++) {
+ addHookActionToTree(hooksActive[j], thisFile, actions, "file");
+ }
+ // gate behind flag
+ if (confIsTrue('dashboard_xml_file_experimental_actions', false)) {
+ var file_parts_for_openurl = thisFile.match(regex_file_path_to_dashboard_parts);
+ if (file_parts_for_openurl) {
+ actions.push($("Attempt view in browser
").on("click", function(){
+ hooksCfg.openurl("/app/" + file_parts_for_openurl[2] + "/" + file_parts_for_openurl[3]);
+ }));
+ actions.push($("Attempt edit via REST API
").on("click", function(){
+ if (file_parts_for_openurl[1]=="apps") {
+ hooksCfg.rest("/servicesNS/nobody/" + file_parts_for_openurl[2] + "/data/ui/views/" + file_parts_for_openurl[3]);
+ } else {
+ hooksCfg.rest("/servicesNS/" + file_parts_for_openurl[1].substr(6) + "/" + file_parts_for_openurl[2] + "/data/ui/views/" + file_parts_for_openurl[3]);
+ }
+ }));
+
+
+ }
+ }
+ }
+ if ($leftnavElem.hasClass("ce_is_folder")) {
+ for (j = 0; j < hooksActive.length; j++) {
+ addHookActionToTree(hooksActive[j], thisFile, actions, "folder");
+ }
+ }
+ if ($leftnavElem.hasClass("ce_leftnav_editable") && confIsTrue('write_access', false)) {
+ // can rename, can trash
+ actions.push($("Rename
").on("click", function(){
+ fileSystemRename(thisFile);
+ }));
+ actions.push($("Delete
").on("click", function(){
+ filesystemDelete(thisFile);
+ }));
+
+ }
+ if ($leftnavElem.hasClass("ce_conf")) {
+ for (j = 0; j < hooksActive.length; j++) {
+ addHookActionToTree(hooksActive[j], thisFile, actions, "conf");
+ }
+ actions.push($("Show btool (hide paths)
").on("click", function(){
+ runBToolList(thisFile, 'btool-hidepaths');
+ }));
+ actions.push($("Show btool (hide all defaults)
").on("click", function(){
+ runBToolList(thisFile, 'btool-hidedefaults');
+ }));
+ actions.push($("Show btool (hide system defaults)
").on("click", function(){
+ runBToolList(thisFile, 'btool-hidesystemdefaults');
+ }));
+
+ if (conf.btool_dir_for_master_apps) {
+ actions.push($("[master-apps] Show btool
").on("click", function(){
+ runBToolList(thisFile + ":" + conf.btool_dir_for_master_apps, 'btool', conf.btool_dir_for_master_apps, "/splunk/etc/master-apps/");
+ }));
+ actions.push($("[master-apps] Show btool (hide all defaults)
").on("click", function(){
+ runBToolList(thisFile + ":" + conf.btool_dir_for_master_apps, 'btool-hidedefaults', conf.btool_dir_for_master_apps, "/splunk/etc/master-apps/");
+ }));
+ }
+ if (conf.btool_dir_for_manager_apps) {
+ actions.push($("[manager-apps] Show btool
").on("click", function(){
+ runBToolList(thisFile + ":" + conf.btool_dir_for_manager_apps, 'btool', conf.btool_dir_for_manager_apps, "/splunk/etc/manager-apps/");
+ }));
+ actions.push($("[manager-apps] Show btool (hide all defaults)
").on("click", function(){
+ runBToolList(thisFile + ":" + conf.btool_dir_for_manager_apps, 'btool-hidedefaults', conf.btool_dir_for_manager_apps, "/splunk/etc/manager-apps/");
+ }));
+ }
+ if (conf.btool_dir_for_deployment_apps) {
+ actions.push($("[deployment-apps] Show btool
").on("click", function(){
+ runBToolList(thisFile + ":" + conf.btool_dir_for_deployment_apps, 'btool', conf.btool_dir_for_deployment_apps, "/splunk/etc/deployment-apps/");
+ }));
+ actions.push($("[deployment-apps] Show btool (hide all defaults)
").on("click", function(){
+ runBToolList(thisFile + ":" + conf.btool_dir_for_deployment_apps, 'btool-hidedefaults', conf.btool_dir_for_deployment_apps, "/splunk/etc/deployment-apps/");
+ }));
+ }
+ if (conf.btool_dir_for_shcluster_apps) {
+ actions.push($("[shcluster-apps] Show btool
").on("click", function(){
+ runBToolList(thisFile + ":" + conf.btool_dir_for_shcluster_apps, 'btool');
+ }));
+ actions.push($("[shcluster-apps] Show btool (hide all defaults)
").on("click", function(){
+ runBToolList(thisFile + ":" + conf.btool_dir_for_shcluster_apps, 'btool-hidedefaults');
+ }));
+ }
+
+ actions.push($("Show .spec file
").on("click", function(){
+ displaySpecFile(thisFile);
+ }));
+ actions.push($("Show live (running) config
").on("click", function(){
+ runningVsLayered(thisFile, false);
+ }));
+ actions.push($("Compare live config against btool output
").on("click", function(){
+ runningVsLayered(thisFile, true);
+ }));
+ }
+
+ if (isFile) {
+ if (confIsTrue('git_autocommit', false)) {
+ // can show history
+ actions.push($("View file history
").on("click", function(){
+ getFileHistory(thisFile, inFolder);
+ }));
+ }
+ // download file
+ actions.push($("Download
").on("click", function(){
+ serverAction({action: 'filedownload', path: inFolder, param1: thisFile}).then(function(b64data){
+ var byteCharacters = atob(b64data);
+ var byteArrays = [];
+ for (var offset = 0; offset < byteCharacters.length; offset += 512) {
+ var slice = byteCharacters.slice(offset, offset + 512);
+ var byteNumbers = new Array(slice.length);
+ for (var i = 0; i < slice.length; i++) {
+ byteNumbers[i] = slice.charCodeAt(i);
+ }
+ var byteArray = new Uint8Array(byteNumbers);
+ byteArrays.push(byteArray);
+ }
+ var blob = new Blob(byteArrays, {type: "application/octet-stream"});
+ var filename = dodgyBasename(thisFile);
+ if (typeof window.navigator.msSaveBlob !== 'undefined') {
+ // IE workaround for "HTML7007: One or more blob URLs were revoked by closing the blob for which they were created. These URLs will no longer resolve as the data backing the URL has been freed."
+ window.navigator.msSaveBlob(blob, filename);
+ } else {
+ var URL = window.URL || window.webkitURL;
+ var downloadUrl = URL.createObjectURL(blob);
+ // use HTML5 a[download] attribute to specify filename
+ var a = document.createElement("a");
+ // safari doesn't support this yet
+ if (typeof a.download === 'undefined') {
+ window.location = downloadUrl;
+ } else {
+ a.href = downloadUrl;
+ a.download = filename;
+ document.body.appendChild(a);
+ a.click();
+ }
+ setTimeout(function () { URL.revokeObjectURL(downloadUrl); }, 100); // cleanup
+ }
+ });
+ }));
+ // can compare
+ actions.push($("Mark for comparison
").on("click", function(){
+ comparisonLeftFile = thisFile;
+ }));
+ if (comparisonLeftFile && comparisonLeftFile !== thisFile) {
+ actions.push($("Compare to " + htmlEncode(dodgyBasename(comparisonLeftFile)) + "
").on("click", function(){
+ compareFiles(thisFile, comparisonLeftFile);
+ }));
+ }
+ }
+
+ if ($leftnavElem.hasClass("ce_leftnav_restfile")) {
+ var file_parts_for_openurl_rest = $leftnavElem.attr('restfile').match(/([^\/]+)\/data\/ui\/views\/(.*)$/);
+ if (file_parts_for_openurl_rest) {
+ actions.push($("Attempt view in browser
").on("click", function(){
+ hooksCfg.openurl("/app/" + file_parts_for_openurl_rest[1] + "/" + file_parts_for_openurl_rest[2]);
+ }));
+ }
+ }
+
+ if (actions.length) {
+ buildLeftContextMenu(actions, e, $leftnavElem);
+ }
+ });
+
+ // Event handlers for the editor tabs
+ $ce_tabs.on("click", ".ce_close_tab", function(e){
+ e.stopPropagation();
+ closeTabWithConfirmation($(this).parent().index());
+
+ // Middle click to close tab
+ }).on("auxclick", ".ce_tab", function(e){
+ if (e.which !== 3) {
+ e.stopPropagation();
+ closeTabWithConfirmation($(this).index());
+ }
+ // Clicking tab
+ }).on("click", ".ce_tab", function(){
+ activateTab($(this).index());
+
+ // On hover show the cross
+ }).on("mouseenter", ".ce_tab", function(){
+ $(this).append("");
+
+ }).on("mouseleave", ".ce_tab", function(){
+ $(this).find('.ce_close_tab').remove();
+ });
+
+ function buildLeftContextMenu(actions, e, $t) {
+ e.preventDefault(); // To prevent the default context menu.
+ if (! actions.length) {
+ return;
+ }
+ e.stopPropagation();
+ var $menu = $(".ce_context_menu_wrap");
+ $menu.empty().append(actions);
+ $(".ce_leftnav_highlighted").removeClass("ce_leftnav_highlighted");
+ if ($t) {
+ $t.addClass("ce_leftnav_highlighted");
+ }
+ var windowHeight = $(window).height();
+ if((e.clientY + 200) > windowHeight) {
+ $menu.css({opacity:1, left:30 + e.clientX, bottom:$(window).height()-e.clientY, right:"auto", top:"auto"});
+ } else {
+ $menu.css({opacity:1, left:30 + e.clientX, bottom:"auto", right:"auto", top: e.clientY - 30});
+ }
+ $ce_context_menu_overlay.removeClass("ce_hidden");
+ $(document).one("click contextmenu", function(e2) {
+ $menu.removeAttr("style");
+ $ce_context_menu_overlay.addClass("ce_hidden");
+ if ($t) {
+ $t.removeClass("ce_leftnav_highlighted");
+ }
+ e2.preventDefault();
+ });
+ }
+
+ function compareFiles(rightFile, leftFile) {
+ var ecfg = createTab('diff', rightFile + " " + leftFile, "diff: " + rightFile + " " + leftFile);
+ ecfg.diffFileRight = rightFile;
+ ecfg.diffFileLeft = leftFile;
+ // get both files
+ Promise.all([
+ serverActionWithoutFlicker({action: 'read', path: leftFile}),
+ serverActionWithoutFlicker({action: 'read', path: rightFile}),
+ ]).then(function(contents){
+ updateTabAsDiffer(ecfg, leftFile + "\n" + contents[0], rightFile + "\n" + contents[1]);
+ }).catch(function(){
+ closeTabByCfg(ecfg);
+ });
+ }
+
+ function debugRefreshBumpHook(endpoint, embeddedMode){
+ // get localisation url
+ var url = "/" + document.location.pathname.split("/")[1] + "/";
+ var label = "";
+ var ecfg;
+ if (typeof embeddedMode === "undefined") {
+ embeddedMode = false;
+ }
+ if (endpoint && endpoint === "?") {
+ debugRefreshEndpointSelection();
+ return;
+ }
+ if (endpoint && endpoint !== "all") {
+ if (endpoint === "bump") {
+ url += "_bump";
+ label = "bump";
+ } else {
+ url += "debug/refresh?entity=" + endpoint;
+ label = "debug/refresh: " + endpoint;
+ }
+ } else {
+ label = "debug/refresh: all";
+ url += "debug/refresh";
+ endpoint = "all";
+ }
+ if (embeddedMode) {
+ ecfg = createTabSidecar(label);
+ } else {
+ // Load as a stand alone tab
+ ecfg = createTab('refresh', endpoint, label);
+ }
+
+ $.post(url, function(data){
+ if (endpoint === "bump") {
+ data = $('').html(data).text();
+ } else {
+ data = data.replace(/'''[\s\S]*'''/,"");
+ }
+ if (embeddedMode) {
+ updateSidecarAsEditor(ecfg, data);
+ } else {
+ updateTabAsEditor(ecfg, data, 'plaintext');
+ }
+
+ }).fail(function(jqXHR, textStatus, errorThrown) {
+ if (embeddedMode) {
+ updateSidecarAsEditor(ecfg, "Status code: " + jqXHR.status + "\n\n" + errorThrown);
+ } else {
+ closeTabByCfg(ecfg);
+ showModal({
+ title: "Error",
+ body: "" + label + " - Error occurred!
Status code: " + jqXHR.status + "
",
+ });
+ }
+ });
+
+ }
+
+ function changeDirectory(dir){
+ if (dir) {
+ $(".ce_show_filesystem ").click();
+ readFolder(dir.replace(/[\/\\]$/g, ""), 'fwd');
+ }
+ }
+
+ function replaceTokens(str, file){
+ var basefile = dodgyBasename(file);
+ var dirname = dodgyDirname(file);
+ return str.replace(/\$\{(FILE|BASEFILE|DIRNAME)(?:,(\-?\d+))?(?:,(\-?\d+))?\}/g,function(all, g1, g2, g3){
+ var ret, l;
+ if (g1=="FILE") { ret = file; }
+ if (g1=="BASEFILE") { ret = basefile; }
+ if (g1=="DIRNAME") { ret = dirname; }
+ l = ret.length;
+ if (typeof g3 !== "undefined") { g2 = parseInt(g2); g3 = parseInt(g3); return ret.substr(g2 < 0 ? l + g2 : g2, g3 < 0 ? l + g3 : g3); }
+ if (typeof g2 !== "undefined") { g2 = parseInt(g2); return ret.substr(g2 < 0 ? l + g2 : g2); }
+ return ret;
+ });
+ }
+
+ function runAction(actionStr, file, embeddedMode) {
+ var parts = actionStr.split(":");
+ var action = parts.shift();
+ var args = parts.join(":");
+ if (file !== undefined) {
+ args = replaceTokens(args, file);
+ }
+ hooksCfg[action](args, undefined, embeddedMode);
+ }
+
+ // Keep track of what tabs are open in local storage.
+ function openTabsListChanged(){
+ var t = [];
+ for (var j = 0; j < editors.length; j++){
+ editors[j].position = editors[j].tab.index();
+ }
+ editors.sort(function(a,b){
+ if (a.position > b.position) {
+ return 1;
+ } else if (b.position > a.position) {
+ return -1;
+ } else {
+ return 0;
+ }
+ });
+ activeTab = $ce_tabs.children(".ce_active").index();
+ for (var i = 0; i < editors.length; i++){
+ if (tabCfg[editors[i].type].can_reopen) {
+ t.push({label: editors[i].label, type: editors[i].type, file: editors[i].file});
+ }
+ }
+ localStorage.setItem('ce_open_tabs', JSON.stringify(t));
+ updateUrlHash();
+ }
+
+ function updateUrlHash(){
+ var hashparts = [inFolder],
+ last_used_idx,
+ newest;
+ for (var i = 0; i < editors.length; i++){
+ if (tabCfg[editors[i].type].can_reopen) {
+ if (! newest || newest < editors[i].last_opened) {
+ newest = editors[i].last_opened;
+ last_used_idx = (hashparts.length - 1) / 2;
+ }
+ hashparts.push(editors[i].type);
+ hashparts.push(editors[i].file);
+ }
+ }
+ hashparts.unshift(last_used_idx);
+ if (history.replaceState) {
+ history.replaceState(null, null, '#' + hashparts.join("|"));
+ } else {
+ location.hash = '#' + encodeURIComponent(hashparts.join("|"));
+ }
+ }
+
+ function readUrlHash(){
+ var parts = decodeURIComponent(document.location.hash.substr(1)).split("|");
+ if (parts.length > 1) {
+ inFolder = parts[1];
+ for (var i = 2; (i + 1) < parts.length; i+=2) {
+ // check to make sure its allowed first! This protects against someone crafting a bad url (e.g. a "run" command) and sending it to a victim
+ if (tabCfg[parts[i]].can_reopen) {
+ var file_parts = parts[i+1].split("@");
+ if (file_parts.length > 1) {
+ doLineHighlight = file_parts[1];
+ hooksCfg[parts[i]](file_parts[0]);
+
+ } else {
+ hooksCfg[parts[i]](parts[i+1]);
+ }
+
+ }
+ }
+ var tabIdx = parseInt(parts[0],10);
+ if (parts.length > 2 && !isNaN(tabIdx)) {
+ activateTab(tabIdx);
+ }
+ }
+ }
+
+ // This can be used like so:
+ // var bc = new BroadcastChannel("config_explorer"); bc.postMessage({action:"open",type:"rest",path:"/servicesNS/admin/search/data/ui/views/aaa_dump"})
+ function handleBroadcastMessage(event) {
+ console.log("Received broadcast message", event);
+ if (event.data && event.data.hasOwnProperty("action") && event.data.action==="open") {
+ if (tabCfg[event.data.type].can_reopen) {
+ hooksCfg[event.data.type](event.data.path);
+ broadcastChannel.postMessage({
+ action:"opened",
+ type: event.data.type,
+ path: event.data.path
+ });
+ }
+ }
+ }
+
+ function getPreferences() {
+ var preferences;
+ try {
+ preferences = JSON.parse(localStorage.getItem('ce_preferences'));
+ } catch(e) {}
+ if (! preferences || $.isEmptyObject(preferences)) {
+ preferences = {
+ "cursorBlinking": "blink",
+ "cursorSmoothCaretAnimation": false,
+ "minimap": {
+ "renderCharacters": true,
+ "showSlider": "mouseover"
+ }
+ };
+ }
+ return preferences;
+ }
+ // This is an action that will occur after saving the file
+ function openPreferences() {
+ showModal({
+ title: "Preferences",
+ size: 500,
+ body: "Status code: " + jqXHR.status + "
" + htmlEncode(errorThrown) + "
Preferences will only affect sessions from this browser."+
+ "
Enable word-wrap "+ + "
Enable visible whitespace "+ + //"
Reuse tabs for post-save actions "+ + "
Hover tooltip "+ + "
Show full file path in tab (refresh required)"+ + "
Advanced editor options (See here)
"+ + ""+ + "
",
+ onShow: function(){
+ // On load set the fields to the current values
+ var preferences = getPreferences();
+ if (preferences.hasOwnProperty("wordWrap") && preferences.wordWrap === "on") {
+ $(".ce_pref_item .ce_wordWrap").prop('checked', true);
+ }
+ if (preferences.hasOwnProperty("renderWhitespace") && preferences.renderWhitespace === "all") {
+ $(".ce_pref_item .ce_renderWhitespace").prop('checked', true);
+ }
+ //if (preferences.hasOwnProperty("ce_reuseWindow") && preferences.ce_reuseWindow) {
+ // $(".ce_pref_item .ce_reuseWindow").prop('checked', true);
+ //}
+ if (!(preferences.hasOwnProperty("hover") && preferences.hover.hasOwnProperty("enabled") && ! preferences.hover.enabled)) {
+ $(".ce_pref_item .ce_hideSpecTooltip").prop('checked', true);
+ }
+ if (preferences.hasOwnProperty("ce_fullPathTab") && preferences.ce_fullPathTab) {
+ $(".ce_pref_item .ce_fullPathTab").prop('checked', true);
+ }
+
+
+ delete preferences.wordWrap;
+ delete preferences.renderWhitespace;
+ delete preferences.ce_reuseWindow;
+ delete preferences.ce_fullPathTab;
+ if (preferences.hasOwnProperty("hover")) {
+ delete preferences.hover.enabled;
+ if ($.isEmptyObject(preferences.hover)) {
+ delete preferences.hover;
+ }
+ }
+ $(".ce_pref_item .ce_pref_advanced").val(JSON.stringify(preferences,null,3));
+ },
+ actions: [{
+ onClick: function(){
+ try {
+ preferences = JSON.parse($(".ce_pref_item .ce_pref_advanced").val());
+ } catch (e) {
+ preferences = {};
+ }
+ preferences.wordWrap = ($(".ce_pref_item input.ce_wordWrap:checked").length > 0) ? "on" : "off";
+ preferences.renderWhitespace = ($(".ce_pref_item input.ce_renderWhitespace:checked").length > 0) ? "all" : "none";
+ //preferences.ce_reuseWindow = ($(".ce_pref_item input.ce_reuseWindow:checked").length > 0);
+ preferences.ce_fullPathTab = ($(".ce_pref_item input.ce_fullPathTab:checked").length > 0);
+ if (! preferences.hasOwnProperty("hover")) {
+ preferences.hover = {};
+ }
+ if ($(".ce_pref_item input.ce_hideSpecTooltip:checked").length === 0) {
+ preferences.hover.enabled = false;
+ } else {
+ preferences.hover.enabled = true;
+ }
+ localStorage.setItem('ce_preferences', JSON.stringify(preferences));
+ // Update all currently open windows
+ for (var i = 0; i < editors.length; i++) {
+ if (editors[i].hasOwnProperty("editor")) {
+ editors[i].editor.updateOptions(preferences);
+ }
+ }
+ $(".modal").modal('hide');
+ },
+ cssClass: 'btn-primary',
+ label: "Save"
+ },{
+ onClick: function(){ $(".modal").modal('hide'); },
+ label: "Cancel"
+ }]
+ });
+ }
+
+ // This is an action that will occur after saving the file
+ function setPostSaveAction() {
+ var ecfg = editors[activeTab];
+ var suggestions = [];
+ for (var j = 0; j < hooksActive.length; j++) {
+ if (hooksActive[j]._match.test(ecfg.file) && hooksActive[j].matchtype == "file" && isTrueValue(hooksActive[j].showWithSave)) {
+ suggestions.push("Suggest: Enable word-wrap "+ + "
Enable visible whitespace "+ + //"
Reuse tabs for post-save actions "+ + "
Hover tooltip "+ + "
Show full file path in tab (refresh required)"+ + "
Advanced editor options (See here)
"+ + ""+ + "
" + htmlEncode(replaceTokens(hooksActive[j].action, ecfg.file)) + ""); + } + } + showModal({ + title: "Set post-save action", + size: 900, + body: "
Enter a command to automatically run after successful save of this file only. This action will be saved in your browser local storage "+
+ "(it will not affect other users or other browsers you use, but it will be remembered after browser refresh). "+
+ "Run commands will be executed from the SPLUNK_HOME directory.
"+ + "File:
"+ + suggestions.join('') + + "
"+ + "
"+
+ //""+ + "File:
" + htmlEncode(ecfg.file) + ""+
+ ""+ + suggestions.join('') + + "
"+ + "
Run in background tab:
"+
+ //"The following options will check the returned content from a post-save action for a specific string and will show a success or failure icon on the tab. Only one value is required for the icon to be displayed.
"+
+ //"Content match for success:
"+
+ //"Content match for failure:
"+
+ "",
+ onShow: function(){
+ // On load set the fields to the current values
+ var p = getPostSave(ecfg.file);
+ if (p !== null) {
+ $(".ce_postsave_arg0").val(p[0]);
+ $(".ce_postsave_arg1").val(p[1]);
+ //$(".ce_postsave_background").val(p[2]);
+ //$(".ce_postsave_strmatch_good").val(p[3]);
+ //$(".ce_postsave_strmatch_bad").val(p[4]);
+ }
+ $(".ce_postsave_suggestion").on("click", function(){
+ var s = $(this).html();
+ var sparts = s.split(":");
+ $(".ce_postsave_arg0").val(sparts.shift());
+ $(".ce_postsave_arg1").val(sparts.join(":"));
+ });
+ },
+ actions: [{
+ onClick: function(){
+ var postsave = (JSON.parse(localStorage.getItem('ce_postsave')) || {});
+ var arg0 = $(".ce_postsave_arg0").val();
+ var arg1 = $(".ce_postsave_arg1").val();
+ //var background = $(".ce_postsave_background").val();
+ //var strmatch_good = $(".ce_postsave_strmatch_good").val();
+ //var strmatch_bad = $(".ce_postsave_strmatch_bad").val();
+ if (arg0 === "nothing") {
+ delete postsave[ecfg.file];
+ } else {
+ postsave[ecfg.file] = [arg0, arg1]; //, background, strmatch_good, strmatch_bad];
+ }
+ localStorage.setItem('ce_postsave', JSON.stringify(postsave));
+ $(".modal").modal('hide');
+ },
+ cssClass: 'btn-primary',
+ label: "Save"
+ },{
+ onClick: function(){ $(".modal").modal('hide'); },
+ label: "Cancel"
+ }]
+ });
+ }
+
+ // Read local storage to get any post-save action that exists for this file
+ function getPostSave(file) {
+ var parts;
+ var postsave = (JSON.parse(localStorage.getItem('ce_postsave')) || {});
+ if (postsave.hasOwnProperty(file)){
+ // Handle legacy format
+ if (typeof postsave[file] === "string") {
+ parts = postsave[file].split(":");
+ var action = parts.shift();
+ var args = replaceTokens(parts.join(":"), file);
+ return [action,args];
+ } else {
+ parts = postsave[file];
+ parts[1] = replaceTokens(parts[1], file);
+ return parts;
+ }
+ }
+ return null;
+ }
+
+ // Run button
+ function runShellCommand(contents, useSHOME) {
+ var history_idx = run_history.length,
+ in_progress_cmd = '',
+ $input,
+ cwd = "";
+ if (inFolder !== "."){
+ cwd = "Working directory:
"+ + ""+ + ""; + } + showModal({ + title: "Run ", + size: 600, + body: "
Enter a command to run on the server. Warning: Be careful with commands that do not exit as they will become orphaned processes. This does not have a timeout.
" + + cwd + + ""+ + "
",
+ onShow: function(){
+ $input = $('.ce_prompt_input');
+ if (contents) {
+ $input.val(contents);
+ }
+ // Provide a history of run commands
+ $input.focus().on('keydown', function(e) {
+ // on enter, submit form
+ if (e.which === 13) {
+ $('.modal').find('button:first-child').click();
+ } else if (e.which === 38) {// up arrow
+ if (history_idx === run_history.length) {
+ in_progress_cmd = $input.val();
+ }
+ history_idx--;
+ if (history_idx < 0) {history_idx = 0;}
+ $input.val(run_history[history_idx]);
+ } else if (e.which === 40) { // down arrow
+ if (history_idx === run_history.length) { return; }
+ history_idx++;
+ if (history_idx === run_history.length) {
+ $input.val(in_progress_cmd);
+ } else {
+ $input.val(run_history[history_idx]);
+ }
+ }
+ });
+ },
+ actions: [{
+ onClick: function(){
+ var runDir = $(".ce_run_cwd_radio_shome:checked").length;
+ $('.modal').one('hidden.bs.modal', function() {
+ var command = $input.val();
+ if (command) {
+ if (runDir) {
+ runShellCommandNow(command, "", false);
+ } else {
+ runShellCommandNow(command, inFolder, false);
+ }
+ }
+ }).modal('hide');
+ },
+ cssClass: 'btn-primary',
+ label: "Run"
+ },{
+ onClick: function(){ $(".modal").modal('hide'); },
+ label: "Cancel"
+ }]
+ });
+ }
+
+ function debugRefreshEndpointSelection() {
+ showModal({
+ title: "Debug/refresh endpoints",
+ size: 1000,
+ body: "" + + cwd + + ""+ + "
Select endpoint to debug/refresh. This list of endpoints is configured in Settings (config_explorer.conf) property:
",
+ onShow: function(){
+ var $debugrefreshEndpoints = $(".ce-debugrefresh-endpoints");
+ var str ="";
+ for (var i = 0; i < conf._debug_refresh_endpoints.length; i++) {
+ var epoint = $.trim(conf._debug_refresh_endpoints[i]);
+ if (epoint) {
+ str += "" + htmlEncode(epoint) + "";
+ }
+ }
+
+ $debugrefreshEndpoints
+ .html(str)
+ .on("click","a",function(e){
+ e.preventDefault();
+ e.stopPropagation();
+ var $this = $(this);
+ $(".modal").modal('hide');
+ debugRefreshBumpHook( $this.text() );
+ });
+ },
+ actions: [{
+ onClick: function(){ $(".modal").modal('hide'); },
+ label: "Cancel"
+ }]
+ });
+ }
+
+
+
+ // Run button
+ function runReloadDeployServer() {
+ showModal({
+ title: "Reload deploy-server",
+ size: 1000,
+ body: "",
+ onShow: function(){
+ var $serverClasses = $(".ce-server-classes");
+ $ce_spinner.clone().appendTo($serverClasses);
+
+ service.get('/services/deployment/server/serverclasses', {count:0, f:"name"}, function(err, r) {
+ if (err) {
+ console.error(err);
+ showModal({
+ title: "Error",
+ body: "debug_refresh_endpointsUnexpected error occurred retreiving serverclasses list
",
+ });
+ }
+ var str = "";
+ //console.log("resp",r.data);
+ if (r && r.data && r.data.entry) {
+ for (var i = 0; i < r.data.entry.length; i++) {
+ str += "" + htmlEncode(r.data.entry[i].name) + "";
+ }
+ }
+ $serverClasses.html(str);
+ $(".ce-deployserver").on("click","a",function(e){
+ e.preventDefault();
+ e.stopPropagation();
+ var $this = $(this);
+ $(".modal").modal('hide');
+ if ($this.hasClass("ce-server-classes-all")) {
+ runReloadDeployServerNow();
+ } else {
+ runReloadDeployServerNow($this.text());
+ //runShellCommandNow("./bin/splunk reload deploy-server -class \"" + $this.text() + "\"");
+ }
+ });
+ });
+ },
+ actions: [{
+ onClick: function(){ $(".modal").modal('hide'); },
+ label: "Cancel"
+ }]
+ });
+ }
+
+ function runReloadDeployServerNow(srvclass) {
+ if (typeof srvclass === undefined) {
+ srvclass = "";
+ }
+ var command = "reload deploy-server";
+ if (tabAlreadyOpen('deployserver', "")) {
+ closeTabByName('deployserver', "");
+ }
+ var ecfg = createTab('deployserver', "", '$ ' + htmlEncode(command));
+ serverActionWithoutFlicker({action: 'deployserver', path: srvclass}).then(function(contents){
+ updateTabAsEditor(ecfg, contents, 'plaintext');
+ }).catch(function(){
+ closeTabByCfg(ecfg);
+ });
+ }
+
+
+ function runShellCommandNow(command, fromFolder, embeddedMode){
+ if (typeof embeddedMode === "undefined") {
+ embeddedMode = false;
+ }
+ var ecfg;
+ var label = '$ ' + htmlEncode(command);
+ var timer = $("");
+ if (embeddedMode) {
+ ecfg = createTabSidecar(label);
+ timer.appendTo(ecfg.sidecar_editor_container);
+ } else {
+ ecfg = createTab('run', command, label);
+ timer.appendTo(ecfg.editor_container);
+ }
+ //var cancel = $("" + htmlEncode(JSON.stringify(err)) + "
Cancel
").appendTo(ecfg.container);
+
+ var started = Date.now();
+ var interval = setInterval(function() {
+ var tt = Math.round((Date.now() - started) / 1000);
+ if (tt > 2) {
+ timer.html(tt + " sec");
+ }
+ },1000);
+ // trim length
+ if (run_history.length > 50) {
+ run_history.shift();
+ }
+ // only save if the command is different to what was last run
+ if (command !== run_history[(run_history.length - 1)]) {
+ run_history.push(command);
+ }
+ // save to localstorage
+ localStorage.setItem('ce_run_history', JSON.stringify(run_history));
+ if (typeof fromFolder === "undefined") {
+ fromFolder = "";
+ }
+ ecfg.fromFolder = fromFolder;
+ serverActionWithoutFlicker({action: 'run', path: command, param1: fromFolder}).then(function(contents){
+ clearInterval(interval);
+ if (embeddedMode) {
+ updateSidecarAsEditor(ecfg, contents);
+ } else {
+ if (/git +diff/.test(command)) {
+ updateTabAsEditor(ecfg, contents, "git-diff");
+ } else if (/git +log/.test(command)) {
+ updateTabAsEditor(ecfg, contents, "git-log");
+ } else {
+ updateTabAsEditor(ecfg, contents, 'plaintext');
+ }
+ }
+ // refresh left pane
+ refreshFolder();
+ }).catch(function(){
+ clearInterval(interval);
+ if (embeddedMode) {
+ updateSidecarAsEditor(ecfg, "An unexpected error occured.");
+ } else {
+ closeTabByCfg(ecfg);
+ }
+ });
+ }
+
+ // Check config
+ function runBToolCheck() {
+ var ecfg = createTab('btool-check', 'btool-check', 'btool check ');
+ serverActionWithoutFlicker({action: 'btool-check'}).then(function(contents){
+ contents = contents.replace(/^(No spec file for|Checking):.*\r?\n/mg,'').replace(/^\t\t/mg,'').replace(/\n{2,}/g,'\n\n');
+ if ($.trim(contents)) {
+ updateTabAsEditor(ecfg, contents, 'plaintext');
+ } else {
+ closeTabByCfg(ecfg);
+ showModal({
+ title: "Info",
+ body: "No configuration errors found
",
+ size: 300
+ });
+ }
+ }).catch(function(){
+ closeTabByCfg(ecfg);
+ });
+ }
+
+ function getRest(path, args) {
+ return new Promise(function(resolve, reject){
+ service.get(path, args, function(err, r) {
+ if (err) {
+ reject(err);
+ }
+ if (r && r.data && r.data.entry) {
+ // for (var i = 0; i < r.data.entry.length; i++) {
+ // str += "[" + r.data.entry[i].name + "]\n";
+ // var props = Object.keys(r.data.entry[i].content);
+ // props.sort();
+ // for (var j = 0; j < props.length; j++) {
+ // if (props[j].substr(0,4) !== "eai:" && !(props[j] === "disabled" && ! r.data.entry[i].content[props[j]])) {
+ // str += props[j] + " = " + r.data.entry[i].content[props[j]] + "\n";
+ // }
+ // }
+ // }
+ //if (str) {
+ resolve(r.data.entry);
+ //} else {
+ // reject();
+ //}
+ } else {
+ reject();
+ }
+ });
+ });
+ }
+
+ function getRunningConfig(path) {
+ path = path.replace(/\.conf$/i,"");
+ return new Promise(function(resolve, reject){
+ service.get('/servicesNS/-/-/configs/conf-' + path, null, function(err, r) {
+ if (err) {
+ reject(err);
+ }
+ var str = "";
+ if (r && r.data && r.data.entry) {
+ for (var i = 0; i < r.data.entry.length; i++) {
+ str += "[" + r.data.entry[i].name + "]\n";
+ var props = Object.keys(r.data.entry[i].content);
+ props.sort();
+ for (var j = 0; j < props.length; j++) {
+ if (props[j].substr(0,4) !== "eai:" && !(props[j] === "disabled" && ! r.data.entry[i].content[props[j]])) {
+ str += props[j] + " = " + r.data.entry[i].content[props[j]] + "\n";
+ }
+ }
+ }
+ if (str) {
+ resolve(str);
+ } else {
+ reject();
+ }
+ } else {
+ reject();
+ }
+ });
+ });
+ }
+
+ function runningVsLayered(path, compare){
+ path = path.replace(/\.conf$/i,"");
+ var type = 'live';
+ var tab_path_fmt = 'live: ' + path;
+ if (compare) {
+ type = 'live-diff';
+ tab_path_fmt = 'live/btool: ' + path;
+ }
+ if (! tabAlreadyOpen(type, path)) {
+ var ecfg = createTab(type, path, tab_path_fmt);
+ serverActionWithoutFlicker({action: 'btool-list', path: path}).then(function(contents){
+ var c = formatBtoolList(contents, "btool-hidepaths");
+ if ($.trim(c)) {
+ getRunningConfig(path).then(function(contents_running){
+ if (compare) {
+ updateTabAsDiffer(
+ ecfg,
+ "# Filesystem config\n" + formatLikeRunningConfig(contents),
+ "# Running config\n" + contents_running
+ );
+ } else {
+ updateTabAsEditor(ecfg, contents_running, 'ini');
+ }
+ }).catch(function(){
+ closeTabByCfg(ecfg);
+ showModal({
+ title: "Warning",
+ body: "Could not get retreieve running config for " + htmlEncode(path) + "
",
+ size: 300
+ });
+ });
+ } else {
+ closeTabByCfg(ecfg);
+ showModal({
+ title: "Error",
+ body: "No btool data returned for " + htmlEncode(path) + "
",
+ size: 300
+ });
+ }
+ }).catch(function(){
+ closeTabByCfg(ecfg);
+ });
+ }
+ }
+
+ function runBToolList(inPath, type, origPath, replacementPath){
+ var parts = inPath.split(":");
+ var conf_file = parts.shift().replace(/\.conf$/i, "");
+ var path = parts.join(":");
+ // There are three special "paths" which we replace with the dynamic value
+ if (path === "deployment-apps"){
+ if (conf.btool_dir_for_deployment_apps) {
+ path = conf.btool_dir_for_deployment_apps;
+ origPath = conf.btool_dir_for_deployment_apps;
+ replacementPath = "/splunk/etc/deployment-apps/";
+ } else {
+ path = "";
+ }
+ }
+ if (path === "master-apps") {
+ if (conf.btool_dir_for_master_apps) {
+ path = conf.btool_dir_for_master_apps;
+ origPath = conf.btool_dir_for_master_apps;
+ replacementPath = "/splunk/etc/master-apps/";
+ } else {
+ path = "";
+ }
+ }
+ if (path === "manager-apps") {
+ if (conf.btool_dir_for_manager_apps) {
+ path = conf.btool_dir_for_manager_apps;
+ origPath = conf.btool_dir_for_manager_apps;
+ replacementPath = "/splunk/etc/manager-apps/";
+ } else {
+ path = "";
+ }
+ }
+ if (path === "shcluster") {
+ if (conf.btool_dir_for_shcluster_apps) {
+ path = conf.btool_dir_for_shcluster_apps;
+ } else {
+ path = "";
+ }
+ }
+ var tab_path_fmt = 'btool: ' + conf_file + (type === "btool" ? "" : " (" + type.substr(6) + ")");
+ if (tabAlreadyOpen(type, conf_file + ":" + path)) {
+ closeTabByName(type, conf_file + ":" + path);
+ }
+ var ecfg = createTab(type, conf_file + ":" + path, tab_path_fmt);
+ serverActionWithoutFlicker({action: 'btool-list', path: conf_file, param1: path}).then(function(contents){
+ if (typeof origPath !== "undefined") {
+ contents = adjustBtoolPaths(contents, origPath, replacementPath);
+ }
+ var c = formatBtoolList(contents, type);
+ if ($.trim(c)) {
+ updateTabAsEditor(ecfg, c, 'ini');
+ ecfg.btoollist = contents;
+ serverAction({action: 'spec-hinting', path: conf_file}).then(function(h){
+ ecfg.hinting = buildHintingLookup(conf_file, h);
+ });
+ } else {
+ closeTabByCfg(ecfg);
+ showModal({
+ title: "Warning",
+ body: "No contents for \"" + htmlEncode(tab_path_fmt) + "\"
",
+ size: 300
+ });
+ }
+ }).catch(function(){
+ console.error(arguments);
+ closeTabByCfg(ecfg);
+ });
+ }
+
+ function displaySpecFile(path) {
+ path = path.replace(/\.conf$/i,"");
+ var tab_path_fmt = 'spec: ' + path;
+ if (! tabAlreadyOpen('spec', path)) {
+ var ecfg = createTab('spec', path, tab_path_fmt);
+ serverActionWithoutFlicker({action: 'spec', path: path}).then(function(contents) {
+ if ($.trim(contents)) {
+ updateTabAsEditor(ecfg, contents, 'ini');
+ } else {
+ closeTabByCfg(ecfg);
+ showModal({
+ title: "Error",
+ body: "No spec file found!
",
+ size: 300
+ });
+ }
+ }).catch(function(){
+ closeTabByCfg(ecfg);
+ });
+ }
+ }
+
+ // Update and display the left pane in filesystem mode
+ function showTreePaneSpinner(direction) {
+ if (! leftpane_ignore) {
+ leftpane_ignore = direction || "none";
+ $ce_file_wrap.addClass("ce_move_" + leftpane_ignore);
+ $ce_spinner.clone().appendTo($ce_tree_pane);
+ $ce_tree_icons.find('i').addClass("ce_disabled");
+ }
+ }
+
+ function refreshFolder(){
+ readFolderFromServer(inFolder);
+ }
+
+ function getTreeCache(path, depth) {
+ var patharray = path.split("/");
+ if (typeof depth === "undefined") {
+ depth = patharray.length;
+ } else {
+ // make sure we arent attempting to go deeper than the length of the path
+ depth = Math.min(patharray.length, depth);
+ }
+ var base = filecache;
+ if (filecache === null) {
+ return base;
+ }
+ for (var i = 1; i < depth; i++) {
+ if (base.hasOwnProperty(patharray[i])) {
+ base = base[patharray[i]];
+ } else {
+ base = null;
+ break;
+ }
+ }
+ return base;
+ }
+
+ // Read the folder from the cache
+ function readFolder(path, direction) {
+ //path = path.replace(/\/{2,}/,"/");
+ path = path.replace(/(?:\/\.|\/)+$/g,"");
+ filterModeReset();
+ var base = getTreeCache(path);
+ if (base === null || ! base.hasOwnProperty(".")){
+ readFolderFromServer(path, direction);
+ } else {
+ folderContents = [];
+ for (var key in base) {
+ if (base.hasOwnProperty(key) && key !== ".") {
+ folderContents.push({
+ sortkey: key.toLocaleLowerCase(),
+ dir: true,
+ name: key
+ });
+ }
+ }
+ if (base.hasOwnProperty(".")) {
+ for (var j = 0; j < base["."].length; j++) {
+ folderContents.push({
+ sortkey: base["."][j].toLocaleLowerCase(),
+ dir: false,
+ name: base["."][j]
+ });
+ }
+ }
+ readFolderLoad(path);
+ // Even though we just loaded the folder contents from cache, we still request data from the server which will be updated once it is ready.
+ // this keeps the UI fast and makes sure that stuff hasnt changed after the cache was generated. It also allows for sorting by size/timestamp
+ readFolderFromServerWithoutSpinner(path, direction);
+ }
+ }
+
+ function readFolderFromServer(path, direction) {
+ showTreePaneSpinner(direction);
+ openingFolder = path;
+ return readFolderFromServerActual(path, direction);
+ }
+
+ function readFolderFromServerWithoutSpinner(path, direction) {
+ openingFolder = path;
+ return readFolderFromServerActual(path, direction);
+ }
+
+ function readFolderFromServerActual(path, direction) {
+ return serverAction({action: 'read', path: path}).then(function(contents){
+ // Make sure the user didnt navigate to another folder while waiting for the server query
+ if (openingFolder !== path) { return; }
+ var i;
+ // if filecache is null it means user turned it off by setting conf to -1
+ if (filecache !== null) {
+ var base = getTreeCache(path);
+ // base can be null if the screen was opened when we were already deep in the uncached zone
+ if (base !== null) {
+ var folders = ["."];
+ base["."] = [];
+ for (i = 0; i < contents.length; i++) {
+ if (!contents[i][0]) {
+ base["."].push(contents[i][1]);
+ } else {
+ folders.push(contents[i][1]);
+ if (! base.hasOwnProperty(contents[i][1])) {
+ base[contents[i][1]] = {};
+ }
+ }
+ }
+ // Go through and delete any keys that might no longer exist
+ for (var key in base) {
+ if (base.hasOwnProperty(key) && folders.indexOf(key) === -1) {
+ delete base[key];
+ }
+ }
+ }
+ }
+ folderContents = [];
+ for (i = 0; i < contents.length; i++) {
+ folderContents.push({
+ sortkey: contents[i][1].toLocaleLowerCase(),
+ dir: !!(contents[i][0]),
+ name: contents[i][1],
+ time: contents[i][2],
+ size: contents[i][3],
+ });
+ }
+ readFolderLoad(path);
+ }).catch(function(msg){
+ leftPaneRemoveSpinner();
+ $ce_file_wrap.empty();
+ $ce_file_path.empty();
+ $("Error loading folder contents
(was folder deleted?)
Retry or Go to SPLUNK_HOME
").appendTo($ce_file_wrap);
+ $ce_file_wrap.find(".ce_tree_retry").on("click", function(){
+ return readFolderFromServer(path, direction);
+ });
+ $ce_file_wrap.find(".ce_tree_reset").on("click", function(){
+ return readFolderFromServer(".");
+ });
+ });
+ }
+
+ function readFolderLoad(path){
+ inFolder = path;
+ updateUrlHash();
+ localStorage.setItem('ce_current_path', inFolder);
+ folderContents.sort(function(a, b) {
+ if (a.dir === b.dir) {
+ if (sortMode === "size" || sortMode === "time") {
+ if (sortAsc) {
+ return a[sortMode] > b[sortMode] ? -1 : a[sortMode] < b[sortMode] ? 1 : a.sortkey > b.sortkey ? 1 : a.sortkey < b.sortkey ? -1 : 0;
+ }
+ return a[sortMode] > b[sortMode] ? 1 : a[sortMode] < b[sortMode] ? -1 : a.sortkey > b.sortkey ? 1 : a.sortkey < b.sortkey ? -1 : 0;
+ }
+ // sort by name
+ if (sortAsc) {
+ return a.sortkey > b.sortkey ? 1 : a.sortkey < b.sortkey ? -1 : 0;
+ }
+ return a.sortkey > b.sortkey ? -1 : a.sortkey < b.sortkey ? 1 : 0;
+ }
+ return b.dir ? 1 : -1;
+ });
+ leftPaneFileList();
+ }
+
+ function filePathRTLCheck() {
+ var span = $ce_file_path.find("span");
+ if (span.attr("title")) {
+ if (span.width() > $ce_file_path.width()) {
+ $ce_file_path.addClass('ce_rtl');
+ } else {
+ $ce_file_path.removeClass('ce_rtl');
+ }
+ }
+ }
+
+ function leftPaneRemoveSpinner(){
+ if (leftpane_ignore) {
+ if (leftpane_ignore === 'fwd') {
+ $ce_file_wrap.css({transition: "all 0ms", transform: "translate(200px, 0px)", opacity: 0});
+ } else if (leftpane_ignore === 'back') {
+ $ce_file_wrap.css({transition: "all 0ms", transform: "translate(-200px, 0px)", opacity: 0});
+ } else {
+ $ce_file_wrap.css({transition: "all 0ms", transform: "", opacity: 0});
+ }
+ $ce_file_wrap.removeClass("ce_move_none ce_move_fwd ce_move_back");
+ $ce_tree_pane.find(".ce_spinner, .ce_fs_slow_message").remove();
+ setTimeout(function(){
+ $ce_file_wrap.css({transition: "", transform: "", opacity: ""});
+ },0);
+ leftpane_ignore = false;
+ }
+ }
+
+ function formatSize(bytes) {
+ if (bytes === 0) return '0 B';
+ var k = 1024;
+ var dm = 2;
+ var sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+ var i = Math.floor(Math.log(bytes) / Math.log(k));
+ return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i] + '';
+ }
+
+ function formatDate(val) {
+ var d = new Date(val*1000);
+ return d.toLocaleString();
+ }
+
+ function leftPaneFileList(filter){
+ leftPaneRemoveSpinner();
+ $ce_file_wrap.empty();
+ $ce_file_path.empty();
+ $ce_tree_icons.find('i').removeClass("ce_disabled");
+ if (inFolder === ".") {
+ $(".ce_folder_up").addClass("ce_disabled");
+ } else {
+ $(".ce_folder_up").removeClass("ce_disabled");
+ }
+ $("").appendTo($ce_file_path);
+ var files = 0;
+ var filter_re;
+ if (filter) {
+ filter_re = new RegExp(escapeRegExp(filter), 'gi');
+ }
+ for (var i = 0; i < folderContents.length; i++) {
+ var item = folderContents[i].name;
+ if (! filter || item.toLowerCase().indexOf(filter) > -1) {
+ var icon = (folderContents[i].dir) ? "folder" : "report";
+ var text = htmlEncode(item);
+ if (filter) {
+ text = text.replace(filter_re, "$&");
+ }
+ $("(was folder deleted?)
Retry or Go to SPLUNK_HOME
"+
+ " " +
+ "
").attr("file", inFolder + "/" + item).appendTo($ce_file_wrap);
+ files++;
+ }
+ }
+ if (files===0) {
+ if (filter) {
+ $("" + text + "
"+
+ "" + (folderContents[i].size > -1 && folderContents[i].hasOwnProperty("size") ? formatSize(folderContents[i].size) : "") + "
"+
+ "" + (folderContents[i].time > -1 && folderContents[i].hasOwnProperty("time") ? formatDate(folderContents[i].time) : "") + "
"+
+ "Not found: " + htmlEncode(filter) + "
").appendTo($ce_file_wrap);
+ } else {
+ $("Folder empty
").appendTo($ce_file_wrap);
+ }
+ } else {
+ if (treeSearchFocus && $(".ce_leftnav_keyboard_selected").length == 0) {
+ $ce_file_wrap.children(".ce_leftnav").first().addClass("ce_leftnav_keyboard_selected");
+ }
+
+ }
+ $ce_file_path.find("span, bdi").attr("title", inFolder).text(inFolder + '/' + (files > 1 ? '\xa0\xa0\xa0\xa0\xa0' + files : ""));
+ filePathRTLCheck();
+ }
+
+ function leftPaneRestList(filter){
+ //leftPaneRemoveSpinner();
+ $ce_file_wrap.empty();
+ $ce_file_path.empty();
+ $ce_tree_icons.find('i').removeClass("ce_disabled");
+ var crumbs = "";
+ if (inFolderRestType === "") {
+ $(".ce_folder_up_rest").addClass("ce_disabled");
+ //leftPaneRestListGetTypes();
+ } else if (inFolderRestApp === "") {
+ $(".ce_folder_up_rest").addClass("ce_disabled");
+ crumbs = "."; //inFolderRestType;
+ leftPaneRestListGet("apps", filter);
+ } else {
+ crumbs = "./" + inFolderRestApp; //inFolderRestType +
+ leftPaneRestListGet(inFolderRestType, filter);
+ }
+ $("").appendTo($ce_file_path);
+ $ce_file_path.find("span, bdi").attr("title", crumbs).text(crumbs + '/');
+ filePathRTLCheck();
+ localStorage.setItem('ce_current_path_restapp', inFolderRestApp);
+ }
+
+ var restTypes = {
+ "views": {
+ endpoint: "/data/ui/views",
+ args: {
+ count:0,
+ f: "label",
+ search: "(isDashboard=1 AND (rootNode=\"dashboard\" OR rootNode=\"form\" OR rootNode=\"view\" OR rootNode=\"html\") AND isVisible=1)"
+ }
+ },
+ "apps": {
+ endpoint: "/services/apps/local",
+ },
+
+ };
+
+ function leftPaneRestListGet(type, filter) {
+ var label;
+ var files = false;
+ var i;
+ var filter_re;
+ if (filter) {
+ filter_re = new RegExp(escapeRegExp(filter), 'gi');
+ }
+
+ // if app's cache doesnt exist, do that
+ if (! restTypes.apps.hasOwnProperty("cache")) {
+ getRest(restTypes.apps.endpoint, {count:0, f:"label"}).then(function(restData) {
+ //console.log(restData);
+ restTypes.apps.cache = {};
+ for (var i = 0; i < restData.length; i++) {
+ restTypes.apps.cache[restData[i].name] = restData[i].content.label;
+ }
+ // try again
+ leftPaneRestListGet(type, filter);
+ }).catch(function(){
+ showModal({
+ title: "Warning",
+ body: "Could not get rest data for apps
",
+ size: 300
+ });
+ });
+
+
+ // if we dont have a cached copy of the data we need e.g. views, then get it now
+ } else if (! restTypes[inFolderRestType].hasOwnProperty("cache") ) {
+ getRest(restTypes[inFolderRestType].endpoint, restTypes[inFolderRestType].args).then(function(restData) {
+ //console.log(restData);
+ restTypes[inFolderRestType].cache = [];
+ for (var i = 0; i < restData.length; i++) {
+ var item = {
+ date: new Date(restData[i].updated).valueOf(),
+ link: restData[i].links.alternate,
+ app: restData[i].acl.app,
+ label: restData[i].content.hasOwnProperty("label") ? restData[i].content.label : "",
+ name: restData[i].name,
+ };
+ restTypes[inFolderRestType].cache.push(item);
+ }
+ // try again
+ leftPaneRestListGet(type, filter);
+ }).catch(function(){
+ showModal({
+ title: "Warning",
+ body: "Could not get rest data for " + htmlEncode(inFolderRestType) + "
",
+ size: 300
+ });
+ });
+
+ // we have the apps list and the data list
+ } else {
+ //console.log("using " + inFolderRestType + " cache", restTypes[inFolderRestType].cache);
+ if (type === "apps") {
+ var appList = {};
+ var appListArray = [];
+ for (i = 0; i < restTypes[inFolderRestType].cache.length; i++) {
+ var app = restTypes[inFolderRestType].cache[i].app;
+ if (! appList.hasOwnProperty(app)) {
+ appList[app] = {
+ count:0,
+ latest:0,
+ app: app,
+ label_orig: restTypes.apps.cache[app]
+ };
+ appListArray.push(appList[app]);
+ if (! restTypes.apps.cache[app] || displayModeRest==="n") {
+ appList[app].label = htmlEncode(app);
+ } else if (displayModeRest==="l") {
+ appList[app].label = htmlEncode(restTypes.apps.cache[app]);
+ } else if (displayModeRest==="ln") {
+ appList[app].label = htmlEncode(restTypes.apps.cache[app]) + " (" + htmlEncode(app) + ")";
+ } else { //nl
+ appList[app].label = htmlEncode(app) + " (" + htmlEncode(restTypes.apps.cache[app]) + ")";
+ }
+ }
+ appList[app].count++;
+ if (appList[app].latest < restTypes[inFolderRestType].cache[i].date) {
+ appList[app].latest = restTypes[inFolderRestType].cache[i].date;
+ }
+ }
+
+ // sort apps
+ appListArray.sort(function(a, b) {
+ if (sortModeRest==="label"){
+ return sortAscRest==="1" ? a.label.localeCompare(b.label) : b.label.localeCompare(a.label);
+ } else if ( sortModeRest==="time"){
+ return sortAscRest==="1" ? a.latest - b.latest : b.latest - a.latest;
+ }
+ });
+
+ for (i = 0; i < appListArray.length; i++) {
+ if (! filter || appListArray[i].app.toLowerCase().indexOf(filter) > -1 || appListArray[i].label_orig.toLowerCase().indexOf(filter) > -1) {
+
+ files = true;
+ if (filter) {
+ appListArray[i].label = appListArray[i].label.replace(filter_re, "$&");
+ }
+ $(""+
+ " " +
+ "
").attr("restapp", appListArray[i].app).appendTo($ce_file_wrap);
+ }
+
+ }
+ } else {
+
+ // sort views / etc
+ restTypes[type].cache.sort(function(a, b) {
+ if (sortModeRest==="label"){
+ if (displayModeRest==="l" || displayModeRest==="ln") {
+ return sortAscRest==="1" ? a.label.localeCompare(b.label) : b.label.localeCompare(a.label);
+ } else {
+ return sortAscRest==="1" ? a.name.localeCompare(b.name) : b.name.localeCompare(a.name);
+ }
+ } else if ( sortModeRest==="time"){
+ return sortAscRest==="1" ? a.date - b.date : b.date - a.date;
+ }
+ });
+
+ for (i = 0; i < restTypes[type].cache.length; i++) {
+ if (restTypes[type].cache[i].app === inFolderRestApp) {
+ if (! filter || restTypes[type].cache[i].name.toLowerCase().indexOf(filter) > -1 || restTypes[type].cache[i].label.toLowerCase().indexOf(filter) > -1) {
+ files = true;
+ if (! restTypes[type].cache[i].label || displayModeRest==="n") {
+ label = htmlEncode(restTypes[type].cache[i].name);
+ } else if (displayModeRest==="l") {
+ label = htmlEncode(restTypes[type].cache[i].label);
+ } else if (displayModeRest==="ln") {
+ label = htmlEncode(restTypes[type].cache[i].label) + " (" + htmlEncode(restTypes[type].cache[i].name) + ")";
+ } else { //nl
+ label = htmlEncode(restTypes[type].cache[i].name) + " (" + htmlEncode(restTypes[type].cache[i].label) + ")";
+ }
+ if (filter) {
+ label = label.replace(filter_re, "$&");
+ }
+ $("" + appListArray[i].label + " " + appListArray[i].count + "
"+
+ ""+
+ "
").attr("restfile", restTypes[type].cache[i].link).appendTo($ce_file_wrap);
+ }
+ }
+ }
+ }
+ if (!files) {
+ $("" + label + "
"+
+ "Nothing found
").appendTo($ce_file_wrap);
+ } else {
+ if (treeSearchFocus && $(".ce_leftnav_keyboard_selected").length == 0) {
+ $ce_file_wrap.children(".ce_leftnav").first().addClass("ce_leftnav_keyboard_selected");
+ }
+ }
+ }
+ }
+
+ // Handle clicking a rest link in the left pane, to open it in the right pane
+ function readFileRest(path){
+ var label = preferences.ce_fullPathTab ? "" + dodgyRemoveRelPath(dodgyDirname(path)) + "" + dodgyBasename(path) : dodgyBasename(path);
+ var type = "rest";
+ if (! tabAlreadyOpen(type, path)) {
+ var ecfg = createTab(type, path, label);
+ getRest(path, null).then(function(restData) {
+ //console.log(restData); //?output_mode=json&count=0&f=title&f=label
+ if (restData.length === 0) {
+ showModal({
+ title: "Warning",
+ body: "Nothing returned from REST API at: " + htmlEncode(path) + "
",
+ size: 300
+ });
+ closeTabByCfg(ecfg);
+ } else if (restData.length === 1) {
+ updateTabAsEditor(ecfg, restData[0].content['eai:data'], "xml");
+ } else {
+ showModal({
+ title: "Warning",
+ body: "unexpectedly returned too many items from REST API at: " + htmlEncode(path) + "
",
+ size: 300
+ });
+ closeTabByCfg(ecfg);
+ }
+
+ }).catch(function(){
+ showModal({
+ title: "Warning",
+ body: "Unexpected error getting data from Splunk REST api: " + htmlEncode(path) + "
",
+ size: 300
+ });
+ closeTabByCfg(ecfg);
+ });
+ }
+ }
+
+
+ // The conf file list
+ function leftPaneConfList(filter) {
+ $ce_file_wrap.empty();
+ $ce_file_path.removeClass('ce_rtl').empty();
+ var filter_re;
+ var files = false;
+ if (filter) {
+ filter_re = new RegExp(escapeRegExp(filter), 'gi');
+ }
+ $("Splunk conf files").appendTo($ce_file_path);
+ for (var i = 0; i < confFilesSorted.length; i++) {
+ if (! filter) {
+ $("").text(confFilesSorted[i]).attr("file", confFilesSorted[i]).prepend(" ").appendTo($ce_file_wrap);
+ files = true;
+
+ } else if (confFilesSorted[i].toLowerCase().indexOf(filter) > -1) {
+ var text = htmlEncode(confFilesSorted[i]);
+ text = text.replace(filter_re, "$&");
+ $("").html(text).attr("file", confFilesSorted[i]).prepend(" ").appendTo($ce_file_wrap);
+ files = true;
+ }
+ }
+ if (!files){
+ $("Not found: " + htmlEncode(filter) + "
").appendTo($ce_file_wrap);
+ } else {
+ if (treeSearchFocus && $(".ce_leftnav_keyboard_selected").length == 0) {
+ $ce_file_wrap.children(".ce_leftnav").first().addClass("ce_leftnav_keyboard_selected");
+ }
+ }
+ }
+
+ // Click handler for Recent Files button in top right
+ // TODO [low] can we enhance this so it shows files by how often you use them?
+ function leftPaneRecentList(filter) {
+ $ce_file_wrap.empty();
+ $ce_file_path.removeClass('ce_rtl').empty();
+ var filter_re;
+ if (filter) {
+ filter_re = new RegExp(escapeRegExp(filter), 'gi');
+ }
+ $("Recent files").appendTo($ce_file_path);
+ var counter = 0;
+ var openlabels = [];
+ for (var j = 0; j < editors.length; j++) {
+ openlabels.push(editors[j].label);
+ }
+ for (var i = closed_tabs.length - 1; i >= 0 ; i--) {
+ if (counter > max_recent_files_show) {
+ break;
+ }
+ // hide item if they are actually open at the moment
+ if (openlabels.indexOf(closed_tabs[i].label) === -1) {
+ var text = closed_tabs[i].label.replace(/^read:\s/,"");
+ if (! filter || text.toLowerCase().indexOf(filter) > -1) {
+ text = htmlEncode(text);
+ if (filter) {
+ text = text.replace(filter_re, "$&");
+ }
+ var icon = "report";
+ if (closed_tabs[i].type !== "read") {
+ icon = "bulb";
+ }
+ counter++;
+ $(" " + text + "
").attr("file", closed_tabs[i].file).attr("title", closed_tabs[i].file).attr("type", closed_tabs[i].type).appendTo($ce_file_wrap);
+ }
+ }
+ }
+ if (counter === 0) {
+ if (filter) {
+ $("Not found: " + htmlEncode(filter) + "
").appendTo($ce_file_wrap);
+ } else {
+ $("Nothing here
").appendTo($ce_file_wrap);
+ }
+ } else {
+ if (treeSearchFocus && $(".ce_leftnav_keyboard_selected").length == 0) {
+ $ce_file_wrap.children(".ce_leftnav").first().addClass("ce_leftnav_keyboard_selected");
+ }
+ }
+ }
+
+ // Handle clicking an file or folder in the left pane
+ function readFile(path, customErrorCB){
+ var label = preferences.ce_fullPathTab ? "" + dodgyRemoveRelPath(dodgyDirname(path)) + "" + dodgyBasename(path) : dodgyBasename(path);
+ var type = "read";
+ if (path === "") {
+ label = "Settings";
+ type = "settings";
+ }
+ if (! tabAlreadyOpen(type, path)) {
+ var ecfg = createTab(type, path, label);
+ serverActionWithoutFlicker({action: 'read', path: path}, customErrorCB).then(function(contents){
+ updateTabAsEditor(ecfg, contents);
+ if (ecfg.hasOwnProperty('matchedConf')) {
+ highlightBadConfig(ecfg);
+ if (confFiles.hasOwnProperty(ecfg.matchedConf)) {
+ serverAction({action: 'spec-hinting', path: ecfg.matchedConf}).then(function(c){
+ ecfg.hinting = buildHintingLookup(ecfg.matchedConf, c);
+ });
+ }
+ }
+ }).catch(function(){
+ closeTabByCfg(ecfg);
+ });
+ }
+ }
+
+
+ function fileSystemUpload(parentPath){
+ showModal({
+ title: "Create file, create folder or upload a file",
+ size: 580,
+ body: ""+
+ "
",
+ onShow: function(){
+ $('.ce_prompt_input_file').focus().on('keydown', function(e) {
+ // submit form on enter key
+ if (e.which === 13) {
+ $('.ce_prompt_btn_file').click();
+ }
+ });
+ $('.ce_prompt_btn_file').on("click", function(){
+ $('.modal').one('hidden.bs.modal', function() {
+ var fname = $('.ce_prompt_input_file').val();
+ if (fname) {
+ showTreePaneSpinner();
+ serverAction({action: 'newfile', path: parentPath, param1: fname}).then(function(){
+ refreshFolder();
+ showToast('Success');
+ }).catch(function(){
+ refreshFolder();
+ });
+ }
+ }).modal('hide');
+ });
+ $('.ce_prompt_input_folder').on('keydown', function(e) {
+ // submit form on enter key
+ if (e.which === 13) {
+ $('.ce_prompt_btn_folder').click();
+ }
+ });
+ $('.ce_prompt_btn_folder').on("click", function(){
+ $('.modal').one('hidden.bs.modal', function() {
+ var fname = $('.ce_prompt_input_folder').val();
+ if (fname) {
+ showTreePaneSpinner();
+ serverAction({action: 'newfolder', path: parentPath, param1: fname}).then(function(){
+ refreshFolder();
+ showToast('Success');
+ }).catch(function(){
+ refreshFolder();
+ });
+ }
+ }).modal('hide');
+ });
+ $('.ce_prompt_btn_upload').on("click", function(){
+ $('.modal').one('hidden.bs.modal', function() {
+ var file = $('.ce_file_upload_input')[0].files[0];
+ var reader = new FileReader();
+ var extract = "";
+ var ecfg;
+ if ($('.ce_file_upload_extract:checked').length) {
+ extract = "e";
+ ecfg = createTab('run', "", 'Extracted files: ' + htmlEncode(file.name));
+ }
+ reader.onloadend = function() {
+ var upFileB64 = reader.result;
+ showTreePaneSpinner();
+ serverAction({action: 'fileupload' + extract, path: parentPath, param1: file.name, file: upFileB64}).then(function(contents){
+ if (ecfg) {
+ updateTabAsEditor(ecfg, contents, "plaintext");
+ } else {
+ showToast('Success');
+ }
+ refreshFolder();
+ }).catch(function(){
+ if (ecfg) {
+ closeTabByCfg(ecfg);
+ }
+ refreshFolder();
+ });
+ };
+ reader.readAsDataURL(file);
+ }).modal('hide');
+ });
+ },
+ actions: []
+ });
+ }
+
+ // Rename a file or folder with a prompt window
+ function fileSystemRename(parentPath) {
+ if (fileIsOpenAndHasChanges(parentPath)) { return; }
+ var bn = dodgyBasename(parentPath);
+ showModal({
+ title: "Rename",
+ size: 400,
+ body: "New file name:
"+
+
+ "New folder name:
"+
+
+ "Select upload file:
"+
+ "Enter new name for
",
+ onShow: function(){
+ $('.ce_prompt_input').focus().on('keydown', function(e) {
+ // submit form on enter key
+ if (e.which === 13) {
+ $('.modal').find('button:first-child').click();
+ }
+ });
+ },
+ actions: [{
+ onClick: function(){
+ $('.modal').one('hidden.bs.modal', function() {
+ var newname = $('.ce_prompt_input').val();
+ if (newname && newname !== bn) {
+ showTreePaneSpinner();
+ serverAction({action: 'rename', path: parentPath, param1: newname}).then(function(){
+ refreshFolder();
+ showToast('Success');
+ // if "path" is open in an editor, it needs to be closed without warning
+ closeTabByName("read", parentPath);
+ }).catch(function(){
+ refreshFolder();
+ });
+ }
+ }).modal('hide');
+ },
+ cssClass: 'btn-primary',
+ label: "Rename"
+ },{
+ onClick: function(){ $(".modal").modal('hide'); },
+ label: "Cancel"
+ }]
+ });
+ }
+
+ // Delete a file or folder with a popup windows
+ function filesystemDelete(file) {
+ if (fileIsOpenAndHasChanges(file)) { return; }
+ showModal({
+ title: "Delete",
+ size: 550,
+ body: "" + bn + "Are you sure you want to delete:
To confirm type 'yes':
",
+ onShow: function(){
+ $('.ce_prompt_input').focus().on("keyup blur", function(){
+ if ($('.ce_prompt_input').val().toLowerCase() === "yes") {
+ $('.modal').find(".btn-danger").removeClass('btn-disabled');
+ } else {
+ $('.modal').find(".btn-danger").addClass('btn-disabled');
+ }
+ }).on('keydown', function(e) {
+ if (e.which === 13) {
+ $('.modal').find('button:first-child').click();
+ }
+ });
+ $('.modal').find('.ce_type_yes').on("click",function(){
+ $('.ce_prompt_input').val("yes").blur();
+ });
+ },
+ actions: [{
+ onClick: function(){
+ if ($('.ce_prompt_input').val().toLowerCase() !== "yes") {
+ return;
+ }
+ $('.modal').one('hidden.bs.modal', function() {
+ showTreePaneSpinner();
+ serverAction({action: 'delete', path: file}).then(function(){
+ refreshFolder();
+ showToast('Success');
+ // if "path" is open in an editor, it needs to be closed without warning
+ closeTabByName("read", file);
+ }).catch(function(){
+ refreshFolder();
+ });
+ }).modal('hide');
+ },
+ cssClass: 'btn-danger btn-disabled',
+ label: "Delete"
+ },{
+ onClick: function(){ $(".modal").modal('hide'); },
+ label: "Cancel"
+ }]
+ });
+ }
+
+ function showChangeLog() {
+ var ecfg = createTab('change-log', "", "Change log");
+ serverActionWithoutFlicker({action: 'git-log', path: inFolder}).then(function(contents){
+ updateTabAsEditor(ecfg, contents, "git-log");
+ }).catch(function(){
+ closeTabByCfg(ecfg);
+ });
+ }
+
+ // Git history of a specific file optionally between two commit tags
+ function getFileHistory(file, folder){
+ var ecfg = createTab('history', file, "history: " + dodgyBasename(file));
+ serverActionWithoutFlicker({action: 'git-history', path: file, param1: folder}).then(function(contents){
+ contents = $.trim(contents);
+ if (! contents) {
+ showModal({
+ title: "Warning",
+ body: "" + file + "To confirm type 'yes':
No change history found for:
",
+ size: 400
+ });
+ closeTabByCfg(ecfg);
+ return;
+ }
+ updateTabAsEditor(ecfg, contents, "git-diff");
+ }).catch(function(){
+ closeTabByCfg(ecfg);
+ });
+ }
+
+ function activateTab(idx){
+ if (idx < -1 || idx > (editors.length - 1) || (activeTab === idx && activeTab > -1)) {
+ return;
+ }
+ $ce_contents.children().addClass("ce_hidden");
+ $ce_contents_home.addClass("ce_hidden");
+ $ce_tabs.children().removeClass("ce_active");
+ $ce_home_tab.removeClass("ce_active");
+ activeTab = idx;
+ if (idx !== -1) {
+ editors[idx].tab.addClass('ce_active');
+ editors[idx].tab_container.removeClass('ce_hidden');
+ editors[idx].last_opened = Date.now();
+ } else {
+ $ce_home_tab.addClass('ce_active');
+ $ce_contents_home.removeClass('ce_hidden');
+ }
+ doPipeTabSeperators();
+ updateUrlHash();
+ if (editors[idx] && editors[idx].hasOwnProperty("editor")) {
+ editors[idx].editor.focus();
+ }
+ // switching tabs. check for changes
+ if (idx > -1) {
+ clearTimeout(fileModsCheckTimer);
+ fileModsCheckTimer = setTimeout(function(){ checkFileMods(); }, 1000);
+ }
+ }
+
+ // The pipe seperators are between active tabs but not on the currently active tab or the one to its left.
+ function doPipeTabSeperators(){
+ $(".ce_pipe, .ce_pipe_left").remove();
+ for (var i = 0; i < editors.length; i++) {
+ if ((activeTab - 1) !== i && activeTab !== i) {
+ editors[i].tab.append('');
+ }
+ }
+ if (activeTab >= 0) {
+ $ce_home_tab.append('');
+ if (activeTab > 0) {
+ $ce_home_tab.append('');
+ }
+ }
+ }
+
+ // Check if tab is open with unsaved changes
+ function fileIsOpenAndHasChanges(file) {
+ for (var i = 0; i < editors.length; i++) {
+ if (editors[i].file === file) {
+ if (editors[i].hasChanges) {
+ showModal({
+ title: "Warning",
+ body: "" + htmlEncode(file) + " Cannot rename or delete file becuase it is currently open with unsaved changes.
",
+ size: 350
+ });
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ // A tab was opened but there was nothing to put in it, so it is closed.
+ function closeTabByCfg(ecfg) {
+ for (var i = 0; i < editors.length; i++) {
+ if (editors[i].id === ecfg.id) {
+ closeTabNow(i);
+ return;
+ }
+ }
+ }
+
+ function closeTabByName(type, file) {
+ for (var i = 0; i < editors.length; i++) {
+ if (editors[i].file === file && editors[i].type === type) {
+ closeTabNow(i);
+ return;
+ }
+ }
+ }
+
+ function closeTabByHookDetails(arg0, arg1) {
+ //if (preferences.ce_reuseWindow) {
+ if (arg0 === "bump") {
+ closeTabByName("refresh", "bump");
+ } else if (arg0 === "run-safe") {
+ closeTabByName("run", arg1);
+ } else {
+ closeTabByName(arg0, arg1);
+ }
+ //}
+ }
+
+ // Check if tab is already open, and if so, active it instead.
+ function tabAlreadyOpen(type, file) {
+ // check if file is already open
+ for (var i = 0; i < editors.length; i++) {
+ if (editors[i].type === type && editors[i].file === file) {
+ activateTab(i);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ function closeTabWithConfirmation(idx){
+ if (editors[idx].hasChanges) {
+ showModal({
+ title: "Unsaved changes",
+ body: "Discard unsaved changes?
",
+ size: 300,
+ actions: [{
+ onClick: function(){
+ $(".modal").modal('hide');
+ closeTabNow(idx);
+ },
+ cssClass: 'btn-danger',
+ label: "Discard"
+ },{
+ onClick: function(){ $(".modal").modal('hide'); },
+ label: "Cancel"
+ }]
+ });
+ } else {
+ closeTabNow(idx);
+ }
+ }
+
+ // when tabs are closed, remember in local storage for recent files list
+ function logClosedTab(ecfg){
+ // make sure unique items only appear once
+ var splicy = -1;
+ for (var j = 0; j < closed_tabs.length; j++) {
+ if (ecfg.label === closed_tabs[j].label) {
+ splicy = j;
+ }
+ }
+ if (splicy > -1){
+ closed_tabs.splice(splicy, 1);
+ }
+ if (tabCfg.hasOwnProperty(ecfg.type) && tabCfg[ecfg.type].can_reopen) {
+ closed_tabs.push({label: ecfg.label, type: ecfg.type, file: ecfg.file});
+ }
+ // trim length
+ // There is a buffer of 10 so we can have things to show if the tabs are opened and thus removed from the list
+ if (closed_tabs.length > (max_recent_files_show + 10)) {
+ closed_tabs.shift();
+ }
+ //persist to localstorage
+ localStorage.setItem('ce_closed_tabs', JSON.stringify(closed_tabs));
+ }
+
+ function closeTabNow(idx) {
+ logClosedTab(editors[idx]);
+ if (editors[idx].hasOwnProperty("editor")) {
+ editors[idx].editor.dispose();
+ }
+ if (editors[idx].hasOwnProperty("model")) {
+ editors[idx].model.dispose();
+ }
+ if (editors[idx].hasOwnProperty("sidecar_editor")) {
+ editors[idx].sidecar_editor.dispose();
+ }
+ if (editors[idx].hasOwnProperty("sidecar_model")) {
+ editors[idx].sidecar_model.dispose();
+ }
+ editors[idx].tab.remove();
+ editors[idx].tab_container.remove();
+ editors.splice(idx, 1);
+ openTabsListChanged();
+ // if there are still tabs open, find the most recently used tab and activate that one
+ if ($ce_tabs.children().length === 0) {
+ activateTab(-1);
+ // if there is already a tab selected
+ } else if ($ce_tabs.children(".ce_active").length === 0) {
+ var last_used_idx,
+ newest;
+ for (var i = 0; i < editors.length; i++) {
+ if (! newest || newest < editors[i].last_opened) {
+ newest = editors[i].last_opened;
+ last_used_idx = i;
+ }
+ }
+ activateTab(last_used_idx);
+ }
+ }
+
+ function createTabSidecar(label) {
+ var ecfg = editors[activeTab];
+ if (! ecfg.sidecar_container) {
+ ecfg.sidecar_container = $("").appendTo(ecfg.tab_container);
+ $("").appendTo(ecfg.sidecar_container)
+ .on("click", function(){
+ if (ecfg.hasOwnProperty("sidecar_editor")) {
+ ecfg.sidecar_editor.dispose();
+ }
+ if (ecfg.hasOwnProperty("sidecar_model")) {
+ ecfg.sidecar_model.dispose();
+ }
+ ecfg.sidecar_container.remove();
+ ecfg.sidecar_container = null;
+ });
+ $("").appendTo(ecfg.sidecar_container)
+ .on("click", function(){
+ if(ecfg.sidecar_container.hasClass("ce_editor_sidecar_autohide_on")) {
+ ecfg.sidecar_container.removeClass("ce_editor_sidecar_autohide_on");
+ } else {
+ ecfg.sidecar_container.addClass("ce_editor_sidecar_autohide_on");
+ }
+
+ });
+ ecfg.sidecar_title = $("").appendTo(ecfg.sidecar_container).on("click", function(){
+ //console.log("ecfg.sidecar_container.css.transform=", ecfg.sidecar_container.css("transform"));
+ // if the sidecar is collapsed
+ //if (ecfg.sidecar_container.css("transform") === "matrix(1, 0, 0, 1, 0, 467)") {
+
+ // if sidecar is expanded
+ //} else
+ if (ecfg.sidecar_container.css("transform") === "" || ecfg.sidecar_container.css("transform") === "none" || ecfg.sidecar_container.css("transform") === "matrix(1, 0, 0, 1, 0, 0)"){
+ ecfg.sidecar_container.css({transform: "translateY(" + (ecfg.sidecar_container.height() - 35) + "px)"});
+ } else {
+ ecfg.sidecar_container.css({transform: "translateY(0)"});
+ }
+ });
+ ecfg.sidecar_resizer = $("").appendTo(ecfg.sidecar_container);
+ ecfg.sidecar_autohide = $("").appendTo(ecfg.sidecar_container);
+ ecfg.sidecar_editor_container = $("").appendTo(ecfg.sidecar_container);
+
+ // // Handler for resizing the tree pane/editor divider
+ ecfg.sidecar_resizer.on("mousedown", function(e) {
+ e.preventDefault();
+ var was_autohide_on = !! ecfg.sidecar_container.hasClass("ce_editor_sidecar_autohide_on");
+ ecfg.sidecar_container.removeClass("ce_editor_sidecar_autohide_on");
+ $(document).one("mouseup",function(e) {
+ if (was_autohide_on) {
+ ecfg.sidecar_container.addClass("ce_editor_sidecar_autohide_on");
+ }
+ $(document).off('mousemove.sidecar_resize');
+ });
+ $(document).on("mousemove.sidecar_resize", function(e) {
+ ecfg.sidecar_container.css({
+ "transform": "translateY(0)",
+ "width": Math.min($ce_contents.width()-158, Math.max(360, (window.innerWidth - 150 - e.pageX))) + "px",
+ "height": Math.min($ce_contents.height(), Math.max(190, (window.innerHeight - e.pageY))) + "px"
+ });
+ });
+ });
+
+ }
+ ecfg.sidecar_title.html(label);
+ ecfg.sidecar_editor_container.empty().append($ce_spinner.clone());
+ setTimeout(function(){
+ if (ecfg.sidecar_container.hasClass("ce_editor_sidecar_autohide_on")) {
+ ecfg.sidecar_container.css({transform: "translateY(0)", opacity: "1"});
+ }
+ }, 100);
+ ecfg.sidecar_autohide.css({"border-left-width":"1px"});
+ return ecfg;
+ }
+
+ function updateSidecarAsEditor(ecfg, contents) {
+ ecfg.sidecar_editor_container.empty();
+ // The monaco URL must be unique or it will silently close. We use the same file when running different versions of btool and in other circumstances so need to prefix with a unique id.
+ var url = "T" + (tabCreationCount++) + "/" + ecfg.file;
+ ecfg.sidecar_model = monaco.editor.createModel(contents, "plaintext", monaco.Uri.file(url));
+
+ var options = {
+ automaticLayout: true,
+ model: ecfg.sidecar_model,
+ minimap: {
+ enabled: false
+ },
+ lineNumbers: 'off',
+ wordWrap: 'on',
+ folding: false,
+ lineDecorationsWidth: 0,
+ lineNumbersMinChars: 0,
+ glyphMargin: false,
+ hover: { delay: 700 }
+ };
+ ecfg.sidecar_editor = monaco.editor.create(ecfg.sidecar_editor_container[0], options);
+ //ecfg.server_content = ecfg.editor.getValue();
+ var autohideTimeout = setTimeout(function(){
+ if (ecfg.sidecar_container.hasClass("ce_editor_sidecar_autohide_on")) {
+ ecfg.sidecar_container.css({transform: "translateY(" + (ecfg.sidecar_container.height() - 35) + "px)"});
+ }
+ ecfg.sidecar_autohide.css({"border-left-color":"transparent", "border-left-width":"1px"});
+ },5000);
+ setTimeout(function(){
+ ecfg.sidecar_autohide.css({"border-left-width":(ecfg.sidecar_container.width() - 4) + "px", "border-left-color":"rgba(255,255,255,0.5)"});
+ }, 10);
+ if (ecfg.sidecar_container.hasClass("ce_editor_sidecar_autohide_on")) {
+ ecfg.sidecar_container.css({transform: "translateY(0)"});
+ }
+ ecfg.sidecar_editor.onMouseDown(function(e) {
+ clearTimeout(autohideTimeout);
+ ecfg.sidecar_autohide.css({"border-left-color":"transparent", "border-left-width":"1px"});
+ });
+ }
+
+ function createTab(type, file, label){
+ var ecfg = {
+ type: type,
+ file: file,
+ label: type + ": " + file,
+ id: tabid++
+ };
+ editors.push(ecfg);
+ ecfg.tab_container = $("").appendTo($ce_contents);
+ ecfg.editor_container = $("").appendTo(ecfg.tab_container);
+ ecfg.editor_container.append($ce_spinner.clone());
+ // Remove the "restore session" link
+ $(".ce_restore_session").remove();
+ ecfg.tab = $("" + label + "
").attr("title", ecfg.label).data({"tab": ecfg}).appendTo($ce_tabs);
+ ecfg.hasChanges = false;
+ ecfg.server_content = '';
+ activateTab(editors.length-1);
+ openTabsListChanged();
+ return ecfg;
+ }
+
+ function addHookActionToEditor(hook, ecfg) {
+ if (hook._match.test(ecfg.file) && hook.matchtype == "file" && ! (hook.hasOwnProperty("showInPane") && hook.showInPane === "tree")) {
+ var lab = replaceTokens(hook.label, ecfg.file);
+ if (isTrueValue(hook.showWithSave) && ecfg.canBeSavedFile) {
+ ecfg.editor.addAction({
+ id: "Save and " + lab,
+ contextMenuOrder: 0.2,
+ contextMenuGroupId: 'navigation',
+ label: "Save and " + lab,
+ run: function() {
+ saveActiveTab(function(){
+ runAction(hook.action, ecfg.file, true);
+ });
+ }
+ });
+ }
+
+ ecfg.editor.addAction({
+ id: lab,
+ contextMenuOrder: 0.3,
+ contextMenuGroupId: 'navigation',
+ label: lab,
+ run: function() {
+ runAction(hook.action, ecfg.file, true);
+ }
+ });
+ }
+ }
+
+ function updateTabAsEditor(ecfg, contents, language) {
+ // uses the built-in language detection where possible
+ if (! language) {
+ if (/\.(?:conf|meta|spec)/.test(ecfg.file)) {
+ language = "ini";
+ }
+ }
+ var re = /([^\/\\]+).conf$/;
+ var found = ecfg.file.match(re);
+ ecfg.canBeSavedFile = (ecfg.type === "read" || ecfg.type === "settings");
+ ecfg.canBeSavedRest = (ecfg.type === "rest");
+ if (found && ecfg.canBeSavedFile && found[1] !== 'app') {
+ ecfg.matchedConf = found[1];
+ } else if (ecfg.type === "settings"){
+ ecfg.matchedConf = "config_explorer";
+ }
+ if (ecfg.canBeSavedFile || ecfg.canBeSavedRest) {
+ // Start the process of checking filemodtimes
+ // A filemodcheck might be about to occur, but delay it another 100ms in case its the first load a bunch of tabs are opening at once.
+ clearTimeout(fileModsCheckTimer);
+ fileModsCheckTimer = setTimeout(function(){ checkFileMods(); }, 100);
+ }
+ ecfg.saving = false;
+ ecfg.decorations = [];
+ ecfg.editor_container.empty();
+ // The monaco URL must be unique or it will silently close. We use the same file when running different versions of btool and in other circumstances so need to prefix with a unique id.
+ var url = "T" + (tabCreationCount++) + "/" + ecfg.file;
+ ecfg.model = monaco.editor.createModel(contents, language, monaco.Uri.file(url));
+ // Default things to be ini syntax highlighting rather than none
+ if (ecfg.model.getModeId() === "plaintext" && ! language) {
+ monaco.editor.setModelLanguage(ecfg.model, "ini");
+ }
+ var options = $.extend({}, preferences, {
+ automaticLayout: true,
+ model: ecfg.model,
+ lineNumbersMinChars: 3,
+ ariaLabel: ecfg.file,
+ //readOnly: ! ecfg.canBeSavedFile,
+ glyphMargin: true,
+ hover: { delay: 700 }
+ });
+ ecfg.editor = monaco.editor.create(ecfg.editor_container[0], options);
+ ecfg.server_content = ecfg.editor.getValue();
+
+ // check if we need to scroll to a particular location and highlight a line
+ if (doLineHighlight !== "") {
+ var line_nums = doLineHighlight.split(",");
+ //console.log(doLineHighlight, line_nums);
+ if (line_nums.length > 1) {
+ ecfg.editor.setSelection(new monaco.Selection(Number(line_nums[0]),1,(Number(line_nums[1]) + 1),1));
+ ecfg.editor.revealLineInCenter(Number(line_nums[0]), 0);
+ ecfg.editor.focus();
+ }
+ doLineHighlight = "";
+ }
+
+ if (ecfg.canBeSavedFile || ecfg.canBeSavedRest) {
+ ecfg.editor.onDidChangeModelContent(function() {
+ // check against saved copy
+ if (ecfg.editor.getValue() !== ecfg.server_content) {
+ if (!ecfg.hasChanges) {
+ ecfg.tab.append("");
+ ecfg.hasChanges = true;
+ }
+ } else {
+ if (ecfg.hasChanges) {
+ ecfg.tab.find('.icon-alert-circle').remove();
+ ecfg.hasChanges = false;
+ }
+ }
+ // Turn off the glyphs until next save
+ ecfg.decorations = ecfg.editor.deltaDecorations(ecfg.decorations, []);
+ });
+ }
+ ecfg.editor.addAction({
+ id: 'prev-tab',
+ label: 'Switch tab to left of current',
+ keybindings: [monaco.KeyMod.Alt | monaco.KeyMod.Shift | monaco.KeyCode.LeftArrow],
+ run: function() {
+ if (editors.length > 1) {
+ activateTab((activeTab === 0) ? editors.length - 1 : activeTab - 1);
+ }
+ return null;
+ }
+ });
+ ecfg.editor.addAction({
+ id: 'next-tab',
+ label: 'Switch tab to right of current',
+ keybindings: [monaco.KeyMod.Alt | monaco.KeyMod.Shift | monaco.KeyCode.RightArrow],
+ run: function() {
+ if (editors.length > 1) {
+ activateTab((activeTab === editors.length - 1) ? 0 : activeTab + 1);
+ }
+ return null;
+ }
+ });
+ ecfg.editor.addAction({
+ id: 'last-used-tab',
+ label: 'Switch tab to last active',
+ keybindings: [monaco.KeyMod.Alt | monaco.KeyMod.Shift | monaco.KeyCode.UpArrow],
+ run: function() {
+ var last_used_idx,
+ newest;
+ if (editors.length > 1) {
+ for (var i = 0; i < editors.length; i++){
+ if (activeTab !== i) {
+ if (! newest || newest < editors[i].last_opened) {
+ newest = editors[i].last_opened;
+ last_used_idx = i;
+ }
+ }
+ }
+ activateTab(last_used_idx);
+ }
+ return null;
+ }
+ });
+ ecfg.editor.addAction({
+ id: 'close-tab',
+ label: 'Close tab',
+ keybindings: [monaco.KeyMod.Alt | monaco.KeyMod.Shift | monaco.KeyCode.KEY_W],
+ run: function() {
+ closeTabByCfg(ecfg);
+ return null;
+ }
+ });
+ if (ecfg.canBeSavedFile || ecfg.canBeSavedRest) {
+ ecfg.editor.addAction({
+ id: 'save-file',
+ contextMenuOrder: 0.1,
+ contextMenuGroupId: 'navigation',
+ label: 'Save file',
+ run: function() {
+ saveActiveTab();
+ }
+ });
+ }
+ if (ecfg.canBeSavedFile) {
+ ecfg.editor.addAction({
+ id: 'save-file-action',
+ contextMenuOrder: 1,
+ contextMenuGroupId: '99_prefs',
+ label: 'Set post-save action',
+ run: function() {
+ setPostSaveAction();
+ }
+ });
+ }
+ if (ecfg.canBeSavedFile) {
+ ecfg.editor.addAction({
+ id: 'link-to-highlight',
+ contextMenuOrder: 3,
+ contextMenuGroupId: '99_prefs',
+ label: 'Create link to line/selection',
+ run: function() {
+ var editor_selection = ecfg.editor.getSelection();
+ var hashparts = window.location.href.replace(/#.*/,"") + "#0|" + inFolder + "|" + ecfg.type + "|" + ecfg.file + "@" + editor_selection.startLineNumber + "," + editor_selection.endLineNumber;
+ console.log(hashparts);
+ copyTextToClipboard(hashparts);
+ }
+ });
+ }
+ if (ecfg.type !== "rest") {
+ ecfg.editor.addAction({
+ id: 'attempt-open-file',
+ contextMenuOrder: 0.4,
+ contextMenuGroupId: 'navigation',
+ label: 'Attempt open',
+ run: function(ed) {
+ var position = ed.getPosition();
+ var text = ed.getValue(position);
+ var splitedText=text.split("\n");
+ var line = splitedText[position.lineNumber-1];
+ var replace = "(.{" + position.column + "}[^\\s\'\":]+).*";
+ var re = new RegExp(replace,"g");
+ var filename_string = line.replace(re, "$1");
+ filename_string = filename_string.replace(/.*[\s\"\']/,"");
+ if (filename_string.length <= 3) {
+ showModal({
+ title: "Warning",
+ body: " Use the 'Attempt Open' menu option on editor text for a file/folder path
",
+ size: 350
+ });
+ return;
+ }
+ var proposedPaths = {};
+ // we check a few different ways of finding a legitimate path from the highlighted text
+ proposedPaths[dodgyRemoveRelPath(filename_string)] = 2;
+ // when looking in etc/ it needs to be 3 folders deep
+ proposedPaths["etc/" + dodgyRemoveRelPath(filename_string)] = 3;
+ // if its a "run" editor tab, then the fromFolder will be set.
+ if (ecfg.hasOwnProperty("fromFolder")) {
+ proposedPaths[dodgyRemoveRelPath(ecfg.fromFolder + "/" + filename_string)] = 2;
+ } else {
+ proposedPaths[dodgyRemoveRelPath(dodgyDirname(ecfg.file) + filename_string)] = 2;
+ }
+ var success = false;
+ var errorFunction = function(){
+ showModal({
+ title: "Warning",
+ body: " Unable to find file or folder path to open:
(Looked in $SPLUNK_HOME, $SPLUNK_HOME/etc and relative to current file)
",
+ size: 450
+ });
+ };
+ for (var proposedPath in proposedPaths) {
+ if (proposedPaths.hasOwnProperty(proposedPath)) {
+ //console.log("attempting path ==> " + proposedPath);
+ if (filecache !== null) {
+ // we only check if the first 2 parts of the path are legit. If the path is less than two folders deep, then it wont open
+ var base = getTreeCache("./" + proposedPath, 1 + proposedPaths[proposedPath]);
+ //console.log("checking file cache for path ", "./" + proposedPath, ":", filecache, base);
+ if (base !== null) {
+ // this doesnt handle the case where its a bare folder with no trailing slash, but its good enough
+ if (proposedPath.slice(-1) === "/") {
+ readFolder("./" + proposedPath);
+ } else {
+ readFile("./" + proposedPath, errorFunction);
+ }
+ success = true;
+ break;
+ }
+ }
+ }
+ }
+ if (!success) {
+ errorFunction();
+ }
+ }
+ });
+ }
+ ecfg.editor.addAction({
+ id: 'open-prefs-action',
+ contextMenuOrder: 2,
+ contextMenuGroupId: '99_prefs',
+ label: 'Preferences',
+ run: function() {
+ openPreferences();
+ }
+ });
+ if (ecfg.type === "settings") {
+ ecfg.editor.addAction({
+ id: "settings_spec",
+ contextMenuOrder: 0.3,
+ contextMenuGroupId: 'navigation',
+ label: "Open documentation (.spec file)",
+ run: function() {
+ runAction("spec:config_explorer.conf", "", true);
+ }
+ });
+ ecfg.editor.addAction({
+ id: "settings_examples",
+ contextMenuOrder: 0.3,
+ contextMenuGroupId: 'navigation',
+ label: "Show default config",
+ run: function() {
+ runAction("read:./etc/apps/config_explorer/default/config_explorer.conf", "", true);
+ }
+ });
+ }
+ if (ecfg.type === "read") {
+ for (var j = 0; j < hooksActive.length; j++) {
+ var hook = hooksActive[j];
+ addHookActionToEditor(hook, ecfg);
+ }
+ }
+ if (ecfg.type === "read") {
+ ecfg.editor.addAction({
+ id: 'reload',
+ contextMenuOrder: 0.2,
+ contextMenuGroupId: 'navigation',
+ label: 'Reload from disk',
+ run: function() {
+ closeTabByCfg(ecfg);
+ hooksCfg[ecfg.type](ecfg.file, ecfg.fromFolder);
+ }
+ });
+ ecfg.editor.addAction({
+ id: 'editorchanges',
+ contextMenuOrder: 0.3,
+ contextMenuGroupId: 'navigation',
+ label: 'Diff unsaved changes',
+ run: function() {
+ openDiffOfUnsavedChanges(ecfg);
+ }
+ });
+
+ // If this is an XML file, provide an option to try opening it
+ // warning: There are plenty of situations where this wont work, becuase of permissions layering etc
+ if (confIsTrue('dashboard_xml_file_experimental_actions', false)) {
+ var file_parts_for_openurl = ecfg.file.match(regex_file_path_to_dashboard_parts);
+ if (file_parts_for_openurl) {
+ ecfg.editor.addAction({
+ id: 'opendashboard',
+ contextMenuOrder: 0.31,
+ contextMenuGroupId: 'navigation',
+ label: 'Attempt view in browser',
+ run: function() {
+ hooksCfg.openurl("/app/" + file_parts_for_openurl[2] + "/" + file_parts_for_openurl[3]);
+ }
+ });
+ ecfg.editor.addAction({
+ id: 'editrestdashboard',
+ contextMenuOrder: 0.32,
+ contextMenuGroupId: 'navigation',
+ label: 'Attempt edit via REST API',
+ run: function() {
+ if (file_parts_for_openurl[1]=="apps") {
+ hooksCfg.rest("/servicesNS/nobody/" + file_parts_for_openurl[2] + "/data/ui/views/" + file_parts_for_openurl[3]);
+ } else {
+ hooksCfg.rest("/servicesNS/" + file_parts_for_openurl[1].substr(6) + "/" + file_parts_for_openurl[2] + "/data/ui/views/" + file_parts_for_openurl[3]);
+ }
+ }
+ });
+ }
+ }
+
+ }
+ if (ecfg.type === "rest") {
+ // reload rest
+ ecfg.editor.addAction({
+ id: 'reload',
+ contextMenuOrder: 0.2,
+ contextMenuGroupId: 'navigation',
+ label: 'Reload from REST API',
+ run: function() {
+ closeTabByCfg(ecfg);
+ hooksCfg.rest(ecfg.file);
+ }
+ });
+ var file_parts_for_openurl_rest = ecfg.file.match(/([^\/]+)\/data\/ui\/views\/(.*)$/);
+ if (file_parts_for_openurl_rest) {
+ ecfg.editor.addAction({
+ id: 'opendashboard',
+ contextMenuOrder: 0.31,
+ contextMenuGroupId: 'navigation',
+ label: 'Attempt view in browser',
+ run: function() {
+ hooksCfg.openurl("/app/" + file_parts_for_openurl_rest[1] + "/" + file_parts_for_openurl_rest[2]);
+ }
+ });
+ }
+ }
+ // Add a right-click option
+ if (tabCfg[ecfg.type].can_rerun) {
+ ecfg.editor.addAction({
+ id: 'rerun',
+ contextMenuOrder: 0.1,
+ contextMenuGroupId: 'navigation',
+ label: 'Rerun',
+ run: function() {
+ closeTabByCfg(ecfg);
+ hooksCfg[ecfg.type](ecfg.file, ecfg.fromFolder);
+ }
+ });
+ }
+ openTabsListChanged();
+ ecfg.tab.trigger("ce_loaded");
+ }
+
+ function openDiffOfUnsavedChanges(ecfg) {
+ var ecfgDiff = createTab('diff', ecfg.file, "diff: " + ecfg.file);
+ var saved_value = ecfg.editor.getValue();
+ serverActionWithoutFlicker({action: 'read', path: ecfg.file}).then(function(contents){
+ updateTabAsDiffer(ecfgDiff, ecfg.file + " (on disk)\n" + contents, "(Unsaved changes)\n" + saved_value);
+ }).catch(function(){
+ closeTabByCfg(ecfgDiff);
+ });
+ }
+
+ function saveActiveTab(cb){
+ var saved_value;
+ if (activeTab === null || activeTab === -1) {
+ return;
+ }
+ var ecfg = editors[activeTab];
+ if (ecfg.canBeSavedFile) {
+ if (! ecfg.saving) {
+ /// Warn again if file has changed
+ var $warn_msg = ecfg.tab.find(".ce_modified_on_disk");
+ if ($warn_msg.length > 0 && ! ecfg.modified_on_disk_ignored) {
+ showModal({
+ title: "Warning",
+ body: "" + htmlEncode(filename_string) + "(Looked in $SPLUNK_HOME, $SPLUNK_HOME/etc and relative to current file)
" + $warn_msg.attr("title").replace(/\..*/,"") + "
",
+ size: 600,
+ actions: [{
+ label: "Save anyway",
+ onClick: function(){
+ $(".modal").modal('hide');
+ // set a flag and resave
+ ecfg.modified_on_disk_ignored = true;
+ saveActiveTab(cb);
+ }
+ },{
+ label: "Cancel and diff",
+ onClick: function(){
+ $(".modal").modal('hide');
+ openDiffOfUnsavedChanges(ecfg);
+ }
+ },{
+ label: "Cancel",
+ onClick: function(){ $(".modal").modal('hide'); }
+ }]
+ });
+ return;
+ }
+ saved_value = ecfg.editor.getValue();
+ ecfg.saving = true;
+ ecfg.tab.append("");
+ serverAction({action: 'save', path: ecfg.file, file: saved_value}).then(function(){
+ // After file has been saved, delete its filemod time and get a new filemod time
+ delete ecfg.filemod;
+ // remove unsaved changes icon from tab
+ ecfg.tab.find('.ce_modified_on_disk').remove();
+ ecfg.tab.css("color","");
+ clearTimeout(fileModsCheckTimer);
+ fileModsCheckTimer = setTimeout(function(){ checkFileMods(); }, 100);
+
+ ecfg.saving = false;
+ ecfg.modified_on_disk_ignored = false;
+ ecfg.tab.find('.ce_tab_saving_icon').remove();
+ showToast('Saved');
+ ecfg.server_content = saved_value;
+ ecfg.tab.find('.icon-alert-circle').remove();
+ ecfg.hasChanges = false;
+ highlightBadConfig(ecfg);
+ if (ecfg.file === "") {
+ loadPermissionsAndConfList();
+ }
+ if (cb) {
+ cb();
+ }
+ // Run any post-save hook
+ var p = getPostSave(ecfg.file);
+ if (p !== null) {
+ if (p[0] === "run" && ! approvedPostSaveHooks.hasOwnProperty(p[0] + "|" + p[1])) {
+ showModal({
+ title: "Confirm post-save action ",
+ body: "The following action is configured to run after every save:
",
+ size: 600,
+ actions: [{
+ onClick: function(){
+ $(".modal").modal('hide');
+ approvedPostSaveHooks[p[0] + "|" + p[1]] = true;
+ runPostSaveAction(p);
+ },
+ cssClass: 'btn-primary',
+ label: "Approve"
+ },{
+ onClick: function(){ $(".modal").modal('hide'); },
+ label: "Cancel"
+ }]
+ });
+ } else {
+ runPostSaveAction(p);
+ }
+ }
+ }, function(){
+ ecfg.saving = false;
+ ecfg.tab.find('.ce_tab_saving_icon').remove();
+ });
+ }
+ return null;
+ } else if (ecfg.canBeSavedRest) {
+ if (! ecfg.saving) {
+ saved_value = ecfg.editor.getValue();
+ ecfg.saving = true;
+ ecfg.tab.append("");
+
+ service.post(ecfg.file, {"eai:data": saved_value}, function(err, r) {
+ if (err) {
+ if (err.data.hasOwnProperty('messages')) {
+ errText = "" + htmlEncode(p[0]) + ":" + htmlEncode(p[1]) + "" + htmlEncode(err.data.messages["0"].text) + ""; + } else { + errText = "
" + htmlEncode(JSON.stringify(err)) + ""; + } + showModal({ + title: "Warning", + body: "
Error while saving: " + errText + "
",
+ size: 500
+ });
+ console.log(err);
+ ecfg.saving = false;
+ ecfg.tab.find('.ce_tab_saving_icon').remove();
+ }
+ if (r && r.data) {
+ //console.log("ok saving to rest", r.data);
+ ecfg.tab.find('.ce_modified_on_disk').remove();
+ ecfg.tab.css("color","");
+ clearTimeout(fileModsCheckTimer);
+ fileModsCheckTimer = setTimeout(function(){ checkFileMods(); }, 100);
+
+ ecfg.saving = false;
+ ecfg.tab.find('.ce_tab_saving_icon').remove();
+ showToast('Saved');
+ ecfg.server_content = saved_value;
+ ecfg.tab.find('.icon-alert-circle').remove();
+ ecfg.hasChanges = false;
+
+ // send broadcast message:
+ broadcastChannel.postMessage({
+ action:"saved",
+ type: ecfg.type,
+ path: ecfg.file
+ });
+
+ } else {
+ console.error("unexpected error when saving", r.data);
+ ecfg.saving = false;
+ ecfg.tab.find('.ce_tab_saving_icon').remove();
+ showModal({
+ title: "Warning",
+ body: "Unpexpected error while saving!
", // err.data.messages["0"].text
+ size: 500
+ });
+ }
+ });
+ }
+ return null;
+ } else {
+ showModal({
+ title: "Warning",
+ body: "This file cannot be saved
",
+ size: 300
+ });
+ }
+ }
+
+ function runPostSaveAction(parts) {
+ closeTabByHookDetails(parts[0], parts[1]);
+ hooksCfg[parts[0]](parts[1], undefined, true);
+ }
+
+ function updateTabHTML(ecfg, contents) {
+ ecfg.editor_container.html(contents).css("overflow", "auto");
+ ecfg.tab.trigger("ce_loaded");
+ }
+
+ function updateTabAsDiffer(ecfg, left, right) {
+ var originalModel = monaco.editor.createModel(left);
+ var modifiedModel = monaco.editor.createModel(right);
+ ecfg.editor_container.empty();
+ ecfg.editor = monaco.editor.createDiffEditor(ecfg.editor_container[0],{
+ automaticLayout: true,
+ });
+ ecfg.editor.setModel({
+ original: originalModel,
+ modified: modifiedModel
+ });
+ ecfg.tab.trigger("ce_loaded");
+
+ if (ecfg.hasOwnProperty("diffFileRight")) {
+
+ ecfg.editor.addAction({
+ id: 'updatediffer',
+ contextMenuOrder: 0.3,
+ contextMenuGroupId: 'navigation',
+ label: 'Rerun diff',
+ run: function() {
+ compareFiles(ecfg.diffFileRight, ecfg.diffFileLeft);
+ closeTabByCfg(ecfg);
+ }
+ });
+ }
+ }
+
+ // Make sure the server action that results in a tab open, takes a minimum amount of time so as not to flicker and look dumb
+ function serverActionWithoutFlicker(postData, customErrorCB) {
+ var promise = serverAction(postData, customErrorCB);
+ var promiseTimeout = new Promise(function(resolve) {
+ setTimeout(resolve, 800);
+ });
+ var promiseCombined = Promise.all([promise, promiseTimeout]);
+ return promiseCombined.then(function(values) {
+ return values[0];
+ });
+ }
+
+ // Make a rest call to our backend python script
+ function serverAction(postData, customErrorCB) {
+ //console.log("CBY SERVERACTION:", postData);
+ return new Promise(function(resolve, reject) {
+ inFlightRequests++;
+ $('.ce_saving_icon').removeClass('ce_hidden');
+ //console.log(postData);
+ service.post('/services/config_explorer', postData, function(err, r) {
+ inFlightRequests--;
+ if (inFlightRequests === 0) {
+ $('.ce_saving_icon').addClass('ce_hidden');
+ }
+ var errText = '';
+ //console.log(err, r);
+ if (err) {
+ if (err.data.hasOwnProperty('messages')) {
+ errText = "" + htmlEncode(err.data.messages["0"].text) + ""; + } else { + errText = "
" + htmlEncode(JSON.stringify(err)) + ""; + } + } else { + if (! r.data) { + errText = "
Error communicating with Splunk"; + + } else if (! (r.data.hasOwnProperty('result') || r.data.hasOwnProperty('reason'))) { + errText = "
" + htmlEncode(r.data) + ""; + + } else if (r.data.reason === "missing_perm_read") { + errText = "
To use this application you must be have the capability \"admin_all_objects\" via a role.
"; + + } else if (r.data.reason === "missing_perm_run") { + errText = "You must enable the run_commands setting
You must enable the write_access setting
Unable to write to the settings file becuase it is locked and must be edited externally: etc/apps/config_explorer/local/config_explorer.conf
Unable to open binary file (right-click and 'download' file instead)
"; + + } else if (r.data.reason !== "") { + errText = "" + htmlEncode(r.data.reason) + ""; + } + } + if (errText) { + // dont show the error for background requests such as filemods + if (postData.action !== "filemods") { + if (typeof customErrorCB === "undefined") { + showModal({ + title: "Error", + body: "
An error occurred!
" + htmlEncode(postData.action) + ": " + htmlEncode(postData.hasOwnProperty("path") ? postData.path : "") + "
" + errText + "
",
+ });
+ } else {
+ customErrorCB();
+ }
+ }
+ reject(Error("error"));
+ } else {
+ // if there was some unexpected git output, then open a window to display it
+ if (r.data.git && r.data.git_status !== -1) {
+ var git_autocommit_show_output = "auto";
+ if (conf.hasOwnProperty("git_autocommit_show_output")) {
+ git_autocommit_show_output = conf.git_autocommit_show_output.toLowerCase();
+ }
+ if (git_autocommit_show_output === "true" || (git_autocommit_show_output === "auto" && r.data.git_status > 0)) {
+ var git_output = "" + htmlEncode(postData.action) + ": " + htmlEncode(postData.hasOwnProperty("path") ? postData.path : "") + "
" + errText + "
"; + if (git_autocommit_show_output === "auto") { + git_output = "Warning: Unexpected return code when attempting to autocommit changes to version control. "; + } + git_output = "Git output is below:
"; + for (var j = 0; j < r.data.git.length; j++) { + git_output += "" + htmlEncode($.trim(r.data.git[j].content)) + "
";
+ }
+ var ecfg = createTab('git', '', 'git output');
+ updateTabHTML(ecfg, "" + git_output + "
");
+ }
+ }
+ resolve(r.data.result);
+ }
+ });
+ });
+ }
+
+ // Try to build a conf file from calling the rest services. turns out this is pretty unreliable.
+ function formatLikeRunningConfig(contents) {
+ return contents.replace(/^.+?splunk[\/\\]etc[\/\\].*?\.conf\s+(?:(.+) = (.*)|(\[.+))\r?\n/img,function(all, g1, g2, g3){
+ if (g3 !== undefined) { return g3 + "\n"; }
+ if (g2.toLowerCase() == "true") { return g1 + " = 1\n";}
+ if (g2.toLowerCase() == "false") { return g1 + " = 0\n";}
+ return g1 + " = " + g2 + "\n";
+ });
+ }
+
+ function adjustBtoolPaths(contents, inPath, outPath) {
+ return contents.replace(new RegExp(regexEscape(inPath) + "[\\/\\\\]apps[\\/\\\\]", 'g'), outPath);
+ }
+
+ // Formats the output of "btool list" depending on what checkboxes are selected in the left pane
+ function formatBtoolList(contents, type) {
+ var indent = 80;
+ return contents.replace(/\\/g,'/').replace(/^.+?splunk[\/]etc[\/](.*?\.conf)\s+(.+)(\r?\n)/img,function(all, g1, g2, g3){
+ var path = '';
+ // I am pretty sure that stanzas cant be set to default when containing a child that isnt
+ if (type === "btool-hidesystemdefaults" && /system[\/\\]default[\/\\]/.test(g1)) {
+ return '';
+ }
+ if (type === "btool-hidedefaults" && /[\/\\]default[\/\\]/.test(g1)) {
+ return '';
+ }
+ if (type !== "btool-hidepaths") {
+ path = (" ".repeat(Math.max(1, (indent - g2.length)))) + " " + g1;
+ }
+ return g2 + path + g3;
+ });
+ }
+
+ function addGutter(newdecorations, i, className, message) {
+ newdecorations.push({ range: new monaco.Range((1+i),1,(1+i),1), options: { isWholeLine: true, glyphMarginClassName: className, glyphMarginHoverMessage: [{value: message }] }});
+ }
+
+ function regexEscape(s) {
+ return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+ }
+
+
+ // After loading a .conf file or after saving and before any changes are made, red or green colour will
+ // be shown in the gutter about if the current line can be found in the output of btool list.
+ function highlightBadConfig(ecfg){
+ if (! confIsTrue('conf_validate_on_save', true)) {
+ return;
+ }
+ if (! ecfg.hasOwnProperty('matchedConf') || ecfg.file === "") {
+ return;
+ }
+ if (conf._conf_validate_on_save_exclusions.test(ecfg.matchedConf)) {
+ console.log("Not doing btool validation in code gutter for [" + ecfg.matchedConf + "] becuase it matches conf_validate_on_save_exclusions.");
+ return;
+ }
+ var run_path = "";
+ var run_path_parts = ecfg.file.split(/[\/\\]/);
+ if (run_path_parts[0] === ".") {
+ run_path_parts.shift();
+ }
+ if (run_path_parts.length > 1) {
+ run_path = run_path_parts[1];
+ }
+ // console.log("runpath is ",run_path);
+ // possible locations you can run btool: etc/master-apps, etc/slave-apps, etc/apps, etc/system/local, etc/user, etc/shcluster/apps
+ // can also run btool on slave-apps, but who has config explorer installed on an indexer anyway?
+ if (run_path === "apps" || run_path === "system") {
+ serverAction({action: 'btool-list', path: ecfg.matchedConf}).then(function(btoolcontents){
+ highlightBadConfigContinue(ecfg, btoolcontents, run_path);
+ });
+
+ } else if (run_path === "deployment-apps" && conf.btool_dir_for_deployment_apps) {
+ serverAction({action: 'btool-list', path: ecfg.matchedConf, param1: conf.btool_dir_for_deployment_apps}).then(function(btoolcontents){
+ if (btoolcontents) {
+ // nix only paths. this feature wont work with win becuase you cant symlink
+ var btoolcontents2 = adjustBtoolPaths(btoolcontents, conf.btool_dir_for_deployment_apps, "/splunk/etc/deployment-apps/");
+ if (btoolcontents2 !== btoolcontents) {
+ highlightBadConfigContinue(ecfg, btoolcontents2, run_path);
+ return;
+ }
+ }
+ highlightBadConfigContinue(ecfg, "", run_path);
+ });
+
+ } else if (run_path === "master-apps" && conf.btool_dir_for_master_apps) {
+ serverAction({action: 'btool-list', path: ecfg.matchedConf, param1: conf.btool_dir_for_master_apps}).then(function(btoolcontents){
+ if (btoolcontents) {
+ var btoolcontents2 = adjustBtoolPaths(btoolcontents, conf.btool_dir_for_master_apps, "/splunk/etc/master-apps/");
+ // if the replace did nothing, then the btool gutters are probably going to be all wrong anyway
+ if (btoolcontents2 !== btoolcontents) {
+ highlightBadConfigContinue(ecfg, btoolcontents2, run_path);
+ return;
+ }
+ }
+ highlightBadConfigContinue(ecfg, "", run_path);
+ });
+
+ } else if (run_path === "manager-apps" && conf.btool_dir_for_manager_apps) {
+ serverAction({action: 'btool-list', path: ecfg.matchedConf, param1: conf.btool_dir_for_manager_apps}).then(function(btoolcontents){
+ if (btoolcontents) {
+ var btoolcontents2 = adjustBtoolPaths(btoolcontents, conf.btool_dir_for_manager_apps, "/splunk/etc/manager-apps/");
+ // if the replace did nothing, then the btool gutters are probably going to be all wrong anyway
+ if (btoolcontents2 !== btoolcontents) {
+ highlightBadConfigContinue(ecfg, btoolcontents2, run_path);
+ return;
+ }
+ }
+ highlightBadConfigContinue(ecfg, "", run_path);
+ });
+
+ } else if (run_path === "shcluster" && conf.btool_dir_for_shcluster_apps) {
+ serverAction({action: 'btool-list', path: ecfg.matchedConf, param1: conf.btool_dir_for_shcluster_apps}).then(function(btoolcontents){
+ //console.log("btoolcontents",btoolcontents);
+ highlightBadConfigContinue(ecfg, btoolcontents, run_path);
+ });
+
+ } else {
+ highlightBadConfigContinue(ecfg, "", run_path);
+ }
+ }
+
+ function highlightBadConfigContinue(ecfg, btoolcontents, run_path){
+ var rexSplunkHome = /^(.+?)[\\\/]etc[\\\/]/;
+ var foundSplunkHome;
+ var lookup = {};
+ var splunk_home = "";
+ var seenStanzas = {};
+ var seenProps = {};
+ var normalBtoolChecks = true;
+ var masterappsPropsTransformsChecks = false;
+ var masterappsPropsSourcetypeChecks = false;
+ var allConfigsAreUnnecisary = false;
+
+ // There is some special logic if we are in the master-apps directory
+ if (run_path === "master-apps" || run_path === "manager-apps") {
+ if (conf.hasOwnProperty("_master_apps_gutter_useful_props_and_transforms") && (ecfg.matchedConf === "props" || ecfg.matchedConf === "transforms")) {
+ masterappsPropsTransformsChecks = true;
+ }
+ // split the master_apps_allowed_config by commas, then split each by full colon. ecfg.matchedConf
+ if (conf.hasOwnProperty("_master_apps_gutter_used_sourcetypes") && ecfg.matchedConf === "props") {
+ masterappsPropsSourcetypeChecks = true;
+ }
+ if (conf.hasOwnProperty("_master_apps_gutter_unnecissary_config_files") && conf._master_apps_gutter_unnecissary_config_files.test(ecfg.matchedConf)) {
+ allConfigsAreUnnecisary = true;
+ }
+ }
+
+
+ if (! $.trim(btoolcontents)) {
+ console.log("no btool contents for ", ecfg.matchedConf);
+ normalBtoolChecks = false;
+ }
+
+ //console.log("hinting file for [" + ecfg.matchedConf + "] is MB long: " + Math.round(btoolcontents.length / 1024) / 1024);
+
+ if (normalBtoolChecks) {
+ btoolcontents = btoolcontents.replace(/\\/g,'/');
+ // Build lookup of btool output
+ lookup = buildBadCodeLookup(btoolcontents);
+ if (debug_gutters) {
+ console.log("Btool:", lookup);
+ if (ecfg.hasOwnProperty('hinting')) {
+ console.log("Spec:", ecfg.hinting);
+ }
+ }
+ // try to figure out the SPLUNK_HOME value
+ // Its common that in inputs.conf, some stanzas are defined with $SPLUNK_HOME which btool always expands
+ foundSplunkHome = btoolcontents.match(rexSplunkHome);
+ splunk_home = "";
+ if (foundSplunkHome && foundSplunkHome.length == 2) {
+ splunk_home = foundSplunkHome[1];
+ }
+ }
+
+ // Go through everyline of the editor
+ var contents = ecfg.editor.getValue(),
+ rows = contents.split(/\r?\n/),
+ currentStanza = "",
+ currentStanzaTrimmed = "",
+ // This regex is complex becuase sometimes properties have a unique string on the end of them
+ // e.g "EVAL-src = whatever"
+ // found[1] will be "EVAL-src"
+ // found[2] will be "EVAL"
+ reProps = /^\s*((\w+)[^=\s]*)\s*=/,
+ newdecorations = [],
+ currentStanzaAsExpectedInBtool,
+ extraProp,
+ extraStanz;
+ for (var i = 0; i < rows.length; i++) {
+ if (rows[i].substr(0,1) === "[") {
+ if (rows[i].substr(0,9) === "[default]") {
+ currentStanza = "";
+ } else {
+ currentStanza = $.trim(rows[i]);
+ }
+ currentStanzaTrimmed = currentStanza.replace(/^(\[\w+).*$/,"$1");
+ // Stanzas that have $SPLUNK_HOME in them will be expanded by btool (stanzas in inputs.conf often have $SPLUNK_HOME in them)
+ currentStanzaAsExpectedInBtool = currentStanza.replace(/\$SPLUNK_HOME/i, splunk_home);
+ // Stanzas with windows path seperators are converted to unix seperators by btool
+ currentStanzaAsExpectedInBtool = currentStanzaAsExpectedInBtool.replace(/\\/g, '/');
+ // Stanzas that use relative paths, will be expanded by btool. (e.g. inputs.conf [script://./bin/go.sh] from current script location)
+ currentStanzaAsExpectedInBtool = currentStanzaAsExpectedInBtool.replace(/\/\/\.\//, "//" + splunk_home + ecfg.file.substr(1).replace(/[^\/\\]*\/[^\/\\]*$/,''));
+
+ if (seenStanzas.hasOwnProperty(currentStanza)) {
+ addGutter(newdecorations, i, 'ceOrangeLine', "Duplicate Stanza in this file");
+ } else if (masterappsPropsSourcetypeChecks) {
+ // This does does not work with source:: or host:: stanzas, or those that look like they might be a regular expression (not perfect)
+ if (! conf._master_apps_gutter_used_sourcetypes.test(currentStanza) && currentStanza.substr(0,9) !== "[source::" && currentStanza.substr(0,7) !== "[host::" && currentStanza.substr(0,2) !== "[(") {
+ addGutter(newdecorations, i, 'ceBlueLine', "This stanza \"" + currentStanza + "\" does not match a sourcetype in master_apps_gutter_used_sourcetypes (which is " + conf._master_apps_gutter_used_sourcetypes_date + " days old)");
+ }
+ } else if (allConfigsAreUnnecisary) {
+ addGutter(newdecorations, i, 'ceBlueLine', "In most environments, the properties in this file are not needed on indexers.");
+ }
+ seenStanzas[currentStanza] = 1;
+ seenProps = {};
+ } else {
+ var found = rows[i].match(reProps);
+ if (found) {
+ if (found[1].substr(0,1) !== "#") {
+ var g_sev = 2;
+ var g_messages = [];
+ var prop = found[1];
+ // Check for duplicated key in stanza
+ if (seenProps.hasOwnProperty(found[1])) {
+ //addGutter(newdecorations, i, 'ceOrangeLine', "Duplicate key in stanza");
+ g_sev = Math.max(g_sev, 5);
+ g_messages.push("Duplicate key in stanza");
+ } else {
+ seenProps[found[1]] = 1;
+
+ if (normalBtoolChecks) {
+ // Look if stanza/property exists in btool
+ if (! lookup.hasOwnProperty(currentStanzaAsExpectedInBtool)){
+ //addGutter(newdecorations, i, 'ceRedLine', "Not found in \"btool\" output (btool does not list the stanza \"" + currentStanzaAsExpectedInBtool +"\")");
+ g_sev = Math.max(g_sev, 6);
+ g_messages.push("Not found in \"btool\" output (btool does not list the stanza " + currentStanzaAsExpectedInBtool +")");
+
+ } else if (! lookup[currentStanzaAsExpectedInBtool].hasOwnProperty(found[1])){
+ // [default] is a special case and is reflected through all other stanzas in the file
+ if (currentStanzaAsExpectedInBtool !== "") {
+ //addGutter(newdecorations, i, 'ceRedLine', "Not found in \"btool\" output (btool with stanza [" + currentStanzaAsExpectedInBtool +"] does not have property \"" + found[1] + "\")");
+ g_sev = Math.max(g_sev, 6);
+ g_messages.push("Not found in \"btool\" output (could not find property in stanza " + currentStanzaAsExpectedInBtool +"");
+ }
+
+ } else if (lookup[currentStanzaAsExpectedInBtool][found[1]] !== ecfg.file && lookup[currentStanzaAsExpectedInBtool][found[1]].substr(2) !== ecfg.file) {
+ //addGutter(newdecorations, i, 'ceRedLine', "Not found in \"btool\" output (set in :" + lookup[currentStanzaAsExpectedInBtool][found[1]] + ")");
+ g_sev = Math.max(g_sev, 6);
+ g_messages.push("Not found in \"btool\" output (set in :" + lookup[currentStanzaAsExpectedInBtool][found[1]] + " and i am :" + ecfg.file + ")");
+
+ } else {
+ // addGutter(newdecorations, i, 'ceGreeenLine', "Found in \"btool\" output");
+ g_messages.push("Found in \"btool\" output");
+ }
+ }
+
+ // If a spec file exists
+ if (ecfg.hasOwnProperty('hinting') && found.length > 2) {
+ // Look in the unstanzaed part of the spec
+ if (ecfg.hinting[""].hasOwnProperty(found[2])) {
+ //addGutter(newdecorations, i, 'ceGreeenLine', "Found in \"btool\" output and spec file. (Stanza=\"\" Property=\"" + found[2] + "\")");
+ g_messages.push("Exists in spec file");
+ prop = found[2];
+
+ // Look in the stanzaed part of the spec
+ } else if (ecfg.hinting.hasOwnProperty(currentStanza) && ecfg.hinting[currentStanza].hasOwnProperty(found[2])) {
+ //addGutter(newdecorations, i, 'ceGreeenLine', "Found in \"btool\" output and spec file. (Stanza=\"" + currentStanza + "\" Property=\"" + found[2] + "\")");
+ g_messages.push("Exists in spec file (Stanza=" + currentStanza + ")");
+ prop = found[2];
+
+ // Look for a trimmed version of the stanza in the spec. e.g. [endpoint:blah_rest] might be in the spec as [endpoint]
+ } else if (ecfg.hinting.hasOwnProperty(currentStanzaTrimmed) && ecfg.hinting[currentStanzaTrimmed].hasOwnProperty(found[2])) {
+ //addGutter(newdecorations, i, 'ceGreeenLine', "Found in \"btool\" output and spec file. (Stanza=\"" + currentStanzaTrimmed + "\" Property=\"" + found[2] + "\")");
+ g_messages.push("Exists in spec file (Stanza=" + currentStanzaTrimmed + ")");
+ prop = found[2];
+
+ // Now go through those same three checks, but look for the whole thing. For Example in web.conf found[2] is "tools" where as found[1] is "tools.sessions.timeout"
+ } else if (ecfg.hinting[""].hasOwnProperty(found[1])) {
+ //addGutter(newdecorations, i, 'ceGreeenLine', "Found in \"btool\" output and spec file. (Stanza=\"\" Property=\"" + found[1] + "\")");
+ g_messages.push("Exists in spec file");
+
+ // Look in the stanzaed part of the spec
+ } else if (ecfg.hinting.hasOwnProperty(currentStanza) && ecfg.hinting[currentStanza].hasOwnProperty(found[1])) {
+ //addGutter(newdecorations, i, 'ceGreeenLine', "Found in \"btool\" output and spec file. (Stanza=\"" + currentStanza + "\" Property=\"" + found[1] + "\")");
+ g_messages.push("Exists in spec file (Stanza=" + currentStanza + ")");
+
+ // Look for a trimmed version of the stanza in the spec. e.g. [endpoint:blah_rest] might be in the spec as [endpoint]
+ } else if (ecfg.hinting.hasOwnProperty(currentStanzaTrimmed) && ecfg.hinting[currentStanzaTrimmed].hasOwnProperty(found[1])) {
+ //addGutter(newdecorations, i, 'ceGreeenLine', "Found in \"btool\" output and spec file. (Stanza=\"" + currentStanzaTrimmed + "\" Property=\"" + found[1] + "\")");
+ g_messages.push("Exists in spec file (Stanza=" + currentStanzaTrimmed + ")");
+
+ } else {
+ if (found[2] === found[1]) {
+ extraProp = "Looked for property ";
+ } else {
+ extraProp = "Looked for property (or \"" + found[2] + "\" ";
+ }
+ if (currentStanza === currentStanzaTrimmed) {
+ extraStanz = "in stanzas \"\" or " + currentStanza + "";
+ } else {
+ extraStanz = "in stanzas \"\", " + currentStanza + " and " + currentStanzaTrimmed + "";
+ }
+ //addGutter(newdecorations, i, 'ceDimGreeenLine', "Found in \"btool\" output, but not found in spec file. "+ extraProp + extraStanz);
+ g_sev = Math.max(g_sev, 3);
+ g_messages.push("Not found in spec file ("+ extraProp + extraStanz + ")");
+ }
+ }
+ if (masterappsPropsTransformsChecks) {
+ if (! conf._master_apps_gutter_useful_props_and_transforms.test(found[2])) {
+ g_sev = Math.max(g_sev, 4);
+ g_messages.push("In most environments, this property is not needed on indexers (there is no harm in having it there though).");
+ }
+ }
+ if (allConfigsAreUnnecisary) {
+ g_sev = Math.max(g_sev, 4);
+ g_messages.push("In most environments, the properties in this file are not needed on indexers.");
+ }
+ }
+ // add gutters now
+ if (g_messages.length) {
+ var g_color = g_sev == 6 ? "ceRedLine" : g_sev == 5 ? "ceOrangeLine" : g_sev == 4 ? "ceBlueLine" : g_sev == 3 ? "ceDimGreeenLine" : "ceGreeenLine";
+ addGutter(newdecorations, i, g_color, "`" + prop + "`: " + g_messages.join(". "));
+ }
+ }
+ }
+ }
+ }
+ ecfg.decorations = ecfg.editor.deltaDecorations(ecfg.decorations, newdecorations);
+ }
+
+ // The bad code lookup builds a structure of the btool list output so it can be quickly referenced to see what config
+ // from the current editor is being recognised by btool or not.
+ function buildBadCodeLookup(contents){
+ //(conf file path)(property)(stanza)
+ var rex = /^.+?splunk([\/\\]etc[\/\\].*?\.conf)\s+(?:([^=\s\[]+)\s*=|(\[[^\]]+\]))/gim;
+ var res;
+ var currentStanza = "";
+ var currentField = "";
+ var ret = {"": {"":""}};
+ while(res = rex.exec(contents)) {
+ if (res[2]) {
+ currentField = res[2];
+ ret[currentStanza][currentField] = '.' + res[1];
+ } else if (res[3]) {
+ if (res[3].substr(0,9) === "[default]") {
+ currentStanza = "";
+ } else {
+ currentStanza = res[3];
+ }
+ currentField = "";
+ ret[currentStanza] = {"":""}; // dont care about stanzas and where they come from
+ } //else {
+ //console.log("unexpected row:", res[0]);
+ //}
+ }
+ return ret;
+ }
+
+ // parse the spec file and build a lookup to use for code completion
+ function buildHintingLookup(conf, contents){
+ // left side is for properties, right size for stanzas
+ var rex = /^(?:([\w\.]+).*=|(\[\w+))?.*$/gm;
+ var res;
+ var currentStanza = "";
+ var currentField = "";
+ confFiles[conf] = {"": {"":{t:"", c:""}}};
+ while(res = rex.exec(contents)) {
+ // need this because our rex can match a zero length string
+ if (res.index == rex.lastIndex) {
+ rex.lastIndex++;
+ }
+ if (res[1] || res[2]) {
+ if (res[1]) {
+ currentField = res[1];
+ confFiles[conf][currentStanza][currentField] = {t:"", c:""};
+ } else {
+ if (res[2].substr(0,9) === "[default]") {
+ currentStanza = "";
+ } else {
+ currentStanza = res[2];
+ }
+ currentField = "";
+ if (! confFiles[conf].hasOwnProperty(currentStanza)) {
+ confFiles[conf][currentStanza] = {"":{t:"", c:""}};
+ }
+ }
+ confFiles[conf][currentStanza][currentField].t = res[0];
+ } else {
+ confFiles[conf][currentStanza][currentField].c += res[0] + "\n";
+ }
+ }
+ return confFiles[conf];
+ }
+
+ // When hovering lines in a .conf file, Monaco will lookup the current property in the README/*.conf.spec files.
+ // Becuase the README/*.conf.spec files are not perfect, neither is this documentation!
+ monaco.languages.registerHoverProvider('ini', {
+ provideHover: function(model, position, token) {
+ return new Promise(function(resolve, reject) {
+ // do somthing
+ if (editors[activeTab].hasOwnProperty('hinting')) {
+ // get all text up to hovered line becuase we need to find what stanza we are in
+ var contents = model.getValueInRange(new monaco.Range(1, 1, position.lineNumber, model.getLineMaxColumn(position.lineNumber)));
+ var rex = /^(?:([\w\.]+)|(\[\w+))?.*$/gm;
+ var currentStanza = "";
+ var currentField = "";
+ var hintdata;
+ var res;
+ while(res = rex.exec(contents)) {
+ // need this because our rex can match a zero length string
+ if (res.index == rex.lastIndex) {
+ rex.lastIndex++;
+ }
+ if (res[1]) {
+ currentField = res[1];
+ } else if (res[2]) {
+ if (res[2].substr(0,9) === "[default]") {
+ currentStanza = "";
+ } else {
+ currentStanza = res[2];
+ }
+ currentField = "";
+ }
+ }
+ if (editors[activeTab].hinting.hasOwnProperty(currentStanza) && editors[activeTab].hinting[currentStanza].hasOwnProperty(currentField)) {
+ hintdata = editors[activeTab].hinting[currentStanza][currentField];
+
+ } else if (editors[activeTab].hinting[""].hasOwnProperty(currentField)) {
+ hintdata = editors[activeTab].hinting[""][currentField];
+
+ } else {
+ resolve();
+ return;
+ }
+ resolve({
+ // This is what will be highlighted
+ range: new monaco.Range(position.lineNumber, 1, position.lineNumber, model.getLineMaxColumn(position.lineNumber)),
+ contents: [
+ { value: '**' + hintdata.t + '**' },
+ { value: '\n' + hintdata.c.replace(/^#/mg,'') + '\n' }
+ ]
+ });
+ } else {
+ resolve();
+ }
+ });
+ }
+ });
+
+ // When hitting CTRL-SPACE in .conf files, monaco will suggest all valid keys - with doco!
+ // Becuase the README/*.conf.spec files are not perfect, neither is this hinting!
+ monaco.languages.registerCompletionItemProvider('ini', {
+ provideCompletionItems: function(model, position) {
+ if (editors[activeTab].hasOwnProperty('hinting')) {
+ // get all text up to hovered line becuase we need to find what stanza we are in
+ var contents = model.getValueInRange(new monaco.Range(1, 1, position.lineNumber, model.getLineMaxColumn(position.lineNumber)));
+ var ret = [];
+ var rex = /[\s\S]*\n\s*(\[\w+)/;
+ var currentStanza = "";
+ var found = contents.match(rex);
+ if (found && editors[activeTab].hinting.hasOwnProperty(found[1])) {
+ if (found[1].substr(0,9) === "[default]") {
+ currentStanza = "";
+ } else {
+ currentStanza = found[1];
+ }
+ }
+ for (var key in editors[activeTab].hinting[currentStanza]) {
+ if (editors[activeTab].hinting[currentStanza].hasOwnProperty(key) && key) {
+ ret.push({
+ label: key,
+ insertText: key + " = ",
+ kind: monaco.languages.CompletionItemKind.Property,
+ documentation: "" + editors[activeTab].hinting[currentStanza][key].t + "\n\n" + editors[activeTab].hinting[currentStanza][key].c + "\n",
+ });
+ }
+ }
+ return { suggestions: ret };
+ }
+ return { suggestions: [] };
+ }
+ });
+
+ // Register a new simple language for prettying up git diffs
+ monaco.languages.register({ id: 'git-diff' });
+ monaco.languages.setMonarchTokensProvider('git-diff', {
+ tokenizer: {
+ root: [
+ [/^diff.*/, "constant"],
+ [/^\+[^\n]*/, "comment"], // additions
+ [/^\-[^\n]*/, "metatag"], // deletions
+ [/^@@.+?@@/, "regexp"],
+ [/^\w[^\n]+/, "white"],
+ [/\s[^\n]+/, "delimiter.xml"], // other lines
+ ]
+ }
+ });
+
+ // Register a new simple language for prettying up git log
+ monaco.languages.register({ id: 'git-log' });
+ monaco.languages.setMonarchTokensProvider('git-log', {
+ tokenizer: {
+ root: [
+ [/^(commit|Author:|Date:)[^\n]+/, "constant"], // additions
+ [/(?:\++(?=[\-\s]*$)|\(\+\))/, "comment"], // plus (?:\++(?=[\-\s]*$)|(?<=\()\+(?=\)))
+ [/(?:(\-+)\s*$|\(\-\))/, "metatag"], // minus (?:(\-+)\s*$|(?<=\()\-(?=\)))
+ ]
+ }
+ });
+ // dubious
+ function dodgyBasename(f) {
+ return f.replace(/.*[\/\\]/,'');
+ }
+
+ function dodgyDirname(f) {
+ return f.replace(/[^\/\\]*$/,'');
+ }
+
+ function dodgyRemoveRelPath(f) {
+ return f.replace(/^\.?[\/\\]/,'');
+ }
+
+ //create a in-memory div, set it's inner text(which jQuery automatically encodes)
+ //then grab the encoded contents back out. The div never exists on the page.
+ function htmlEncode(value){
+ return $('').text(value).html();
+ }
+
+ function escapeRegExp(str) {
+ return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+ }
+
+ function confIsTrue(param, defaultValue) {
+ if (!conf.hasOwnProperty(param)) {
+ return defaultValue;
+ }
+ return isTrueValue(conf[param]);
+ }
+
+ function isTrueValue(param) {
+ return (["1", "true", "yes", "t", "y"].indexOf($.trim(param.toLowerCase())) > -1);
+ }
+
+ function copyTextToClipboard(text) {
+ if (!navigator.clipboard) {
+ fallbackCopyTextToClipboard(text);
+ } else {
+ navigator.clipboard.writeText(text).then(function() {
+ showToast('Copied to clipboard!');
+ }, function (err) {
+ console.error('Async: Could not copy to clipboard.', err);
+ });
+ }
+ }
+
+ function fallbackCopyTextToClipboard(text) {
+ var textArea = document.createElement("textarea");
+ textArea.value = text;
+ document.body.appendChild(textArea);
+ textArea.focus();
+ textArea.select();
+ try {
+ var successful = document.execCommand('copy');
+ if (successful) {
+ showToast('Copied to clipboard!');
+ } else {
+ console.error('Fallback2: Could not copy to clipboard.');
+ }
+ } catch (err) {
+ console.error('Fallback: Could not copy to clipboard.', err);
+ }
+ document.body.removeChild(textArea);
+ }
+
+ function showToast(message) {
+ var t = $('.ce_toaster');
+ t.find('span').text(message);
+ t.addClass('ce_show');
+ setTimeout(function(){
+ t.removeClass('ce_show');
+ },3000);
+ }
+
+ var showModal = function self(o) {
+ var options = $.extend({
+ title : '',
+ body : '',
+ remote : false,
+ backdrop : true,
+ size : 500,
+ onShow : false,
+ onHide : false,
+ actions : false
+ }, o);
+ self.onShow = typeof options.onShow == 'function' ? options.onShow : function () {};
+ self.onHide = typeof options.onHide == 'function' ? options.onHide : function () {};
+ if (self.$modal === undefined) {
+ self.$modal = $('${title}
${body}
'.replace('${title}', options.title).replace('${body}', options.body));
+
+ var footer = self.$modal.find('.modal-footer');
+ if (Object.prototype.toString.call(options.actions) == "[object Array]") {
+ for (var i = 0, l = options.actions.length; i < l; i++) {
+ options.actions[i].onClick = typeof options.actions[i].onClick == 'function' ? options.actions[i].onClick : function () {};
+ $('').appendTo(footer).on('click', options.actions[i].onClick);
+ }
+ } else {
+ $('').appendTo(footer);
+ }
+ self.$modal.modal(options);
+ };
+
+ // "vs" | "vs-dark" (default) | "hc-black"
+ function setThemeMode(mode){
+ // Remove existing theme class from parent
+ $dashboard_body.removeClass(function (index, className) {
+ return (className.match (/(^|\s)ce_theme_\S+/g) || []).join(' ');
+ });
+ $dashboard_body.addClass("ce_theme_" + mode);
+ // Set theme for editors
+ monaco.editor.setTheme(mode);
+ // save to local storage
+ localStorage.setItem('ce_theme', mode);
+ }
+
+ function checkFileMods() {
+ var files = {};
+ var problems = [];
+ var hasFiles = false;
+ var ecfg;
+ // check if change detection is disabled
+ if (!confIsTrue('detect_changed_files', true)) {
+ return;
+ }
+ clearTimeout(fileModsCheckTimer);
+ fileModsCheckTimer = setTimeout(checkFileMods, fileModsCheckTimerPeriod);
+
+ if (fileModsCheckTimerInProgress) {
+ return;
+ }
+
+ // if current focused tab is "rest" then check it to see if it has changed
+ if (activeTab > 0 && editors[activeTab].type === "rest") {
+ ecfg = editors[activeTab];
+ if (ecfg.tab.find(".ce_modified_on_disk").length === 0 ) {
+ //console.log("check for REST changes in ", ecfg);
+ fileModsCheckTimerInProgress = true;
+
+ getRest(ecfg.file, null).then(function(restData) {
+ fileModsCheckTimerInProgress = false;
+ //console.log(restData); //?output_mode=json&count=0&f=title&f=label
+ if (restData.length === 0) {
+ ecfg.tab.css("color","orange").append("");
+ showModal({
+ title: "Warning",
+ body: "Warning: Unable to check for changes. File might have been deleted, moved or had its permissions changed.
",
+ size: 600
+ });
+ } else if (restData.length === 1) {
+ if (ecfg.server_content !== restData[0].content['eai:data']) {
+ ecfg.tab.css("color","orange").append("");
+ showModal({
+ title: "Warning",
+ body: "" + htmlEncode(ecfg.file) + "Warning: File has unexpectedly changed while open.
",
+ size: 600
+ });
+ }
+ } else {
+ console.error("Unexpeted response when checking if rest dashboard contents has changed while open - returned dashboards: " + restData.length);
+ }
+
+ }).catch(function(){
+ fileModsCheckTimerInProgress = false;
+ console.error("Unexpeted response when checking if rest dashboard contents has changed while open");
+ });
+ }
+
+ } else {
+ for (var j = 0; j < editors.length; j++){
+ if (editors[j].type === "read") {
+ files[editors[j].file] = 0;
+ hasFiles = true;
+ }
+ }
+ if (hasFiles && ! fileModsCheckTimerInProgress) {
+ //console.log("check for FILE changes");
+ fileModsCheckTimerInProgress = true;
+ serverAction({action: 'filemods', paths: JSON.stringify(files)}).then(function(filemods) {
+ fileModsCheckTimerInProgress = false;
+ var editorMap = {};
+ for (var i = 0; i < editors.length; i++) {
+ if (editors[i].type === "read") {
+ editorMap[editors[i].file] = editors[i];
+ }
+ }
+ for (var file in files) {
+ if (files.hasOwnProperty(file)) {
+ if (filemods.hasOwnProperty(file)) {
+ if (filemods[file] === "") {
+ // file was deleted
+ if (editorMap[file].tab.find(".ce_modified_on_disk").length === 0) {
+ problems.push("Deleted: " + htmlEncode(ecfg.file) + "" + htmlEncode(file) + "");
+ editorMap[file].tab.css("color","orange").append("");
+ }
+ } else if (! editorMap[file].hasOwnProperty("filemod")) {
+ // first time we have checked filemod on this file. so store the response
+ editorMap[file].filemod = filemods[file];
+ } else if (filemods[file] > editorMap[file].filemod + 10) { // add a buffer of 10 seconds
+ // file has updated behind the scenes
+ if (editorMap[file].tab.find(".ce_modified_on_disk").length === 0) {
+ problems.push("Changed: " + htmlEncode(file) + "");
+ editorMap[file].tab.css("color","orange").append("");
+ }
+ }
+ }
+ }
+ }
+ if (problems.length) {
+ showModal({
+ title: "Warning",
+ body: "Warning: An open file has unexpectedly changed on disk. You should right-click in the affected editor and select either: 'Diff unsaved changes' to see what might have changed, or 'Reload from disk'.
" + problems.join("
") + "
",
+ size: 600
+ });
+ }
+ }).catch(function(){
+ fileModsCheckTimerInProgress = false;
+ });
+ }
+ }
+ }
+
+ // Build the list of config files,
+ // This function is also called after settings are changed.
+ function loadPermissionsAndConfList(){
+ return serverAction({action:'init'}).then(function(data) {
+ var rex = /^Checking: .*[\/\\]([^\/\\]+?).conf\s*$/gmi;
+ var res;
+ var stanza;
+ conf = data.conf.global;
+ if (! conf.hasOwnProperty('git_autocommit_work_tree')) {
+ conf.git_autocommit_work_tree = "";
+ } else {
+ conf.git_autocommit_work_tree = $.trim(conf.git_autocommit_work_tree);
+ }
+ $dashboard_body.addClass('ce_no_write_access ce_no_run_access ce_no_settings_access ce_no_git_access ');
+ if (confIsTrue('write_access', false)) {
+ $dashboard_body.removeClass('ce_no_write_access');
+ }
+ if (confIsTrue('run_commands', false)) {
+ $dashboard_body.removeClass('ce_no_run_access');
+ }
+ if (! confIsTrue('hide_settings', false)) {
+ $dashboard_body.removeClass('ce_no_settings_access');
+ }
+ if (confIsTrue('git_autocommit', false) && conf.git_autocommit_work_tree !== "") {
+ $dashboard_body.removeClass('ce_no_git_access');
+ }
+
+ if (conf.btool_dir_for_deployment_apps) {
+ conf.btool_dir_for_deployment_apps = $.trim(conf.btool_dir_for_deployment_apps).replace(/\/$/, "");
+ }
+ if (conf.btool_dir_for_master_apps) {
+ conf.btool_dir_for_master_apps = $.trim(conf.btool_dir_for_master_apps).replace(/\/$/, "");
+ }
+ if (conf.btool_dir_for_shcluster_apps) {
+ conf.btool_dir_for_shcluster_apps = $.trim(conf.btool_dir_for_shcluster_apps).replace(/\/$/, "");
+ }
+
+ if (conf.hasOwnProperty('conf_validate_on_save_exclusions')) {
+ conf.conf_validate_on_save_exclusions = $.trim(conf.conf_validate_on_save_exclusions);
+ if (conf.conf_validate_on_save_exclusions !== "") {
+ try {
+ conf._conf_validate_on_save_exclusions = new RegExp(conf.conf_validate_on_save_exclusions, '');
+ } catch (e) {
+ console.error("Config file property: \"conf_validate_on_save_exclusions\" has bad regular expression and will be ignored.");
+ }
+ }
+ }
+ if (typeof conf._conf_validate_on_save_exclusions !== "object") {
+ conf._conf_validate_on_save_exclusions = new RegExp("savedsearches", '');
+ }
+
+
+ if (conf.hasOwnProperty('master_apps_gutter_useful_props_and_transforms')) {
+ conf.master_apps_gutter_useful_props_and_transforms = $.trim(conf.master_apps_gutter_useful_props_and_transforms);
+ if (conf.master_apps_gutter_useful_props_and_transforms !== "") {
+ try {
+ conf._master_apps_gutter_useful_props_and_transforms = new RegExp(conf.master_apps_gutter_useful_props_and_transforms, '');
+ } catch (e) {
+ console.error("Config file property: \"master_apps_gutter_useful_props_and_transforms\" has bad regular expression and will be ignored.");
+ }
+ }
+ }
+
+ if (conf.hasOwnProperty('master_apps_gutter_used_sourcetypes')) {
+ conf.master_apps_gutter_used_sourcetypes = $.trim(conf.master_apps_gutter_used_sourcetypes);
+ if (conf.master_apps_gutter_used_sourcetypes !== "") {
+ try {
+ conf._master_apps_gutter_used_sourcetypes = new RegExp(conf.master_apps_gutter_used_sourcetypes, '');
+ // attempt to load the date
+ if (! conf.hasOwnProperty('master_apps_gutter_used_sourcetypes_date')) {
+ conf.master_apps_gutter_used_sourcetypes_date = "";
+ }
+ var date_set = new Date(conf.master_apps_gutter_used_sourcetypes_date).valueOf();
+ if (isNaN(date_set)) {
+ conf._master_apps_gutter_used_sourcetypes_date = "Unknown";
+ } else {
+ conf._master_apps_gutter_used_sourcetypes_date = Math.floor(((new Date().valueOf()) - date_set) / 86400000);
+ }
+
+ } catch (e) {
+ console.error("Config file property: \"master_apps_gutter_used_sourcetypes\" has bad regular expression and will be ignored.");
+ }
+ }
+ }
+
+ if (conf.hasOwnProperty('master_apps_gutter_unnecissary_config_files')) {
+ conf.master_apps_gutter_unnecissary_config_files = $.trim(conf.master_apps_gutter_unnecissary_config_files);
+ if (conf.master_apps_gutter_unnecissary_config_files !== "") {
+ try {
+ conf._master_apps_gutter_unnecissary_config_files = new RegExp(conf.master_apps_gutter_unnecissary_config_files, '');
+ } catch (e) {
+ console.error("Config file property: \"master_apps_gutter_unnecissary_config_files\" has bad regular expression and will be ignored.");
+ }
+ }
+ }
+
+ if (conf.hasOwnProperty('debug_refresh_endpoints')) {
+ conf._debug_refresh_endpoints = conf.debug_refresh_endpoints.split("|");
+ } else {
+ conf._debug_refresh_endpoints = [];
+ }
+
+ if (confIsTrue('rest_api_dashboard_list', false)) {
+ $(".ce_show_rest").css("display","");
+ } else {
+ $(".ce_show_rest").css("display","none");
+ }
+
+ // Build the quick access hooksActive object
+ hooksActive = [];
+ var hookDefaults = data.conf.hook || {};
+ for (stanza in data.conf) {
+ if (data.conf.hasOwnProperty(stanza)) {
+ if (stanza.substr(0,5) === "hook:") {
+ data.conf[stanza] = $.extend({}, hookDefaults, data.conf[stanza]);
+ if (! isTrueValue(data.conf[stanza].disabled)) {
+ var action = data.conf[stanza].action.split(":")[0];
+ if (! hooksCfg.hasOwnProperty(action)) {
+ console.error("Stanza: [" + stanza + "] has unknown action value and will be ignored.");
+ continue;
+ }
+ if (action.substr(0,3) === "run") {
+ if (! confIsTrue('run_commands', false)) {
+ //console.error("Stanza: [" + stanza + "] has 'run' action but run_commands is false");
+ continue;
+ }
+ if (action === "run") {
+ data.conf[stanza].label = "$" + data.conf[stanza].label;
+ }
+ }
+ try {
+ data.conf[stanza]._match = new RegExp(data.conf[stanza].match, 'i');
+ hooksActive.push(data.conf[stanza]);
+ } catch (e) {
+ console.error("Stanza: [" + stanza + "] has bad regular expression and will be ignored.");
+ }
+ }
+ }
+ }
+ }
+ hooksActive.sort(function(a, b) {
+ if (a.order < b.order)
+ return -1;
+ if (a.order > b.order)
+ return 1;
+ return 0;
+ });
+ var actions = [];
+ var actionDefaults = data.conf.action || {};
+ var ce_custom_actions = $(".ce_custom_actions");
+ // Build the actions buttons on the home tab
+ ce_custom_actions.css("display","block");
+ for (stanza in data.conf) {
+ if (data.conf.hasOwnProperty(stanza)) {
+ if (stanza.substr(0,7) === "action:") {
+ var act = $.extend({}, actionDefaults, data.conf[stanza]);
+ if (! isTrueValue(act.disabled)) {
+ actions.push(act);
+ }
+ }
+ }
+ }
+ actions.sort(function(a, b) {
+ if (a.order < b.order)
+ return -1;
+ if (a.order > b.order)
+ return 1;
+ return 0;
+ });
+
+ ce_custom_actions.empty();
+ for (var i = 0; i < actions.length; i++) {
+ if (actions[i].action === "heading") {
+ $("").text(actions[i].label).appendTo(ce_custom_actions);
+
+ } else if (actions[i].action === "text") {
+ $("").text(actions[i].label).appendTo(ce_custom_actions);
+
+ } else if (actions[i].action === "br") {
+ $("" + problems.join("
") + "
").appendTo(ce_custom_actions); + + } else { + // add to the home screen + (function(a, i, l){ + var button = $("").text(a.label).attr("title",a.description).on("click", function(){ + runAction(a.action, undefined, false); + }); + button.appendTo(ce_custom_actions); + })(actions[i], i, actions.length); + } + } + + + confFiles = {}; + confFilesSorted = []; + while((res = rex.exec(data.files)) !== null) { + if (! confFiles.hasOwnProperty(res[1])) { + confFiles[res[1]] = null; + confFilesSorted.push(res[1]); + } + } + confFilesSorted.sort(); + }); + } + + // First load after init has occcured, setup the page + loadPermissionsAndConfList().then(function(){ + $ce_spinner.detach(); + $dashboard_body.removeClass("ce_loading"); + + setThemeMode(localStorage.getItem('ce_theme') || "vs-dark"); + setLeftPathWidth(localStorage.getItem('ce_lwidth') || 280); + + // on page load, log that tabs that were open previously + var ce_open_tabs = (JSON.parse(localStorage.getItem('ce_open_tabs')) || []); + if (ce_open_tabs.length) { + // move any previously open tabs into the close tabs list + for (var i = 0; i < ce_open_tabs.length; i++){ + logClosedTab(ce_open_tabs[i]); + } + var $restore = $(" Restore " + (ce_open_tabs.length === 1 ? "1 tab" : ce_open_tabs.length + " tabs") + "").appendTo($ce_tabs); + $restore.on("click", function(){ + for (var j = 0; j < ce_open_tabs.length; j++) { + hooksCfg[ce_open_tabs[j].type](ce_open_tabs[j].file); + } + }); + } + + // Allow tabs to be rearranged + Sortable.create($ce_tabs[0], { + draggable: ".ce_tab", + animation: 150, + onEnd: function () { + // figure out how things moved and reorder list + openTabsListChanged(); + doPipeTabSeperators(); + } + }); + + // Add tooltips + $ce_tree_icons.find('i').tooltip({delay: 100, placement: 'bottom'}); + + $("body").css("overflow",""); + + readUrlHash(); + + // Left pane styled scrollbar + OverlayScrollbars($ce_file_list[0],{ className : "os-theme-light", overflowBehavior : { x: "hidden"} }); + + // Show a warning the first time someone opens the app + if (! localStorage.getItem('ce_seen_warning')) { + localStorage.setItem('ce_seen_warning', "1"); + showModal({ + title: "Dragons ahead!", + size: 600, + body: + "
Warning: This is designed for advanced users.
This app can allow you to change Splunk files on the "+ + "filesystem. When you change files, if you don't know what you are doing, then you may break your Splunk environment.
" + + (!(confIsTrue('write_access', false) || confIsTrue('hide_settings', false)) ? "By default,
" : "") + + '
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ' + + 'IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ' + + 'FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ' + + 'AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ' + + 'LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ' + + 'OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ' + + 'SOFTWARE.' + + "
",
+ onShow: function(){
+ $('.ce_quicksettings').on("click",function(e){
+ e.preventDefault();
+ readFile("");
+ $(".modal").modal('hide');
+ });
+ },
+ actions: [{
+ onClick: function(){ $(".modal").modal('hide'); },
+ cssClass: 'btn-primary',
+ label: "OK"
+ }]
+ });
+ }
+ // Build the left pane
+ showTreePaneSpinner();
+ if (Number(conf.cache_file_depth) > 0) {
+ var fsCompleted = false;
+ serverAction({action:'fs'}).then(function(contents){
+ filecache = contents;
+ readFolder(inFolder);
+ fsCompleted = true;
+ });
+ setTimeout(function(){
+ if (!fsCompleted) {
+ $("").appendTo($ce_tree_pane);
+ }
+ }, 3000);
+ } else {
+ if (Number(conf.cache_file_depth) === -1) {
+ filecache = null;
+ }
+ readFolder(inFolder);
+ }
+ // Keep track if the page is visible or not. This will affect how often we check for changes to open files
+ $(document).on('visibilitychange', function(){
+ if (document.hidden) {
+ fileModsCheckTimerPeriod = 60000;
+ clearTimeout(fileModsCheckTimer);
+ setTimeout(function(){ checkFileMods(); }, fileModsCheckTimerPeriod);
+ } else {
+ fileModsCheckTimerPeriod = 10000;
+ // When the tab gains focus, immidiatly check for updated files
+ checkFileMods();
+ }
+ });
+ });
+});
diff --git a/apps/config_explorer/appserver/static/mirage-upgrade.png b/apps/config_explorer/appserver/static/mirage-upgrade.png
new file mode 100755
index 00000000..1f8eeead
Binary files /dev/null and b/apps/config_explorer/appserver/static/mirage-upgrade.png differ
diff --git a/apps/config_explorer/appserver/static/node_modules/monaco-editor/CHANGELOG.md b/apps/config_explorer/appserver/static/node_modules/monaco-editor/CHANGELOG.md
new file mode 100755
index 00000000..c03925a0
--- /dev/null
+++ b/apps/config_explorer/appserver/static/node_modules/monaco-editor/CHANGELOG.md
@@ -0,0 +1,756 @@
+# Monaco Editor Changelog
+
+## [0.19.3] (14.01.2020)
+
+* brings back a way to get resolved editor options - [#1734](https://github.com/microsoft/monaco-editor/issues/1734)
+
+### Thank you
+
+Contributions to `monaco-editor`:
+* [Brijesh Bittu (@brijeshb42)](https://github.com/brijeshb42): Playground: Add keyboard shortcut to run playground code [PR #1756](https://github.com/microsoft/monaco-editor/pull/1756)
+
+Contributions to `monaco-languages`:
+* [Rikki Schulte (@acao)](https://github.com/acao): add tokenizer for graphql language variables [PR #78](https://github.com/microsoft/monaco-languages/pull/78)
+
+
+## [0.19.2] (06.01.2020)
+
+* fixes issue with default value of `autoIndent` - [#1726](https://github.com/microsoft/monaco-editor/issues/1726)
+
+## [0.19.1] (06.01.2020)
+
+* fixes issue with .d.ts file in the ESM distribution - [#1729](https://github.com/microsoft/monaco-editor/issues/1729)
+* adds types for global editor options (such as `wordBasedSuggestions`) - [#1746](https://github.com/microsoft/monaco-editor/issues/1746)
+* adds support for reStructuredText.
+
+### Thank you
+
+Contributions to `monaco-editor`:
+* [Lars Hvam (@larshp)](https://github.com/larshp)
+ * Playground: add ABAP sample [PR #1737](https://github.com/microsoft/monaco-editor/pull/1737)
+ * Playground: fix codelens provider example [PR #1738](https://github.com/microsoft/monaco-editor/pull/1738)
+
+Contributions to `monaco-languages`:
+* [Changwon Choe (@qwefgh90)](https://github.com/qwefgh90): add support for reStructuredText [PR #77](https://github.com/microsoft/monaco-languages/pull/77)
+
+
+## [0.19.0] (20.12.2019)
+
+### New & Noteworthy
+
+* It is now possible to pass in a `dimension` in the editor construction options in order to avoid a synchronous layout.
+* There is new API to provide semantic tokens.
+* New options:
+ * `multiCursorPaste`: define how to distribute paste in case of multi-cursor
+ * `matchBrackets`: control if enclosing brackets should be highlighted
+* Fixes for tokenization in: TypeScript, JavaScript, Handlebars, Kotlin and VB.
+
+### Breaking changes
+
+* `getConfiguration()` is replaced by `getRawOptions()`, which returns the passed in editor options.
+
+### Thank you
+
+Contributions to `monaco-editor`:
+
+* [Lars Hvam (@larshp)](https://github.com/larshp)
+ * contributing: add details for running website locally [PR #1617](https://github.com/microsoft/monaco-editor/pull/1617)
+ * playground: update symbols-provider-example [PR #1616](https://github.com/microsoft/monaco-editor/pull/1616)
+* [Remy Suen (@rcjsuen)](https://github.com/rcjsuen): Add CompletionItem with snippet support to the example [PR #1703](https://github.com/microsoft/monaco-editor/pull/1703)
+
+Contributions to `monaco-editor-webpack-plugin`:
+* [Dominik Moritz (@domoritz)](https://github.com/domoritz): Bump to 0.16 [PR #62](https://github.com/microsoft/monaco-editor-webpack-plugin/pull/62)
+* [Mike Greiling (@mikegreiling)](https://github.com/mikegreiling): Fix __webpack_public_path__ within getWorkerUrl method [PR #63](https://github.com/microsoft/monaco-editor-webpack-plugin/pull/63)
+* [Roman Krasiuk (@rkrasiuk)](https://github.com/rkrasiuk): Bump to 0.17.0 and Add graphql support [PR #67](https://github.com/microsoft/monaco-editor-webpack-plugin/pull/67)
+* [Niklas Mollenhauer (@nikeee)](https://github.com/nikeee): Add loader-utils and make @types/webpack a dev dependency [PR #74](https://github.com/microsoft/monaco-editor-webpack-plugin/pull/74)
+* [James Diefenderfer (@jimmydief)](https://github.com/jimmydief)
+ * Add support for plugin-specific public path [PR #81](https://github.com/microsoft/monaco-editor-webpack-plugin/pull/81)
+ * Add support for dynamic filenames [PR #83](https://github.com/microsoft/monaco-editor-webpack-plugin/pull/83)
+
+Contributions to `monaco-languages`:
+
+* [Maksym Bykovskyy (@mbykovskyy)](https://github.com/mbykovskyy): Adds cameligo language support [PR #75](https://github.com/microsoft/monaco-languages/pull/75)
+* [Steven Degutis (@sdegutis)](https://github.com/sdegutis): Adds Markdown Table syntax highlighting [PR #73](https://github.com/microsoft/monaco-languages/pull/73)
+* [Sergey Romanov (@Serhioromano)](https://github.com/Serhioromano): Improvements to ST language [PR #76](https://github.com/microsoft/monaco-languages/pull/76)
+* [Sebastian Pahnke (@spahnke)](https://github.com/spahnke): [JS/TS] Add support for the nullish-coalesce operator [PR #74](https://github.com/microsoft/monaco-languages/pull/74)
+
+Contributions to `monaco-typescript`:
+
+* [Denys Vuika (@DenysVuika)](https://github.com/DenysVuika): register multiple extra libs at once [PR #24](https://github.com/microsoft/monaco-typescript/pull/24)
+* [Elizabeth Craig (@ecraig12345)](https://github.com/ecraig12345)
+ * Generate and publish typings for package [PR #50](https://github.com/microsoft/monaco-typescript/pull/50)
+ * Remove another require call [PR #49](https://github.com/microsoft/monaco-typescript/pull/49)
+* [@katis](https://github.com/katis): Update TypeScript to 3.7.2 [PR #51](https://github.com/microsoft/monaco-typescript/pull/51)
+* [Tamas Kiss (@kisstkondoros)](https://github.com/kisstkondoros): Add documentation to signature help [PR #52](https://github.com/microsoft/monaco-typescript/pull/52)
+* [Lars Hvam (@larshp)](https://github.com/larshp): fix typo [PR #45](https://github.com/microsoft/monaco-typescript/pull/45)
+* [Sebastian Pahnke (@spahnke)](https://github.com/spahnke)
+ * Provide related information to diagnostics [PR #48](https://github.com/microsoft/monaco-typescript/pull/48)
+* [Alessandro Fragnani (@alefragnani)](https://github.com/alefragnani): Add Pascal samples [PR #1358](https://github.com/microsoft/monaco-editor/pull/1358)
+ * Adopt monaco.MarkerTag API [PR #47](https://github.com/microsoft/monaco-typescript/pull/47)
+ * Add support to ignore certain diagnostics [PR #46](https://github.com/microsoft/monaco-typescript/pull/46)
+
+## [0.18.1] (19.09.2019)
+
+* fixes 2 issues with the ESM distribution - [#1572](https://github.com/microsoft/monaco-editor/issues/1572) and [#1574](https://github.com/microsoft/monaco-editor/issues/1574)
+* fixes very slow scrolling in Firefox - [#1575](https://github.com/microsoft/monaco-editor/issues/1575)
+* new syntax highlighting for: pascaligo, ABAP, Sophia ML, Twig and MIPS.
+
+### Thank you
+
+Contributions to `monaco-editor`:
+
+* [Alessandro Fragnani (@alefragnani)](https://github.com/alefragnani): Add Pascal samples [PR #1358](https://github.com/microsoft/monaco-editor/pull/1358)
+* [Daniel Wang (@datou0412)](https://github.com/datou0412): Add koltin sample for website [PR #1351](https://github.com/microsoft/monaco-editor/pull/1351)
+* [Ehsan (@ehsan-mohammadi)](https://github.com/ehsan-mohammadi): Updated html sample code [PR #1387](https://github.com/microsoft/monaco-editor/pull/1387)
+* [Jonas Fonseca (@jonas)](https://github.com/jonas): CHANGELOG: Fix year for releases made in 2019 [PR #1388](https://github.com/microsoft/monaco-editor/pull/1388)
+* [Milen Radkov (@mradkov)](https://github.com/mradkov): Add Sophia ML example [PR #1543](https://github.com/microsoft/monaco-editor/pull/1543)
+* [Sergey Romanov (@Serhioromano)](https://github.com/Serhioromano): Structured text example [PR #1552](https://github.com/microsoft/monaco-editor/pull/1552)
+* [zhnlviing (@zhanghongnian)](https://github.com/zhanghongnian): fix demo: completion provider example [PR #1537](https://github.com/microsoft/monaco-editor/pull/1537)
+
+Contributions to `monaco-json`:
+
+* [Dominik Moritz (@domoritz)](https://github.com/domoritz)
+ * Upgrade dependencies [PR #11](https://github.com/microsoft/monaco-json/pull/11)
+ * Add config to disable default formatter [PR #10](https://github.com/microsoft/monaco-json/pull/10)
+
+Contributions to `monaco-languages`:
+
+* [Brice Aldrich (@DefinitelyNotAGoat)](https://github.com/DefinitelyNotAGoat): pascaligo: adding pascaligo language support [PR #69](https://github.com/microsoft/monaco-languages/pull/69)
+* [Salam Elbilig (@finalfantasia)](https://github.com/finalfantasia): [clojure] treat comma as whitespace [PR #63](https://github.com/microsoft/monaco-languages/pull/63)
+* [Alf Eaton (@hubgit)](https://github.com/hubgit): [xml] Add OPF and XSL file extensions [PR #64](https://github.com/microsoft/monaco-languages/pull/64)
+* [Lars Hvam (@larshp)](https://github.com/larshp)
+ * [ABAP] Add ABAP language support [PR #72](https://github.com/microsoft/monaco-languages/pull/72)
+ * readme: align "add new language" example [PR #70](https://github.com/microsoft/monaco-languages/pull/70)
+* [Milen Radkov (@mradkov)](https://github.com/mradkov)
+ * Add support for Sophia ML [PR #67](https://github.com/microsoft/monaco-languages/pull/67)
+ * add `None` and `Some` keywords to SophiaML [PR #68](https://github.com/microsoft/monaco-languages/pull/68)
+* [Marco Petersen (@ocrampete16)](https://github.com/ocrampete16): Add support for the Twig template language [PR #71](https://github.com/microsoft/monaco-languages/pull/71)
+* [Progyan Bhattacharya (@Progyan1997)](https://github.com/Progyan1997): [Feat] MIPS: Support for Syntax Highlight and Basic Colorization [PR #65](https://github.com/microsoft/monaco-languages/pull/65)
+* [Sergey Romanov (@Serhioromano)](https://github.com/Serhioromano): [ST] Some updated for Structured Text Language support [PR #66](https://github.com/microsoft/monaco-languages/pull/66)
+* [Sebastian Pahnke (@spahnke)](https://github.com/spahnke): [JS/TS] Add support for BigInt [PR #62](https://github.com/microsoft/monaco-languages/pull/62)
+
+Contributions to `monaco-typescript`:
+
+* [Andre Wachsmuth (@blutorange)](https://github.com/blutorange): Fix microsoft/monaco-editor#1576 update dependency to core [PR #41](https://github.com/microsoft/monaco-typescript/pull/41)
+* [Javey (@Javey)](https://github.com/Javey): Make it can be compressed by uglify-js [PR #34](https://github.com/microsoft/monaco-typescript/pull/34)
+* [Sebastian Pahnke (@spahnke)](https://github.com/spahnke): Add a rename provider [PR #39](https://github.com/microsoft/monaco-typescript/pull/39)
+* [@ulrichb](https://github.com/ulrichb): Expose TypeScript version via `monaco.languages.typescript.typeScriptVersion` [PR #31](https://github.com/microsoft/monaco-typescript/pull/31)
+
+## [0.18.0] (04.09.2019)
+
+### New & Noteworthy
+
+* Minimap enhancement
+ * Selections and find results are now rendered in the minimap.
+ * Model decorations now support `IModelDecorationOptions.minimap`, once set the decoration will be rendered in the minimap
+* New editor options
+ * `autoClosingOvertype`: it controls whether the editor allows [typing over closing quotes or brackets](https://github.com/microsoft/vscode/issues/37315#issuecomment-515200477).
+ * `cursorSurroundingLines`: it controls how many visible lines to display around the cursor while moving the cursor towards beginning or end of a file.
+ * `renderWhitespace: "selection"`: the editor can render whitespaces only in selection.
+
+### API changes
+
+* `DeclarationProvider`: The declaration provider interface defines the contract between extensions and the go to declaration feature.
+* `SelectionRangeProvider` Provide smart selection ranges for the given positions, see VS Code [issue](https://github.com/microsoft/vscode/issues/67872).
+* CodeLensProvider should now return `CodeLensList` instead of `ICodeLensSymbol[]`.
+* `DocumentSymbol` has a new property `tags` to support more types.
+* View Zone id is now `string` instead of `number`.
+
+### Thank you
+
+Contributions to `monaco-json`:
+
+* [Ԝеѕ @wesinator](https://github.com/wesinator): Add .har extension [#9](https://github.com/microsoft/monaco-json/pull/9)
+
+## [0.17.1] (25.06.2019)
+* Update monaco-typescript to TypeScript 3.5.0.
+
+## [0.17.0] (05.05.2019)
+
+### New & Noteworthy
+
+* Localization support is brought back for AMD bundle. We lost the localization support when VS Code moved to the localization system but now AMD bundles ships the same localized strings VS Code localization extensions ship. For more details, please read [Monaco#822](https://github.com/Microsoft/monaco-editor/issues/822) and related [VS Code upstream issue](https://github.com/Microsoft/vscode/issues/71065)
+* `LinkProvider.ProvideLinks` should now return `ILinksList` instead of `ILink[]`.
+* `IEditorOptions.iconsInSuggestions` and `EditorContribOptions.iconsInSuggestions` are now replaced by `EditorContribOptions.suggest.showIcons`.
+* We introduced `EditorContribOptions.suggest.maxVisibleSuggestions` to control maximum suggestions to show in suggestions widget.
+* `EditorContribOptions.suggest.filteredTypes` is now introduced to allow suggestions to be filtered by the user. For more details, please read [vscode#45039](https://github.com/Microsoft/vscode/issues/45039).
+
+### Thank You
+
+Contributions to `monaco-editor`:
+
+* [Jonas Fonseca @jonas](https://github.com/jonas): Fix year for releases made in 2019 [PR #1388](https://github.com/Microsoft/monaco-editor/pull/1388)
+
+
+## [0.16.2] (19.03.2019)
+* Fixes for HTML and JSON (https://github.com/Microsoft/monaco-editor/issues/1367, https://github.com/Microsoft/monaco-editor/issues/1254)
+
+## [0.16.1] (14.03.2019)
+* Fixes issue with context menu (https://github.com/Microsoft/monaco-editor/issues/1357)
+
+## [0.16.0] (05.03.2019)
+
+### New & Noteworthy
+
+* Added built-in support for AMD cross-domain web worker loading.
+* Added API to remeasure fonts (`monaco.editor.remeasureFonts`) in case custom fonts are used and the editor is painted at a time when the fonts are not finished loading.
+* Various editor improvements, such as an option to `renderFinalNewline`, or to have a `cursorSmoothCaretAnimation`
+* Colorization support for Tcl, Pascal, Kotlin and GraphQL.
+
+### Breaking changes
+
+* We are no longer shipping WinJS.Promise, but we are shipping with a Promise shim (for IE11).
+* `CompletionItem.range` is now mandatory. Most times, you can use `model.getWordUntilPosition()` to get a good range.
+* `DefinitionLink` has been renamed to `LocationLink` and a couple of its fields have also been renamed.
+
+### Thank you
+
+Contributions to `monaco-editor`:
+
+* [Sebastián Gurin (@cancerberoSgx)](https://github.com/cancerberoSgx): fix worker paths in parcel [PR #1339](https://github.com/Microsoft/monaco-editor/pull/1339)
+* [@datou0412](https://github.com/datou0412): Fix lineDecoration example css error [PR #1337](https://github.com/Microsoft/monaco-editor/pull/1337)
+* [Joshua Sullivan (@jbsulli)](https://github.com/jbsulli): Fix JavaScript RegExp range closing bracket [PR #1329](https://github.com/Microsoft/monaco-editor/pull/1329)
+* [Krish De Souza (@Kedstar99)](https://github.com/Kedstar99): Fixed various HTML errors with the various webpages [PR #1309](https://github.com/Microsoft/monaco-editor/pull/1309)
+* [Swarnava Sengupta (@swarnava)](https://github.com/swarnava): Make copyright year dynamic [PR #1303](https://github.com/Microsoft/monaco-editor/pull/1303)
+
+Contributions to `monaco-languages`:
+
+* [alan.invents (@ALANVF)](https://github.com/ALANVF): Add Tcl support [PR #59](https://github.com/Microsoft/monaco-languages/pull/59)
+* [Alessandro Fragnani (@alefragnani)](https://github.com/alefragnani): Pascal language support [PR #60](https://github.com/Microsoft/monaco-languages/pull/60)
+* [Brijesh Bittu (@brijeshb42)](https://github.com/brijeshb42): Update ruby auto indentation rules [PR #58](https://github.com/Microsoft/monaco-languages/pull/58)
+* [Andrew (@creativedrewy)](https://github.com/creativedrewy): Add Kotlin Language Support [PR #57](https://github.com/Microsoft/monaco-languages/pull/57)
+* [Salam Elbilig (@finalfantasia)](https://github.com/finalfantasia): [clojure] Improve the regular expressions for various symbols [PR #56](https://github.com/Microsoft/monaco-languages/pull/56)
+* [Neil Jones (@futurejones)](https://github.com/futurejones): Solidity - add "constructor" to main keywords [PR #55](https://github.com/Microsoft/monaco-languages/pull/55)
+* [Pavel Lang (@langpavel)](https://github.com/langpavel): GraphQL language support [PR #54](https://github.com/Microsoft/monaco-languages/pull/54)
+* [Samuel Helms (@samghelms)](https://github.com/samghelms): allows annotation in markdown language block headers [PR #61](https://github.com/Microsoft/monaco-languages/pull/61)
+
+Contributions to `monaco-typescript`:
+
+* [Olga Lesnikova (@Geloosa)](https://github.com/Geloosa): more safe extra lib filePath generation [PR #29](https://github.com/Microsoft/monaco-typescript/pull/29)
+* [Stefan Lacatus (@stefan-lacatus)](https://github.com/stefan-lacatus): Optimize how external libs are handled and allow for custom languages [PR #30](https://github.com/Microsoft/monaco-typescript/pull/30)
+
+## [0.15.6] (23.11.2018)
+* Fixes issue with context menu (https://github.com/Microsoft/monaco-editor/issues/1199)
+
+## [0.15.5] (16.11.2018)
+* Re-remove cast to any from our code base to allow for tree shaking to not shake useful code (https://github.com/Microsoft/monaco-editor/issues/1013)
+
+## [0.15.4] (15.11.2018)
+* Fixes context menu in IE11 - https://github.com/Microsoft/monaco-editor/issues/1191
+* Fixes suggest widget - https://github.com/Microsoft/monaco-editor/issues/1185 and https://github.com/Microsoft/monaco-editor/issues/1186
+
+## [0.15.3] (15.11.2018)
+* Remove cast to any from our code base to allow for tree shaking to not shake useful code (https://github.com/Microsoft/monaco-editor/issues/1013)
+
+## [0.15.2] (14.11.2018)
+* Fixes usage of `marked` to allow for packaging with rollup (https://github.com/Microsoft/monaco-editor/issues/1183)
+
+## [0.15.1] (13.11.2018)
+* Fixes the `/esm/` distribution (https://github.com/Microsoft/monaco-editor/issues/1178)
+
+## [0.15.0] (12.11.2018)
+
+### New & Noteworthy
+
+* Improved typings in `monaco.d.ts` to better reflect null types.
+
+### Breaking changes
+
+* We are slowly migrating our code-base away from WinJS promises, so the exposed `monaco.Promise` API has been reduced to indicate that. We are setting up a Promise polyfill to cover browsers which do not have a native Promise implementation yet (i.e. IE11).
+* `CompletionItemProvider.provideCompletionItems` and `CompletionItemProvider.resolveCompletionItem` have been modified to better reflect the API of VS Code. Both arguments and return type have changed.
+* `SignatureHelpProvider.provideSignatureHelp` now receives an extra argument for the context.
+* Various new editor options or tweaks to existing ones: `parameterHints`, `autoClosingBrackets`, `autoClosingQuotes`, `autoSurround`, `copyWithSyntaxHighlighting`, `tabCompletion`.
+
+### Thank you
+
+Contributions to `monaco-editor`:
+
+* [Arvind S (@arvind0598)](https://github.com/arvind0598): Updated C# sample code for a simpler game. [PR #1160](https://github.com/Microsoft/monaco-editor/pull/1160)
+* [Brooks Becton (@brooksbecton)](https://github.com/brooksbecton): Removing obsolete Note in Monarch Docs [PR #1089](https://github.com/Microsoft/monaco-editor/pull/1089)
+* [James Orr (@buzzcola)](https://github.com/buzzcola): Correct comma splice in README.md [PR #1111](https://github.com/Microsoft/monaco-editor/pull/1111)
+* [Chintogtokh Batbold (@chintogtokh)](https://github.com/chintogtokh): Clarify that repo doesn't contain source code [PR #1119](https://github.com/Microsoft/monaco-editor/pull/1119)
+* [Chris Helgert (@chrishelgert)](https://github.com/chrishelgert): Move issue template to '.github' folder and add some styling for better readability [PR #1121](https://github.com/Microsoft/monaco-editor/pull/1121)
+* [Steven Bock (@dabockster)](https://github.com/dabockster): Added better Java sample (FizzBuzz instead of JUnit) [PR #1161](https://github.com/Microsoft/monaco-editor/pull/1161)
+* [Michele Gobbi (@dynamick)](https://github.com/dynamick): Added Ruby [PR #1102](https://github.com/Microsoft/monaco-editor/pull/1102)
+* [Edilson Ngulele (@EdNgulele)](https://github.com/EdNgulele): style: Updated CONTRIBUTING.md [PR #1088](https://github.com/Microsoft/monaco-editor/pull/1088)
+* [Evan Walters (@evanwaltersdev)](https://github.com/evanwaltersdev): issue guidelines [PR #1096](https://github.com/Microsoft/monaco-editor/pull/1096)
+* [Abdussalam Abdurrahman (@finalfantasia)](https://github.com/finalfantasia): [clojure] Update Clojure example with one that's more representative. [PR #1059](https://github.com/Microsoft/monaco-editor/pull/1059)
+* [@flash76](https://github.com/flash76): Update README.md [PR #1141](https://github.com/Microsoft/monaco-editor/pull/1141)
+* [Daniel Pasch (@gempir)](https://github.com/gempir): fix 2 of 7 npm package vurnerabilities [PR #1087](https://github.com/Microsoft/monaco-editor/pull/1087)
+* [@Hotlar](https://github.com/Hotlar): lingual fixes to readme [PR #1086](https://github.com/Microsoft/monaco-editor/pull/1086)
+* [Jeremy Meiss (@jerdog)](https://github.com/jerdog): correct README grammar [PR #1114](https://github.com/Microsoft/monaco-editor/pull/1114)
+* [Joaquim Honório (@JoaquimCMH)](https://github.com/JoaquimCMH): Update CHANGELOG [PR #1152](https://github.com/Microsoft/monaco-editor/pull/1152)
+* [Ricardo Ambrogi (@KadoBOT)](https://github.com/KadoBOT): Remove commented code [PR #1113](https://github.com/Microsoft/monaco-editor/pull/1113)
+* [Abhinav Srivastava (@krototype)](https://github.com/krototype): changed the license block of readme [PR #1133](https://github.com/Microsoft/monaco-editor/pull/1133)
+* [Mera Gangapersaud (@Mera-Gangapersaud)](https://github.com/Mera-Gangapersaud): Fixed prerequisites link in Contributing.md [PR #1155](https://github.com/Microsoft/monaco-editor/pull/1155)
+* [Michael (@michael-k)](https://github.com/michael-k): Use python examples that work [PR #1053](https://github.com/Microsoft/monaco-editor/pull/1053)
+* [Remy Suen (@rcjsuen)](https://github.com/rcjsuen): Add missing links in CHANGELOG.md [PR #1029](https://github.com/Microsoft/monaco-editor/pull/1029)
+* [Shivansh Saini (@shivanshs9)](https://github.com/shivanshs9): Fixed typos in website page and CHANGELOG [PR #1153](https://github.com/Microsoft/monaco-editor/pull/1153)
+* [Sachin Saini (@thetinygoat)](https://github.com/thetinygoat): hacktoberfest fix [PR #1131](https://github.com/Microsoft/monaco-editor/pull/1131)
+
+Contributions to `monaco-languages`:
+
+* [Aastha (@AasthaGupta)](https://github.com/AasthaGupta): Fix markdown bug #1107 [PR #52](https://github.com/Microsoft/monaco-languages/pull/52)
+* [Abdussalam Abdurrahman (@finalfantasia)](https://github.com/finalfantasia): [clojure] Improve Clojure syntax highlighting. [PR #45](https://github.com/Microsoft/monaco-languages/pull/45)
+* [Abhishek (@GeekAb)](https://github.com/GeekAb): Markdown bug fix for #1107 [PR #51](https://github.com/Microsoft/monaco-languages/pull/51)
+* [Matthew D. Miller (@goober99)](https://github.com/goober99): Added support for Perl quote-like operators to fix #1101 [PR #50](https://github.com/Microsoft/monaco-languages/pull/50)
+* [Grzegorz Wcisło (@grzegorz-wcislo)](https://github.com/grzegorz-wcislo): Fix yaml string tokenization [PR #47](https://github.com/Microsoft/monaco-languages/pull/47)
+* [Pascal Berger (@pascalberger)](https://github.com/pascalberger): Use C# highlighting for Cake scripts [PR #53](https://github.com/Microsoft/monaco-languages/pull/53)
+* [Sebastian Pahnke (@spahnke)](https://github.com/spahnke)
+ * [JS/TS] Add support for alternative octal integer literal syntax [PR #49](https://github.com/Microsoft/monaco-languages/pull/49)
+ * Improve tokenization of regular expressions [PR #46](https://github.com/Microsoft/monaco-languages/pull/46)
+* [Tiago Danin (@TiagoDanin)](https://github.com/TiagoDanin): New rule for non-teminated string in yaml [PR #48](https://github.com/Microsoft/monaco-languages/pull/48)
+
+Contributions to `monaco-typescript`:
+
+* [Parikshit Hooda (@Parikshit-Hooda)](https://github.com/Parikshit-Hooda): fixed typo in line 11 [PR #23](https://github.com/Microsoft/monaco-typescript/pull/23)
+* [Sebastian Pahnke (@spahnke)](https://github.com/spahnke): Render documentation in suggestion widget as Markdown [PR #22](https://github.com/Microsoft/monaco-typescript/pull/22)
+
+Contributions to `monaco-json`:
+
+* [Igor Nesterenko (@nesterone)](https://github.com/nesterone): Provide diagnostic option to enable on-demand schema loading [PR #7](https://github.com/Microsoft/monaco-json/pull/7)
+
+Contributions to `monaco-css`:
+
+* [Richard Samuelson (@ricsam)](https://github.com/ricsam): Fix indentation on the CSS test page [PR #7](https://github.com/Microsoft/monaco-css/pull/7)
+
+
+
+## [0.14.3] (17.08.2018)
+* Fixes TypeScript/JavaScript coloring of regular expressions https://github.com/Microsoft/monaco-editor/issues/1009
+
+## [0.14.2] (10.08.2018)
+* Reverts https://github.com/Microsoft/monaco-editor/pull/981
+
+## [0.14.1] (10.08.2018)
+* Fixes Find All References (https://github.com/Microsoft/vscode/issues/56160)
+
+## [0.14.0] (10.08.2018)
+### New & Noteworthy
+* Using tree-shaking to reduce the amount of shipped code.
+* TypeScript and JavaScript coloring is now done with Monarch.
+* `typescriptServices` is no longer loaded on the UI thread, this helps with webpack's bundle output size.
+* Added coloring for: apex, azcli, clojure, powerquery, rust, scheme and shell.
+* Added sub-word navigation commands.
+* Added font zoom commands.
+* Syntax highlighting for deleted lines in inline diff editor.
+* Highlighted indent guide.
+* Column selection using middle mouse button.
+* Added editor options: `scrollBeyondLastColumn`, `hover`, `suggest`, `highlightActiveIndentGuide`, `showUnused`.
+* Added `setTokensProvider` with `EncodedTokensProvider`.
+* Added `monaco.languages.getEncodedLanguageId` to get the numeric language id.
+* `DefinitionProvider.provideDefinition`, `ImplementationProvider.provideImplementation`, `TypeDefinitionProvider.provideTypeDefinition` can now return a `DefinitionLink`.
+
+### Breaking Changes
+* Removed no longer used `Severity`.
+* Renamed `IEditor.isFocused` to `IEditor.hasTextFocus`.
+* Renamed `ICodeEditor.onDidFocusEditor` to `ICodeEditor.onDidFocusEditorWidget`.
+* Renamed `ICodeEditor.onDidBlurEditor` to `ICodeEditor.onDidBlurEditorWidget`.
+* `DocumentSymbolProvider.provideDocumentSymbols` must now return `DocumentSymbol[]`.
+
+### Thank you
+
+Contributions to `monaco-editor`:
+
+* [Ali Mirlou (@AliMirlou)](https://github.com/AliMirlou): Fix typo [PR #952](https://github.com/Microsoft/monaco-editor/pull/952)
+* [Avelino (@avelino)](https://github.com/avelino): added clojure exampple [PR #904](https://github.com/Microsoft/monaco-editor/pull/904)
+* [Sebastián Gurin (@cancerberoSgx)](https://github.com/cancerberoSgx): fix small error in integration docs [PR #957](https://github.com/Microsoft/monaco-editor/pull/957)
+* [Haegyun Jung (@haeguri)](https://github.com/haeguri): Fix playground sample option [PR #962](https://github.com/Microsoft/monaco-editor/pull/962)
+(https://github.com/Microsoft/monaco-editor/pull/914)
+* [Myles Scolnick (@mscolnick)](https://github.com/mscolnick): add sideEffects false for tree-shaking in webpack [PR #981](https://github.com/Microsoft/monaco-editor/pull/981)
+* [Niklas Mollenhauer (@nikeee)](https://github.com/nikeee): Fix hash comment in xdot sample [PR #916](https://github.com/Microsoft/monaco-editor/pull/916)
+* [Remy Suen (@rcjsuen)](https://github.com/rcjsuen): Add folding provider sample to the playground [PR #878](https://github.com/Microsoft/monaco-
+
+Contributions to `monaco-typescript`:
+
+* [Fathy Boundjadj (@fathyb)](https://github.com/fathyb): Use Markdown code block for hover tooltip [PR #20](https://github.com/Microsoft/monaco-typescript/pull/20)
+* [Matt McCutchen (@mattmccutchen)](https://github.com/mattmccutchen): Clear the `file` fields of `relatedInformation` too. (WIP) [PR #21](https://github.com/Microsoft/monaco-typescript/pull/21)
+
+Contributions to `monaco-languages`:
+
+* [Avelino (@avelino)](https://github.com/avelino)
+ * upgrade all language support (today) [PR #35](https://github.com/Microsoft/monaco-languages/pull/35)
+ * Clojure support [PR #36](https://github.com/Microsoft/monaco-languages/pull/36)
+ * Clojure: added more keywords [PR #37](https://github.com/Microsoft/monaco-languages/pull/37)
+* [Faris Masad (@masad-frost)](https://github.com/masad-frost)
+ * Fix Clojure syntax highlighting [PR #38](https://github.com/Microsoft/monaco-languages/pull/38)
+ * Add Scheme language [PR #34](https://github.com/Microsoft/monaco-languages/pull/34)
+ * Add auto-indentation for python [PR #33](https://github.com/Microsoft/monaco-languages/pull/33)
+* [Matt Masson (@mattmasson)](https://github.com/mattmasson): Add support for Power Query (M) language [PR #42](https://github.com/Microsoft/monaco-languages/pull/42)
+* [Oli Lane (@olane)](https://github.com/olane): Add Apex language [PR #44](https://github.com/Microsoft/monaco-languages/pull/44)
+* [Viktar Pakanechny (@Vityanchys)](https://github.com/Vityanchys): Added azcli [PR #43](https://github.com/Microsoft/monaco-languages/pull/43)
+* [zqlu (@zqlu)](https://github.com/zqlu)
+ * Add Shell language [PR #39](https://github.com/Microsoft/monaco-languages/pull/39)
+ * Add Perl language [PR #40](https://github.com/Microsoft/monaco-languages/pull/40)
+ * add perl to bundle.js [PR #41](https://github.com/Microsoft/monaco-languages/pull/41)
+
+## [0.13.1] (15.05.2018)
+ - Fixes [issue #871](https://github.com/Microsoft/monaco-editor/issues/871): TypeScript import error after mocaco-editor upgraded from 0.12 to 0.13
+
+## [0.13.0] (11.05.2018)
+### New & Noteworthy
+* New folding provider `registerFoldingRangeProvider`.
+* You can now specifies the stack order of a decoration by setting `IModelDecorationOptions.zIndex`. A decoration with greater stack order is always in front of a decoration with a lower stack order.
+* You can now tell Monaco if there is an `inlineClassName` which affects letter spacing. the stack order of a decoration by setting `IModelDecorationOptions.inlineClassNameAffectsLetterSpacing`.
+* Get the text length for a certain line on text model (`ITextModel.getLineLength(lineNumber: number)`)
+* New option `codeActionsOnSave`, controls whether code action kinds will be run on save.
+* New option `codeActionsOnSaveTimeout`, controls timeout for running code actions on save.
+* New option `multiCursorMergeOverlapping`, controls if overlapping selections should be merged. Default to `true`.
+
+### Breaking Change
+* Removed `ICodeEditor.getCenteredRangeInViewport`.
+* `RenameProvider.resolveRenameLocation` now returns `RenameLocation` instead of `IRange`.
+
+### Thank you
+* [Sergey Romanov @Serhioromano](https://github.com/Serhioromano): Add new language Structured Text support [PR monaco-languages#32](https://github.com/Microsoft/monaco-languages/pull/32)
+* [Yukai Huang @Yukaii](https://github.com/Yukaii): Fix backspace in IME composition on iOS Safari [PR vscode#40546](https://github.com/Microsoft/vscode/pull/40546)
+
+## [0.12.0] (11.04.2018)
+* Special thanks to [Tim Kendrick](https://github.com/timkendrick) for contributing a webpack plugin - `monaco-editor-webpack-plugin` - now available on [npm](https://www.npmjs.com/package/monaco-editor-webpack-plugin).
+
+### Breaking changes
+* Introduced `MarkerSeverity` instead of `Severity` for markers serverity.
+* Replaced `RenameProvider.resolveInitialRenameValue` with `RenameProvider.resolveRenameLocation`.
+* Fixed typo in `monaco-typescript`, renamed `setMaximunWorkerIdleTime` to `setMaximumWorkerIdleTime`.
+
+### Thank you
+* [Remy Suen @rcjsuen](https://github.com/rcjsuen): Fix conversion code from MarkedString to IMarkdownString in hovers [PR monaco-css#5](https://github.com/Microsoft/monaco-css/pull/5)
+* [Peng Xiao @pengx17](https://github.com/pengx17): fix an issue of `fromMarkdownString` [PR monaco-json#4](https://github.com/Microsoft/monaco-json/pull/4)
+* [TJ Kells @systemsoverload](https://github.com/systemsoverload): Add rust colorization support [PR monaco-languages#31](https://github.com/Microsoft/monaco-languages/pull/31)
+
+## [0.11.1] (15.03.2018)
+ - Fixes [issue #756](https://github.com/Microsoft/monaco-editor/issues/756): Can't use "Enter" key to accept an IntelliSense item
+ - Fixes [issue #757](https://github.com/Microsoft/monaco-editor/issues/757): TypeScript errors in `editor.api.d.ts` typings
+
+## [0.11.0] (14.03.2018)
+
+### New & Noteworthy
+* **ESM distribution** (compatible with e.g. webpack).
+* New interval tree decorations implementation.
+* New piece tree text buffer implementation.
+* The minimap can be placed to the left.
+* Line numbers can be displayed in an interval.
+* The cursor width can be customized.
+* Smooth scrolling can be turned on.
+* Color decorators and color picker via `DocumentColorProvider`.
+
+### Breaking changes
+* Replaced `MarkedString` with `IMarkdownString`. Source code snippets can be expressed using the GH markdown syntax.
+* Renamed `IResourceEdit` to `ResourceTextEdit`.
+
+### API changes
+* Merged `IModel`, `IReadOnlyModel`, `IEditableTextModel`, `ITextModelWithMarkers`, `ITokenizedModel`, `ITextModelWithDecorations` to `ITextModel`. A type alias for `IModel` is defined for compatibility.
+* Merged `ICommonCodeEditor` and `ICodeEditor` to `ICodeEditor`.
+* Merged `ICommonDiffEditor` and `IDiffEditor` to `IDiffEditor`.
+* `CompletionItem.documentation`, `ParameterInformation.documentation` and `SignatureInformation.documentation` can now be an `IMarkdownString`.
+* Added `CompetionItem.command`, `CompletionItem.commitCharacters` and `CompletionItem.additionalTextEdits`.
+* Added language configuration `folding` which can define markers for code patterns where a folding regions should be created. See for example the [Python configuration](https://github.com/Microsoft/monaco-languages/blob/d2db3faa76b741bf4ee822c403fc355c913bc46d/src/python/python.ts#L35-L41).
+* Added by accident `ResourceFileEdit` (due to how `monaco.d.ts` is generated from vscode). That is not honoured by the editor, and should not be used.
+
+### Thank you
+* [Remy Suen @rcjsuen](https://github.com/rcjsuen):
+ * Fix a small typo in README.md [PR monaco-typescript#18](https://github.com/Microsoft/monaco-typescript/pull/18)
+ * Remove unused IDisposable array [PR monaco-typescript#19](https://github.com/Microsoft/monaco-typescript/pull/19)
+ * Add HEALTHCHECK as a Dockerfile keyword [PR monaco-languages#29](https://github.com/Microsoft/monaco-languages/pull/29)
+ * Add ARG as a Dockerfile keyword [PR monaco-languages#30](https://github.com/Microsoft/monaco-languages/pull/30)
+* [Can Abacigil @abacigil](https://github.com/abacigil): MySQL, Postgres, Redshift and Redis Language Support [PR monaco-languages#26](https://github.com/Microsoft/monaco-languages/pull/26)
+* [Matthias Kadenbach @mattes](https://github.com/mattes): Support Content-Security-Policy syntax highlighting [PR monaco-languages#27](https://github.com/Microsoft/monaco-languages/pull/27)
+* [e.vakili @evakili](https://github.com/evakili): Whitespaces after # are allowed in C++ preprocessor statements [PR monaco-languages#28](https://github.com/Microsoft/monaco-languages/pull/28)
+* [Pankaj Kumar Gautam @PAPERPANKS](https://github.com/PAPERPANKS): adding microsoft logo to footer [PR monaco-editor#577](https://github.com/Microsoft/monaco-editor/pull/577)
+* [Dominik Moritz @domoritz](https://github.com/domoritz): Fix code in changelog [PR monaco-editor#582](https://github.com/Microsoft/monaco-editor/pull/582)
+* [ItsPugle @ItsPugle](https://github.com/ItsPugle): Updating the footer to reflect change of year [PR monaco-editor#707](https://github.com/Microsoft/monaco-editor/pull/707)
+* [Michael Seifert @MSeifert04](https://github.com/MSeifert04): Add linebreak for if [PR monaco-editor#726](https://github.com/Microsoft/monaco-editor/pull/726)
+* [Andrew Palm @apalm](https://github.com/apalm): Fix 'Configure JSON defaults' sample [PR monaco-editor#731](https://github.com/Microsoft/monaco-editor/pull/731)
+* [Niklas Mollenhauer @nikeee](https://github.com/nikeee): Fix line number API usage [PR monaco-editor#740](https://github.com/Microsoft/monaco-editor/pull/740)
+* [Andre @anc](https://github.com/anc): More realistic terminal shell [PR monaco-editor#742](https://github.com/Microsoft/monaco-editor/pull/742)
+* to the many others that have contributed PRs to [vscode](https://github.com/Microsoft/vscode) which have also made their way into the monaco-editor.
+
+
+## [0.10.1] (16.10.2017)
+ - Fixes [issue #601](https://github.com/Microsoft/monaco-editor/issues/601): window.opener should be set to null to protect against malicious code
+
+## [0.10.0] (17.08.2017)
+
+### Breaking changes
+* Removed `CodeAction`.
+* Method `provideCodeActions` in `CodeActionProvider` now returns `Command[] | ThenableThis app can allow you to change Splunk files on the "+ + "filesystem. When you change files, if you don't know what you are doing, then you may break your Splunk environment.
" + + (!(confIsTrue('write_access', false) || confIsTrue('hide_settings', false)) ? "By default,
write_access=false so files cannot be saved. Open the 'Settings' screen to enable." : "") + + '
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ' + + 'IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ' + + 'FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ' + + 'AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ' + + 'LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ' + + 'OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ' + + 'SOFTWARE.' + + "
'+(n?e:d(e,!0))+""+(n?e:d(e,!0))+"\n"+e+"\n"},r.prototype.html=function(e){return e},r.prototype.heading=function(e,t,n,i){return this.options.headerIds?"
\n":"
\n"},r.prototype.list=function(e,t,n){var i=t?"ol":"ul";return"<"+i+(t&&1!==n?' start="'+n+'"':"")+">\n"+e+"\n"},r.prototype.listitem=function(e){return"
"+e+"
\n"},r.prototype.table=function(e,t){return t&&(t=""+t+""),""+e+""},r.prototype.br=function(){return this.options.xhtml?"":"
"},r.prototype.del=function(e){return"
"+d(e.message+"",!0)+"";throw e}}m.exec=m,b.options=b.setOptions=function(e){return v(b.defaults,e),b},b.getDefaults=function(){return{baseUrl:null,breaks:!1,gfm:!0,headerIds:!0,headerPrefix:"",highlight:null,langPrefix:"language-",mangle:!0,pedantic:!1,renderer:new r,sanitize:!1,sanitizer:null,silent:!1,smartLists:!1,smartypants:!1,tables:!0,xhtml:!1}},b.defaults=b.getDefaults(),b.Parser=a,b.parser=a.parse,b.Renderer=r,b.TextRenderer=s,b.Lexer=n,b.lexer=n.lex,b.InlineLexer=o,b.inlineLexer=o.output,b.Slugger=l,b.parse=b,u=b}.call(this),define("vs/base/common/marked/marked",(function(){return u})),define(n[128],i([0,1]),(function(e,t){"use strict" +;Object.defineProperty(t,"__esModule",{value:!0}),t.clamp=function(e,t,n){return Math.min(Math.max(e,t),n)}})),define(n[16],i([0,1]),(function(e,t){"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=!1,i=!1,o=!1,r=!1,s=!1,a=!1,l=void 0,u="undefined"!=typeof process&&void 0!==process.versions&&void 0!==process.versions.electron&&"renderer"===process.type;if("object"!=typeof navigator||u){if("object"==typeof process){n="win32"===process.platform,i="darwin"===process.platform,o="linux"===process.platform,"en","en";var d=process.env.VSCODE_NLS_CONFIG;if(d)try{var c=JSON.parse(d),h=c.availableLanguages["*"];c.locale,h||"en",c._translationsConfigFile}catch(e){}r=!0}}else n=(l=navigator.userAgent).indexOf("Windows")>=0,i=l.indexOf("Macintosh")>=0,a=l.indexOf("Macintosh")>=0&&!!navigator.maxTouchPoints&&navigator.maxTouchPoints>0,o=l.indexOf("Linux")>=0,s=!0,navigator.language;t.isWindows=n,t.isMacintosh=i,t.isLinux=o,t.isNative=r,t.isWeb=s,t.isIOS=a +;var p="object"==typeof self?self:"object"==typeof global?global:{};t.globals=p,t.setImmediate=function(){if(t.globals.setImmediate)return t.globals.setImmediate.bind(t.globals);if("function"==typeof t.globals.postMessage&&!t.globals.importScripts){var e=[];t.globals.addEventListener("message",(function(t){if(t.data&&t.data.vscodeSetImmediateId)for(var n=0,i=e.length;n
"+e+"
"}, +t.codeBlockRenderer&&(y.code=function(e,n){var i=t.codeBlockRenderer(n,e),o=s.defaultGenerator.nextId(),r=Promise.all([i,_]).then((function(e){var t=e[0],n=g.querySelector('div[data-code="'+o+'"]');n&&(n.innerHTML=t)})).catch((function(e){}));return t.codeBlockRenderCallback&&r.then(t.codeBlockRenderCallback),''+c.escape(e)+"
"});var C=t.actionHandler;C&&C.disposeables.add(n.addStandardDisposableListener(g,"click",(function(e){var t=e.target;if("A"===t.tagName||(t=t.parentElement)&&"A"===t.tagName)try{var n=t.dataset.href;n&&C.callback(n,e)}catch(e){o.onUnexpectedError(e)}finally{e.preventDefault()}})));var b={sanitize:!0,renderer:y},S=[p.Schemas.http,p.Schemas.https,p.Schemas.mailto,p.Schemas.data,p.Schemas.file,p.Schemas.vscodeRemote,p.Schemas.vscodeRemoteResource];e.isTrusted&&S.push(p.Schemas.command);var w=a.parse(e.value,b);return g.innerHTML=l.insane(w,{allowedSchemes:S,allowedAttributes:{a:["href","name","target","data-href"],
+iframe:["allowfullscreen","frameborder","src"],img:["src","title","alt","width","height"],div:["class","data-code"],span:["class"]}}),f(),g}}));var h=this&&this.__decorate||function(e,t,n,i){var o,r=arguments.length,s=r<3?t:null===i?i=Object.getOwnPropertyDescriptor(t,n):i;if("object"==typeof Reflect&&"function"==typeof Reflect.decorate)s=Reflect.decorate(e,t,n,i);else for(var a=e.length-1;a>=0;a--)(o=e[a])&&(s=(r<3?o(s):r>3?o(t,n,s):o(t,n))||s);return r>3&&s&&Object.defineProperty(t,n,s),s};define(n[57],i([0,1,19,2,8,98]),(function(e,t,n,i,o,s){"use strict";var a;Object.defineProperty(t,"__esModule",{value:!0}),function(e){e.Tap="-monaco-gesturetap",e.Change="-monaco-gesturechange",e.Start="-monaco-gesturestart",e.End="-monaco-gesturesend",e.Contextmenu="-monaco-gesturecontextmenu"}(a=t.EventType||(t.EventType={}));var l=function(e){function t(){var t=e.call(this)||this;return t.dispatched=!1,t.activeTouches={},t.handle=null,t.targets=[],t.ignoreTargets=[],t._lastSetTapCountTime=0,
+t._register(o.addDisposableListener(document,"touchstart",(function(e){return t.onTouchStart(e)}))),t._register(o.addDisposableListener(document,"touchend",(function(e){return t.onTouchEnd(e)}))),t._register(o.addDisposableListener(document,"touchmove",(function(e){return t.onTouchMove(e)}))),t}return r(t,e),t.addTarget=function(e){return t.isTouchDevice()?(t.INSTANCE||(t.INSTANCE=new t),t.INSTANCE.targets.push(e),{dispose:function(){t.INSTANCE.targets=t.INSTANCE.targets.filter((function(t){return t!==e}))}}):i.Disposable.None},t.ignoreTarget=function(e){return t.isTouchDevice()?(t.INSTANCE||(t.INSTANCE=new t),t.INSTANCE.ignoreTargets.push(e),{dispose:function(){t.INSTANCE.ignoreTargets=t.INSTANCE.ignoreTargets.filter((function(t){return t!==e}))}}):i.Disposable.None},t.isTouchDevice=function(){return"ontouchstart"in window||navigator.maxTouchPoints>0||window.navigator.msMaxTouchPoints>0},t.prototype.dispose=function(){this.handle&&(this.handle.dispose(),this.handle=null),e.prototype.dispose.call(this)},
+t.prototype.onTouchStart=function(e){var t=Date.now();this.handle&&(this.handle.dispose(),this.handle=null);for(var n=0,i=e.targetTouches.length;n